-
2018-04-20 01:31:11
(1)多态:允许将子类型的指针赋给父类类型的指针,子类类型对象转变为父类类型
对象。
(2)好处:隐藏了子类类型,提高了代码的可扩展性。
(3)弊端:只能使用父类的功能,无法使用子类的特有的功能,功能有限制。
更多相关内容 -
多态的好处与弊端
2022-03-28 21:26:571.不使用多态时: 好处:可以调用子类的特有行为 弊端:扩展性极差 2.使用多态时: 好处:扩展性强,让代码更灵活,提高代码的复用性 弊端:不能调用子类对象的特有行为(方法) 在使用多态时,要调用子类对象...1.不使用多态时:
好处:可以调用子类的特有行为
弊端:扩展性极差
2.使用多态时:
好处:扩展性强,让代码更灵活,提高代码的复用性
弊端:不能调用子类对象的特有行为(方法)
在使用多态时,要调用子类对象特有方法是,我们可以向下转型,这时,为了避免强转出现问题,我们应该使用instanceof关键字来判断关键字左边的变量是否为右边的类型,返回boolean类型的结果即可。
-
多态的好处和弊端
2021-04-25 10:22:07package itheima_03;... } } 多态的好处和弊端 多态的好处:提高了程序的扩张性 具体体现:定义方法的时候,使用父类型作为参数,将来在使用的时候,使用具体的子类型参与操作 多态的弊端:不能使用子类的特有功能package itheima_03;
public class Animal { public void eat(){ System.out.println("狗吃骨头");
}
}
package itheima_03;
/*
测试类
*/public class AnimalDemo { public static void main(String[] args) {
//创建动物操作类的对象,调用方法
AnimalOperator ao = new AnimalOperator(); Cat c = new Cat(); ao.useAnimal(c); Dog d = new Dog(); ao.useAnimal(d); pig p = new pig(); ao.useAnimal(p);
}
}
package itheima_03;
/*
动物操作类
*/public class AnimalOperator {
/*
public void useAnimal(Cat c){//cat c = new Cat();
c.eat();
}public void usAnimal(Dog d){ d.eat();
}
public void useAnimal(Dog d) {//Dog d = new Dog();
d.eat();} */
public void useAnimal(Animal a){ //Animal a = new Cat(); //Animal a = new Dog();
a.eat(); // a.lookDoor(); }
}
package itheima_03;
public class Cat extends Animal {
@Override
public void eat(){ System.out.println("猫吃鱼");
}
}
package itheima_03;
public class Dog extends Animal{
@Override
public void eat(){ System.out.println("狗吃骨头");
}
public void lookDoor(){ System.out.println("狗看门");
}
}
package itheima_03;
public class pig extends Animal{
@Override
public void eat(){ System.out.println("猪吃白菜");
}
}
多态的好处和弊端
多态的好处:提高了程序的扩张性
具体体现:定义方法的时候,使用父类型作为参数,将来在使用的时候,使用具体的子类型参与操作
多态的弊端:不能使用子类的特有功能 -
Java多态的好处和弊端,代码实例
2020-06-19 19:37:32多态的好处 A: 提高了代码的维护性(继承保证) B:提高了代码的扩展性(多态保证) */ /*猫狗的案例*/ class Animal{ public void eat(){ Systemout.println("eat"); } public void sleep(){ .../* 多态的好处 A: 提高了代码的维护性(继承保证) B:提高了代码的扩展性(多态保证) */ /*猫狗的案例*/ class Animal{ public void eat(){ Systemout.println("eat"); } public void sleep(){ Systemout.println("sleep"); } } class Dog extends Animal{ public void eat(){ Systemout.println("狗吃肉"); } public void sleep(){ Systemout.println("狗站着睡觉"); } } class Cat extends Animal{ public void eat(){ Systemout.println("猫吃鱼"); } public void sleep(){ Systemout.println("猫趴着睡觉"); } } class Pig extends Animal{ public void eat(){ Systemout.println("猪吃白菜"); } public void sleep(){ Systemout.println("猪躺着睡觉"); } } //针对动物操作的工具类 class AnimalTool{ private AnimalTool(){} /* //调用猫的功能 public static void useCat(Cat c){ c.eat(); c.sleep(); } //调用狗的功能 public static void useDog(Dog d){ d.eat(); d.sleep(); } } //调用猪的功能 public static void usePig(Pig p){ p.eat(); p.sleep(); } */ public static void useAnimal(Animal a){ a.eat(); a.sleep() } } class Dome{ public static void main(STring[] args){ //我养了一直猫 Cat c = new Cat(); c.eat(); c.sleep(); //我再养了一直猫 Cat c2 = new Cat(); c2.eat(); c2.sleep(); //我又养了一直猫 Cat c3 = new Cat(); c3.eat(); c3.sleep(); //问题来了,我养了很多只猫,每次创建对象时可以接受的 //但是,调用方法,不觉的很相似吗?仅仅对象名不一样 //所以我们用方法改进 //建立了一个新的类,针对动物操作的工具类 AnimalTool.useAnimal(c); AnimalTool.useAnimal(c2); AnimalTool.useAnimal(c3); //我养了一狗 Dog d = new Dog(); d.eat(); d.sleep(); AnimalTool.useAnimal(d); //我喜欢宠物猪 //定义一个猪类,它要继承自动物,提供两个方法,并且还得在工具类中添加该类的方法调用 Pig p = new Pig(); p .eat(); p .sleep(); AnimalTool.useAnimal(p ); //我喜欢宠物狼,老虎 //定义一个猪类,它要继承自动物,提供两个方法,并且还得在工具类中添加该类的方法调用 //前面个几个必须写 //但是,工具类每次都该,很麻烦 //所以我们在在工具类中写了一个方法 /* public static void useAnimal(Animal a){ a.eat(); a.sleep() */ //将来不管添加多少宠物,我接受的都是动物 } } /* 多态的弊端 //不能访问子类特有的功能 */ class Fu{ public void show(){ System.out.println("show Fu"); } } class Zi extends Fu{ public void show(){ System.out.println("show Zi"); } public void method(){ System.out.println("method Zi"); } } class Dome{ public static void main(Striing[] args){ //测试 Fu f = new Zi f.show(); //编译不通过 //不能访问子类特有的功能 f.method(); } } /* 多态的弊端 //不能访问子类特有的功能 怎么使用子类特有的功能呢? A:创建子类对象调用方法(可以,但是很多时候不合理,而且太占内存) B:把父类的引用强制转换为子类的引用。(向下转型) 对象的转型问题: 向上转型: //子类引用的对象转换为父类类型称为向上转型。通俗地说就是是将子类对象转为父类对象。此处父类对象可以是接口。 Fu f = new Zi();new出来的对象f在Zi但是引用却是指向Fu 向下转向: 如果不理解看9.11和9.12 Zi z = (Zi) f ;//要求该f必须是可以能够转换为Zi的 */ class Fu{ public void show(){ System.out.println("show Fu"); } } class Zi extends Fu{ public void show(){ System.out.println("show Zi"); } public void method(){ System.out.println("method Zi"); } } class Dome{ public static void main(Striing[] args){ //测试 Fu f = new Zi(); f.show(); //编译不通过 f.method(); /* //创建子类对象 Zi z = new Zi(); z.show(); z.method(); */ //能否把子类的对象赋值给父亲,那么我能不能把父的引用赋值给子的引用 //如下 Zi z = (Zi) f; z.show(); z.method(); } }
-
java8-3 多态的好处和弊端以及多态的理解
2021-03-05 16:29:48多态的好处:A:提高了代码的维护性(继承保证)B:提高了代码的扩展性(由多态保证)猫狗案例代码1 classAnimal {2 public voideat(){3 System.out.println("eat");4 }56 public voidsleep(){7 System.out.println("sleep... -
Java基础(封装、继承、多态)之 多态的好处和弊端
2020-08-12 18:20:10多态的好处和弊端: 1.多态的好处:提高了程序的扩展性 具体:定义方法的时候,使用父类型作为参数,将来在使用的时候,使用具体的子类型参与操作 2.弊端:不能使用子类的特有功能 /** * @author Wrry * @... -
java中多态,多态访问特点,多态的好处和弊端
2020-04-23 10:52:381.多态 2.多态访问特点 package java_learn; /* 多态: 多态成员访问特点: 1)成员变量:编译看左边,执行看左边; 2)成员方法:编译看左边,执行看右边。 为什么不一样?--因为成员方法有重写,而成员变量... -
多态的好处与弊端.pdf
2021-08-10 13:51:12多态的好处与弊端.pdf -
多态的好处和弊端以及对象的向上转型和向下转型
2020-07-28 00:11:33多态的好处和弊端以及对象的向上转型和向下转型 多态的好处 提高了代码的可维护性(继承保证) 2.提高了代码的扩展性(由多态保证) // An highlighted block var foo = 'bar'; -
多态的优点和弊端
2021-09-16 11:27:59提高了代码的扩展性(由多态保证) 2.弊端 不能访问子类特有的成员变量和成员方法 解决方法:把父类的引用强制转换为子类的引用。(向下转型) 案例演示 public class MyTest { public static void main(String[] ... -
多态的好处和弊端以及多态的理解
2018-01-31 18:51:03java8-3 多态的好处和弊端以及多态的理解 多态的好处: A:提高了代码的维护性(继承保证) B:提高了代码的扩展性(由多态保证) 猫狗案例代码 class Animal { public void eat(){ System.out.println("eat... -
Java中多态的好处与弊端
2019-04-23 22:03:07多态的好处 1.提高的代码的维护性(继承保证,即可以通过改写父类属性与方法同义改写子类共有属性与方法) 2.提高了代码的扩展性(由多态保证,即父类为形式参数,接收任意子类对象,在开发的时候用多态,扩展性强)... -
Java中使用多态的好处和弊端及其举例
2019-05-09 16:18:20Java中多态的好处: 提高了代码的维护性(继承保证) 提高了代码的扩展性 猫狗案例举例: //定义一个动物类 class Animal { public void eat() { System.out.println("eat"); } public void sleep()... -
02Java面向对象进阶-12. 多态的好处和弊端
2020-07-31 09:40:3702Java面向对象进阶-12. 多态的好处和弊端* -
面向对象多态的好处和弊端
2019-07-01 21:37:40面向对象多态的好处和弊端 优点 1.提高代码的维护性(由继承保证):上面修改了下面也跟着修改。 2.提高了代码的延展性(由多态保证)。 3.可以当做形式参数,可以接受任何类型的子类对象。 缺点 不能使用子类... -
Java基础_Java编程思想_面向对象之多态的好处和弊端
2021-03-12 00:52:26多态的好处和弊端 多态的好处 可维护性 基于继承关系,只需要维护父类代码,提高了代码的复用性,大大降低了维护程序的工作量 为什么要学习多态 从程序的模块化和复用性来解释 封装:隐藏数据的实现细节,让数据的...