类的五大成员：属性、方法、构造器、代码块、内部类

1. 定义

1.1 完整的类定义

1
2
3
类声明
    成员变量声明（可有多个）
    方法定义及事项（可有多个）
1
2
3
4
5
6
[public][abstract | final] class className [extends superclassName] [implements InterfaceNameList]{
    [public | protected | private][static][final][transient][volatile] type variableName
    [public | protected | private][static][final | abstract][native][synchronized] returnType methodName ([paramList]) [throws exceptionList]{
        statement;
    }
}

1.2. 完整的Java源文件

源文件的名称必须与属性为 public 的类的类名完全相同

在一个.java 文件中，package 语句和 public 类最多只能有一个

1
2
3
4
指定文件中的类所在的包，0个或1个
指定引入的类，0个或多个
属性为public的类定义，0个或1个
接口或类定义，0个或多个
1
2
3
4
package packageName;
import packageName.[className | *];
public classDefinition
interfaceDefinition and classDefinition

2. 常用访问修饰符

Java中有四种常用的访问修饰符

  • default（默认，即什么也不写的时候就自动加上）：在同一包内可见。可以使用的对象：类、接口、变量、方法。
  • private：在同一类中可见。可以使用的对象：变量、方法、内部类。
  • public：对所有类可见。可以使用的对象：类、接口、变量、方法。
  • protected：对同一包内的类和所有子类可见。可以使用的对象：变量、方法、内部类。

访问权限如下表：

修饰符 当前类 同一包内 子孙类（同一包） 子孙类（不同包） 其他包
default Y Y Y N N
private Y N N N N
protected Y Y Y Y/N N
public Y Y Y Y Y

对于 protected ：

  • 基类的 protected 是包内可见的，并且子类也是可见的
  • 若子类和基类不在同一包中，那么在子类中，子类实例可以访问其从基类继承而来的 protected 方法，而不能访问 基类的 对象实例中的 受protected约束的方法

3. 继承

3.1 this 和 super

this 关键字的作用：

  • this 调用本类中的属性和方法
  • this 调用本类中的其他构造器
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
public class Father {
    private String name;
    private int age;
    private char sex;

    public Father() { }

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

    public Father(String name, int age) {
        this(name);
        this.age = age;
    }

    public Father(String name, int age, char sex) {
        this(name, age);
        this.sex = sex;
    }

    public void test() {
        this.check();
    }

    public void check() { }
}

super 关键字的作用：

  • super 调用基类中的非私有属性和方法
  • super 调用父类中的构造器，在构造函数中使用super时，super只能放在第一句
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
class Son extends Father {
    private String name;

    public Son() {
        super();
    }

    public Son(String name) {
        super(name);
    }

    void check01() {
        super.check();
        super.test();
    }
}

注意：虽然 super 和 this 用法相似，但是他们并不是一个概念。this 实际上是对当前对象的引用，而 super 并不是对一个对象的引用，他只是一个指示编译器调用超类方法的特殊关键字。

1
2
Father father = this; //right
Sun sun = super;      //error

3.2 方法重写（override）

注意事项和使用细节：

方法重写也叫方法覆盖，需要满足下列条件

  1. 子类的方法的参数，方法名称，要和父类方法的参数，方法名称完全一样。
  2. 子类方法的返回类型和父类方法返回类型一样，或是父类返回类型的子类。比如父类方法返回类型是Object，子类方法返回类型是String。
  3. 子类方法不能缩小父类方法的访问权限。

4. 多态

4.1 类的多态

  1. 一个对象的编译类型可以和运行类型不一致。
  2. 编译类型在创建时就确定了，不能改变。
  3. 运行类型可以变化。
  4. =左边是编译类型，=右边是运行类型。

可以用二元运算符 instanceof 判断运行类型。

4.2 动态绑定

Java 具有动态绑定机制

  1. 当调用对象方法的时候，该方法会和该对象的内存地址/运行类型绑定
  2. 当调用对象属性的时候，没有动态绑定机制，哪里声明就在哪里使用

即：方法有动态绑定机制，属性没有动态绑定机制

5. 抽象类

抽象类使用 abstract 关键词修饰，它的基本功能依旧存在，成员变量、成员方法和构造方法的访问方式和普通类一样。抽象类不能实例化对象，必须被继承才能被使用。包含抽象方法的类就是抽象类。

书写格式：

1
2
3
4
5
6
7
8
//抽象类格式
public abstract class 类名{
    
}

//抽象方法格式
public abstract 返回值类型 方法名(参数);
public abstract void eat(int num);