百木园-与人分享,
就是让自己快乐。

Head First Java 学习笔记

一、常用概念

1. JVM(Java Virtual Machine):Java 虚拟机

  • 虚拟机:通过软件模拟的具有完整硬件系统功能的,运行在一个完全隔离环境中的完整计算机系统。
  • JVM:是运行所有Java程序的抽象计算机,是 Java 语言的运行环境。
  • 注意:Java 的跨平台特性正是通过在 JVM 中运行 Java 程序实现的,但是不同操作系统之上的 JVM 是不同的。

2. GC(Garbage Collection):垃圾回收

  • 创建对象时,它会被存放在称为堆的内存区域中。不管对象如何创建都会放在此区域中。此区域并非普通的堆;它是可回收垃圾的堆(Garbage-Collectible Heap)。Java会根据对象的大小来分配内存空间。但对象使用完毕时内存要如何回收呢?Java会主动帮你管理内存!当某个对象被 Java 虚拟机察觉不再会被使用到,该对象就会被标记成可回收的。如果内存开始不足,垃圾收集器就会启动来清理垃圾、回收空间,让空间能够再次被利用。

二、常用指令

  • 假设命令行的当前工作目录下存在源文件 Demo.java(需要使用 cmd 命令 cd 来指定 Demo.java 所在目录)
    • javac Demo.java
      
      • 对当前目录下的 Demo.java 文件进行编译。
      • 当前目录下会生成 Demo.class 文件。
    • java Demo
      
      • 运行当前目录下的 Demo.class 文件。
      • 如果有参数,用空格隔开。例如:
        • java Demo a 1 bc 23
          

三、一些零碎的知识

1. System.out.print 与 System.out.println 的区别

  • println 会在最后面插入换行,若你想要让后续的输出以新的一行开始,可以使用 println,若是使用 print,则后续的输出还是会在同一行。

2. 圆点运算符(.)

  • 调用对象的实例变量和方法

3. 若有成百上千的类时要如何提交 Java 程序?

  • 可以把所有文件包装进依据 pkzip 格式来存档的 Java Archive-.jar 文件。在 jar 文件中可以引入一个简单文字格式的文字文件,它被称为 manifest,里面有定义出 jar 中的哪一个文件带有启动应用程序的 main 方法。

四、进入 Java 的世界

1. Java 程序的运行过程

  • 编写:编写源文件( *.java 文件)。
  • 编译:使用 Java 编译器( Javac 编译程序)编译源文件,编译器会对源文件进行错误检查,如果没有错误将会生成字节码文件( *.class 文件)。
  • 运行:使用 Java 解释器将字节码文件翻译成机器代码并执行
    • Java 解释器是 JVM 的一部分,JVM 负责解释执行 Java 字节码程序,并且 Java 字节码程序只能运行于 JVM 之上。这样,利用 JVM 就可以把 Java 字节码程序和具体的硬件平台以及操作系统环境分隔开。只要在不同的计算机上安装了针对特定平台的 JVM ,Java 程序就可以运行,而不用考虑当前具体的硬件平台以及操作系统环境,也不用考虑字节码文件是在何种平台上生成的。

2. Java 的程序结构

1. 源文件、类、方法、语句

  • 源文件:扩展名为 .java 。
  • 类:用来表示程序的一个组件,类的内容必须包在花括号里面,类中带有一个或多个方法
    • 在 Java 中的所有东西都会属于某个类。我们会建立源文件( *.java 文件),然后将它编译成新的类文件( *.class 文件)。真正被解释执行的是类文件。
  • 方法:是一组语句的集合,它们在一起执行一个功能,方法的花括号中编写方法应该执行的语句,方法必须在类的内部声明。
  • 语句:在 Java 中,语句是最小的组成单位,每个语句必须使用分号作为结束符。

2. 关于 main()

1. 什么是 main()

  • public static void main (String[] args) {
    
    }
    
  • main() 是 Java 程序的入口方法(程序的起点),程序在运行的时候,第一个执行的方法就是 main()
    • 当 Java 虚拟机启动执行时,它会寻找你在命令行所指定的类。然后他会锁定 main 方法,接着 Java 虚拟机就会执行 main() 在花括号间的所有指令。

2. 需要注意的点

  • 访问控制权限是公有的(public)。
  • main() 是静态的。如果要在 main() 方法中调用本类中的其他方法,则该方法也必须是静态的,否则需要先创建本类的对象,然后再通过对象调用成员方法。
  • main() 没有返回值,只能使用 void。
  • main() 具有一个字符串数组参数,用来接收执行 Java 程序的命令行参数。
  • 参数列表中字符串数组的名字(代码中的 args)可以任意设置。
  • main() 定义必须是“public static void main(String[] 参数名)”。
  • 一个类只能有一个 main()。
  • 每个 Java 程序有且只有一个 main()。

3. main() 的两种用途

  • 测试真正的类。
  • 启动Java应用程序。

4. 你能在 main() 中做什么

1. 语法 Tips

  • 语句是以分号结束
    • x = x + 1;
      
  • 以两条斜线开始的行是注释
    • // 我是注释
      
  • 空格符通常无关紧要
    • x   =   3 ;
      
  • 用名称与类型(type)来声明变量
    • int weight;
      // 类型:int,名称:weight
      

2. 循环结构

1. while 循环
  • while (布尔表达式) {
        // 循环内容
    }
    
  • 要点:
    • 语句以分号结束。
    • 程序块以{}划出范围。
    • 用名称与类型声明变量。
    • 等号是赋值运算符。
    • 两个等号用来当等式等号运算符。
    • 只要条件测试结果为真,while 循环就会一直执行块内的程序
    • 把 boolean 测试放在括号中
2. do-while 循环
  • do {
        // 循环内容
    } while (布尔表达式);
    
  • do-while 循环和 while 循环相似,不同的是,do-while 循环至少会执行一次。
3. for 循环
  • for (初始化; 布尔表达式; 更新) {
        // 循环内容
    }
    
  • 要点:
    • 最先执行初始化步骤。可以声明一种类型,但可初始化一个或多个循环控制变量,也可以是空语句。
    • 然后,检测布尔表达式的值。如果为 true,循环体被执行。如果为 false,循环终止,开始执行循环体后面的语句。
    • 执行一次循环后,更新循环控制变量。
    • 再次检测布尔表达式。循环执行上面的过程。

3. 分支结构

1. if 语句
  • if (布尔表达式) {
        // 如果布尔表达式为 true 将执行的语句
    }
    
  • 如果布尔表达式的值为 true,则执行 if 语句中的代码块。否则执行 if 语句后面的代码。
2. if...else 语句
  • if (布尔表达式) {
        // 如果布尔表达式的值为 true 将执行的语句
    } else {
        // 如果布尔表达式的值为 false 将执行的语句
    }
    
  • 如果布尔表达式的值为 true,则执行 if 语句中的代码块。否则执行 else 语句中的代码块。
3. if...else if...else 语句
  • if (布尔表达式 1) {
        // 如果布尔表达式 1的值为 true 将执行的语句
    } else if (布尔表达式 2) {
        // 如果布尔表达式 2的值为 true 将执行的语句
    } else if (布尔表达式 3) {
        //如果布尔表达式 3的值为 true 将执行的语句
    } else {
        // 如果以上布尔表达式都不为 true 将执行的语句
    }
    
  • 要点:
    • if 语句至多有1个 else 语句,else 语句在所有的 else if 语句之后。
    • if 语句可以有若干个 else if 语句,它们必须在 else 语句之前。
    • 一旦其中一个 else if 语句检测为 true,其他的 else if 以及 else 语句都将跳过执行。
4. 嵌套的 if…else 语句
  • if (布尔表达式 1) {
        // 如果布尔表达式 1的值为 true 将执行的语句
        if (布尔表达式 2) {
            //如果布尔表达式 2的值为 true 将执行的语句
        }
    }
    
5. switch 语句
  • switch (expression) {
        case value :
            //语句
            break; //可选
        case value :
            //语句
            break; //可选
        //你可以有任意数量的case语句
        default : //可选
            //语句
    }
    
  • 要点:
    • switch 语句中的变量类型只能为 byte、short、int 或者 char。从 Java SE 7 开始,switch 支持字符串 String 类型了,同时 case 标签必须为字符串常量或字面量。
    • switch 语句可以拥有多个 case 语句。每个 case 后面跟一个要比较的值和冒号。
    • case 语句中的值的数据类型必须与变量的数据类型相同,而且只能是常量或者字面常量。
    • 当变量的值与 case 语句的值相等时,那么 case 语句之后的语句开始执行,直到 break 语句出现才会跳出 switch 语句。
    • 当遇到 break 语句时,switch 语句终止。程序跳转到 switch 语句后面的语句执行。case 语句不必须要包含 break 语句。如果没有 break 语句出现,程序会继续执行下一条 case 语句,直到出现 break 语句。
    • switch 语句可以包含一个 default 分支,该分支必须是 switch 语句的最后一个分支。default 在没有 case 语句的值和变量值相等的时候执行。default 分支不需要 break 语句。

五、拜访对象村

1. 对象和类的概念

  • 对象:对象是类的一个实例,有状态和行为。
  • 类:类是一个模板,它描述一类对象的状态和行为。
  • 注:
    • 软件对象和现实对象十分相似,实例变量用来存储状态,行为通过方法来体现。

2. 要点

  • 面向对象设计扩展功能不需要改动之前已经测试好的程序代码。
  • 所有的 Java 程序都定义在类中。
  • 类如同蓝图描述该类型的对象要如何创建。
  • 创建类时,可能同时会需要创建独立、测试用的类。
  • 类可以继承自较为抽象的父类。
  • 对象自治;你无需在意它如何完成任务。
  • 对象有状态和行为。
  • 实例变量用来存储状态,行为通过方法来体现。
  • Java 的程序在执行期是一组会相互交谈的对象。

六、认识变量

1. 什么是变量

  • 变量就像是杯子,是一种容器,有大小和类型,用来存储变量值(对 primitive 主数据类型变量来说,变量值是该值的字节表示。对引用变量来说,变量值就是存取特定对象的方法)。
  • 变量有两种:primitive 主数据类型(基本数据类型)变量和引用变量。
  • 声明变量的规则:
    • 变量必须拥有类型。
    • 变量必须要有名称。
      • // 类型 名称;
        int count;
        
  • 变量命名规则
    • 名称必须以字母、下划线(_)或 $ 符号开头,不能用数字开头。
    • 除了第一个字符以外,后面都可以用数字。
    • 不可以使用 Java 的保留字来命名。

2. primitive 主数据类型变量

  • primitive 主数据类型有八种
    • 整数类型
      • byte 8 bits
      • short 16 bits
      • int 32 bits
      • long 64 bits
    • 浮点数类型
      • float 32 bits
      • double 64 bits
    • boolean 和 char
      • boolean(true 或 false) 位数由Java虚拟机决定
  • primitive 主数据类型的声明与赋值声明
    • // 在不赋值的情况下声明变量,然后再赋值
      int myNum;
      myNum = 15;
      
      // 声明一个 int 类型的变量,名称为 myNum(将数值 15 以字节的形式放进变量 myNum 中)
      int myNum = 15;
      

3. 引用变量

  • 对象的声明、创建与赋值有三个步骤:
    • 声明一个引用变量
      • Dog myDog
      • 要求 Java 虚拟机分配空间给引用变量,并将此变量命名为 myDog。此引用变量将永远被固定为 Dog 类型。
    • 创建对象
      • new Dog()
      • 要求Java虚拟机分配堆空间给新建立的 Dog 对象(对象只会存在于可回收垃圾的堆上!)。
    • 连接对象和引用
      • Dog myDog = new Dog();
      • 将新的 Dog 对象赋值给 myDog 这个引用变量(代表取得 Dog 对象的方法以字节形式放进变量中),此时 myDog 变量能够引用到新创建的 Dog 对象。
    • 注意:
      • 引用变量只会保存引用,而不是对象本身!
      • 没有引用到任何对象的引用变量的值为 null 值。
  • 数组也是对象
    • int[] nums;
      • 声明一个 int 数组变量。数组变量保存数组对象的引用。
    • nums = new int[3];
      • 创建可以存放 3 个元素的 int 数组,并将它赋值给之前声明为 int[] 的变量 nums。
    • nums[0] = 16;
      nums[1] = 19;
      nums[2] = 44;

      • 赋予 int 数组的每一个元素一个 int 值。要记得在 int 数组中的每个元素皆为 int 类型的变量。
    • 注意:
      • 数组一定是个对象(数组对象),数组中的每个元素都是变量,可以是 8 种 primitive 主数据类型变量中的 1 种,也可以是引用变量。所以在 int 类型的数组中,每个元素可以装在一个 int 类型的变量值;在 Dog 数组中(Dog[]),每个元素持有的是 Dog 的引用。
      • 一旦数组被声明出来,你就只能装入所声明类型的元素。
      • 不管所声明的元素是否为 primitive 主数据类型,并没有 primitive 主数据类型的数组,只有装载 primitive 主数据类型的数组。
  • 创建 Dog 数组
    • Dog[] pets;
      • 声明一个 Dog 数组变量。
    • pets = new Dog[3];
      • 创建大小为7的 Dog 数组,并赋值给前面所声明出的 Dog[] 类型变量 pets。
    • pets[0] = new Dog();
      pets[1] = new Dog();
      pets[2] = new Dog();

      • 创建新的 Dog 对象并将它们赋值给数组的元素。记得 Dog 数组中只带有 Dog 的引用变量。我们还需要 Dog 对象!

来源:https://www.cnblogs.com/whitegogogo/p/16558924.html
本站部分图文来源于网络,如有侵权请联系删除。

未经允许不得转载:百木园 » Head First Java 学习笔记

相关推荐

  • 暂无文章