百木园-与人分享，
就是让自己快乐。
当前位置：百木园 > 野生技术 > 正文

Head First Java 学习笔记

2022-08-26 分类：野生技术 阅读(381) 评论(0)

一、常用概念

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 学习笔记
标签：

相关推荐

  • 暂无文章

热门文章