面向对象基础(Java)

方法

public、private

private 使用 method 来间接赋值
SetNum()
GetNum()
this.x = x;
传入数组类型 (String[] names)

方法可以让外部代码安全地访问实例字段
方法是一组执行语句，并且可以执行任意逻辑
方法内部遇到return返回
外部代码通过public方法操作实例，内部代码通过调用private方法

可变参数

相当于数组类型

class Group {
    private String[] names;
    public void setNames(String... names) {
        this.names = names;
    }
}

Group g = new Group();
g.setNames("Xiao Ming", "Xiao Hong", "Xiao Jun"); // 传入3个String
g.setNames("Xiao Ming", "Xiao Hong"); // 传入2个String
g.setNames("Xiao Ming"); // 传入1个String
g.setNames(); // 传入0个String

如果把可变参数改为String[]类型，则传参的时候比较麻烦，需要自己构造String[]先。

class Group {
    private String[] names;

    public void setNames(String[] names) {
        this.names = names;
    }
}
Group g = new Group();
g.setNames(new String[] {"Xiao Ming", "Xiao Hong", "Xiao Jun"}); // 传入1个String[]

构造方法

没有构造方法时，编译器会自动生成一个默认构造方法，构造方法名称与类名一样。
如果既要使用带参数的构造方法，又想保留不带参数的构造方法，那么只能把两个构造方法都定义出来

public class Main {
    public static void main(String[] args) {
        Person p1 = new Person("Xiao Ming", 15); // 既可以调用带参数的构造方法
        Person p2 = new Person(); // 也可以调用无参数构造方法
    }
}

class Person {
    private String name;
    private int age;

    public Person() {
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    
    public String getName() {
        return this.name;
    }

    public int getAge() {
        return this.age;
    }
}

其实也可以定义只有一个参数的构造方法，有点重载的感觉，即多构造方法

方法重载

在一个类中，我们可以定义多个方法。如果有一系列方法，它们的功能都是类似的，只有参数有所不同，那么，可以把这一组方法名做成同名方法。

class Hello {
    public void hello() {
        System.out.println("Hello, world!");
    }

    public void hello(String name) {
        System.out.println("Hello, " + name + "!");
    }

    public void hello(String name, int age) {
        if (age < 18) {
            System.out.println("Hi, " + name + "!");
        } else {
            System.out.println("Hello, " + name + "!");
        }
    }
}

继承

继承是面向对象编程中非常强大的一种机制，它首先可以复用代码。子类自动获得了父类的所有字段，严禁定义与父类重名的字段。

Java使用extends关键字来实现继承
超类、父类、基类是同一个，子类、扩展类是同一个
Java只允许一个class继承一个类，一个类只有一个父类
子类无法访问父类的private或者private方法
为了让子类可以访问，需要把private改为protected，一个protected字段和方法可以被子类和子类的子类访问
子类引用父类的字段时，可以用super.()
子类不会继承任何父类的构造方法

class Student extends Person {
    protected int score;

    public Student(String name, int age, int score) {
        super(name, age);
        // 调用父类的构造方法Person(String, int)
        this.score = score;
    }
}

向上转型和向下转型

Student是从Person继承下来的，那么一个引用类型为Person的变量，能否只想Student类型的实例

Person p = new Student();

把一个子类类型变为父类类型的赋值，称为向上转型。
向上转型实际上是把一个子类变为更抽象的父类，安全。
向上转型时，父类指向子类引用对象会遗失除与父类对象共有的其他方法，也就是在转型过程中，子类的新有的方法都会遗失掉，在编译时，系统会提供找不到方法的错误。
一个父类类型强制转型为子类类型，就是向下转型。
向下转型，恢复了子类的成员变量以及方法。

Person p1 = new Student(); // upcasting, ok
Person p2 = new Person();
Student s1 = (Student) p1; // ok
Student s2 = (Student) p2; // runtime error! ClassCastException!

多态

override和overload不同的地方。override是重载，如果方法类型和参数不一样就是overload

public class Main {
    public static void main(String[] args) {
        Person p = new Student();
        p.run(); // 应该打印Person.run还是Student.run?
    }
}

class Person {
    public void run() {
        System.out.println("Person.run");
    }
}

class Student extends Person {
    @Override
    public void run() {
        System.out.println("Student.run");
    }
}

//打印的是Student.run

Java的实例方法调用是基于运行时的实际类型的动态调用，而非变量的声明类型。即调用的是Student的run()方法
多态指针对某个类型的方法调用，其真正执行的方法取决于运行时期实际类型的方法。
在子类的覆写方法中，如果要调用父类的被覆写的方法，可以通过super来调用
继承可以允许子类覆写父类的方法。如果一个父类不允许子类对它的某个方法进行覆写，可以把该方法标记为final。用final修饰的方法不能被Override
如果一个类不希望任何其他类继承自它，那么可以把这个类本身标记为final。用final修饰的类不能被继承
可以在构造方法中初始化final字段

class Person {
    public final String name;
    public Person(String name) {
        this.name = name;
    }
}

这样name被赋值后就不能被修改。

抽象类

如果父类方法本身不需要实现任何功能，仅是定义方法签名，目的是让子类去覆写，这就是抽象方法
abstract class Person 抽象类
抽象类不能被实例，Persion p = new Person()错误

接口

如果一个抽象类没有字段，所有方法全部是抽象方法，就可以把该抽象类改写为接口interface。

在抽象类中，抽象方法本质上是定义接口规范：即规定高层类的接口，从而保证所有子类都有相同的接口实现，这样，多态就能发挥出威力。

abstract class Person {
    public abstract void run();
    public abstract String getName();
}

interface Person {
    void run();
    String getName();
}

所谓interface，就是比抽象类还要抽象的纯抽象接口，因为它连字段都不能有。因为接口定义的所有方法默认都是public abstract的，所以这两个修饰符不需要写出来（写不写效果都一样）。
当一个具体的class去实现一个interface时，需要使用implements关键字

class Student implements Person {
    private String name;

    public Student(String name) {
        this.name = name;
    }

    @Override
    public void run() {
        System.out.println(this.name + " run");
    }

    @Override
    public String getName() {
        return this.name;
    }
}

implements用于接口。在Java中，一个类只能继承另一个类，不能从多个类继承。但是一个类可以实现多个interface。

class Student implements Person, Hello { // 实现了两个interface
    ...
}

一个interface可以继承自另一个interface。interface继承自interface使用extends，它相当于扩展了接口的方法
实现类可以不必覆写default方法。default方法的目的是，当我们需要给接口新增一个方法时，会涉及到修改全部子类。如果新增的是default方法，那么子类就不必全部修改，只需要在需要覆写的地方去覆写新增方法。

静态字段和静态方法

静态字段static field。静态字段只有一个共享空间，所有变量的静态字段共享一个空间。比如两个对象a,b a.x和b.x是一样的假设x是static

静态方法

调用静态方法不需要实例变量，通过类名就可以调用。

public class Main {
    public static void main(String[] args) {
        Person.setNumber(99);
        System.out.println(Person.number);
    }
}

class Person {
    public static int number;

    public static void setNumber(int value) {
        number = value;
    }
}

因为静态方法属于class而不属于实例，因此，静态方法内部，无法访问this变量，也无法访问实例字段，它只能访问静态字段。
静态方法常用于工具类，例如Arrays.sort()和Math.random()

接口的静态字段

因为interface是一个纯抽象类，所以它不能定义实例字段。但是，interface是可以有静态字段的，并且静态字段必须为final类型

public interface Person {
    public static final int MALE = 1;
    public static final int FEMALE = 2;
}

classpath和jar

classpath是JVM用到的一个环境变量，它用来指示JVM如何搜索class
jar包就是用来干这个事的，它可以把package组织的目录层级，以及各个目录下的所有文件（包括.class文件和其他文件）都打成一个jar文件，这样一来，无论是备份，还是发给客户，就简单多了。
jar包还可以包含一个特殊的/META-INF/MANIFEST.MF文件，MANIFEST.MF是纯文本，可以指定Main-Class和其它信息。JVM会自动读取这个MANIFEST.MF文件，如果存在Main-Class，我们就不必在命令行指定启动的类名，而是用更方便的命令

模块

如果漏写了某个运行时需要用到的jar，那么在运行期极有可能抛出ClassNotFoundException
从Java 9开始引入的模块，主要是为了解决“依赖”这个问题。如果a.jar必须依赖另一个b.jar才能运行，那我们应该给a.jar加点说明啥的，让程序在编译和运行的时候能自动定位到b.jar，这种自带“依赖关系”的class容器就是模块。
这些模块以.jmod扩展名标识，可以在$JAVA_HOME/jmods目录下找到它们
模块之间的依赖关系已经被写入到模块内的module-info.class文件了。所有的模块都直接或间接地依赖java.base模块，只有java.base模块不依赖任何模块，它可以被看作是“根模块”，好比所有的类都是从Object直接或间接继承而来。