【多态-动态绑定-向上转型-抽象类】

文章目录

静态绑定
动态绑定
多态的具体实现
向上转型
多态的优缺点
抽象类
- 抽象类的作用
总结

静态绑定

重载就是典型例子
在这里插入图片描述

动态绑定

在这里插入图片描述

多态的具体实现

//多态
class Animal{public String name;public int age;//无参构造方法public Animal() {}//有参构造方法public Animal(String name,int age) {this.name = name;this.age = age;}//成员方法public void eat(){System.out.println(this.name+"正在吃饭");}}
class Dog extends Animal {//子类构造完成之前要帮助父类构造完成public Dog(String name, int age) {super(name, age);}//重写eat方法public void eat() {System.out.println(this.name + "正在吃狗粮");}
}
class Cat extends Animal {//子类构造完成之前要帮助父类构造完成public Cat(String name, int age) {super(name, age);}//重写eat方法public void eat() {System.out.println(this.name + "正在吃猫粮");}
}
public class Test {//多态的第一种public static void func(Animal animal){animal.eat();//向上转型中的方法传参}public static void main(String[] args) {Dog dog = new Dog("红红",12);func(dog);Cat cat = new Cat("青青",13);func(cat);}//多态的第二种public static void main2(String[] args) {Animal animal = new Dog("红红",12);//向上转型中的直接赋值animal.eat();Animal animal2 = new Cat("青青",13);animal2.eat();}}

在这里插入图片描述

向上转型

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

animal是父类类型，但可以引用一个子类对象，因为是从小范围向大范围的转换。

【使用场景】
例如上面的代码中

直接赋值
例如上面的代码

Animal animal = new Dog("红红",12);

方法传参
例如上面的代码

   public static void func(Animal animal){animal.eat();}

方法返回

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

总结：
向上转型的优点：让代码实现更简单灵活。
向上转型的缺陷：不能调用到子类特有的方法

多态的优缺点

【使用多态的好处】

能够降低代码的 “圈复杂度”, 避免使用大量的 if - else
可扩展能力更强
如果要新增一种新的形状, 使用多态的方式代码改动成本也比较低

【多态缺陷】
3. 代码的运行效率降低。
4. 属性没有多态性
当父类和子类都有同名属性的时候，通过父类引用，只能引用父类自己的成员属性
5. 构造方法没有多态性

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

抽象类

在面向对象的概念中，所有的对象都是通过类来描绘的，但是反过来，并不是所有的类都是用来描绘对象的，如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类
在这里插入图片描述

1.被abstract修饰的类叫做抽象类
2.被abstract修饰的方法叫做抽象方法
3.抽象类不可以实例化

在这里插入图片描述
4.当一个普通类继承了抽象类，那么需要重写这个抽象类中的所有抽象方法！！

abstract class Shape{public abstract void draw();
}
class Cycle extends Shape{@Overridepublic void draw() {System.out.println("⚪");}
}

如果不继承，子类也是抽象类，必须要使用 abstract 修饰

abstract class C{public abstract void draw();
}
abstract class A extends C {abstract public void run();
}
class B extends A{@Overridepublic void draw() {}@Overridepublic void run() {}
}

总结:抽象类的出现就是为了被继承

abstract class Shape{public abstract void draw();
}
class Cycle extends Shape{//重写抽象类的抽象方法@Overridepublic void draw() {System.out.println("⚪");}
}class Rect extends Shape{//重写抽象类的抽象方法@Overridepublic void draw() {System.out.println("矩形");}
}
public class Test {public static void func(Shape shape){shape.draw();}public static void main(String[] args) {Shape shape =new Cycle();Shape shape2 =new Rect();shape.draw();shape2.draw();}
}