主要内容

• 继承
• 重写
• super关键字
• 组合
• final关键字
• 访问控制符
• 多态

笔记详情

1. 继承

在Java中，子类可以继承父类，获得父类所有的属性和方法（构造方法除外）。在Java中，只有单继承，没有像C++中的多继承，但是如果想要实现多继承，可以使用接口来完成。在定义一个类时，如果没有显式说明该类继承自哪一个类，那么它的父类是 java.lang.OBject 。下面给出继承的一个实例：

public class Animal {
    String name;

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

    public void eat() {
        System.out.println("吃吃");
    }
}

class Cat extends Animal { // Cat类继承自Animal类
    public void say() {
        System.out.println("喵喵");
    }

    public static void main(String[] args) {
        Cat Tom = new Cat();

        // 调用该类自身的方法
        Tom.say();

        // 调用该类继承的方法和属性
        Tom.name = "Tom";
        Tom.eat();
        System.out.println(Tom.name);
    }
}

2. 重写

子类中可以重新定义一个和父类中一模一样的方法，这样父类中的方法就会被覆盖掉，这就是重写。但是被覆盖的父类中的方法并没有消失，在子类中依然可以通过 super 引用来调用父类中被覆盖的方法。下面给出重写的一个实例：

public class Animal {
    String name;

    public void say() {
        System.out.println("我是动物，我的说话方式是：叫叫");
    }

    public void eat() {
        System.out.println("吃吃");
    }
}

class Cat extends Animal { // Cat类继承自Animal类
    // 重写父类中的方法
    public void say() {
        super.say();        // 通过super来调用父类中的方法
        System.out.println("我是动物，我的说话方式是：喵喵");
    }
}

3. super关键字

在Java的方法中，有两个默认的隐形参数：this和super。其中this指向的是当前的实例对象；super指向的是当前实例对象的直接父类对象。

我们可以通过super来调用父类对象中被覆盖的方法，同时在子类的构造函数中，也会自动在第一行中隐式使用 super() 调用父类的构造函数，来初始化父类对象。

4. 组合

在Java中，有一个和继承非常类似的概念：组合。使用组合也可以达到和使用继承相同的效果：实现代码的复用。下面给出一个实例：

public class Screen {
    int width;
    int height;

    public void setValue(int width, int height) {
        this.width = width;
        this.height = height;
    }

    public void showValue() {
        System.out.println("显示器的宽和高分别是：" + this.width + "  " + this.height);
    }

}

class Computer {
    // 电脑里面包含显示器，这里可以使用组合，在电脑类中定义一个显示器对象
    // 后面可以通过电脑对象里面的显示器对象，使用相应的属性和方法
    Screen sc = new Screen();

    String brand;
    double price;

    public static void main(String[] args) {
        Computer com = new Computer();

        com.sc.setValue(600, 800);
        com.sc.showValue();
    }
}

在Java中，继承和组合是非常类似的，且使用的频率都很高，至于使用哪一种方式，还要根据实际情况来定。如果是包含关系：比如电脑包含显示器，手机包含按键，汽车包含轮子等，使用组合的方式；如果是 是 的关系，比如猴子是动物，自行车是交通工具，智能手机是通讯仪器等，使用继承的方式。

5. final关键字

在Java中，final关键字可以用来修饰定义的变量、方法和类：

1. 修饰变量的时候，此变量就是一个常量，后面不能再修改变量数值。
2. 修改方法的时候，此方法不能被子类重写，但是可以被重载。
3. 修饰类的时候，此类不能有子类，不能被继承。比如String、Math类

访问控制符

访问控制符	同一个类	同一个包中	子类	所有类
private	可见
default	可见	可见
protect	可见	可见	可见
public	可见	可见	可见	可见

6. 多态

多态是面向对象的一个重要特性，主要是用来实现动态联编的，也即是说使用多态可以实现：程序的运行结果不是在编译期间决定的，而是在执行过程中决定的。使用多态可以提高程序的灵活性和扩展性，这在大型程序中很有用处。

实现多态的三个条件：继承、重写、父类引用指向子类对象。下面给出一个多态的实例：

public class Animal {
    public void voice() {
        System.out.println("普通动物的叫声");
    }
}

// 定义Cat类，继承自Animal类
class Cat extends Animal {
    public void voice() {
        System.out.println("喵喵喵");
    }
}

//定义Dog类，继承自Animal类
class Dog extends Animal {
    public void voice() {
        System.out.println("汪汪汪");
    }
}

//定义Pig类，继承自Animal类
class Pig extends Animal {
    public void voice() {
        System.out.println("哼哼哼");
    }
}

// 测试类
public class Test {

    public void testAnimalVoice(Animal a) {
        a.voice();
    }

    public static void main(String[] args) {
        Test test = new Test();
        
        // 父类引用指向子类对象，这里使用子类引用也是可以的
        Animal a = new Animal();
        Animal c = new Cat();
        Animal d = new Dog();
        Animal p = new Pig();

        test.testAnimalVoice(a);        // 普通动物的叫声
        test.testAnimalVoice(c);        // 喵喵喵
        test.testAnimalVoice(d);        // 汪汪汪
        test.testAnimalVoice(p);        // 哼哼哼
    }
}