继承和多态的详解

最新推荐文章于 2023-05-20 14:37:35 发布
最新推荐文章于 2023-05-20 14:37:35 发布
阅读量1.9k 收藏 6
点赞数 1
文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_55079859/article/details/125391142
版权

一*继承：

1.1概念：

继承是面向对象程序设计使得代码可以重复使用的重要手段，它使得在保持原有类的特性的基础上进行扩展，增加新的功能，这样产生新的类，也称派生类。继承呈现了面向对象程序设计的层次结构，体现了从简单到复杂的认知过程。主要解决的问题：共性的抽取，实现代码的复用。

1.2语法：

在java中如果要表示类与类之间的关系，需要使用extends关键字。

基本结构为：

            访问修饰符 class 子类  extends  父类{ 

}

例1：子类继承父类

class Animal{    //Animal是父类
    String name;
    int age;
    public void eat(){
        System.out.println(name+"正在吃饭！");
    }

    public void sleep(){
        System.out.println(name+"正在睡觉！");
    }

}

class Dog extends Animal{  //Dog是子类 继承了Animal父类中的类成员

    String color;
    public void bark(){
        System.out.println(name+"正在汪汪汪！");
    }
}

class Cat extends Animal{  //Cat是子类 继承了Animal父类中的类成员

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


public class Test1 {
    public static void main(String[] args) {
        Dog dog=new Dog();
        dog.name="小狗";
        dog.age=2;
        dog.color="黄色";
        dog.bark();
        dog.eat();
        dog.sleep();
    }
}

注意：

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

2.子类继承父类后，必须要添加自己特有的成员（特别的成员变量或者成员方法），体现与基类的不同，否则就没有必要继承。

1.3父类成员的访问：

1.3.1子类中访问父类的成员变量：

例2：访问不同名的成员变量

class A{
    int a=10;
    int b=11;
    int c=12;
}
class B extends A{
    int d;
    public void methodB(){
        System.out.println(a);//访问父类继承下来的a
        System.out.println(b);//访问父类继承下来的b
        System.out.println(c);//访问父类继承下来的c
        System.out.println(d);//访问子类自己的d
    }
}
public class Test2 {
    public static void main(String[] args) {
        B b=new B();
        b.methodB();
    }
}

例3：访问同名的成员变量

class C{
    int a=10;
    int b=11;
    int c;
}
class D extends C{
    int a=1;
    int b=2;
  
    public void methodD(){
        System.out.println(a);//存在同名变量a,优先访问子类的
        System.out.println(b);//存在同名变量b,优先访问子类的
        System.out.println(c);//访问父类继承下来的d
        System.out.println(e);//编译报错
    }
}
public class Test3 {
    public static void main(String[] args) {
        D d=new D();
        d.methodD();
    }
}

在子类方法中或者通过子类对象访问成员时：

1.如果访问的成员变量子类中有，优先访问自己的成员变量。

2.如果访问的成员变量子类中无，则访问父类继承下来的，如果父类也没有，则编译报错。

3.如果访问的成员变量与父类中成员变量同名，优先访问自己的。

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

例4：访问不同名的成员方法

class E {
    public void methodE(){
        System.out.println("E类中的methodE");
    }
}
class F extends E{
    public void methodF(){
        System.out.println("F类中的methodF");
    }
    public void methodG(){
        methodE();//访问父类继承下来的methodE()
        methodF();//访问子类自己的methodF()
    }
}

public class Test4 {
    public static void main(String[] args) {
        F f=new F();
        f.methodG();
    }
}

例5：访问同名的成员方法

class Demo{
    public void method1(){
        System.out.println("Demo类中的method1");
    }

    public void method2(){
        System.out.println("Demo类中的method2");
    }
}
class Demo1 extends Demo{
    public void method1(){
        System.out.println("Demo1类中的method1");
    }
    public void method2(int a){
        System.out.println("Demo1类中的method2(int)");
    }

    public void method3(){
        method1();//访问的是子类中的method1
        method2();//访问的是父类继承下来的method2
        method2(10);//访问的是子类中的method2(int)
    }
}

public class Test5 {
    public static void main(String[] args) {
        Demo1 demo1=new Demo1();
        demo1.method3();
    }
}

在子类方法中或者通过子类对象访问成员时：

1.成员方法没有同名时，则优先访问自己的，自己没有时再到父类中找，如果父类中也没有则报错。

2.成员方法同名时，优先在子类中找，找到则访问，否则在父类中找，找到则访问，否则编译报错。

3.成员方法同名时，如果父类和子类同名方法的参数列表不同(重载)，根据调用方法适传递的参数选择合适的方法访问，如果没有则报错；

总结：

当子类中存在与父类中相同的成员时，不能在子类中直接访问父类相同的名称的成员。此时java提供了super关键字。

1.3.3super关键字的使用：

该关键字主要作用：在子类方法中访问父类的成员。

例6：super的使用

class Base{
    int a=10;
    int b=20;

    public void methodA(){
        System.out.println("Base中的methodA()");
    }
    public void methodB(){
        System.out.println("Base中的methodB()");
    }
}
class Derived extends Base{
    int a=1;
    char b;
    public void methodA(int a){//与父类中的methodA()构成重载
        System.out.println("Derived中的methodB()");
    }
    public void methodB(){//与父类的methodB()构成重写
        System.out.println("Derived中的methodB()");
    }
    public void methodC(){

        System.out.println("Derived中的methodC()");
        //对于同名的成员变量，直接访问时，访问的都是子类的
        a=100;//等价于：this.a=100;
        b=101;//等价于：this.b=101;
        //注意：this是当前对象的引用
        System.out.println(a);
        System.out.println(b);

        System.out.println("===================");
        //访问父类的成员变量(特别是同名变量，为了区分)，需要借助super关键字
        super.a=200;
        super.b=201;
        System.out.println(super.a);
        System.out.println(super.b);

        //父类和子类中构成重载的方法，直接访问可以通过参数列表不同来区分是访问父类还是子类的方法
        methodA(20);//传递int参数，访问的是子类中的methodA(int)
        methodA();//没有传参，访问的父类继承下来的methodA()

        //如果在子类中访问重写的父类方法(类型，参数列表，返回值都相同)，需要借助super关键字
        methodB();//直接访问，永远都只能访问到子类中的methodB()
        super.methodB();//访问的父类的methodB()
    }
}
public class Test6 {
    public static void main(String[] args) {
        Derived derived=new Derived();
        derived.methodC();
    }
}

注意事项： 

1.super和this都只能在非静态方法中使用，不能在静态方法中使用

2.在子类方法中，super可以间接访问父类的成员变量和方法

1.4子类构造方法：

父子父子，先有父再有子，即：子类对象构造时，需要先调用父类构造方法，然后执行子类构造方法。

例7：子类构造方法的实现

class Father{
    public Father(){
        System.out.println("Father()构造方法");
    }
}
class Son extends Father{
    public Son(){//子类构造方法
        //super();//注意子类构造方法中默认会调用父类的无参构造方法：super();
        //用户没有写的时候，编译器会自动添加，而且super()必须是子类构造方法中第一条语句。
        //并且只能出现一次super()
        //如果要调用父类的有参构造方法，就需要自己写super(参数);且在第一条语句。
        System.out.println("Derived()构造方法");
    }
}

public class Test7 {
    public static void main(String[] args) {
        Son son=new Son();
    }
}

 总结：

在子类构造方法中，并没有写任何关于父类构造的代码，但是在构造子类对象时，先执行父类的构造方法，然后执行子类的构造方法。因为：子类对象中成员是由两部分组成的，一个是父类继承下来的，另一个是子类新增的部分。故在构造子类对象时，先要调用父类的构造方法，把从父类继承下来的成员构造完整，然后再调用子类自己的构造方法，将子类新增的成员初始化完整。

注意：

1.若是父类显示定义无参或者默认的构造方法，在子类构造方法第一条语句默认有隐藏的super()调用，即调用父类构造方法。

2.如果父类构造方法是带有参数的，此时编译器将不再给子类生成默认的构造方法，此时需要用户为子类显示定义构造方法，并且在子类构造方法中选择合适的父类构造方法调用，否则编译失败。

3.在子类构造方法中，super(...)调用必须是子类构造方法中的第一条语句。

4.super(...)只能在子类构造方法中出现一次，并且不能和this(...)同时出现。

1.5再谈继承后的初始化：

关于继承时，实例代码块，静态代码块，构造代码块运行的顺序。

我们知道，没有继承时：

1.静态代码块先执行，有多个时，按顺序执行，并且只执行一次，在类加载阶段执行。

2.当有对象创建时，才会执行实例代码块，实例代码块执行完成后，最后构造方法执行。

而继承关系上的执行顺序：

例8：继承上代码块的执行顺序

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 Test8 {
    public static void main(String[] args) {
        Student student1=new Student("张三",20);
        System.out.println("========================");
        Student student2=new Student("李四",21);
    }
}

 通过执行结果分析总结：

1.父类静态代码块优先于子类静态代码，且是最早执行的

2.父类实例代码块和父类构造方法紧接着执行

3.子类的实例代码块和子类构造方法紧接着再执行

4.第二次实例化对象时，子类和父类静态代码块都将不会再执行

1.6java中的几种继承方式：

 注意：java中不支持多继承

1.时刻牢记，我们写的类是现实事物的抽象。而我们真正在公司中所遇到的项目往往业务比较复杂， 可能会涉及到 一系列复杂的概念，都需要我们使用代码来表示, 所以我们真实项目中所写的类也会有很多。类之间的关系也会更加复杂。

2.但是即使如此, 我们并不希望类之间的继承层次太复杂。 一般我们不希望出现超过三层的继承关系。如果继承层次太多，就需要考虑对代码进行重构了。

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

final关键字修饰变量，成员方法，类：

a.final修饰变量或字段，表示常量（即不能修改）

b.final修饰成员方法，表示该方法不能被重写

c.final修饰类，表示此类不能被继承

二*多态：

2.1多态的概念：

通俗来说，就是多种形态，具体就是去完成某个行为或者实现某个功能，当不同的对象去完成或者实现时产生不同的状态。

例：

1.对于动物来说：吃食物这个行为，对于猫来说，就是吃猫粮，对于狗来说就是吃狗粮。

这里：父类：动物；父类方法：吃食物的行为；子类：猫和狗；子类方法：对于猫来说就是吃猫粮的行为，对于狗来说就是吃狗粮的行为

2.对于打印机来说：打印这项功能，对于彩色打印机来说，就是实现彩色打印的功能，对于黑白打印机来说，就是实现黑白打印的功能。

这里：父类：打印机；父类方法：打印的功能；子类：黑白打印机和彩色打印机；子类方法：对于黑白打印机来说就是实现黑白打印的功能，对于彩色打印机来说就是实现彩色打印的功能。

2.2java多态实现条件：条件缺一不可

1.必须要在继承的体系下

2.子类必须要对父类中的方法进行重写

3.通过父类的引用调用重写方法

例9：多态的实现

public 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 static void eat(Animal animal){//通过父类的引用调用重写的方法,有个向上转型
        animal.eat();//通过传参来判断animal引用哪个具体的对象，然后调用谁的重写方法
    }

    public static void main(String[] args) {
        Dog dog=new Dog("小黄",2);
        eat(dog);
    }
}
class Dog extends Animal{
    public Dog(String name, int age) {//子类继承父类的构造方法
        super(name, age);
    }

    @Override //父类方法在子类重写
    public void eat() {
        System.out.println(name+"啃骨头");
    }
}

分析： 当类的调用者在编写eat()这个方法的时候，参数类型Animal（父类），此时在该方法内部并不知道，也不关注当前animal引用指向的是哪个类型（哪个子类）的实例，此时animal这个引用调用eat()方法可能会有多种不同的表现（和animal引用的实例相关），这种行为就称为多态

2.3重写：

也称为覆盖，重写是子类对父类，非静态static，非private，非final修饰，非构造方法等的实现过程进行重新编写，返回值和形参列表，方法名都不能改变。重写的好处在于子类可以根据需要，定义特定自己的行为或者特定的功能。也就是说子类能够根据需要实现父类的方法。

方法重写的规则：

1.子类在重写父类的方法时，一般必须与父类方法原型一致：修饰符，返回类型，方法，形参列表要完全一致。

2.被重写的方法返回值类型可以不同，但必须是具有父子关系的。

3.访问权限不能比父类中被重写的方法的访问权限更低。

4.父类被static，private，final修饰的方法不能被重写，构造方法也不能被重写。

5.重写的方法，可以使用 @Override 注解来显式指定. 有了这个注解能帮我们进行一些合法性校验。例如不小心将方法名字拼写错了 (比如写成 aet)。那么此时编译器就会发现父类中没有 aet 方法，就会编译报错，提示无法 构成重写。

2.4重写和重载的区别：

方法重载是一个类的多态性表现，而方法重写是子类与父类的一种多态性表现。

2.5向上转型和向下转型：

2.5.1向上转型：

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

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

使用场景：

1.直接赋值

2.方法传参

2.方法返回

例10：向上转型的场景的实现

public class TestAnimal {
    //2.方法传参：形参作为父类引用，可以接受任意子类的对象
    public  static void eat(Animal animal){
        animal.eat();
    }
}


//===================================================
public class TestAnimal {
    //3.坐返回值：返回任意子类的对象
    public static Animal buyAnimal(String var){
        if("狗" == var){
            return new Dog("狗狗",1);
        }else if("猫" == var){
            return new Cat("猫猫", 1);
        }else{
            return null;
        }
    }
}


//====================================================
public static void main(String[] args) {
    Animal cat = new Cat("猫咪",2); // 1. 直接赋值：子类对象赋值给父类对象
    Dog dog = new Dog("狗子", 1);
}

向上转型的优点：让代码实现更简单灵活。

向上转型的缺陷：不能调用到子类特有的方法。

2.5.2向下转型：

将一个子类对象经过向上转型之后当成父类方法使用，再无法调用子类的方法，但有时候可能需要调用子类特有的方法，此时：将父类引用再还原为子类对象即可，即向下转换(强制转换)。

例11：向下转型的实现：

public class TestAnimal {
    public static void main(String[] args) {
        Cat cat = new Cat("猫咪",2);
        Dog dog = new Dog("狗子", 1);
        // 向上转型
        Animal animal = cat;
        animal.sleep();
        animal = dog;
        animal.sleep();
        if(animal instanceof Cat){//判断此时animail对象是否是Cat的子类
            cat = (Cat)animal;//向下转型
            cat.mew();
        }
        if(animal instanceof Dog){//判断此时animail对象是否是Dog的子类
            dog = (Dog)animal;
            dog.bark();
        }
    }
}

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

2.6再谈构造方法中避免调用重写的方法：

例12：构造方法中实现重写

class B {
    public B() {
        // do nothing
        func();
    }
    public void func() {
        System.out.println("B.func()");
    }
}

class D extends B {
    private int num = 1;
    @Override
    public void func() {
        System.out.println("D.func() " + num);
    }
}

public class Test {
    public static void main(String[] args) {
    D d = new D();
    }
}

 分析：

1.构造 D 对象的同时，会调用 B 的构造方法。

2.B 的构造方法中调用了 func 方法，此时会触发动态绑定，会调用到 D 中的 func。

3.此时 D 对象自身还没有构造，此时 num 处在未初始化的状态，值为 0。

结论：

尽量不要在构造器中调用方法(如果这个方法被子类重写，就会触发动态绑定，但是此时子类对象还没构造完成)，可能会出现一些隐藏的但是又极难发现的问题。

风吹过你脸颊
关注
  • 1
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C#基础继承和多态详解
09-05
C#基础继承和多态详解 在C#编程语言中，继承和多态是两个非常重要的概念，它们是面向对象编程（Object-Oriented Programming，OOP）中的基础内容。了解继承和多态的机理和应用，可以帮助开发者更好地设计和实现软件...
继承与多态
m0_67683346的博客
05-15 5163
初识Java中的继承和多态
继承和多态
weixin_73000974的博客
04-05 719
还是看我们的狗类继承动物类这个例子，下面这段代码运行出来的结果是“萌萌正在吃饭！我们可以看到，只有Animal这个类里面有一个eat方法，Dog类里面并没有eat方法。
（java）继承和多态 （详解）
iiiiiihuang的博客
05-07 3459
1 继承 1.1为什么需要继承 1.2 继承概念 1.3 继承的语法 1.4 父类成员访问 1.4.1 子类中访问父类的成员变量 1.4.2 子类中访问父类的成员方法 1.5 super关键字 1.6 子类构造方法 1.7 super和this 1.7.1 this 1.7.2 super和this 1.8 再谈初始化 1.9继承方式 1.10继承与组合 2 多态 2.1 多态的概念 2.2 多态实现条件 2.3 重写 2.4 向上转移和向下转型
Python 的类、继承和多态详解
12-23
类的定义 假如要定义一个类 Point，表示二维的坐标点： # point.py class Point: def __init__(self, x=0, y=0): self.x, self.y = x, y 最最基本的就是 __init__ 方法，相当于 C++ / Java 的构造函数。...
Python3.5面向对象程序设计之类的继承和多态详解
12-31
本文实例讲述了Python3.5面向对象程序设计之类的继承和多态。分享给大家供大家参考，具体如下： 1、继承的定义 继承是指：可以使用现有类的所有功能，并在无需重新编写原来的类的情况下对这些功能进行扩展。 （1）...
继承和多态的区别是什么?多态应用有几个条件，都分别是什么？
weixin_57471103的博客
10-12 2513
继承和多态的区别是什么?多态应用有几个条件，都分别是什么？
java-继承和多态
追梦丶
08-25 2万+
继承： 继承就是保持已有类的特性而构造新类的过程。继承后，子类能够利用父类中定义的变量和方法，就像它们属于子类本身一样。 单继承：在类层次中，子类只继承一个父类的数据结构和方法，一个类只有一个父类 多继承：在类层次中，子类继承了多个父类的数据结构和方法，一个类允许有多个继承 （java支持多层继承） //父类 public class file{ public long ...
继承和多态的联系和区别？
天际的博客
10-12 5022
区别：继承是子类使用父类的方法，而多态则是父类使用子类的方法。 联系： 1、  什么是继承，继承的特点？ 子类继承父类的特征和行为，使得子类具有父类的各种属性和方法。 2、  为什么需要继承？什么时候应该继承？ 使用继承可以有效实现代码复用，避免重复代码的出现。 3、  什么是多态？ 相同的事物，调用其相同的方法，参数也相同时，但表现的行为却不同。 4、  为什么需要使用多态？多态的好处？ 可以增强程序的可扩展性及可维护性，使代
继承与多态的区别
热门推荐
baidu_33714003的博客
08-23 5万+
想起有一次面试,一位技术部领导问"面向对象的基本特征说一下".于是我说了"封装,继承,多态",然后有啰啰嗦嗦的说了一些对这些知识点的理解.然而,当我说完,面试官说"其实面向对象的基本特征可以总结为两个,继承和多态可以总结为一个特征....."云云,我当时就蒙了.觉得好新鲜的说法,难道是因为自己理解的不够深刻?但是内心还是知道继承和多态是有一定的区别的,于是只好委婉的说"可能是我的理解还没达到过深的
C++之对封装、继承、多态的理解
最新发布
爱喝橙汁儿的博客
05-20 2822
对封装、继承、多态的简单认识和理解。
Educoder —Java面向对象 - 封装、继承和多态的综合练习（1）
陈陈不like的博客
11-01 1万+
通关任务1： 任务描述 本关任务：按要求编写一个Java应用程序，巩固Java面向对象知识。 相关知识 为了完成本关任务，我们回顾一下前面所学知识：1.面向对象思想 ；2.封装；3.继承；4.构造函数；5.super()和this()。 面向对象思想 构造器：new就是一个构造器，作用是：①分配空间；②赋初始值（避免错误，简化输入）； new Object(Parameters)构造器调用构造函数，传参为了赋初始值； 对象的基本元素是：属性和方法 类成员（属性和方法）。属
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值