java方法重写的好处_Java基础：继承

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()方法比较的是对象的引用，也就是对象的地址，所以两个对象是不同的！