主要内容

继承
重写
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关键字可以用来修饰定义的变量、方法和类：

修饰变量的时候，此变量就是一个常量，后面不能再修改变量数值。
修改方法的时候，此方法不能被子类重写，但是可以被重载。
修饰类的时候，此类不能有子类，不能被继承。比如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);        // 哼哼哼
    }
}

Java学习——day 04