学习目录：

  1. Java的注释
  2. Java对象和类

一. Java 注释

注释不会被运行出来，用于源代码中解释代码的作用

  1. 单行注释 ：//
  2. 多行注释： /* 注释开始，*/ 注释结束
  3. 文档注释 ：/** 注释开始， */ 注释结束
1
2
3
4
5
6
7
8
9
10
11
int i = 36
    // 这是一个单行注释
    flag={}
    /* 现在这个
    是个多行注释
    */
int a = 55
    /** 这个
    *是个文档注释
    *它通常包含有关类、方法或字段的详细信息
    */

二. Java 对象和类

1、类（Class）：定义对象的蓝图，包括属性和方法

2、对象（Object）：类的实例，具有状态和行为。

例：

1
2
3
4
5
6
Car myCar = new Car()
  /*Car 表示一个类，
  声明变量名 mycar，用来引用 `Car` 类的一个对象实例, 
  new Car()：调用 `Car` 类的构造方法，创建一个新的 `Car` 类对象，并将其赋值给变量 `myCar`
  */

3、继承（Inheritance）：一个类可以继承另一个类的属性和方法

1
2
3
4
5
6
7
public class Dog extends Animal { ... }
 // 定义一个名为 Dog 的类，继承自 Animal 类
  /*  public：访问修饰符，表示该类是公共的，可以在任何地方被访问。
    class Dog：定义一个名为 Dog 的类。
    extends Animal：表示 Dog 类继承自 Animal 类。也就是说，Dog 类将会拥有 Animal 类的所有属性和方法（除非它们被 Dog 类重新定义或修改）。这是面向对象编程中的“继承”概念。
    { ... }：类的主体部分，包含类的具体实现（例如字段、方法等）
    */

4、封装（Encapsulation）：将对象的状态（字段）私有化，通过公共方法访问。

1
2
3
4
private String name; 
// private 访问修饰符，外部不能直接访问
public String getName() { return name; }
// public 访问修饰符，外部可以直接访问

私有字符串变量 name 和一个公共的 getter 方法 getName() 用来获取该变量的值

get 是 getter 方法的常见命名约定

5、方法

1
2
3
public void displayInfo() { // 方法体
    System.out.println("Info");
}

定义了一个公共方法 displayInfo，该方法不接收任何参数，执行/被调用时会输出字符串 "Info" 到控制台。

6、多态（Polymorphism）：对象可以表现为多种形态，主要通过方法重载和方法重写实现。

A、方法重载：指的是在同一个类中，方法名相同，但参数列表不同（可以是参数的类型、数量或顺序不同）

1
2
3
4
5
6
7
public int add(int a, int b) { 
    // 方法体 ，add 方法接受两个整数 (int 类型) 参数并返回一个整数结果。
}

public double add(double a, double b) { 
    // 方法体，add 方法接受两个浮点数 (double 类型) 参数并返回一个浮点数结果。
}

示例：方法重载

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public class Main {
  static int add(int x, int y) {
    return x + y;
  }
  
  static double add(double x, double y) {
    return x + y;
  }
  
  public static void main(String[] args) {
    int myNum1 = add(8, 5);
    double myNum2 = add(5.3, 9.56);
    System.out.println("int: " + myNum1);
    System.out.println("double: " + myNum2);
  }
}

重载了 add 方法，使其可以同时处理 int 和 double 类型。

B、方法重写：是子类重新实现父类的方法，用自己的方式定义行为。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
// 父类 Animal
class Animal {
    // 父类中的方法
    public void makeSound() {
        System.out.println("Animal makes a sound");
    }
}

// 子类 Cat 继承自 Animal
class Cat extends Animal {
    // 重写父类的 makeSound 方法
    @Override // @Override 注解表示你正在重写父类中的方法。
    public void makeSound() {
        // makeSound 是一个方法的名称，它在父类中可能已经定义过，而在子类中重新定义其行为。
        System.out.println("Meow");
    }
}

// 子类 Dog 继承自 Animal
class Dog extends Animal {
    // 重写父类的 makeSound 方法
    @Override  // @Override 注解表示你正在重写父类中的方法。
    public void makeSound() {
        System.out.println("Bark");
    }
}

7、抽象类：提供了类的基本框架，可以包含抽象方法（没有实现的方法）和具体方法（有实现的方法。

  • 抽象类不能实例化，必须通过继承来实现其抽象方法。
  • 抽象方法没有方法体，表示“类的行为在子类中定义”，子类必须提供该方法的具体实现。
1
2
3
4
5
public abstract class Shape {
    // 声明了一个 Shape 类，并使用 abstract 关键字标记它为抽象类
    abstract void draw();
    // 这是一个抽象方法。
}

上述代码解释：

  • 这个抽象类 Shape 代表了一个“形状”，它有一个抽象方法 draw()，表示绘制形状的行为。
  • 由于 draw() 是抽象方法，任何继承 Shape 的类都必须实现这个方法，具体地定义如何“绘制”该形状（如绘制圆形、方形等）。

8、接口：定义了一组必须实现的方法，是一种更为严格的规范，任何类实现了接口就必须实现接口中声明的所有方法。

  • 接口是一个完全抽象的类型，它只能包含抽象方法（在 Java 8 之后可以有默认方法和静态方法，但抽象方法是接口的核心）。
  • 接口定义了类应当遵循的一组规则。
1
2
3
4
5
public interface Animal {
    // 声明了一个 Animal 接口
    void eat();
    // 这是一个没有方法体的抽象方法。
}

上述代码解释：

  • 这个接口 Animal 定义了一个 eat() 方法，表示所有实现该接口的类都应该有“吃”这个行为。

  • 接口中的方法默认是 public 和 abstract（抽象的） 的，因此我们不需要显式地使用 public 或 abstract 关键字来声明方法。

  • 任何实现了 Animal 接口的类（例如 Dog、Cat）都必须实现 eat() 方法。

    示例：

    假设有一个 Dog 类实现了 Animal 接口，和 Circle 类继承自 Shape 抽象类，代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
// 实现 Animal 接口的类
class Dog implements Animal { // class Dog 声明了一个类Dog，定义狗的一个行为, Dog 类实现了 Animal 接口
    @Override // 重写父类 eat
    public void eat() { // eat() 方法的名字
        System.out.println("Dog is eating");
    }
}

// 继承 Shape 抽象类的类
class Circle extends Shape { // class Circle 声明了一个类circle，表示一个圆
    @Override // extends shape 表示Circle类继承了抽象类Shape
    void draw() { // 方法draw()重写 
        System.out.println("Drawing a circle");
    }
}

public class Main {
    public static void main(String[] args) {
// 创建 Dog 对象并调用 eat 方法:
        Animal dog = new Dog();
        dog.eat();
        // Animal：声明一个Animal类型的变量dog，这意味着dog变量可以引用任何实现了Animal接口的对象。
        //dog = new Dog():使用new Dog()创建了一个 Dog 类的实例，并将它赋值给 dog 变量。
        // 调用 dog 对象的 eat() 方法，会执行 Dog 类中的 eat() 方法，输出 "Dog is eating"
// 创建 Circle 对象并调用 draw 方法:
        Shape circle = new Circle();
        circle.draw(); 
       // Shape：声明一个 Shape 类型的变量 circle，这意味着 circle 变量可以引用任何继承了 Shape 类的对象。
       // circle = new Circle()：使用 new Circle() 创建了一个 Circle 类的实例，并将它赋值给 circle 变量。
       // 调用 circle对象的 draw() 方法，将执行，输出：“Drawing a circle”
    }
}