首页 > 编程语言 >Java程序基础⑦Java继承和多态

Java程序基础⑦Java继承和多态

时间：2025-01-13 23:00:25浏览次数：3  
标签：Java name 继承 子类 void 多态 class 父类 public

目录

1. 继承

1.1 引入继承

1.2 继承的概念和语法

1.3 父类成员访问

1.4 super关键字

1.5 子类构造方法

1.6 继承时的初始化

1.7 继承的方式

1.8 final关键字

2. 多态

2.1 多态的概念

2.2 多态的实现条件

2.3 重写

2.4 向上转型和向下转型

2.4.1 向上转型

2.4.2 向下转型

2.5 多态的优缺点

本篇完。

1. 继承

1.1 引入继承

        为了深入了解JAVA的面向对象的特性，今天我们来学习剖析多态。多态在Java中的应用非常广泛，可以大大优化代码，让代码清晰整洁，它需要在继承的前提下让子类将父类中的方法进行重写，最后通过父类对象访问到子类重写的方法实现多态。

        多态需要在继承的前提下使用，那么就需要先知道继承是什么。在生活中有许多事物，一类人，一类物品等，这些都有着或多或少的联系，事物之间会产生一些关联，那在设计程序时就需要考虑。

举个例子：动物一类中的猫和狗。

// 定义一个猫类
class Cat {
    String name;
    int age;
    String color;

    public Cat(String name, int age, String color) {
        this.name = name;
        this.age = age;
        this.color = color;
    }

    public void mew() {
        System.out.println(this.name + "正在喵喵喵~");
    }
}
// 定义一个狗类
class Dog {
    String name;
    int age;
    String color;

    public Dog(String name, int age, String color) {
        this.name = name;
        this.age = age;
        this.color = color;
    }

    public void barks() {
        System.out.println(this.name + "正在汪汪汪~");
    }
}
// 输出运用
public class test {
    public static void main(String[] args) {
        Dog dog = new Dog("大黄",3,"金黄");
        dog.barks();
        Cat cat = new Cat("小黑",1,"黑色");
        cat.mew();
    }
}

// 最后输出结果分别是：
// “大黄正在汪汪叫~”和“小黑正在喵喵叫~”

通过观察代码可以发现，猫类和狗类都有重复的部分：

圈画的部分都是一模一样的，那能否将这些共性提取出来呢？

“面向对象思想便提出了继承的概念，专门用来进行共性抽取，实现代码的复用。”

1.2 继承的概念和语法

        继承(inheritance)机制：是面向对象程序设计使代码可以复用的最重要的手段，它允许程序员在保持原有类特性的基础上进行扩展，增加新功能，这样产生新的类，称派生类。继承呈现了面向对象程序设计的层次结构， 体现了由简单到复杂的认知过程。

继承主要解决的问题是：共性的抽取，实现代码复用。

被继承的称为：父类，基类或者超类。继承的称为：子类或者派生类。

        上图中Dog类和Cat类就是Animal的子类，继承了Animal中的元素，实现复用，子类在实现时只需要管各自的成员即可。

在java中如果想表示继承的关系，需要借助extends关键字，具体如下：

修饰符 class 子类 extends 父类 {
	...;
}

对刚刚的猫狗场景使用继承方式重新设计，代码如下：

// 定义动物类（父类）
class Animal {
    String name;
    int age;
    String color;
}

// 定义狗类（子类）
class Dog extends Animal {
    public void barks() {
        System.out.println(this.name + "正在汪汪汪~");
    }
}

// 定义猫类
class Cat extends Animal {
    public void mew(){
        System.out.println(this.name + "正在喵喵喵~");
    }
}

public class test {
    public static void main(String[] args) {
        Dog dog = new Dog();
        // dog类中并没有定义任何成员变量，name和age属性肯定是从父类Animal中继承下来的
        System.out.println(dog.name);
        System.out.println(dog.age);
        dog.barks();
    }
}

1.子类会将父类中的成员变量或成员方法继承到子类中。

2.子类继承父类后，必须添加自己特有的新成员体现不同，否则就没必要来继承。

1.3 父类成员访问

        在继承体系中，子类将父类的内容继承下来了，那在子类中能否直接访问父类中继承下来的成员呢？

1.3.1 子类中访问父类的成员变量分两种情况：

1.3.1.1 子类和父类中没有同名的成员变量：

class Base {
    int a;
    int b;
}

class Drived extends Base {
    int c;
    public void methods() {
        // 访问父类中的成员变量
        a = 10;
        b = 20;
        // 访问子类自己的C
        c = 30;
    }
}

public class test1 {
    public static void main(String[] args) {
        Drived drived = new Drived();
        drived.methods();
        System.out.println(drived.a);
        System.out.println(drived.b);
        System.out.println(drived.c);
    }
    //运行结果为
    //10
    //20
    //30
}

1.3.1.2 子类和父类中有同名的成员变量：

class Base 
    int a;
    int b;

}

/*class Drived extends Base{
    int c;
    public void methods(){
        // 访问父类中的成员变量
        a = 10;
        b = 20;
        c = 30;
    }
}*/

class Drived extends Base {
    int a;
    int b;

    public void methods() {
        // 访问父类中的成员变量
        a = 10;
        b = 20;
    }
}

public class test1 {
    public static void main(String[] args) {
        Drived drived = new Drived();
        Base base = new Base();
        drived.methods(); // 进行赋值
        System.out.println(drived.a); // 看看子类的变化
        System.out.println(drived.b);
        System.out.println(base.a); // 再看看父类的变化
        System.out.println(base.b);
    }
    //运行结果为
    //10
    //20
    //0
    //0
}

由此可见，在子类方法中或者通过子类对象访问成员时：

  • 如果访问的成员变量子类中有，优先访问自己的成员变量。
  • 如果访问的成员变量子类中没有，则访问继承的父类的，如果父类中也没有定义，则编译报错。
  • 如果访问的成员变量与父类中成员变量同名，则优先访问自己的。

遵循就近原则，自己有优先，没有就向父类中找。

1.3.2 子类中访问父类的成员方法：

也是分两种：

1.3.2.1 成员方法名不同：

class Base {
    public void methodA() {
        System.out.println("Base中的method");
    }
}

class Drived extends Base {

    public void methodB() {
        System.out.println("Drived中的method");
    }
    public void methodC() {
        methodA(); // 访问父类中的methodA
        methodB(); // 访问子类自己的methodB
        // methodD(); // 编译失败，在整个继承体系中没有发现方法methodD()
    }

}

public class test2 {
    public static void main(String[] args) {
        Drived drived = new Drived();
        drived.methodC();
    }
}

1.3.2.2 成员方法名相同：

class Base{

    public void methodA() {
        System.out.println("Base中的method");
    }
    public void methodB() {
        System.out.println("Base中的method");
    }

}

class Derived extends Base {

    public void methodA(int a) {
        System.out.println("Derived中的method(int)");
    }
    public void methodB() {
        System.out.println("Derived中的method");
    }

    public void methodC() {
        methodA(); // 没有传参，访问父类中的methodA
        methodA(3); // 有传参，访问子类中的methodA
        methodB(); // 子类中有，访问子类中的methodB
    }
}

总结：

  • 通过子类对象访问父类与子类中不同名方法时，优先在子类中找，找到则访问，否则在父类中找，找到则访问，否则报错。
  • 通过子类对象访问父类与子类同名方法时，如果父类和子类同名方法的参数列表不同（即重载），根据调用方法适应的参数选择合适的方法访问，没有对应方法则报错。

疑问：如果子类中存在与父类中相同的成员时，该如何在子类中访问同名的父类的成员？

1.4 super关键字

        因为可能会出现上面问题的情况，java提供了super关键字，该关键字主要作用：在子类方法中访问父类成员。

可以尝试更改一下上面的示例（主要看最后三行）：

class Base {
    int a;
    int b;
	public void methodA() {
        System.out.println("Base中的method");
    }
}

class Derived extends Base {
    int a;
    int b;
    public void methods() {
        // 访问父类中的成员变量
        super.a = 10;
        super.b = 20;
        super.methodA(); // 访问父类的methodA()
    }
}

借助super关键字这样就可以访问父类中的成员了。

注意事项：

  • 只能在非静态方法（无static）中使用。
  • 在子类方法中，访问父类的成员变量和方法。

1.5 子类构造方法

子类的构造方法也很关键，稍不注意就会报错无法运行。

在java环境中，子类对象构造时，需要先调用父类的构造方法，然后在执行子类的构造方法。

package rtx;

import com.sun.javafx.css.parser.DeriveSizeConverter;

class Base{
    public Base(){
        System.out.println("Base()");
    }
}

class Derived extends Base{
    public Derived(){
        // super() 注意子类构造方法中会默认调用父类的无参构造方法super()
        // 用户没有写时，编译器会自动添加，而且在子类构造方法中的第一条语句
        // 并且只能出现一次
        System.out.println("Derived()");
    }
}

public class test3 {
    public static void main(String[] args) {
        Derived derived = new Derived();
    }
}

结果打印：

        在子类的构造方法中，没有写任何关于基类构造的代码，但是在构造子类对象时，先执行基类的构造方法，然后执行子类的构造方法，这是因为：

        子类对象是由两部分构成的，基类继承下来的部分和子类新增的部分。有父才有子，构造子类对象时，会先调用基类的构造方法，将从基类继承下来的成员构造完整，然后再调用自己的构造方法，将子类自己新增的成员初始化完整。

注意：

  • 若父类显式定义午餐或者默认的构造方法，在子类构造方法的第一行默认又隐含的super()调用
  • 如果父类构造方法是带有参数的，此时需要用户为子类显式定义构造方法，并在子类构造方法中选择合适的位置父类构造方法调用，否则编译失败。
  • 在子类构造方法中，super(…)调用父类构造时，必须是子类构造函数的第一条语句。
  • super(…)只能在子类构造方法中出现一次，而且不能和this同时出现。

1.6 继承时的初始化

之前我们有探究过代码块，静态代码块和实例代码块。

1. 静态代码块先执行，在类加载阶段执行，且只执行一次
2. 当有对象创建时，才会执行实例化代码块，实例化代码块执行完成后，最后构造方法执行。

总结下初始化顺序就是：静态代码块（只会初始化一次）->实例化代码块->构造方法。

但这是一般情况，现在讲到的继承关系上的执行顺序会是什么样子呢？

继承关系上的执行顺序：

package rtx;

class Person {
    public String name;
    public int age;
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
        System.out.println("Person：构造方法执行");
    }
    {
        System.out.println("Person：实例代码块执行");
    }
    static {
        System.out.println("Person：静态代码块执行");
    }
}

class Student extends Person {
    public Student(String name,int age) {
        super(name,age);
        System.out.println("Student：构造方法执行");
    }
    {
        System.out.println("Student：实例代码块执行");
    }
    static {
        System.out.println("Student：静态代码块执行");
    }
}

public class Hello {
    public static void main(String[] args) {
        Student student1 = new Student("GR", 10);
        System.out.println("===========================");
        Student student2 = new Student("csdn", 20);
    }
}

运行结果：

由此分析可知：

  1. 父类静态代码块先于子类静态代码块，最早执行
  2. 第二次实例化子类对象时，父类和子类的静态代码块都不会再执行

也就是变成：父类静态-》子类静态-》父类实例化-》父类构造方法-》子类实例化-》子类构造方法

1.7 继承的方式

Java中只支持以下几种继承方式：

  1. 单继承
  2. 多层继承

  3. 不同类继承同一个类

注意：Java中不支持一个类同时继承多个父类

        注意我们在实际应用时，类之间的关系会更加复杂，但我们并不希望类之间的继承层次太复杂，一般不希望出现超过三层的继承关系。

如果想从语法上进行继承的限制，就可以使用final关键字。

1.8 final关键字

final关键字可以用来修饰变量，成员方法以及类：

1. 由final修饰的变量相当于常量

final public class Animal {
...
}
public class Bird extends Animal {
...
}
// 编译出错
Error:(3, 27) java: 无法从最终com.bit.Animal进行

2. 类（class）前加【final】代表当前类不可继承，被称为密封类

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

3. final修饰成员方法说明该方法不能被重写。

2. 多态

2.1 多态的概念

        多态的概念：简单来说，就是多种形态，去完成某个行为，当不同的对象去完成时会产生不同的状态。

举个例子：自然界有各种动物，它们发出的声音不尽相同，但都是做的发声这个动作：

同一件事，发生在不同对象身上，就会产生不同的结果。语言环境中如何实现多态？

2.2 多态的实现条件

在Java中如要实现多态，则需要满足以下三个条件，缺一不可：

  1. 必须要在继承的条件下。
  2. 子类必须要对父类中的相关成员方法进行重写。
  3. 通过父类的引用调用重写的方法。

看一段代码：

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);
    }
    @Override
    public void eat() {
        System.out.println(name + "正在吃狗粮.....");
    }
}

class Cat extends Animal {
    public Cat(String name, int age) {
        super(name, age);
    }
    @Override
    public void eat() {
        System.out.println(name+"正在吃猫粮......");;
    }
}

public class test {
    static void eat(Animal A) {
        A.eat();
    }
    public static void main(String[] args) {
        Dog dog = new Dog("冲冲",18);
        Cat cat = new Cat("JAVA",90);
        eat(dog);
        eat(cat);
    }
}
//运行结果：
//冲冲正在吃狗粮.....
//JAVA正在吃猫粮.....

        可以看到同样用eat方法最后输出的内容却不同。 当类的调用者在调用eat方法的时候，参数类型为Animal(父类)，此时该方法的内部并不知道，也不关注当前的A引用指向的是哪种类型（哪个子类）的实例，则此时A引用调用eat方法时就可能会有不同的结果表现，而这种思想行为就称为多态。

2.3 重写

        在上面的实现条件中讲到要对父类中的相关方法进行重写，那么重写又是什么呢？

        重写（Override）：也称之为覆盖，覆写。重写是对子类对父类中类非静态、非private修饰，非final修饰，非构造方法等的成员方法进行重新编写。返回值，方法名和形参都不能改变。 即外壳不变，核心重写。

        重写的好处在于能实现子类的需要，定义特定于自己的行为，也就是说子类能根据需要实现父类的方法。

方法重写的规则：

  1. 子类在重写父类对应方法时，一般必须与父类对应方法一致：返回值类型、形参（参数列表）、方法名。
  2. 访问权限不能比父类对应重写方法的访问权限更低。例如：如果父类方法由protected修饰，则重写的子类方法只能由protected或public修饰，否则重写失败。
  3. 父类被static、private、final修饰的方法不能被重写。
  4. @Override 注解 重写方法时可使用该注解来显式指定，有了该注解可以帮我们在编写代码时进行一些合法性校验。 例如：编写时不小心将eat打成了aet（出现了拼写错误），那么此时编译器就会发现父类中没有aet方法，就会编译报错，提示无法进行重写。

重写和重载的区别：

要点重写（Override）重载（overload）
参数列表一定不能修改必须修改
返回类型一定不能修改（除非能构成父子关系）可以修改
访问限定符一定不能做更严格的限制（可以降低限制）可以修改

        重写的设计原则：对于已经投入使用的类，尽量不要进行修改。最好的方法是：重复利用其中共性的内容，并且添加或者改动新的内容，实现迭代更新。

2.4 向上转型和向下转型

2.4.1 向上转型

实际上就是创建一个子类对象，将其当成父类对象来使用。

语法格式：父类类型 对象名 = new 子类类型()

Animal animal = new Cat("小猫", 7);

animal是父类类型，但可以引用子类对象，因为是从大范围中找小范围的效果。

向上转型使用方法：

  1. 直接赋值 
    public static void main(String[] args) {
    Dog dog = new Dog("冲冲",18);
    Animal animal1 = dog; // 直接赋值
    animal1.eat();
    Cat cat = new Cat("JAVA",90);
    Animal animal2 = cat;
    animal2.eat();
}
  2. 方法传参 
    static void eat(Animal A){
    A.eat();
}
public static void main(String[] args) {
    Dog dog = new Dog("冲冲",18);
    Cat cat = new Cat("JAVA",90);
    eat(dog); // 传参实现向上转型
    eat(cat);
}
  3. 通过返回值，进行向上转型 
    Animal eat() {
    return new Cat("小猫",2);
}
  • 向上转型的优点：让代码实现的更简单灵活。
  • 向上转型的缺陷：不能调用到子类的特有方法。

2.4.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);
    }

    @Override
    public void eat() {
        System.out.println(name + "正在吃狗粮.....");
    }

    public void bark() {
        System.out.println(name + "正在旺旺叫.....");
    }
}

class Cat extends Animal {
    public Cat(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat() {
        System.out.println(name + "正在吃猫粮......");
        ;
    }

    public void mew() {
        System.out.println(name + "正在喵喵叫.....");
    }
}

public class down {
    public static void main(String[] args) {
        Cat cat = new Cat("小黑", 2);
        Dog dog = new Dog("小橘", 1);

        Animal animal1 = cat;
        animal1.mew();
        Animal animal2 = dog;
        animal2.bark();
    }
}
//最后会编译失败，编译时编译器将animal当成Animal对象处理
//而Animal类中没有bark和mew方法，因此编译失败

可以通过向下转型操作实现：

//程序可以通过编程，但运行时抛出异常
//现在要强制还原
public class down {
    public static void main(String[] args) {
        Cat cat = new Cat("小黑",2);
        Dog dog = new Dog("小橘", 1);

        Animal animal1 = cat;
        //animal1.mew();
        cat = (Cat)animal1; // 进行强制还原
        cat.mew();
        Animal animal2 = dog;
        //animal2.bark();
        dog = (Dog)animal2;
        dog.bark();
    }
}

//编译结果：
//小黑正在喵喵叫.....
//小橘正在旺旺叫.....

        因向下转型用的比较少，而且不安全，万一转换失败，运行时就会抛出异常。Java为了提高向下转型的安全性，引入了关键词instanceof，如果表达式为true，则可安全转换。

public class down {
    public static void main(String[] args) {
        Cat cat = new Cat("小黑",2);
        Dog dog = new Dog("小橘", 1);

        Animal animal1 = cat;
        Animal animal2 = dog;
        //animal1.mew();
        if(animal1 instanceof Cat) {
            cat = (Cat)animal1;
            cat.mew();
        }
        //animal2.bark();
        if(animal2 instanceof Dog) {
            dog = (Dog)animal2;
            dog.bark();
        }
    }
}

instanceof关键词官方介绍：Chapter 15. Expressions

2.5 多态的优缺点

多态的优点：

  1. 能够降低代码的“圈复杂度”，避免使用大量的if-else

    什么叫“圈复杂度”？
            圈复杂度是一种描述一段代码复杂程度的方式。一段代码如果是平铺直叙，那么就比较简单容易理解，但如果有很多的条件分支或循环语句，则认为理解起来更复杂。
            因此我们可以简单粗暴的计算一段代码中条件语句和循环语句出现的个数，结果个数就称为“圈复杂度”。如果一个方法的圈复杂度台稿，就需要考虑重构

  2. 可扩展能力更强，如果要增加一种新的功能，使用多态方式的代码改动成本也比较低。

多态的缺点：

代码的运行效率降低。

  1. 属性没有多态性：当父类和子类都有同名属性的时候，通过父类引用，只能引用父类自己的成员属性
  2. 构造方法没有多态性：尽量不要在构造器中调用方法，如果该方法被子类重写，就会触发动态绑定，而此时子类对象还没构造完成，可能会出现一些隐藏而又极难发现的问题。

本篇完。

下一篇是Java程序基础⑧抽象类+Object类+内部类的内容。

标签：Java,name,继承,子类,void,多态,class,父类,public
From： https://blog.csdn.net/GRrtx/article/details/144956659

相关文章

  • python bs4 selenium 查找a href=javascript:()；的实际点击事件和url
    在使用BeautifulSoup和Selenium时，处理href="javascript:;"的链接需要一些额外的步骤，因为这些链接不直接指向一个URL，而是通过JavaScript代码来执行某些操作。这可能包括导航到另一个页面、触发模态窗口、显示/隐藏内容等。以下是如何使用Selenium来查找和处理这......
  • java第二章数组学习
    java第二章数组数组的概念和特点数组(Array)，是多个相同类型数据按一定顺序排列的集合，并使用一个名字命名，并通过编号的方式对这些数据进行统一管理。特点数组本身是引用数据类型，而数组中的元素可以是任何数据类型，包括基本数据类型和引用数据类型。创建数组对象会在内存中开......
  • leetcode刷题记录（java）——参考代码随想录：数组 链表 哈希表
    四、题目之：代码随想录https://programmercarl.com/(1)代码随想录：数组704.二分查找classSolution{publicintsearch(int[]nums,inttarget){if(target<nums[0]||target>nums[nums.length-1]){return-1;}intleft=0......
  • JAVA SE 方法的使用
    ......
  • 《Java核心技术II》网络使用telnet
    使用telnettelnet是一种用于网络编程的非常强大的调试工具，可以在命令shell中输入telnet来启动它。注释：在Windows中需要激活它，控制面板->程序->打开/关闭Windows特性->Telnet客户端。连接当日时间服务连接到当日时间服务，由美国国家标准与技术研究所运维，提......
  • 高级java每日一道面试题-2025年01月12日-框架篇[Mybatis]-什么是MyBatis?
    如果有遗漏,评论区告诉我进行补充面试官:什么是MyBatis?我回答:在Java高级面试中，MyBatis是一个常见的讨论话题。以下是对MyBatis的详细解释：一、MyBatis简介MyBatis是一个开源的持久层框架，它提供了将SQL语句和Java对象进行映射的功能。MyBatis简化了JDBC的开发，减少了手......
  • 高级java每日一道面试题-2025年01月13日-框架篇[Spring篇]-Spring 是怎么解决循环依赖
    如果有遗漏,评论区告诉我进行补充面试官:Spring是怎么解决循环依赖的?我回答:在Java高级面试中，Spring框架如何解决循环依赖是一个重要且常见的问题。以下是对Spring解决循环依赖的详细解释：循环依赖的定义与类型循环依赖是指两个或多个Bean之间互相依赖，形成一个闭环。......
  • Java-数据结构-栈与队列(常考面试题与单调栈)
    在上一篇的学习中，我们学习了栈和队列的基本知识，以及它们对应都有哪些方法，在什么应用场景下如何使用，并且还对它们进行了模拟实现，而其实对于栈和队列的相关知识还远不止于此，而今天我们就对栈与队列进行复盘，认识更多使用它们的场景，夯实代码功底吧~一、常考面试题-思维以下习题在......
  • JavaScript函数：从基础到进阶拓展
    一、引言在前端开发的广袤领域中，JavaScript函数无疑是构建交互性与功能性的基石，其重要性如同搭建积木时的一块块基础组件。想象一下，我们在搭建一座宏伟的积木城堡，每个积木块都代表着一个函数，它们各司其职，有的负责构建城堡的主体结构，有的塑造独特的装饰细节。而函数的拓展，就......
  • java高校数字化防疫管理系统论文+源码 2025毕设
    本系统（程序+源码）带文档lw万字以上 文末可获取一份本项目的java源码和数据库参考。系统程序文件列表开题报告内容一、研究背景在当今社会，数字化已经深入到各个领域。高校作为人员高度密集且流动性较大的场所，在应对公共卫生事件（如曾经的新冠疫情）时面临着巨大的挑战。传统的......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99