工欲善其事，必先利其器，在入门Java安全的时候，必须再过一遍基础知识

1. Java 方法

Java 方法是一种面向对象的函数，它可以接收参数并返回结果。主方法（main）也是一种特殊的 Java 方法，是程序的入口点。

1
2
public static void main(String[] args){
}

Java 方法的调用

我们可以通过三种方式调用 Java 方法：静态方法、非静态方法和构造方法。

  • 静态方法 (static): 静态方法可以直接使用，无需实例化对象。如果是在同一个文件中，可以直接调用。如果不是在同一个文件中，可以通过 对象名.方法名 的方式调用。
  • 非静态方法: 非静态方法需要先实例化对象，也就是使用 new 关键字创建对象。
  • 构造方法: 构造方法是一种特殊的方法，用于创建和初始化对象。它的名称与类名相同。

方法的重载 (Overloading)

在 Java 中，我们可以创建多个名称相同但参数列表不同的方法，这被称为方法的重载。重载的方法必须具有不同的参数类型，参数数量可以不同，参数顺序也可以不同。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public class OverloadExample {
    // 方法一：无参数
    public void display() {
        System.out.println("Display without parameters");
    }
    // 方法二：一个参数
    public void display(String msg) {
        System.out.println("Display with one parameter: " + msg);
    }
    // 方法三：两个参数
    public void display(String msg, int times) {
        for (int i = 0; i < times; i++) {
            System.out.println("Display with two parameters: " + msg);
        }
    }
}

例如以上代码，在invoke调用的时候需要指定方法名称和参数类型来调用指定的方法

2. Java 类

在 Java 中，.class 文件代表一个类。类是对象的模板或蓝图，包含了对象的属性和方法。对象是基于类创建的实例。

3. Java 对象

Java 对象是基于类创建的实例。我们使用 new 关键字创建对象，如 Person per = new Person();。

类的继承

在 Java 中，一个类可以继承另一个类的字段和方法。我们可以使用 extends 关键字来继承类。如果一个类没有明确地继承一个父类，那么它将自动继承 Object 类，成为 Object 的子类。

具体看这篇

Java 继承 | 菜鸟教程

方法的重写和重载

在 Java 中，子类可以提供一个与父类方法声明相同的方法，这被称为方法的重写。重写的方法必须具有相同的名称、参数列表和返回类型。

Java 重写(Override)与重载(Overload) | 菜鸟教程

抽象类

在 Java 中，抽象类是一种不能被实例化的特殊类，只能被继承。抽象类可以包含抽象方法（无具体实现）和非抽象方法（有具体实现）。

例如，我们可以创建一个名为 Animal 的抽象类，这个类包含一些普通方法和抽象方法，如下所示：

1
2
3
4
5
6
7
8
9
10
11
12
13
public abstract class Animal {
    private String name;
    public Animal(String name) {
        this.name = name;
    }
    // 非抽象方法
    public void eat() {
        System.out.println(name + " is eating.");
    }
    // 抽象方法
    public abstract void sound();
}

在这个例子中，Animal 类是抽象的，它有一个非抽象方法 eat() 和一个抽象方法 sound()。eat() 方法有具体的实现，而 sound() 方法没有具体的实现，需要子类来提供实现。

现在，我们可以创建一个 Animal 的子类 Dog，并实现 sound() 方法：

1
2
3
4
5
6
7
8
9
10
11
12
public class Dog extends Animal {
    public Dog(String name) {
        super(name);
    }

    // 实现父类的抽象方法
    @Override
    public void sound() {
        System.out.println("The dog barks");
    }
}

在这个例子中，Dog 类继承了 Animal 类，并提供了 sound() 方法的具体实现。现在，我们可以创建一个 Dog 的对象，并调用其方法：

1
2
3
4
5
6
7
8
public class Main {
    public static void main(String[] args) {
        Dog dog = new Dog("Tommy");
        dog.eat(); // 输出: Tommy is eating.
        dog.sound(); // 输出: The dog barks
    }
}

这就是抽象类的基本使用方式。通过定义抽象类和抽象方法，我们可以设计出更加通用和灵活的代码结构。

接口

上面的代码用到了接口

在 Java 中，接口是一种完全抽象的类型，它定义了一些方法，这些方法由实现接口的类来提供具体的实现。接口中的所有方法默认都是 public 和 abstract 的，所有变量默认都是 public、static 和 final 的。

下面是一个接口的例子：

1
2
3
4
5
6
7
8
public interface Flyable {
    // 接口中的变量默认是 public、static 和 final 的
    int MAX_SPEED = 100;
    // 接口中的方法默认是 public 和 abstract 的
    void fly();
    void land();
}

在这个例子中，Flyable 接口定义了两个方法：fly() 和 land()。任何实现 Flyable 接口的类都需要提供这两个方法的具体实现。

下面是一个实现 Flyable 接口的类的例子：

1
2
3
4
5
6
7
8
9
10
11
12
public class Bird implements Flyable {
    @Override
    public void fly() {
        System.out.println("The bird is flying.");
    }

    @Override
    public void land() {
        System.out.println("The bird is landing.");
    }
}

在这个例子中，Bird 类实现了 Flyable 接口，提供了 fly() 方法和 land() 方法的具体实现。

接口可以被用来实现多态。例如，我们可以定义一个方法，它接受一个 Flyable 参数：

1
2
3
4
public void letItFly(Flyable f) {
    f.fly();
}

然后，我们可以传入任何实现了 Flyable 接口的对象：

1
2
3
Bird bird = new Bird();
letItFly(bird);  // 输出: The bird is flying.

这就是接口的基本用法。通过定义接口，我们可以规定一组方法，然后由不同的类来提供具体的实现，这样就可以实现多态，提高代码的灵活性和可重用性。