1.2 Java语言的特点

        Java语言的广泛应用主要得益于它的核心特点，主要包括跨平台性、面向对象特性、安全性等。

特性	描述
跨平台性	Java能够在多种操作系统上运行，这得益于JVM（Java虚拟机）。只要设备安装了对应的JVM，Java程序就可以在其上运行。
面向对象	Java是一种面向对象的编程语言。这意味着你可以创建包含属性和方法的对象，并通过对象的交互来实现复杂功能。
安全性	Java为网络编程提供了许多安全特性，包括对源代码的加密，并且在运行时检查类的

1.3 Java开发环境的搭建

        Java开发环境的搭建是Java学习的第一步，主要包括安装JDK（Java开发工具包）和配置环境变量。

步骤	描述
安装JDK	JDK是包含了JRE（Java运行环境）和开发工具（如编译器和调试器）的软件包。
配置环境变量	环境变量是让系统知道如何找到Java命令和库的方式。通常需要设置JAVA

1.4 第一个Java程序

        编写第一个Java程序时，通常从最简单的输出开始，这里我们以“Hello, World!”为例。

// "HelloWorld.java" 示例代码
public class HelloWorld {
    // 主函数，Java 程序入口点
    public static void main(String[] args) {
        // 输出字符串到控制台
        System.out.println("Hello, World!");
    }
}

步骤	描述
创建类	使用 class 关键字定义一个类，类名的首字母应大写。
编写主函数	main 方法是程序的入口，是程序开始执行的地方。
输出信息	使用 System.out.println 在控制台打印信息。

        进阶用法介绍：掌握基本的输入输出操作后，可以学习复杂的 I/O 流操作，包括文件读写，序列化和网络通信。此外，了解执行时异常处理也是进阶重要的一步。

1.5 Java程序编程规范

        遵循Java编程规范能够提高代码的可读性和可维护性。

// Java 编程规范示例代码

/**
 * Calculator 类用于执行基本的数学运算。
 * 类命名使用大驼峰命名法。
 */
public class Calculator {

    /**
     * 常量命名使用全大写字母和下划线分隔。
     */
    public static final String NAME = "Simple Calculator";

    /**
     * 方法命名使用小驼峰命名法，方法名应当清晰表达其功能。
     */
    public int add(int number1, int number2) {
        // 方法内的注释用于解释复杂的逻辑   
        return number1 + number2; // 返回两个数字的和
    }
}

规范类型	描述
类命名规范	使用大写字母开始，后续每个单词首字母大写。
方法命名规范	使用小写字母开始，后续每个单词首字母大写。
常量命名规范	全部使用大写字母，并在单词之间使用下划线分隔。

2.1 关键字和标识符

        在Java中，关键字是预定义的保留字，具有特殊的意义；而标识符是程序员自定义的名字，用于变量、方法、类等的命名。

// 关键字和标识符示例代码

public class Student {
    // 'public', 'class' 是Java关键字

    // 'Student', 'studentName', 'printStudentName' 是标识符
    String studentName;

    // 'void' 是关键字，表示函数不返回任何值
    public void printStudentName() {
        System.out.println(studentName);
    }
}

类型	描述
关键字	Java预定义的单词，如 public, static, void。
标识符	用户自定义的名称，需要遵守命名规则，不能使用关键字。

2.2 变量与常量

        变量和常量是Java中存储数据的基本单元，变量的值可以改变，而常量的值定义后不可更改。

// 变量与常量的示例代码
public class VariableAndConstant {
    // 声明一个变量
    int age = 18;

    // 声明一个常量，一般使用 final 关键字修饰，且常量名大写
    final String NAME = "张三";

    public void updateAge() {
        // 修改变量
        age = 20;
        // 以下常量赋值会导致编译错误，因为常量不能被改变
        // NAME = "李四";
    }
}

类型	描述
变量	可变的存储单元，可以在程序执行过程中改变其值。
常量	使用 final 关键字声明，一旦赋初值后不可更改。

进阶用法介绍：

        在Java编程中，变量和常量的高级用法涉及到更深层次的理解和运用。例如，变量的作用域决定了在哪个部分的代码中可以访问到该变量，而生命周期则与变量在内存中存在的时间有关。变量的作用域可以是类级（成员变量）、方法级（局部变量）、块级（比如在if或for循环中定义的变量），或者是线程生命周期内（ThreadLocal变量）。

        装箱和拆箱是Java中特有的概念，指自动地将基本数据类型转换为相应的包装器类型（装箱），以及将包装器类型转换回基本数据类型（拆箱）。不变设计模式（Immutable Design Pattern）涉及到创建不可变的对象，确保对象一旦被创建后就不能被修改。这种模式有助于创建更加安全和简洁的代码，并容易进行多线程编程，因为不可变对象本身是线程安全的。

// 进阶变量与常量的示例代码
public class AdvancedVariableAndConstant {

    // 类级变量（静态变量），与类一起加载，在程序整个运行期间都存在
    private static int classVariable = 0;

    // 在方法中定义的局部变量，仅在方法调用时存在
    public void localVariableExample() {
        int localVariable = 1;
    }

    // 不变对象示例，创建后其状态不能被改变
    public final static String IMMUTABLE_STRING = "不可变字符串";

    // 装箱:将int基本类型转化为Integer对象类型
    int primitive = 100;
    Integer wrappedInteger = primitive; // 装箱

    // 拆箱:将Integer对象类型转化为int基本类型
    int unboxedInteger = wrappedInteger; // 拆箱
}

高级用法	描述
变量作用域	确定变量可以被访问的代码范围。
变量生命周期	变量从创建到销毁的过程。
装箱与拆箱	自动类型转换，基本数据类型与对象类型之间的转换。
不变设计模式	一种创建不可变对象的设计模式，用于创建线程安全和不可修改的对象。

2.3 数据类型

        Java是静态类型语言，数据类型定义了变量可以存储的数据种类和范围。

// 数据类型的示例代码
public class DataTypes {
    // 基本数据类型
    int intNum = 100;            // 整数
    float floatNum = 10.99f;     // 单精度浮点数
    double doubleNum = 3.14159;  // 双精度浮点数
    char letter = 'A';           // 字符
    boolean flag = true;         // 布尔

    // 对象数据类型（类）
    String text = "Hello Java";  // 字符串
}

数据类型	描述
基本数据类型	包括整数、浮点数、字符和布尔等类型，直接存储值。
对象数据类型	类的实例，通过引用来操作，例如字符串。

2.5 程序控制结构

        程序控制结构决定了程序的流程，包括分支结构如 if、else、循环结构如 for、while。

// 程序控制结构的示例代码
public class ControlStructure {
    public void checkNumber(int number) {
        // 分支结构
        if (number > 0) {
            System.out.println("数字正数");
        } else {
            System.out.println("数字非正数");
        }

        // 循环结构
        for (int i = 0; i < 5; i++) {
            System.out.println(i);
        }
    }
}

控制结构	描述
分支结构	根据条件执行不同的代码路径。
循环结构	重复执行一段代码直至满足退出条件。

3.1 数组概述

        数组在Java中是用来存储固定大小的同类型元素的集合。

// 数组概述示例代码
public class ArrayExample {
    public void arrayDemo() {
        // 声明一个整型数组
        int[] numbers = {10, 20, 30, 40, 50};
        // 遍历数组并打印元素
        for (int i = 0; i < numbers.length; i++) {
            System.out.println(numbers[i]);
        }
    }
}

概念	描述
数组声明	定义数组的类型和名称，可以初始化数组。
数组遍历	使用循环结构去访问数组中的每个元素。
数组长度	属性 length 用来获得数组的大小。

进阶用法介绍：

        数组的高级功能涉及多维数组的使用、数组和集合之间的转换、利用Java的集合框架进行动态数组的操作，以及对数组进行高效排序和搜索等操作。

        多维数组：在Java中，除了一维数组，还可以创建多维数组，如二维数组通常被用于表示矩阵或者表格数据。

// 多维数组示例代码
public class MultiDimensionalArray {
    public void multiArrayDemo() {
        // 声明一个二维数组
        int[][] matrix = {
            {1, 2, 3},
            {4, 5, 6},
            {7, 8, 9}
        };
        // 访问二维数组中的元素
        for (int i = 0; i < matrix.length; i++) {
            for (int j = 0; j < matrix[i].length; j++) {
                System.out.print(matrix[i][j] + " ");
            }
            System.out.println(); //新的一行
        }
    }
}

        Java集合框架：对于更复杂的数据结构操作，可以使用Java的集合框架，如 ArrayList 和 HashMap 提供了动态的、可以改变大小的数组。

// Java集合框架示例代码
import java.util.ArrayList;
import java.util.HashMap;

public class CollectionExample {
    public void collectionDemo() {
        // 创建ArrayList
        ArrayList<Integer> numberList = new ArrayList<>();
        numberList.add(10);
        numberList.add(20);

        // 创建HashMap
        HashMap<String, Integer> nameToAge = new HashMap<>();
        nameToAge.put("张三", 30);
        nameToAge.put("李四", 40);
    }
}

        数组的高级排序与搜索：使用如排序算法 Arrays.sort() 和搜索算法 Arrays.binarySearch() 可以对数组进行高效的排序和搜索。

// 数组高级排序与搜索示例代码
import java.util.Arrays;

public class ArrayAdvancedOperations {
    public void advancedArrayDemo() {
        // 标准数组排序
        int[] numbers = {40, 10, 20, 30};
        Arrays.sort(numbers);

        // 用二分搜索法在数组中搜索值，前提是数组已经排序
        int index = Arrays.binarySearch(numbers, 30);
        System.out.println("Index of 30: " + index);
    }
}

高级功能	描述
多维数组	可以用来表示多维数据结构，例如矩阵。
Java集合框架	动态数组和映射，用于在程序运行时动态存储元素。
高级排序与搜索	利用Java提供的工具类对数组进行高效的排序和搜索。

4.2 类

        类是Java面向对象程序设计的基础，是创建对象的蓝图或原型。

// 类的示例代码
public class Book {
    
    // 实例变量（属性）
    private String title;
    private String author;
    private int year;

    // 类构造器
    public Book(String title, String author, int year) {
        this.title = title;
        this.author = author;
        this.year = year;
    }

    // 实例方法
    public void displayInfo() {
        System.out.println("Book: " + title + ", Author: " + author + ", Year: " + year);
    }
}

概念	描述
类定义	包含属性和方法的模板定义。
构造器	特殊的方法，用于在创建对象时初始化对象。
实例变量	在类中定义，为每个对象实例保留其独有的状态。
实例方法	属于对象的方法，能够访问对象的状态和行为。

第五章 继承与多态

        继承允许一个类继承另一个类的属性和方法，而多态允许子类重写父类的方法。

// 继承与多态示例代码

// 父类
class Animal {
    public void makeSound() {
        System.out.println("Some sound");
    }
}

// 子类
class Dog extends Animal {
    // 重写方法（多态）
    @Override
    public void makeSound() {
        System.out.println("Bark bark");
    }
}

public class TestInheritance {
    public static void main(String[] args) {
        Dog myDog = new Dog();
        myDog.makeSound(); // 输出: Bark bark
    }
}

概念	描述
继承	使用 extends 关键字，子类获得父类的属性和方法。
方法重写	子类提供父类方法的特定实现。
类型转换	子类对象可以被视为是父类的实例，反之不行。

第六章 抽象类与接口

        抽象类和接口都不能实例化，用于声明类的某些行为，具体实现由子类完成。

// 抽象类与接口示例代码

// 抽象类
abstract class Shape {
    String color;
    
    // 抽象方法
    abstract double area();
    
    public String getColor() {
        return color;
    }
}

// 接口
interface Drawable {
    void draw();
}

// 子类
class Circle extends Shape implements Drawable {
    double radius;

    Circle(double radius) {
        this.radius = radius;
    }

    // 实现抽象方法
    @Override
    double area() {
        return Math.PI * radius * radius;
    }

    // 实现接口方法
    @Override
    public void draw() {
        System.out.println("Drawing Circle");
    }
}

概念	描述
抽象类	使用 abstract 关键字声明，可以包含抽象方法和具体方法。
接口	使用 interface 关键字声明，只能包含抽象方法（Java 8之前）。
实现	子类使用 extends 关键字继承抽象类，使用 implements 关键字实现接口。