java学习笔记

期末课堂作业,以下内容为2024年上学期java课堂学习笔记
202402150705

目录

• [第 1 章 : Java 语言概述](#第 1 章: Java 语言概述)
• [第 2 章 : 数据类型与运算符](#第 2 章: 数据类型与运算符)
• [第 3 章: 控制流程语句](#第 3 章: 控制流程语句)
• [第 4 章: 数组](#第 4 章: 数组)
• [第 5 章: 类与对象](#第 5 章: 类与对象)
• [第 6 章: 封装、继承与多态](#第 6 章: 封装、继承与多态)
• [第 7 章: 异常处理](#第 7 章: 异常处理)

第 1 章: Java 语言概述

1.1 Java 的历史与发展

• 略

1.2 Java 的特点

• 略

1.3 Java 的运行环境（JRE）和开发工具包（JDK）

• 略

1.4 第一个 Java 程序（Hello World 示例）

• 略

1.5 Java 程序的基本结构

Java 程序由以下几个部分组成：

• 包声明：定义类所属的包。

  package com.example.myapp;
  

• 导入声明：导入需要使用的外部类。

  import java.util.List;
  import java.util.ArrayList;
  

• 类声明：定义Java类。

  public class HelloWorld {
      // 类体
  }
  

• 主方法：程序的入口方法。

  public static void main(String[] args) {
      // 主方法体
  }
  

• 成员变量：类的属性。

  private String message;
  

• 构造方法：初始化对象。

  public HelloWorld(String message) {
      this.message = message;
  }
  

• 成员方法：类的行为。

  public void printMessage() {
      System.out.println(message);
  }
  

完整示例

package com.example.myapp;

import java.util.List;
import java.util.ArrayList;

public class HelloWorld {
    private String message;

    public HelloWorld(String message) {
        this.message = message;
    }

    public void printMessage() {
        System.out.println(message);
    }

    public static void main(String[] args) {
        HelloWorld helloWorld = new HelloWorld("Hello, World!");
        helloWorld.printMessage();
    }
}

第 2 章: 数据类型与运算符

2.1 基本数据类型（整型、浮点型、字符型、布尔型）

Java 提供了八种基本数据类型，每种数据类型都有特定的用途：

• 整型（整数类型）：

  • byte：8 位有符号整数。范围：-128 到 127。
  • short：16 位有符号整数。范围：-32,768 到 32,767。
  • int：32 位有符号整数。范围：-2^31 到 2^31-1。
  • long：64 位有符号整数。范围：-2^63 到 2^63-1。

• 浮点型（小数类型）：

  • float：32 位单精度浮点数。

  • double：64 位双精度浮点数。

• 字符型：

  • char：16 位 Unicode 字符。范围：0 到 65,535。

• 布尔型：

  • boolean：表示两个值：true 或 false。

2.2 数据类型转换（自动类型转换、强制类型转换）

数据类型转换可以分为自动类型转换和强制类型转换：

• 自动类型转换（隐式类型转换）：

  • 由低精度类型向高精度类型的转换。
  • 例如：int 可以自动转换为 long，float 可以自动转换为 double。

• 强制类型转换（显式类型转换）：

  • 由高精度类型向低精度类型的转换，需要显式声明。

  • 语法：(目标数据类型) 变量/值。

  • 例如：double 转换为 int：

    java

    double d = 9.78;
    int i = (int) d; // i 的值为 9
    

2.3 运算符（算术、关系、逻辑、位运算、赋值等运算符）

Java 提供了多种运算符，用于各种计算和逻辑操作：

• 算术运算符：
  • + 加法; - 减法; * 乘法; / 除法; % 取余;
• 关系运算符：
  • == 等于; != 不等于; > 大于; < 小于; >= 大于等于; <= 小于等于;
• 逻辑运算符：
  • && 逻辑与; || 逻辑或; ! 逻辑非;
• 位运算符：
  • & 按位与; | 按位或; ^ 按位异或; ~ 按位非; << 左移; >> 右移; >>> 无符号右移
• 赋值运算符：
  • = 赋值; += 加并赋值; -= 减并赋值; *= 乘并赋值; /= 除并赋值; %= 取余并赋值

2.4 表达式和语句

• 略

第 3 章: 控制流程语句

3.1 顺序结构

顺序结构是程序最基本的控制结构。

程序中的语句按照它们在源代码中的顺序依次执行。

所有流程控制语句的默认执行方式都是顺序结构。

3.2 选择结构（if - else、switch - case）

选择结构用于根据条件的真假来决定程序的执行路径。

• if - else 语句：

  if (condition) {
      // 当条件为 true 时执行
  } else {
      // 当条件为 false 时执行
  }
  

• switch - case 语句：

  int day = 3;
  switch (day) {
      case 1:
          System.out.println("Monday");
          break;
      case 2:
          System.out.println("Tuesday");
          break;
      case 3:
          System.out.println("Wednesday");
          break;
      // 可以有任意数量的 case 语句
      default:
          System.out.println("Invalid day");
          break;
  }
  

3.3 循环结构（for、while、do - while）

循环结构用于重复执行一段代码块，直到某个条件为假。

• for 循环：

  for (int i = 0; i < 10; i++) {
      System.out.println(i);
  }
  

• while 循环：

  int i = 0;
  while (i < 10) {
      System.out.println(i);
      i++;
  }
  

• do - while 循环：

  int i = 0;
  do {
      System.out.println(i);
      i++;
  } while (i < 10);
  

3.4 跳转语句（break、continue、return）

跳转语句用于控制循环的执行流程或退出函数。

• break：跳出当前循环或 switch 语句。

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

• continue：跳过当前循环的剩余语句并进入下一次循环。

  for (int i = 0; i < 10; i++) {
      if (i == 5) {
          continue; // 跳过剩余语句，继续下一次循环
      }
      System.out.println(i);
  }
  

• return：结束当前方法并返回一个值（如果方法的返回类型不是 void）。

  public int add(int a, int b) {
      return a + b; // 返回 a 和 b 的和
  }
  

第 4 章: 数组

4.1 数组的概念与定义

数组是用于存储相同类型数据的集合。它使用一个单一变量名，通过索引来访问具体的元素。数组在内存中是连续存储的，每个元素占用相同的存储空间。

4.2 一维数组的初始化与访问

一维数组是最简单的数组类型。它可以通过两种方式进行初始化：

• 静态初始化：

  int[] numbers = {1, 2, 3, 4, 5};
  

• 动态初始化：

  int[] numbers = new int[5]; // 创建一个长度为5的数组，默认值为0
  numbers[0] = 1;
  numbers[1] = 2;
  // 依次类推
  

访问一维数组的元素可以通过索引，索引从0开始。例如：

int firstNumber = numbers[0]  //访问第一个元素

4.3 二维数组及多维数组

二维数组可以看作是数组的数组。它通常用于表示矩阵或表格数据：

• 初始化二维数组：

  int[][] matrix = {
      {1, 2, 3},
      {4, 5, 6},
      {7, 8, 9}
  };
  // 或者
  int[][] matrix = new int[3][3]; // 创建一个3x3的矩阵
  matrix[0][0] = 1;
  matrix[0][1] = 2;
  // 依次类推
  

访问二维数组的元素也通过索引。例如：

int element = matrix[1][2]; // 访问第二行第三列的元素

4.4 数组的常见操作（排序、查找等）

• 排序：可以使用 Arrays.sort() 方法对数组进行排序。

  int[] numbers = {5, 3, 8, 1, 2};
  Arrays.sort(numbers); // 对数组进行排序
  

• 查找：可以使用 Arrays.binarySearch() 方法在排序后的数组中查找元素的位置。

  int index = Arrays.binarySearch(numbers, 3); // 查找元素3的位置
  

第 5 章: 类与对象

5.1 面向对象编程（OOP）概念引入

面向对象编程（OOP）是一种编程范式，它将程序设计任务分解为一组相互协作的对象。每个对象都是类的实例，类定义了对象的属性和行为。OOP的四大基本原则是：封装、继承、多态和抽象。

5.2 类的定义（成员变量、成员方法）

类是对象的蓝图，它定义了对象的属性（成员变量）和行为（成员方法）。

• 成员变量：用于存储对象的属性。

  public class Person {
      String name;
      int age;
  }
  

• 成员方法：用于定义对象的行为。

  public class Person {
      String name;
      int age;
      
      void introduce() {
          System.out.println("Hello, my name is " + name);
      }
  }
  

5.3 对象的创建与使用

对象是类的实例，通过 new 关键字创建。

Person person = new Person();
person.name = "Alice";
person.age = 30;
person.introduce();

5.4 构造方法

构造方法用于初始化对象。它的名称与类名相同，没有返回类型。

public class Person {
    String name;
    int age;
    
    // 构造方法
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

使用构造方法创建对象：

Person person = new Person("Alice", 30

5.5 this 关键字

this 关键字用于引用当前对象的实例。它常用于区分成员变量和局部变量。

public class Person {
    String name;
    
    public Person(String name) {
        this.name = name; // 使用 this 来区分成员变量和局部变量
    }

第 6 章: 封装、继承与多态

6.1 封装（访问控制修饰符: private、protected、public）

封装是面向对象编程的基本原则之一，它通过访问控制修饰符来保护对象的属性和方法。Java 提供了三种访问控制修饰符：

• private：私有，成员只能在类内部访问。
• protected：受保护，成员可以在同一个包内或子类中访问。
• public：公共，成员可以在任何地方访问。

示例：

public class Person {
    private String name; // 私有成员变量
    protected int age;   // 受保护成员变量
    public void setName(String name) {
        this.name = name;
    }
    public String getName() {
        return name;
    }
}

6.2 继承（extends 关键字、super 关键字、方法重写）

继承允许一个类从另一个类继承属性和方法，从而实现代码重用。

• extends 关键字：用于声明一个类继承自另一个类。
• super 关键字：用于调用父类的构造方法或父类的方法。
• 方法重写（Override）：子类可以重写父类的方法以提供新的实现。

示例：

public class Animal {
    public void eat() {
        System.out.println("This animal eats food");
    }
}

public class Dog extends Animal {
    @Override
    public void eat() {
        System.out.println("This dog eats bones");
    }
}

6.3 多态（方法重载、对象的多态性）

多态性允许一个接口被多种不同类型的对象实现，程序可以动态选择调用哪个方法实现。

• 方法重载（Overloading）：同一类中可以有多个同名方法，但它们的参数列表不同。
• 对象的多态性：一个父类的引用可以指向子类对象。

示例：

public class MathOperation {
    public int add(int a, int b) {
        return a + b;
    }
    
    public double add(double a, double b) {
        return a + b;
    }
}

Animal myDog = new Dog();
myDog.eat(); // 调用 Dog 类的 eat 方法

6.4 抽象类与抽象方法

抽象类是不能被实例化的类，可以包含抽象方法，这些方法必须在子类中实现。

• abstract 关键字：用于声明抽象类和抽象方法。
• 抽象方法：没有方法体，只在抽象类中声明。

示例：

public abstract class Animal {
    public abstract void makeSound(); // 抽象方法
}

public class Dog extends Animal {
    @Override
    public void makeSound() {
        System.out.println("Woof");
    }
}

6.5 接口（interface）

接口定义了一组方法，但不包含实现。类可以实现多个接口，从而支持多继承的特性。

• interface 关键字：用于声明接口。
• implements 关键字：用于实现接口。

示例：

public interface Animal {
    void eat();
    void sleep();
}

public class Dog implements Animal {
    @Override
    public void eat() {
        System.out.println("Dog eats");
    }

    @Override
    public void sleep() {
        System.out.println("Dog sleeps");
    }
}

第 7 章: 异常处理

7.1 异常的概念与分类

异常是程序在运行过程中发生的意外事件，通常是由程序错误或外部因素导致的。异常的处理是确保程序在发生错误时仍能正常运行的重要机制。

• 异常分类：
  • 检查型异常（Checked Exception）：必须在编译时处理的异常。常见于文件操作、网络通信等。例如：IOException。
  • 非检查型异常（Unchecked Exception）：包括运行时异常和错误。程序可以不显式处理此类异常。例如：NullPointerException。
  • 错误（Error）：通常是系统级别的问题，程序无法恢复。例如：OutOfMemoryError。

7.2 异常处理机制（try - catch - finally）

Java提供了 try - catch - finally 结构来处理异常，确保即使在异常发生时，程序也能继续运行或安全退出。

• try 块：包含可能发生异常的代码。
• catch 块：捕获并处理异常。
• finally 块：无论是否发生异常，都会执行的代码块。常用于释放资源。

示例：

try {
    // 可能发生异常的代码
    int result = 10 / 0;
} catch (ArithmeticException e) {
    // 处理异常
    System.out.println("Cannot divide by zero");
} finally {
    // 必定执行的代码
    System.out.println("This block is always executed");

7.3 自定义异常

有时，需要创建自定义异常来表示特定的错误情况。可以通过继承 Exception 类或 RuntimeException 类来实现。

示例：

public class CustomException extends Exception {
    public CustomException(String message) {
        super(message);
    }
}

// 使用自定义异常
public class Main {
    public static void main(String[] args) {
        try {
            throw new CustomException("This is a custom exception");
        } catch (CustomException e) {
            System.out.println(e.getMessage());
        }
    }
}

7.4 异常处理的最佳实践

• 提前捕获和处理异常：尽早在异常发生的位置处理它们。
• 提供有用的错误信息：异常信息应包含足够的信息，帮助调试和解决问题。
• 避免空捕获块：捕获异常后应采取适当的处理措施，不要忽略异常。
• 使用finally块释放资源：确保资源（如文件、数据库连接）在程序结束时得到释放。
• 抛出特定异常：不要使用过于宽泛的异常类型，应尽可能抛出特定的异常类型。