精华内容
下载资源
问答
  • 关于多态调用子类特有方法 当使用多态方式调用方法时,首先检查父类中是否有该方法,如果有,再去调用子类的同名方法;如果没有,,只能向下转型 import javax.print.attribute.standard.RequestingUserName; ...

    当使用多态方式调用方法时,首先检查父类中是否有该方法,如果有,再去调用子类的同名方法;如果没有,,只能向下转型

    import javax.print.attribute.standard.RequestingUserName;
    import java.util.Scanner;
    public class testfather {
    	public static void main(String[] args)
    	{
    		Animal a = new fish(); //父类对象被赋以子类类型
    		/*Animal a;
    		fish b = new fish b;
    		a= b;      //向上转型,不丢失精度
    		a.talk();*/ //可达到相同效果
    		a.talk(); //fish覆写animal talk方法
    		Animal animal = new bird();
    		//animal .talk2(); //不能实现,因为animal中没有此方法,必须向下转型
    		bird b = (bird)c; //如果不进行转换,父类无法看到子类新扩充的方法
    		b.talk2();
    	}
    }
    class Animal
    {
    	public void talk() //如果父类方法不想被覆写,可改为public static void talk()
    	{
    		System.out.println("walk");
    	}
    }
    class fish extends Animal
    {
    	public void talk()
    	{
    		System.out.println("swim");
    	}
    }
    class bird extends Animal
    {
    	public void talk()
    	{
    		System.out.println("fly");
    	}
    	public void talk2()
    	{
    		System.out.println("i am a bird");
    	}
    }
    
    展开全文
  • 多态调用子类特有方法的两种方式 在日常撸代码的过程当中,总结了多态调用子类特有方法的2种方式,现整理如下,如有错误,欢迎批评指正,不多说,先上代码! public class Animal{ //父类 public void...

    多态中调用子类特有方法的两种方式

    在日常撸代码的过程当中,总结了多态中调用子类特有方法的2种方式,现整理如下,如有错误,欢迎批评指正,不多说,先上代码!

    public  class  Animal{								//父类
      		public void eat(){
      			System.out.println("eat thing");
      		}
    }
    
    class Cat extends Animal{							//子类
    	   public void eat(){
    	   		System.out.println("eat fish");
    		}
    		public void catchMouse(){
    			System.out.println("catch Mouse");
    		}
    		public void climbTree(){
    			System.out.println(" climbTree");
    		}
    }
    

    一.父类强转成子类,调用特有方法。

    此种方式是我们用得最多的一种,相信大家也非常熟悉

    main{
    	Animal a = new Cat();  
    	//a.catchMouse;        此行会报错,父类不能直接调用子类的特有方法,需向下强转成子类对象
    	  Cat  c =(Cat)a;	   //强转成子类对象
    	c.catchMouse;          //调用成功  输出“catch Mouse”
    }
    

    二.匿名内部类对象定义特有方法,并对其调用

    匿名内部类的大坑

    创建匿名内部类,其中定义特有方法,并让其指向父类引用,我们会发现,
    此父类是不能调用特有方法的。
    (匿名内部类其实就是表示继承一个类的子类的匿名对象。其也会受到多态的限制)

    main{
    	Animal a=new Animal(){
    			void catchMouse(){         
    			System.out.println(“catchmouse”); 		
    			}                                  
    	};					   //相当于创建一个子类对象,并让a指向它
    	a.catmouse();          //此行会报错      父类a不能直接调用子类的特有方法。
    }
    

    等号右边虽然盖着Animal的类名,但实际上系统认为它还是Animal的子类。
    所以父类对象a不能直接调用特有方法。

    解决方式:匿名内部类,不让他指向父类变量,直接调用方法

    main{
    	new Animal(){							 
    		public void catchMouse(){                   
    			System.out.println(“catchmouse”); 		
    		}                                  
    	}.catchMouse();         //输出“catch Mouse”
    }
    

    三. 1、2方法对比

    当已经有定义好一个子类时,我们常用强转方法,它有以下优点
    1父类强转成子类后,可多次调用子类的特有方法,
    2.可灵活调用子类各种特有方法()

    ...
    ...
    Cat     c=(Cat)a;	   //强转成子类对象
    c.catchMouse;          //调用成功  输出“catch Mouse”
    c.catchMouse;          //调用成功  输出“catch Mouse”
    c.catchMouse;          //调用成功  输出“catch Mouse”
    c.climbTree();		   //调用成功  输出“climbTree”
    c.climbTree();		   //调用成功  输出“climbTree”
    

    当我们没有定义好一个子类时,且也不想去定义这个子类的时候,只想临时用一下,我们可以采用匿名内部类对象方法,它有以下优劣点
    1.省去了定义子类的过程
    2.较适合于临时,突发性, 想调用一个特有方法时。
    3.它想多次调用一个特有方法时,没有1方法方便

    展开全文
  • 子类对象调用子类特有方法(Java多态) 在使用多态时,可以让我们把具有共同特性的多个类更加方便地使用,但是简单的多态使用会导致一个很严重的问题,就是子类对象只能调用子类中重写的父类方法,而不能调用子类...

    子类对象调用子类特有的方法(Java多态)

    前言

    在使用多态时,可以通过重写父类成员方法实现提升代码效率,然而在实例化对象后,对父类或者子类的成员变量和方法的访问却并不是想象中的那么简单能直接使用,对于此问题我们通过此篇文章进行相关的讨论。

    问题引入

    在使用多态时(即一般的向上转型),可以让我们把具有共同特性的多个类更加方便地使用,但是简单的多态使用会导致一个很严重的问题,就是子类对象只能调用子类中重写的父类方法,而不能调用子类特有的方法;并且对于成员变量,向上转型(也就是一般的多态)只能调用父类的成员变量,而不能访问子类的成员变量,这是很让人头疼的,Java多态提供了一种解决办法,就是多态的转型。

    转型介绍

    转型又分为两类,向上转型和向下转型。

    • 向上转型就是子类创建的对象转型为原本继承的父类对象,后面我们会拿代码进行具体解释;
    • 向下转型就是将向上转型反过来,是将父类对象强制转为子类对象,代码在下面进行具体解释;
    代码

    父类
    类成员描述如下:成员有成员变量name和成员方法eat()方法;

    public class Animal {
    	public String name = "CSDN";
    	public void eat() {
    		System.out.println("动物吃饭");
    	}
    }
    

    子类
    类描述如下:继承了父类,成员有成员变量age、重写的eat()方法和自己特有的game()方法;

    public class Cat extends Animal{
    	public int age = 20;
    	@Override
    	public void eat() {
    		System.out.println("小猫咪吃饭");
    	}
    	public void game() {
    		System.out.println("小猫咪玩游戏");
    	}
    }
    

    向上转型测试类

    public class MainTest{
    	public static void main(String args[]){
    		Animal a = new Cat();//向上转型
    		a.eat();
    		//a.game(); 无法调用 注释掉
    		System.out.println("名字:"+a1.name);
    		//System.out.println(a1.age);  无法使用子类的成员变量 注释掉
    	}
    }
    

    输出结果

    小猫咪吃饭
    名字:CSDN
    

    结论:测试中,通过多态的方式创建对象时其实就是向上转型,测试中调用了父类成员变量name和子类成员变量age,父类eat()方法和子类game()方法,结果显示父类成员变量调用成功,子类成员变量调用失败,父类eat()方法调用成功但无法调用子类中特有的game()方法;

    向下转型测试类
    类的描述如下:

    public class MainTest{
    	public static void main(String args[]){
    		Animal a = new Cat();
    		Cat c = (Cat)a;//向下转型
    		c.eat();
    		c.game(); //调用成功
    		System.out.println("名字:"+c.name);
    		System.out.println("年龄:"+c.age); //输出成功
    	}
    }
    

    输出结果

    小猫咪吃饭
    小猫咪玩游戏
    名字:CSDN
    年龄:20
    

    结论:通过向下转型,我们成功地调用了子类和父类中的所有成员和子类特有的game()方法;

    友情提示:可以近似地把转型理解为强转,但兼具了子类和父类的特征

    结论

    通过多态转型后我们可以访问到子类的特有方法,并且可以访问到父类和子类的成员,如果向下转型,创建的对象在访问成员变量时,只能访问父类的成员变量与子类重写的父类的成员方法,而向下转型后可以访问到所有的成员变量和方法。

    小伙伴们可以下去测试测试,具体代码在我们在下面给出,需要的可以测试一下结果是否如此。

    口诀来啦
    向上转,变量方法都看父类,方法必须是子类重写的方法
    向下转,无限制!

    感谢阅读,希望我的文章能对你有所帮助~有什么疑问或者不对的地方欢迎在评论区留言评论。

    展开全文
  • //在多态调用子类特有的功能 class Demo14 { public static void main(String[] args) { Animal mao =new Cat();//向上转型 //mao.eat(); //把Animal类型转成Cat类型 高---低 Cat xiaomao = (Cat)mao; /...

    abstract class Animal
    {
    public abstract void eat();
    }

    class Cat extends Animal
    {
    public void eat(){
    System.out.println(“猫吃鱼”);
    }

    public  void catchMouse(){
       System.out.println("猫抓耗子");
    }
    

    }
    class Dog extends Animal
    {
    public void eat(){
    System.out.println(“狗吃骨头”);
    }
    public void kanHome(){
    System.out.println(“看家”);
    }
    }

    //在多态中调用子类特有的功能
    class Demo14
    {
    public static void main(String[] args)
    {
    Animal mao =new Cat();//向上转型
    //mao.eat();

        //把Animal类型转成Cat类型  高---低
    	Cat xiaomao = (Cat)mao; //向下转型
    	//xiaomao.catchMouse();
    
        Dog dog = new Dog();
    	chi(dog);
    
    }
    
    public static void chi(Animal dw)//Animal dw=new Cat()
    {
         dw.eat();
    
         if(dw instanceof Cat){
    	    Cat mao = (Cat)dw;
    		mao.catchMouse();
    	 }
    
    	 if(dw instanceof Dog){
    	    Dog dog = (Dog)dw;
    		dog.kanHome();
    	 }
    
    
    }
    

    }

    展开全文
  • } //学生特有方法 public void study() { System.out.println("学生 " + getName() + "正在学java"); } } public class Teacher extends Person{ public double salary; public Teacher(String name, int age, ...
  • /* 多态 1.没有继承就没有多态 ...1》父类类型的变量,不能直接调用子类特有方法,必须强转为子类类型变量后,才能直接调用子类特有方法 Animal*aa = [Catnew]; // Animal是父类 Cat是子类 Cat*dd...
  • ![图片说明](https://img-ask.csdn.net/upload/201707/27/1501140453_87633.png)...!... 如果 ,内存中应该Animal 的引用 指向的是堆内存中的new Dog();而方法区中 Dog.class 里应该有一个look();方法但是为什么不能调用/??
  • 如图:方法removeFirst()为单列集合LinkedList的特有方法,如果使用多态来创建对象,则根据多态的“编译看左边,运行看右边”,在编译期会报错 故直接使用子类自己创建对象: import java.util.LinkedList; ...
  • #include  using   namespace   std;   class   A { public :   virtual ...// 可以通过这种向下转型的方式,调用C中特有的成员函数   ( dynamic_cast *>(pc))->xFunc1();     return   0; }
  • 多态方法调用问题

    2019-09-24 18:11:47
    * 2: 多态情况下,子类中存在跟父类同名的非静态方法时,调用的是子类中的方法 * 3: 多态情况下,子类中存在跟父类同名的静态方法时,访问的是父类中的方法 * 4: 多态情况下,访问不到子类特有的成员 转载于:...
  • 因为我们虽然创建的是子类对象,但实际上我们想要的是父类。正如基本数据类型那样: int i = 1; long l = i ;...或者只需要子类特有方法,那么为什么不直接创建子类对象呢? 个人愚见,欢迎讨论 ...
  • 多态情况下,父类的引用调用和子类同名的普通成员变量,使用的是父类自己的成员变量 ...多态情况下,父类的引用不能调用子类特有的成员变量。 参考https://bbs.csdn.net/topics/391822759 总结就是,成员变量是静态...
  • 多态

    2017-06-06 17:29:07
    向上转型后通过父类引用变量调用的方法是子类覆盖或继承父类的方法,通过父类引用变量无法调用子类特有方法。 向下转型后可以访问子类特有的方法。必须转换为父类指向的真是子类类型,否则
  • 多态的缺点以及解决办法 * 缺点: 通过多态的父类引用无法访问子类所特有的方法 向上转型(自动转换) 格式:<父类型>...此时通过父类引用变量无法调用子类特有的属性和方法 向下转型(强制...
  • 父类引用指向子类对象,多态

    千次阅读 2016-08-31 20:30:03
    多态: 父类引用指向子类对象,即创建...如果想要调用子类特有方法时需要向下转型,即将父类强制转化为子类然后对子类方法进行调用。class Animal{ private String name; private String sounds; public Animal()
  • 多态总结

    2016-09-22 23:57:03
    多态调用时,使用父类变量指向子类对象,只能调用父类中定义的方法或属性,不能调用子类特有方法或属性。 如果子类从写了父类的 方法,会优先调用子类重写方法。 子类重写父类的方法,要求子类方法访问修饰...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 451
精华内容 180
关键字:

多态调用子类特有方法