Java继承，初学者看了就会！！-CSDN博客

本文链接：https://blog.csdn.net/weixin_53318666/article/details/132267593

1.类与对象的回顾

类：类是一种模板，用于定义对象的属性（称为字段）和行为（称为方法）。
对象：对象是类的实例，具有类定义的属性和行为。

2.什么是继承？

继承是一种面向对象编程的基本概念，它允许一个类（子类或派生类）从另一个类（父类或基类）中继承属性和方法。子类可以重用父类的代码，同时还可以在不修改父类的情况下添加自己的新特性。这使得代码更具组织性、可维护性和可扩展性。

Animal.java
public class Animal {
    String name;
    String gender;
    int age;
    public void eat(){
        System.out.println(name+"吃东西");
    }
    public void sleep(){
        System.out.println(name+"在睡觉");
    }
}
 
Dog.java
public class Dog extends Animal{
    void bark(){
        System.out.println(name+"旺旺~");
    }
    public static void main(String[] args) {
        Dog dog = new Dog();
        System.out.println(dog.name);
        System.out.println(dog.gender);
        System.out.println(dog.age);
        dog.eat();
        dog.sleep();
        dog.bark();
    }
}
 
Cat.java
public class Cat extends Animal{
    void mew(){
        System.out.println(name+"喵喵~");
    }
    public static void main(String[] args) {
       Cat cat = new Cat();
        System.out.println(cat.name);
        System.out.println(cat.gender);
        System.out.println(cat.age);
        cat.eat();
        cat.sleep();
        cat.mew();
    }
}

3.父类和子类的关系

Java的继承是单继承，即一个子类只能有一个直接父类

没有显示继承父类是，默认继承object类

子类拥有父类的一切，访问父类的public，protected修饰的成员，还可以访问处在同一个包中父类的默认修饰符成员，不能访问父类的私有成员

通过子类对象可以调用父类的成员（访问权限内）

子类对象由父类对象部分和子对象个性化构成

创建子类对象必然调用父类的构造方法，应当在子类构造方法中通过super（放在第一句）调用，如果在子类构造方法中未显示调用父类构造方法，则默认调用可访问的父类无参构造方法

4.父类成员的访问

4.1子类访问父类的成员变量

public class Base {
    int a;
    int b;
    int c;
}
 
 
public class Derived extends Base {
    char b;   //与父类同名，不同类型
    int c;    //与父类同名，相同类型
    public void method(){
        a = 10;   //访问父类继承
        b = 20;   //访问谁的？
        c = 30;   //访问谁的？
        //d = 40;  //编译器报错
    }
}

· 如果访问的成员变量子类中有，则优先访问子类本身的

· 如果访问的成员变量子类中无，父类中有，则访问继承下来的

· 如果子类与父类中有同名的成员变量，则优先访问子类自己的，即子类将父类的同名变量隐藏

成员变量的访问遵循就近原则，自己有就优先访问自己的

4.2子类中访问父类的成员方法

· 通过子类访问成员方法，先看子类本身有没有，如果有访问自己的，如果没有，访问父类的

· 通过子类访问与父类同名方法时，如果子类和父类方法的参数列表不同则构成重载，根据调用方法传递的参数选择合适的方法访问

· 如果子类和父类同名方法的原型一致，则只能访问到子类的

 
public class Base {
    public void method1(){
        System.out.println("我是父类方法");
    }
    public void method2(){
        System.out.println("我是父类方法");
    }
}
 
 
 
public class Derived extends Base {
    public void method1(int a){
        System.out.println("我是子类方法");
    }
    public void method2(){
       System.out.println("我是子类方法");
   }
    public void method(){
        method1();   //父类方法
        method1(10); //子类方法
        method2();   //子类方法
   }
}

5，super关键字

1.调用父类的构造方法

在子类的构造方法中，可以使用 super() 调用父类的构造方法，以便初始化继承的属性。这在子类需要执行父类的初始化操作时非常有用。

// 定义父类 Parent
class Parent {
    int parentValue; // 声明父类的成员变量 parentValue

    // 父类构造方法，接受一个参数 value 来初始化 parentValue
    Parent(int value) {
        this.parentValue = value; // 使用 this 关键字引用当前对象的成员变量
    }
}

// 定义子类 Child，继承自父类 Parent
class Child extends Parent {
    int childValue; // 声明子类的成员变量 childValue

    // 子类构造方法，接受两个参数 parentValue 和 childValue 来初始化成员变量
    Child(int parentValue, int childValue) {
        super(parentValue); // 使用 super 关键字调用父类的构造方法，初始化父类的属性
        this.childValue = childValue; // 使用 this 关键字引用当前对象的成员变量
    }
}

2. 调用父类的成员变量和方法

在子类中，可以使用 super 关键字引用父类的成员变量和方法。这样可以避免在子类中出现与父类同名的成员变量或方法产生歧义。

class Parent {
    int value = 10;

    void printInfo() {
        System.out.println("This is the parent class.");
    }
}

class Child extends Parent {
    int value = 20;

    void printInfo() {
        System.out.println("This is the child class.");
    }

    void printParentInfo() {
        System.out.println("Parent value: " + super.value); // 引用父类的成员变量
        super.printInfo(); // 调用父类的方法
    }
}

3. 调用父类的构造方法和方法

当子类需要在构造方法中调用父类的构造方法，同时在方法中调用父类的方法时，可以使用 super 关键字来实现

class Parent {
    Parent() {
        System.out.println("Parent constructor");
    }

    void printInfo() {
        System.out.println("This is the parent class.");
    }
}

class Child extends Parent {
    Child() {
        super(); // 调用父类的构造方法
        System.out.println("Child constructor");
    }

    void printInfo() {
        super.printInfo(); // 调用父类的方法
        System.out.println("This is the child class.");
    }
}

6.访问修饰符

在继承中，访问修饰符控制父类成员对子类的可见性。下表列出了四种访问修饰符及其可见性：

7，方法重写

1.概念，子类的方法在方法名，参数定义和返回类型三个方面，与父类型的方法完全一致

2.限制：子类方法重写的访问修饰符应当不低于父类被重写方法的访问修饰符

权限修饰符：public > protected > default > private

3.只要通过子类对象调用重写方法，无论引用该对象的类型是父类幸还是子类型，也无论是直接还是间接调用，都将表示为重写后的行为

4.方法重写后，还想调用父类被重写的方法，只能在子类实例方法中通过super调用

    private void show() {
        System.out.println("Fu中show()方法被调用");
    }

    void method(int a ) {
        System.out.println("Fu中method()方法被调用");
    }

    static void method2() {
        System.out.println("Fu中method2()方法被调用");
    }
}

public class Zi extends Fu {

    // 编译【出错】，子类不能重写父类私有的方法
    @Override
    private void show() {
        System.out.println("Zi中show()方法被调用");
    }
   
    // 编译【出错】，子类重写父类方法的时候，访问权限需要大于等于父类 
    @Override
    private void method() {
        System.out.println("Zi中method()方法被调用");
    }

    // 编译【通过】，子类重写父类方法的时候，访问权限需要大于等于父类 
    @Override
    public void method() {
        System.out.println("Zi中method()方法被调用");
    }
    
    // 编译【出错】，父类的静态方法不能被重写
  	@Override
    static public void method2() {
        System.out.println("Zi中method2()方法被调用");
    }
}