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 对象！