/*
多态的好处
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();
}
}
Java多态的好处和弊端,代码实例
最新推荐文章于 2024-06-26 09:35:10 发布