精华内容
下载资源
问答
  • 什么是多态,多态好处和弊端
    千次阅读
    2018-04-20 01:31:11

    (1)多态:允许将子类型的指针赋给父类类型的指针,子类类型对象转变为父类类型

    对象。

    (2)好处:隐藏了子类类型,提高了代码的可扩展性。

    (3)弊端:只能使用父类的功能,无法使用子类的特有的功能,功能有限制。

    更多相关内容
  • 多态好处弊端

    2022-03-28 21:26:57
    1.不使用多态时: 好处:可以调用子类的特有行为 弊端:扩展性极差 2.使用多态时: 好处:扩展性强,让代码更灵活,提高代码的复用性 弊端:不能调用子类对象的特有行为(方法) 在使用多态时,要调用子类对象...

    1.不使用多态时:

    好处:可以调用子类的特有行为

    弊端:扩展性极差

    2.使用多态时:

    好处:扩展性强,让代码更灵活,提高代码的复用性

    弊端:不能调用子类对象的特有行为(方法)

    在使用多态时,要调用子类对象特有方法是,我们可以向下转型,这时,为了避免强转出现问题,我们应该使用instanceof关键字来判断关键字左边的变量是否为右边的类型,返回boolean类型的结果即可。

    展开全文
  • 多态好处和弊端

    2021-04-25 10:22:07
    package 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("猪吃白菜");
    
    }
    

    }

    多态的好处和弊端
    多态的好处:提高了程序的扩张性
    具体体现:定义方法的时候,使用父类型作为参数,将来在使用的时候,使用具体的子类型参与操作
    多态的弊端:不能使用子类的特有功能

    展开全文
  • 多态好处 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();
    	}
    }
    
    展开全文
  • 多态好处:A:提高了代码的维护性(继承保证)B:提高了代码的扩展性(由多态保证)猫狗案例代码1 classAnimal {2 public voideat(){3 System.out.println("eat");4 }56 public voidsleep(){7 System.out.println("sleep...
  • 多态好处和弊端: 1.多态好处:提高了程序的扩展性 具体:定义方法的时候,使用父类型作为参数,将来在使用的时候,使用具体的子类型参与操作 2.弊端:不能使用子类的特有功能 /** * @author Wrry * @...
  • 1.多态 2.多态访问特点 package java_learn; /* 多态多态成员访问特点: 1)成员变量:编译看左边,执行看左边; 2)成员方法:编译看左边,执行看右边。 为什么不一样?--因为成员方法有重写,而成员变量...
  • 多态好处弊端.pdf

    2021-08-10 13:51:12
    多态好处弊端.pdf
  • 多态好处和弊端以及对象的向上转型向下转型 多态好处 提高了代码的可维护性(继承保证) 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:03
    java8-3 多态好处和弊端以及多态的理解 多态好处: A:提高了代码的维护性(继承保证) B:提高了代码的扩展性(由多态保证) 猫狗案例代码 class Animal { public void eat(){ System.out.println("eat...
  • Java中多态好处弊端

    千次阅读 2019-04-23 22:03:07
    多态好处 1.提高的代码的维护性(继承保证,即可以通过改写父类属性与方法同义改写子类共有属性与方法) 2.提高了代码的扩展性(由多态保证,即父类为形式参数,接收任意子类对象,在开发的时候用多态,扩展性强)...
  • Java中多态好处: 提高了代码的维护性(继承保证) 提高了代码的扩展性 猫狗案例举例: //定义一个动物类 class Animal { public void eat() { System.out.println("eat"); } public void sleep()...
  • 02Java面向对象进阶-12. 多态好处和弊端*
  • 面向对象多态好处和弊端 优点 1.提高代码的维护性(由继承保证):上面修改了下面也跟着修改。 2.提高了代码的延展性(由多态保证)。 3.可以当做形式参数,可以接受任何类型的子类对象。 缺点 不能使用子类...
  • 多态好处和弊端 多态好处 可维护性 基于继承关系,只需要维护父类代码,提高了代码的复用性,大大降低了维护程序的工作量 为什么要学习多态 从程序的模块化复用性来解释 封装:隐藏数据的实现细节,让数据的...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 13,416
精华内容 5,366
关键字:

多态的好处和弊端

友情链接: 图像抖动与量化.zip