主要内容
- 继承
- 重写
- 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); // 哼哼哼
}
}