Java面向对象：初识继承

标签：Java name age Dog 面向对象初识 Animal public String

继承：一个类（子类或派生类）继承另一个类（父类或基类）的特性（属性和方法）。

1、继承

1.1、不使用继承

例子：

class Dog{
    String name;
    int age;
    public Dog(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public void eat(){
        System.out.println(name + "在吃饭");
    }
    public void bark(){
        System.out.println(name + "在狗叫");
    }
}
class Cat{
    String name;
    int age;
    public Cat(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public void eat(){
        System.out.println(name + "在吃饭");
    }
    public void mew(){
        System.out.println(name + "在猫叫");
    }
}

public static void main(String[] args) {
    Dog dog = new Dog("小狗", 5);
    dog.eat();
    dog.bark();

    System.out.println("==============");

    Cat cat = new Cat("小猫",6);
    cat.eat();
    cat.mew();
}

输出：

小狗在吃饭
小狗在狗叫
==============
小猫在吃饭
小猫在猫叫

从上述代码可以看出，Dog和Cat猫的内容上存在大量重复，那么就可以利用继承，将共性的内容进行抽取，实现代码复用。

1.2、使用继承

例子：

class Animal {
     String name;
     int age;
     public Animal(String name, int age) {
        this.name = name;
        this.age = age;
     }
     public void eat(){
        System.out.println(name + "在吃饭");
     }

}
class Dog extends Animal{
    public Dog(String name, int age) {
        super(name,age); // 使用 super 关键字调用父类的构造方法
    }
    public void bark(){
        System.out.println(name + "在狗叫");
    }

}
class Cat extends Animal{
    public Cat(String name, int age) {
        super(name,age); // 使用 super 关键字调用父类的构造方法
    }
    public void mew(){
        System.out.println(name + "在猫叫");
    }
}

public static void main(String[] args) {
    Dog dog = new Dog("小狗", 5);
    dog.eat();
    dog.bark();

    System.out.println("==============");

    Cat cat = new Cat("小猫",6);
    cat.eat();
    cat.mew();
}

输出：

小狗在吃饭
小狗在狗叫
==============
小猫在吃饭
小猫在猫叫

注意：

1、在表示继承时，需要用extends关键字；

2、子类会将父类的成员变量或成员方法继承到子类；

3、一次只能继承一个类，不能继承多个类。

2、子类中访问父类的成员变量

如果访问的成员变量子类有，则优先访问子类；子类没有，则访问父类；都没有，则报错。

2.1、子类和父类中不存在同名成员变量

class Animal {
    String name;
    int age;
}
class Dog extends Animal{
    String color;
    public void fun(){
        name = "小狗"; // 访问从父类中继承下来的name
        age = 5;  // 访问从父类中继承下来的age
        color = "黄色"; // 访问子类自己的color
        System.out.println(name);
        System.out.println(age);
        System.out.println(color);
    }
}

public static void main(String[] args) {
    Dog dog = new Dog();
    dog.fun();
}

输出：

小狗
5
黄色

2.2、子类和父类中存在同名成员变量

例子：

class Animal {
    String name;
    int age;
    String color;
}
class Dog extends Animal{
    char age;
    String color;
    public void fun(){
        name = "小狗";
        age = '5';
        color = "黄色";
        System.out.println(name); //访问父类继承下来的
        System.out.println(age); //访问子类本身的
        System.out.println(color); //访问子类本身的
    }
}

3、子类中访问父类的成员方法

如果访问的成员方法子类有，则优先访问子类；子类没有，则访问父类；都没有，则报错。

3.1、子类和父类中不存在同名成员方法

例子：

class Animal {
     String name;
     int age;
     public Animal(String name, int age) {
        this.name = name;
        this.age = age;
     }
     public void eat1(){
        System.out.println("Animal的name" + "在吃饭1");
     }
}
class Dog extends Animal{
    public Dog(String name, int age) {
        super(name,age); // 使用 super 关键字调用父类的构造方法
    }
    public void eat2(){
        System.out.println("Dog的name" + "在吃饭2");
    }
    public void fun(){
        eat1();
        eat2();
    }
}
public static void main(String[] args) {
    Dog dog = new Dog("小狗", 5);
    dog.fun();
}

输出：

Animal的name在吃饭1
Dog的name在吃饭2

3.2、子类和父类中存在同名成员方法

例子：

class Animal {
     String name;
     int age;
     public Animal(String name, int age) {
        this.name = name;
        this.age = age;
     }
     public void eat(){
        System.out.println(name + "在吃饭");
     }
    public void showName(){
        System.out.println("Animal的name: " + name);
    }

}
class Dog extends Animal{
    String name; // 子类成员变量，与父类同名
    public Dog(String name, int age) {
        super(name,age); // 使用 super 关键字调用父类的构造方法
        this.name = name;
    }
    public void bark(){
        System.out.println(name + "在狗叫");
    }
    public void showName(){
        System.out.println("Dog的name: " + name); // 访问的是子类的name
    }
}

public static void main(String[] args) {
    Dog dog = new Dog("小狗", 5);
    dog.eat();
    dog.bark();
    dog.showName();
}

输出：

小狗在吃饭
小狗在狗叫
Dog的name: 小狗

4、super关键字

4.1、调用父类的构造方法

在子类的构造方法中，可以使用super()来调用父类的构造方法。

例子：

class Animal {
    String name;
    int age;
    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

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

4.2、访问父类的成员变量

如果子类中存在与父类同名的成员变量，可以使用super来访问父类的成员变量。

例子：

class Animal {
    String name;
    int age;
    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public void printAnimal(){
        System.out.println("name" + this.name);
    }

}

class Dog extends Animal{
    String name;
    public Dog(String name, int age) {
        super(name,age); 
        this.name = "小黄";
    }
    public void printDog(){
        System.out.println("Dog的name:" + this.name);
        System.out.println("Animal的name:" + super.name);
    }
}

public static void main(String[] args) {
    Dog dog = new Dog("小狗", 5);
    dog.printDog();
}

输出：

Dog的name:小黄
Animal的name:小狗

4.3、访问父类的方法

如果子类重写了父类的方法，但想要调用父类中被重写的方法，可以使用super来访问父类的成员方法。

例子：

class Animal {
    String name;
    int age;
    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public void eat(){
        System.out.println("Animal在吃饭");
    }
}

class Dog extends Animal{
    public Dog(String name, int age) {
        super(name,age);
    }
    public void eat(){
        System.out.println("Dog在吃饭");
        super.eat();
    }
}

public static void main(String[] args) {
    Dog dog = new Dog("小狗", 5);
    dog.eat();
}

输出：

Dog在吃饭
Animal在吃饭

5、父类和子类同时有构造方法

当父类和子类同时有构造方法时，先执行父类的构造方法，再执行子类的构造方法。

例子：

class Animal {
    public Animal() {
        System.out.println("Animal的构造方法");
    }
}
class Dog extends Animal{
    public Dog() {
        super();
        System.out.println("Dog的构造方法");
    }
}

public static void main(String[] args) {
    Dog dog = new Dog();
}

输出：

Animal的构造方法
Dog的构造方法

注意：

1、在子类构造方法中，如果没有写super(...)，会默认有一条super()；

2、super()只能出现在第一条;

3、super()只能出现一次;

4、super()和this不能同时出现。

标签：Java,name,age,Dog,面向对象,初识,Animal,public,String
From： https://blog.csdn.net/m0_67456201/article/details/139708491