【java】子类与继承

最新推荐文章于 2025-04-01 08:53:05 发布

Zmmm_11

最新推荐文章于 2025-04-01 08:53:05 发布

阅读量3.1k

点赞数 30

文章标签： java 开发语言

本文链接：https://blog.csdn.net/Zmmm_11/article/details/143018528

版权

一、子类与父类

1、子类

由继承得到的类称为子类，被继承的类称为父类（超类）。

Java不支持多重继承，即子类只能有一个父类。

在类的声明中，使用extends关键字来定义一个子类，格式如下：

class  子类名  extends  父类名{
　　　　.......
}

2、子类的树型结构

二、子类的继承性

1、子类和父类在同一包中的继承性

类可以有两种重要的成员，即成员变量和方法。子类继承了父类不是private的成员属性和成员方法。

2、子类和父类不在同一包中的继承性

子类只继承父类中的protected和public访问权限的成员变量和成员方法。

三、子类与对象

当使用子类构造方法创建对象时，不仅子类声明中的成员变量被分配了内存，而且父类的成员变量也分配了内存空间。

注：子类继承的方法只能操作子类继承的成员变量或未继承的成员变量，不可能操作子类新声明的变量。

四、成员变量的隐藏和方法重写

1、成员变量的隐藏

当子类的成员变量和父类的成员变量出现同名时（变量类型可以不同），这样子就会隐藏所继承的成员变量。

特点：

①子类对象已经自己定义的方法操作与父类同名的成员变量是指子类重新声明的这个成员变量；

②子类对象仍然可以调用从父类继承的方法操作被子类隐藏的成员变量，也就是说，子类继承的方法操作的成员变量一定是被子类继承或者隐藏的成员变量；

③子类继承的方法只能操作子类继承和隐藏的成员变量；

④子类新定义的方法可以操作子类继承和子类新声明的成员变量，但无法操作子类隐藏的成员变量（需要使用super关键字操作子类隐藏的成员变量）。

例如：

class Parent {
    int value = 10;
}
 
class Child extends Parent {
    int value = 20;
 
    void showValue() {
        int value = 30;
        System.out.println("Local value: " + value);
        System.out.println("Child value: " + this.value);
        System.out.println("Parent value: " + super.value);
    }
}
 
public class FieldHiding {
    public static void main(String[] args) {
        Child child = new Child();
        child.showValue();
    }
}

2、方法重写（overriding）

子类通过重写可以隐藏已继承的方法（方法重写又称方法覆盖）

重写规则：

①如果子类可以继承父类的某个方法，这个子类就有权力重写这个方法；

②子类的方法名字，返回类型，参数类型个数都要和父类的一致才算重写。

重写目的：

隐藏继承的方法，增加拓展新功能。

注：
重写父类的方法时，不允许降低方法的访问权限，但可以提高访问权限
高到低：public--->protected--->默认的--->private

例如：

class Animal {
    void speak() {
        System.out.println("Animal speaks");
    }
}
 
class Dog extends Animal {
    @Override
    void speak() {
        System.out.println("Dog barks");
    }
}
 
public class Main {
    public static void main(String[] args) {
        Animal myAnimal = new Dog();
        myAnimal.speak(); // 输出 "Dog barks"，因为 speak 方法被重写
    }
}

五、super关键字

1、用super操作被隐藏的成员变量和方法

子类一旦隐藏继承的成员变量/方法，那么子类创建的对象就不再拥有该变量/方法，该变量将归关键字super所有，可以使用super来访问。

2、使用super调用父类的构造方法

在加载子类的时候会使用super（）调用父类的默认构造方法

例如：调用父类的构造函数（在构造函数中）

class Child extends Parent {
    public Child() {
        super(); // 调用父类的默认构造函数
    }
}

调用父类的构造函数（在子类的其他构造函数中）：

class Child extends Parent {
    public Child(int value) {
        super(value); // 调用父类带参数的构造函数
    }
}

六、final关键字

final关键字可以修饰类（表示最终类，不能被继承）、成员变量（表示常量，不能被修改）、方法中的局部变量（修饰方法表示最终方法，只能调用不能重写）

final class A {  

.....

 }

注： final 修饰的类不能被继承，不能有子类

final 修饰方法，那么这个方法不允许子类重写，也就是说，不允许子类隐藏可以继承的final方法老老实实继承，不许任何修改。

例如：修饰基本数据类型变量

public final int i = 10;
// i = 20; // 这行代码会报错，因为i已经被初始化，不能再被更改。

修饰方法：

public class MyClass {
    public final void myMethod() {
        // 方法体
    }
}
 
// 下面的代码会报错，因为final修饰的方法不能被重写。
class MySubClass extends MyClass {
    @Override
    public void myMethod() {
        // 方法体
    }
}

修饰类：

public final class MyClass {
    // 类体
}
 
// 下面的代码会报错，因为final修饰的类不能被继承。
class MySubClass extends MyClass {
    // 类体
}

七、对象的上转型对象

上转对象不能操作子类新增的成员变量/方法（失掉这一部分属性）；

上转对象可以访问子类继承或者隐藏的成员变量/方法，也可以调用子类继承的方法或子类重写的实例方法。调用方法时，调用的是子类重写的方法。

例如：

class Animal {
    void speak() {
        System.out.println("Animal is speaking.");
    }
}
 
class Dog extends Animal {
    @Override
    void speak() {
        System.out.println("Dog is barking.");
    }
}
 
public class Main {
    public static void main(String[] args) {
        Animal myAnimal = new Dog(); // 上转型对象
        myAnimal.speak(); // 输出 "Dog is barking."
    }
}

在这个例子中，Dog 类继承自 Animal 类，并重写了 speak 方法。创建了一个 Dog 类型的对象，并将其上转型为 Animal 类型，然后调用 speak 方法。输出结果是 "Dog is barking."，即使调用的方法是在父类中定义的，但实际执行的是子类中重写的方法。

八、继承与多态

继承是面向对象编程中的一种机制，允许一个类（子类）基于另一个类（父类）来创建。子类可以继承父类的属性和方法，并且可以在不修改父类的情况下进行扩展，可以达到代码复用的目的。

class Animal {
    void speak() {
        System.out.println("Animal is speaking.");
    }
}
 
class Dog extends Animal {
    @Override
    void speak() {
        System.out.println("Woof! Woof!");
    }
}
 
class Cat extends Animal {
    @Override
    void speak() {
        System.out.println("Meow! Meow!");
    }
}
 
public class PolymorphismExample {
    public static void main(String[] args) {
        Animal[] animals = {new Dog(), new Cat()};
 
        for (Animal animal : animals) {
            animal.speak();
        }
    }
}

注：java不存在多继承，要用接口来实现多继承。

多态性就是指父类的某个方法被其子类重写时可以各自产生自己的功能行为。

九、抽象类和抽象方法

用关键字abstract修饰的类称为abstract类（抽象类）

abstract class A{
 ...
}

使用关键字abstract修饰的方法称为abstract方法（抽象方法）

abstract int min(intx,inty);

abstract类中可以有abstract方法，也可以没有abstract方法

abstract class A{                        //抽象类
     abstract int min(int x,int y);     //抽象方法
     int max(int x,int y){
            return x<y?y:x;
   }
}

特点：
①abstract类不能用new运算符创建对象
继承抽象类的类必须重写抽象类的抽象方法（不能使用abstract和final修饰同一个方法）

②abstract类中可以有abstract方法

③abstract的子类
如果一个非抽象类继承该抽象类，必须重写父类的抽象方法（给出方法体），如果是抽象类继承抽象类则，可重写或者继承

④abstract类的对象作上转型的对象
抽象类可以抽象出重要的行为标准，该标准用抽象方法来表示。

抽象类声明的对象可以成为其子类的对象的上转型对象