8.2 多态
8.2.1 多态的概念
通俗来说就是多种形态,具体点就是去完成某个行为,当不同的对象去完成时会产生出不同的状态。
就比如打印机,彩色打印机和黑白打印机,打印出的效果一个是彩色,一个是黑白。
8.2.2 多态实现条件
多态的体现:在代码运行时,当传递不同类对象时,会调用对应类中的方法。
8.2.3 重写
重写(override):也称为覆盖。重写是子类对父类非静态、非private修饰,非final修饰,非构造方法等的实现过程进行重新编写, **返回值和形参都不能改变。即外壳不变,核心重写!**重写的好处在于子类可以根据需要,定义特定于自己的行为。 也就是说子类能够根据需要实现父类的方法。
重写的规则:
注意: 不能被重写的4种情况
public final void eat() {
System.out.println(this.name+" 正在吃。。。");
}
- 被static修饰的方法 不能被重写
public static void eat() {
System.out.println(this.name+" 正在吃。。。");
}
// 父类的方法
//当父类的方法修饰限定符是 默认defau时,子类的方法访问修饰限定符可以是protected、public
public void eat() {
System.out.println(this.name+" 正在吃。。。");
}
//子类的方法
public void eat() {
System.out.println(this.name+" 正在吃狗粮...");
}
-
- 被private修饰的方法 是不被重写的
重写和重载的区别:
重写的方法名和参数都一样,而重载的方法名相同,参数不同。
即:方法重载是一个类的多态性表现,而方法重写是子类与父类的一种多态性表现。
动态绑定:子类和父类都有 编译得时候认为 还是确认调用了父类得eat方法
运行得时候 绑定到子类当中
静态绑定:编译的时候就已经确定调用哪个方法了,如下dog.barks(10);
8.2.4 向上转型和向下转型
向上转型:实际就是创建一个子类对象,将其当成父类对象来使用。
语法格式:父类类型 对象名 = new 子类类型()
- 直接赋值
Animal animal = new Dog("旺财",10,"红色"); //直接赋值
- 方法传参
// 方法传参 :形参作为父类引用,可以接受任意子类的对象
public static void fun(Animal animal) {
animal.eat();// 发生了多态
}
public static void main(String[] args) {
Dog dog = new Dog("旺财",3,"红色");
fun(dog);
Bird bird = new Bird("布谷",1);
fun(bird);
}
同一个引用 调用了 同一个方法,当是因为引用的对象不一样,所表现的行为不一样,称为多态。
- 方法返回
// 通过返回值,进行向上转型
public static Animal fun2() {
return new Dog("旺财",3,"红色");
}
向下转型能让代码变得更加简单灵活,缺点就是不能调用到子类特有的方法。
8.2.5 向下转型
Java中为了提高向下转型的安全性,引入了instanceof ,如果该表达式为true,则可以安全转换。
public static void main(String[] args) {
Animal animal2 = new Bird("布谷",1);
//animal2.eat();
//animal2.fly();
Bird bird = (Bird) animal2;
bird.fly();
Animal animal1 = new Dog("旺财",3,"红色");
if (animal1 instanceof Bird) {
Bird bird2 = (Bird) animal1;
bird2.fly();
}else {
System.out.println("不一定所以的动物都是鸟");
}
}
8.2.6 多态的优缺点
使用多态的好处:
class Shape {
public void draw() {
System.out.println("画图形");
}
}
class Cycle extends Shape {
@Override
public void draw() {
System.out.println("⚪");
}
}
class Rect extends Shape {
@Override
public void draw() {
System.out.println("矩形");
}
}
class Triangle extends Shape {
@Override
public void draw() {
System.out.println("三角形");
}
}
public class Test {
public static void main(String[] args) {
Rect rect = new Rect();
Cycle cycle = new Cycle();
Triangle triangle = new Triangle();
String[] shapes = {"cycle", "rect", "cycle", "rect", "triangle"};
for (String shape : shapes) {
if (shape.equals("cycle")) {
cycle.draw();
} else if (shape.equals("rect")) {
rect.draw();
} else if (shape.equals("triangle")) {
triangle.draw();
}
}
}
}
用多态:
class Shape {
public void draw() {
System.out.println("画图形");
}
}
class Cycle extends Shape {
@Override
public void draw() {
System.out.println("⚪");
}
}
class Rect extends Shape {
@Override
public void draw() {
System.out.println("矩形");
}
}
class Triangle extends Shape {
@Override
public void draw() {
System.out.println("三角形");
}
}
public class Test {
// 使用多态
public static void main(String[] args) {
Rect rect = new Rect();
Cycle cycle = new Cycle();
Triangle triangle = new Triangle();
// 向上转型
Shape[] shapes = {cycle,rect,cycle,rect,triangle};
for (Shape shape : shapes) {
shape.draw();
}
}
}
class Flower extends Shape {
@Override
public void draw() {
System.out.println("❀");
}
}
public class Test {
public static void main(String[] args) {
Rect rect = new Rect(); // 相当于Shape rect = new Rect();
Cycle cycle = new Cycle();
Triangle triangle = new Triangle();
Flower flower = new Flower();
// 向上转型
Shape[] shapes = {cycle,rect,cycle,rect,triangle,flower};
for (Shape shape : shapes) {
shape.draw();
}
}
}
缺点: 代码的运行效率降低
8.2.7 避免在构造方法中调用重写的方法
当在父类的构造方法当中,调用父类和子类同名的方法时候,此时也会发生动态绑定。也意味着 构造方法内 也会发生动态绑定。
注意: 在构造方法当中 不要调用重写的方法。
class B {
public B() {
// 父类的实例 --> 父类的构造 --> 子类的实例 --> 子类的构造
func(); // 调用子类的func方法 没有给num赋值 所以num的值为0
}
public void func() {
System.out.println("B.func()");
}
}
class D extends B {
private int num = 1;
public D() {
super();
}
@Override
public void func() {
System.out.println("D.func() " + num);
}
}
public class Test2 {
public static void main(String[] args) {
//1. 分配内存空间 2. 调用合适的构造方法
D d = new D();
}
}
- 构造 D 对象的同时, 会调用 B 的构造方法.
- B 的构造方法中调用了 func 方法, 此时会触发动态绑定, 会调用到 D 中的 func
- 此时 D 对象自身还没有构造, 此时 num 处在未初始化的状态, 值为 0.。
- 所以在构造函数内,尽量避免使用实例方法,除了final和private方法。
结论:用尽量简单的方式使对象进入可工作状态,尽量不要在构造器中调用方法(如果这个方法被子类重写,就会触发动态绑定,但是此时子类对象还没构造完成),可能会出现一些隐藏的但是又极难发现的问题。
原文地址:https://blog.csdn.net/m0_63440113/article/details/134339081
本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。
如若转载,请注明出处:http://www.7code.cn/show_19641.html
如若内容造成侵权/违法违规/事实不符,请联系代码007邮箱:suwngjj01@126.com进行投诉反馈,一经查实,立即删除!