继承与多态2

最新推荐文章于 2024-11-14 19:49:43 发布

维C泡泡

最新推荐文章于 2024-11-14 19:49:43 发布

阅读量493

点赞数 20

文章标签： java 开发语言

本文链接：https://blog.csdn.net/a2844967431/article/details/139321022

版权

多态

先放代码：

public class Bird extends Animal{

    public  Bird(String name,int age){
        super(name, age);
    }
    } public void play (){
        System.out.println (  this.name +"正在打永杰");
    }

public class Dog extends Animal {
    public Dog(String name,int age){
            super(name,age);
    }
    @Override
    public void play(){
        System.out.println (  this.name +"正在金铲铲");
    }
}

public class Test {
    public static void func(Animal animal) {
     animal.play();
    }
    public static void main(String[] args){
        Dog dog = new Dog("茂伟",11);
        func(dog);
        Bird bird = new Bird("鹏杰",2);
        func(bird);
    }
}

上面代码中，animal引用的对象不相同，但是调用的方法是一样的，但表现出来的结果是不同的：

我们称之为多态。

多态实现条件

1. 必须在继承体系下。

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

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

在调用play这个方法的时候, 参数类型为 Animal (父类), 此时在该方法内部并不知道, 也不关注当前的引用指向的是哪个类型(子类)的实例。此时 a这个引用调用 play方法可能会有多种不同的表现, 这种行为就称为多态。

方法重写注意点

1.子类在重写父类的方法时，一般必须与父类方法原型一致：返回值类型方法名 (参数列表) 要完全一致。

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

3.访问权限不能比父类中被重写的方法的访问权限更低。例如：如果父类方法被public修饰，则子类中重写该方法就不能声明为 protected。

ps ：访问权限大小：public>protected>default>private。

4.父类被static、private修饰的方法、构造方法都不能被重写。

使用多态的好处

1.能够降低代码的 "圈复杂度", 避免使用大量的 if - else。

圈复杂度是一种描述一段代码复杂程度的方式。我们可以简单粗暴的计算一段代码中条件语句和循环语句出现的个数, 这个个数就称为 "圈复杂度"。如果一个方法的圈复杂度太高, 就需要考虑重构。

像下面代码（要创建对应的类，这里图方便就全放在一起了）：

public class Test {
    public class Brid {
        public static void draw() {
            System.out.println ("鸟在叫");
        }
    }
    public class Cat {
        public static void  draw(){
            System.out.println("猫猫在睡觉");
        }
    }

    public class Dog {

        public static void draw() {
            System.out.println("狗狗在吃饭");
        }
    }
    public static void  main(String[] args) {

        String[] strings = {"Dog", "Cat", "Dog", "Cat", "Bird"};
        for (String s : strings) {
            if (s.equals("Dog")) {
                Dog.draw();
            } else if (s.equals("Cat")) {
                Cat.dra();
            } else if (s.equals("Brid")) {
                Brid.draw();
            }
        }
        }
    }

如果使用使用多态我们可以在Test类中实现打印, 则不必写这么多的 if - else 分支语句, 代码更简单。


public class Cat extends  Shape{
    public  void  draw(){
        System.out.println("猫猫在睡觉");
    }
}

public class Dog extends  Shape{

        public  void draw() {
            System.out.println("狗狗在吃饭");
        }
}


public class Brid extends  Shape {
    public void draw() {
        System.out.println ("鸟在叫");
    }
}
public class Test {
    public static void main(String[] args) {
        Dog dog = new Dog();
        Cat cat = new Cat();
        Brid brid = new Brid();
        Shape[] shapes = {dog, cat, dog, cat, brid};
        for (Shape s : shapes) {
            s.draw();
        }
    }
}

可以看到Test代码简化了很多，对于类的调用来说(Test方法), 只要创建一个新类的实例就可以了, 改动成本很低。而对于不用多态的情况, 就要把Test中的 if - else 进行一定的修改, 改动成本更高。

当父类和子类都有同名属性的时候，通过父类引用，只能引用父类自己的成员属性。

class B {
public B() {

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();
}
}

运行的结果：