Java中的继承

拼搏现实的明天。 2023-10-09 18:25 9阅读 0赞

### 继承 ###

#### 1.为什么要有继承 ####

继承是面向对象编程的重要概念之一，它允许一个类（子类）继承另一个类（父类）的属性和方法。**继承的主要目的是代码复用和扩展性，通过继承可以避免重复编写相同的代码，同时可以在保留原有功能的基础上，扩展新的功能。**

#### 2.什么是继承 ####

继承是面向对象编程中的一种机制，**它允许一个类（子类）继承另一个类（父类）的属性和方法。子类可以继承父类的公共方法和属性，也可以重写父类的方法和属性**。继承的关系可以形成一个类的层次结构，其中子类继承了父类的所有属性和方法，还可以添加自己的新属性和方法。

#### 3.代码示例 ####

public class Animal {
        
        private String name;
        private int age;
    
        public Animal(String name, int age) {
        
            this.name = name;
            this.age = age;
        }
    
        public void eat() {
        
            System.out.println(name + " is eating");
        }
    
        public void sleep() {
        
            System.out.println(name + " is sleeping");
        }
    }
    
    public class Dog extends Animal {
        
        public Dog(String name, int age) {
        
            super(name, age);
        }
    
        public void bark() {
        
            System.out.println(getName() + " is barking");
        }
    }
    public class Test {
        
        public static void main(String[] args) {
        
            Animal animal = new Animal("Tommy", 5);
            animal.eat();
            animal.sleep();
    
            Dog dog = new Dog("Charlie", 3);
            dog.eat();
            dog.sleep();
            dog.bark();
        }
    }

解释说明:  
这个例子中，Animal类是父类，Dog类是子类。Dog类继承了Animal类的属性和方法，并添加了自己的方法bark。  
在Dog类中，使用super关键字调用父类的构造方法，以便初始化父类的属性。在bark方法中，使用getName方法获取父类的name属性。

通过这个例子，你可能对Java继承有一定的认知

现在对这个例子进行详细的解释说明

#### 4.语法说明 ####

1.在Java中要表示类之间的继承关系，需要借助extends关键字，具体如下:

> `修饰符 class 子类 extends 父类{ //...}`

就像代码示例中的

public class Dog extends Animal {
        
    }

2.子类将会把父类的成员变量或者成员方法继承到子类中

就像代码示例中的在Test类中。dog可以调用dog.eat()，dog.sleep()；在dog这个类中并没有写这个方法，而是继承父类 Animal的方法

public class Test {
        
        public static void main(String[] args) {
        
            Animal animal = new Animal("Tommy", 5);
            animal.eat();
            animal.sleep();
    
            Dog dog = new Dog("Charlie", 3);
            dog.eat();
            dog.sleep();
            dog.bark();
        }
    }

3.子类继承父类之后，新添加自己特有的成员

在代码示例中，Dog类添加了自己特有的方法bark()

public class Dog extends Animal {
        
        public Dog(String name, int age) {
        
            super(name, age);
        }
    
        public void bark() {
        
            System.out.println(getName() + " is barking");
        }
    }

#### 5.父类成员访问 ####

1.子类中访问父类的成员变量

a.子类和父类不存在同名成员变量，子类可以直接访问父类的成员变量

public class Animal {
        
        protected String name;
    }
    
    public class Dog extends Animal {
        
        public void printName() {
        
            System.out.println(name);
        }
    }

b.子类和父类成员变量同名，子类可以通过super关键字来访问父类的成员变量

public class Animal {
        
        protected String name;
    }
    
    public class Dog extends Animal {
        
        protected String name;
    
        public void printName() {
        
            System.out.println(name);
            System.out.println(super.name);
        }
    }

> 总结:  
> **在子类方法中或者子类对象访问成员时:**  
> 1.如果访问的成员变量子类中有，则优先访问自己的成员变量  
> 2.如果访问的成员变量子类中无，则访问父类继承下来的。如果父类也没有定义，则编译报错  
> 3.如果访问的成员变量与父类成员变量同名，则优先访问自己的，并且子类可以通过super关键字来访问父类的成员变量

**成员变量访问遵循就近原则，自己有，优先自己的的，如果没有，则向父类中找。**

2.子类中访问父类的成员方法

a.子类和父类成员方法名字不同，子类可以直接调用父类的成员方法

public class Animal {
        
        public void eat() {
        
            System.out.println("Animal is eating");
        }
    }
    
    public class Dog extends Animal {
        
        public void printEat() {
        
            System.out.println("Dog is eating");
        }
    }

b.子类和父类成员方法名字相同，子类可以通过重写父类的方法来实现不同的功能

public class Animal {
        
        public void eat() {
        
            System.out.println("Animal is eating");
        }
    }
    
    public class Dog extends Animal {
        
        @Override
        public void eat() {
        
            System.out.println("Dog is eating");
        }
    }

> 总结:  
> 1.通过子类对象访问父类与子类中不同名方法时，优先在子类中找，找到则访问，否则在父类中找，找到则访问，否则编译报错。  
> 2.通过派生类(子类)对象访问父类与子类同名方法时，如果父类和子类同名方法的参数列表不同(重载)，根据调用方法适传递的参数选择合适的方法访问，如果没有则报错；  
> 3.子类可以通过重写父类的方法来实现不同的功能

前面多次提到，如果子类和父类成员变量或成员方法同名，则可以通过super关键字来访问父类中的成员变量或成员方法，那么什么是super关键字呢?

#### 5.Super关键字 ####

1.为什么要有super关键字

在Java中，子类可以继承父类的属性和方法，**当子类需要访问父类中的成员变量或成员方法时，就需要使用super关键字。**

2.super关键字的定义

super关键字是Java中的一个关键字，表示父类对象的引用，**可以通过super关键字来调用父类的构造方法、成员方法和成员变量。**

3.super关键字的作用

1.调用父类的构造方法，以便初始化父类的属性  
2.访问父类中的成员变量  
3.调用父类中的成员方法  
4.在子类中重写父类中的成员方法时，可以使用super关键字来调用父类中的成员方法

4.代码案例

public class Animal {
        
        protected String name;
    
        public Animal(String name) {
        
            this.name = name;
        }
    
        public void eat() {
        
            System.out.println(name + " is eating");
        }
    }
    
    public class Dog extends Animal {
        
        private int age;
    
        public Dog(String name, int age) {
        
            //使用super关键字调用父类的构造方法
            super(name);
            this.age = age;
        }
    
        public void bark() {
        
            //使用super关键字访问父类中的成员变量
            System.out.println(super.name + " is barking");
        }
    
        @Override
        public void eat() {
        
            //使用super关键字调用父类中的eat方法
            super.eat();
            System.out.println(name + " is also eating bones");
        }
    }

在上面的代码中，Dog类继承了Animal类，并使用super关键字调用了父类的构造方法，以便初始化父类的属性。在bark方法中，子类使用super关键字访问了父类中的成员变量。在eat方法中，子类重写了父类的方法，并使用super关键字调用了父类中的eat方法。

> 注意事项:`在这里插入代码片`
> 
> 1.  super关键字只能在非静态方法中使用
> 2.  在子类方法中，super关键字访问父类的成员变量和方法。

#### 6.子类构造方法 ####

**子类对象构造时，需要先调用基类构造方法，再执行子类的构造方法**

public class Base {
        
        public Base() {
        
            System.out.println("Base()");
        }
    
        public class Derived extends Base {
        
            public Derived() {
        
                // super(); 
                System.out.println("Derived()");
            }
        }
    
        public class Test {
        
            public static void main(String[] args) {
        
                Derived d = new Derived();
            }
        }

> **注意事项:**

1.  若父类显式定义无参或者默认的构造方法，在子类构造方法第一行默认有隐含的super()调用，即调用父类构造方法

public class Derived extends Base {
        
           public Derived() {
        
               // super(); 
               System.out.println("Derived()");
           }
       }

1.  如果父类构造方法是带有参数的，此时需要用户为子类显式定义构造方法，并在子类构造方法中选择合适的父类构造方法调用，否则编译失败。

例如在super关键字的代码案例中

public Dog(String name, int age) {
        
            //使用super关键字调用父类的构造方法
            super(name);
            this.age = age;
        }

1.  在子类构造方法中，super(…)调用父类构造时，必须是子类构造函数中第一条语句。
2.  super(…)只能在子类构造方法中出现一次，并且不能和this同时出

#### 7.在继承关系下的初始化 ####

class Animal {
        
        String name;
        static int numAnimals;
    
        static {
        
            numAnimals = 0;
            System.out.println("Animal 静态代码块执行");
        }
    
        {
        
            System.out.println("Animal 实例代码块执行");
        }
    
        Animal(String name) {
        
            this.name = name;
            numAnimals++;
            System.out.println(name + " 构造方法执行");
        }
    }
    
    class Dog extends Animal {
        
        String breed;
    
        static {
        
            System.out.println("Dog 静态代码块执行");
        }
    
        {
        
            System.out.println("Dog 实例代码块执行");
        }
    
        Dog(String name, String breed) {
        
            super(name);
            this.breed = breed;
            System.out.println(name + "是" + breed + " " + "构造方法执行");
        }
    }
    
    public class Main {
        
        public static void main(String[] args) {
        
    
            Dog myDog1 = new Dog("Buddy", "哈士奇");
            System.out.println("-----------------------");
            Dog myDog2 = new Dog("Haha", "哈士奇");
        }
    }

**运行结果:**  
![在这里插入图片描述][f87b611371e644569d8c40d2a3404836.png]

通过分析执行结果，得出以下结论：

1、**静态方法最早执行**，父类静态代码块优先于子类静态代码块执行  
2.**静态方法执行一次**，第二次实例化子类对象时，父类和子类的静态代码块都将不会再执行  
3、父类实例代码块和父类构造方法紧接着执行  
4、子类的实例代码块和子类构造方法紧接着再执行

#### 8.继承方式 ####

1.单继承

class Animal {
        
        void move() {
        
            System.out.println("This animal is moving.");
        }
    }
    
    class Dog extends Animal {
        
        void bark() {
        
            System.out.println("This dog is barking.");
        }
    }
    
    public class Main {
        
        public static void main(String[] args) {
        
            Dog myDog = new Dog();
            myDog.move();
            myDog.bark();
        }
    }

2.多继承

class Animal {
        
        void move() {
        
            System.out.println("This animal is moving.");
        }
    }
    
    class Dog extends Animal {
        
        void bark() {
        
            System.out.println("This dog is barking.");
        }
    }
    
    class Poodle extends Dog {
        
        void groom() {
        
            System.out.println("This poodle is being groomed.");
        }
    }
    
    public class Main {
        
        public static void main(String[] args) {
        
            Poodle myPoodle = new Poodle();
            myPoodle.move();
            myPoodle.bark();
            myPoodle.groom();
        }
    }

3.不同的类继承同一个类

class Animal {
        
        void move() {
        
            System.out.println("This animal is moving.");
        }
    }
    
    class Dog extends Animal {
        
        void bark() {
        
            System.out.println("汪汪汪~~~");
        }
    }
    
    class Cat extends Animal {
        
        void mew() {
        
            System.out.println("喵喵喵~~~");
        }
    
    }
    
    public class Main {
        
        public static void main(String[] args) {
        
            Dog dog = new Dog();
            Cat cat = new Cat();
            dog.move();
            dog.bark();
            cat.move();
            cat.mew();
        }
    }

4.**多继承(不支持)**

//伪代码
    public class A {
        .......}
    public class B {
        .......}
    public class C extends A,B {
        .......}
    //Java中不支持多继承

虽然有继承，但是我们并不希望类之间的继承层次太复杂，**一般我们不希望出现超过三层的继承关系**，如果继承层次太多，就需要考虑对代码进行重构了  
如果想要从语法上限制继承，就可以使用final关键字

#### 9.final关键字 ####

1.修饰变量或字段，表示常量(即不能修改)

final int a = 10;
    a = 20;//编译出错

2.修饰类:表示此类不能被继承  
最典型的是Java中常见的String字符串类  
![在这里插入图片描述][756d2830ba4848e7b9a710f846cb61c3.png]  
3.修饰方法:表示该方法不能被重写

[f87b611371e644569d8c40d2a3404836.png]: https://img-blog.csdnimg.cn/f87b611371e644569d8c40d2a3404836.png
[756d2830ba4848e7b9a710f846cb61c3.png]: https://img-blog.csdnimg.cn/756d2830ba4848e7b9a710f846cb61c3.png