3. 继承
3.1 Java中的继承
继承是类与类的一种关系，是一种“is a”的关系。
注意：Java中的继承是单继承，也就是说，一个类只有一个父类。
继承的好处有哪些？
- 子类拥有父类的所有属性和方法（关键字private修饰的属性和方法除外）
- 实现代码复用
继承的语法规则是什么？
class 子类 extends 父类
例如：
class Dog extends Animal{
......
}
下面来实践一下，实现一个简单的继承。
- 第一步：创建一个类 Animal
package com.example;
public class Animal {
public int age;
public String name;
public void eat() {
System.out.println("动物具有吃东西的能力！");
}
}
- 第二步：创建另一个类 Dog，让其继承自类Animal
package com.example;
public class Dog extends Animal {
}
这一步，在我们的子类中没有定义任何的变量和方法
- 第三步：main方法中实例化Dog类
package com.example;
public class Main {
public static void main(String[] args) {
// write your code here
Dog dog = new Dog(); // 实例化一个Dog对象
dog.age = 10;
dog.name = "huahua";
dog.eat();
}
}
运行一下看看，结果如下：
动物具有吃东西的能力！
我们看到，在这里我们实例化了一个子类对象，然而它也拥有了属性 age 和 name，以及方法eat()，这些属性和方法完全来自于其父类。
比如，我们将父类中的属性age改成private修饰后，测试类中的子类对象再次调用age属性时，编译器提示错误如下：
3.2 Java中的方法重写
如果子类对继承父类的方法不满意，是可以重写父类继承的方法的，当调用方法时会优先调用子类的方法。
方法重写的语法规则是什么？
- 返回值类型
- 方法名
- 参数类型及个数
以上这几点都要与继承父类的方法相同。同样，我们也来代码实践一下。
// 父类：Animal
package com.example;
public class Animal {
public int age;
public String name;
public void eat() {
System.out.println("动物具有吃东西的能力！");
}
}
// 子类：Dog
package com.example;
public class Dog extends Animal {
// 重写父类的eat()方法 [注意：返回类型/方法名/参数个数 都要与父类方法相同]
public void eat() {
System.out.println("狗具有吃东西的能力！");
}
}
// main方法
package com.example;
public class Main {
public static void main(String[] args) {
// write your code here
Dog dog = new Dog(); // 实例化一个子类Dog对象
dog.eat();
}
}
我们来看看程序运行结果，如下：
狗具有吃东西的能力！
从结果来看，方法重写后，优先调用的是子类本身重写后的方法。
3.3 Java中的继承初始化顺序
继承的初始化顺序是什么？
- 初始化父类，再初始化子类
- 先执行初始化对象中的属性，再执行构造方法中的初始化
说白了，初始化过程其实就是相当于执行类的构造方法。同样，我们也来代码实践一下。
首先在父类Animal中的构造方法中打印一句话，如下：
// 父类：Animal
package com.example;
public class Animal {
public int age;
public String name;
public void eat() {
System.out.println("动物具有吃东西的能力！");
}
// Animal类的无参构造方法
public Animal(){
System.out.println("Animal类执行了！");
}
}
然后，在子类Dog中的构造方法中同样也打印一句话，如下：
// 子类：Dog
package com.example;
public class Dog extends Animal {
// 重写父类的eat()方法 [注意：返回类型/方法名/参数个数 都要与父类方法相同]
public void eat() {
System.out.println("狗具有吃东西的能力！");
}
public Dog(){
System.out.println("Dog类执行了！");
}
}
然后，在main方法中只创建一个子类对象，如下：
// main方法
package com.example;
public class Main {
public static void main(String[] args) {
// write your code here
Dog dog = new Dog(); // 实例化一个子类Dog对象
}
}
接着，我们来执行一下程序，看看结果如下：
Animal类执行了！
Dog类执行了！
从上面的结果我们可以看到，。
3.4 Java中final的使用
final可以修饰 类/属性/方法/变量
- final 修饰类的时候，该类不允许被继承
- final 修饰方法的时候，该方法不允许被覆盖（重写）
- final 修饰属性的时候，该类的属性不会进行隐式的初始化（类的初始化属性必须要有值）或者在构造方法中赋值
- final 修饰变量的时候，该变量的值只能赋一次值，即变为常量
3.5 Java中super的使用
在对象内部使用，可以代表父类对象
既然super可以代表父类对象，就可以访问父类的属性，以及调用父类的方法。同样，我们也来代码实践一下。
// 父类：Animal
package com.example;
public class Animal {
public int age = 10;
public String name;
public void eat() {
System.out.println("动物具有吃东西的能力！");
}
// 父类的构造函数
public Animal(){
System.out.println("Animal类执行了！");
}
}
// 子类：Dog
package com.example;
public class Dog extends Animal {
public int age = 20;
//重写父类eat()方法
public void eat() {
System.out.println("狗具有吃东西的能力！");
}
// 子类的构造函数
public Dog() {
System.out.println("Dog类执行了！");
}
public void show() {
System.out.println("super关键字获取父类属性age："+ super.age); //使用super关键字获得父类的属性age
System.out.println("子类本身的属性age："+ age); // 获取子类本身的属性age
super.eat(); // 使用super关键字获取父类的方法
eat(); // 获取子类本身的方法
}
}
// main方法
package com.example;
public class Main {
public static void main(String[] args) {
// write your code here
Dog dog = new Dog(); // 实例化一个子类Dog对象
dog.show();
}
}
接着，我们来执行一下程序，看看结果如下：
Animal类执行了！
Dog类执行了！
super关键字获取父类属性age：10
子类本身的属性age：20
动物具有吃东西的能力！
狗具有吃东西的能力！
3.6 Java中object类
。Object类中的方法，适合所有子类。
3.6.1 toString()方法
在Object类里面定义toString()方法的时候返回的是 对象的哈希code码（对象地址字符串）。
可以通过重写 toString()方法 表示出对象的属性。
比如：在上面的代码中，如果我们在main方法中直接输出Dog对象，如下：
package com.example;
public class Main {
public static void main(String[] args) {
// write your code here
Dog dog = new Dog(); // 实例化一个子类Dog对象
// dog.show();
System.out.println(dog);
}
}
我们看到结果如下：
Animal类执行了！
Dog类执行了！
com.example.Dog@1b6d3586
显然，上面的输出不是我们满意的输出（因为不知道是啥意思，呜呜~）。如果我们想知道对象的属性值，这个时候就需要重写从父类继承过来的 **toString() **方法，如下：
// 子类：Dog
package com.example;
public class Dog extends Animal {
public int age = 20;
//重写父类eat()方法
public void eat() {
System.out.println("狗具有吃东西的能力！");
}
// 子类的构造函数
public Dog() {
System.out.println("Dog类执行了！");
}
public void show() {
System.out.println("super关键字获取父类属性age："+ super.age); //使用super关键字获得父类的属性age
System.out.println("子类本身的属性age："+ age); // 获取子类本身的属性age
super.eat(); // 使用super关键字获取父类的方法
eat(); // 获取子类本身的方法
}
@Override
public String toString() {
return "Dog [age=" + age + "]";
}
}
然后直接运行main()方法，结果如下：
Animal类执行了！
Dog类执行了！
Dog [age=20]
3.6.2 equals()方法
equals()方法：比较的是对象的引用是否指向同一块内存地址。
一般情况下，比较两个对象时，是比较的两个对象的值是否相同，所以要进行重写对象方法。
同样，我们还是来代码实践一下。父类和子类还是之前的Animal和Dog，我们只改变一下main方法，如下：
// main方法
package com.example;
public class Main {
public static void main(String[] args) {
// write your code here
Dog dog1 = new Dog(); // 实例化一个Dog对象
dog1.age = 15;
Dog dog2 = new Dog();
dog2.age = 15;
if(dog1.equals(dog2)) {
System.out.println("两个对象是相同的！");
}else {
System.out.println("两个对象是不相同的！");
}
}
}
我们来看看运行结果，如下：
Animal类执行了！
Dog类执行了！
Animal类执行了！
Dog类执行了！
两个对象是不相同的！
从上面的运行结果，我们看到，虽然两个对象的属性age值时一样的，但通过equals方法比较的结果是 “两个对象是不相同的！” 这是因为实例化两个对象的过程，实际上是在内存中开辟两个内存地址，分别存放两个实例化对象，而equals()方法比较的是对象的引用，也就是对象的地址，所以两个对象是不同的！