精华内容
下载资源
问答
  • 关于多态调用子类特有方法
    2020-08-29 17:11:00

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

    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()方法;

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


    结论

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

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

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

    展开全文
  • } //学生特有方法 public void study() { System.out.println("学生 " + getName() + "正在学java"); } } public class Teacher extends Person{ public double salary; public Teacher(String name, int age, ...
    public class Person {
        private String name;
        private int age;
    
        public Person() {
        }
    
        public Person(String name, int age) {
            this.name = name;
            this.age = age;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public int getAge() {
            return age;
        }
    
        public void setAge(int age) {
            this.age = age;
        }
    
        public String say() { // 返回名字和年龄
            return name + "\t" + age;
        }
    }
    
    public class Student extends Person{
        private double score;
    
        public Student() {
        }
    
        public Student(String name, int age, double score) {
            super(name, age);
            this.score = score;
        }
    
        public Student(String name, int age) {
            super(name, age);
        }
    
        public Student(double score) {
            this.score = score;
        }
    
        //重写父类say方法
        @Override
        public String say() {
            return super.say() + " score=" + score;
        }
    
        //学生特有的方法
        public void study() {
            System.out.println("学生 " + getName() + "正在学java");
        }
    }
    
    public class Teacher extends Person{
        public double salary;
    
        public Teacher(String name, int age, double salary) {
            super(name, age);
            this.salary = salary;
        }
    
        public double getSalary() {
            return salary;
        }
    
        public void setSalary(double salary) {
            this.salary = salary;
        }
    
        @Override
        public String say() {
            return super.say() + " salary=" + salary;
        }
    
        //特有的方法
        public void teach() {
            System.out.println("老师" + getName() + "正在讲java课程");
        }
    }
    
    public class PloyArray {
        public static void main(String[] args) {
            Person[] persons = new Person[5];
            persons[0] = new Person("jack", 20);
            persons[1] = new Student("jack", 18, 100);
            persons[2] = new Student("smith", 19, 30.1);
            persons[3] = new Teacher("scott", 30, 20000);
            persons[4] = new Teacher("king", 50, 25000);
    
            for (int i = 0; i < persons.length; i++) {
    //            System.out.println(persons[i].say());
    //            System.out.println(persons[i] instanceof Person);
                if (persons[i] instanceof Student) {
                    ((Student)persons[i]).study();
                } else if (persons[i] instanceof Teacher) {
                    ((Teacher)persons[i]).teach();
                }
            }
        }
    }
    
    //运行结果
    学生 jack正在学java
    学生 smith正在学java
    老师scott正在讲java课程
    老师king正在讲java课程
    
    展开全文
  • //在多态调用子类特有的功能 class Demo14 { public static void main(String[] args) { Animal mao =new Cat();//向上转型 //mao.eat(); //把Animal类型转成Cat类型 高---低 Cat xiaomao = (Cat)mao; /...
  • 多态是什么 父类如何调用子类方法(美团面试)

    千次阅读 多人点赞 2020-07-08 14:03:06
    这道题是来自牛客网的一位小哥在2019的最后一天面试系统开发工程师的补招的一个面试题目, 在Java面试中,多态是一个被问到的频率很高的一个概念。 面试官:什么是多态呢? 猪队友:多种形态,气体,液体,固体~ ...
  • ![图片说明](https://img-ask.csdn.net/upload/201707/27/1501140453_87633.png)...!... 如果 ,内存中应该Animal 的引用 指向的是堆内存中的new Dog();而方法区中 Dog.class 里应该有一个look();方法但是为什么不能调用/??
  • 以前调用子类方法的时候没有出现过这种状态,我估计是多态的情况下出现了问题,于是我准备换种方式试一下。 Student p1=new Student(); 果然不报错了。 但是多态的情况下没有办法解决的吗? 方法一 并不是,使用Alt+...
  • #include  using   namespace   std;   class   A { public :   virtual ...// 可以通过这种向下转型的方式,调用C中特有的成员函数   ( dynamic_cast *>(pc))->xFunc1();     return   0; }
  • 父类:A 子类:Person A a1 = new Person(); if(a1 instanceof Person) { System.out.println("true");... //调用子类独有的方法 } 转载于:https://www.cnblogs.com/paul011/p/8072796.ht...
  • /* 多态 1.没有继承就没有多态 ...1》父类类型的变量,不能直接调用子类特有方法,必须强转为子类类型变量后,才能直接调用子类特有方法 Animal*aa = [Catnew]; // Animal是父类 Cat是子类 Cat*dd...
  • 因为我们虽然创建的是子类对象,但实际上我们想要的是父类。正如基本数据类型那样: int i = 1; long l = i ;...或者只需要子类特有方法,那么为什么不直接创建子类对象呢? 个人愚见,欢迎讨论 ...
  • 多态 子类和父类方法

    2019-08-26 15:11:55
    子类和父类方法 简单研究一下子类和父类的方法。 class Animal { public void eat() { System.out.println("父类吃"); } public void drink() ... System.out.println("父类 特有方法"); } } class Cat e...
  • 如需调用子类特有方法,则不能使用多态形式创建子类对象
  • 这个问题其实很简单,但是今天有人突然一说竟然不知道该怎么做了,我记得是使用instance of,但有同事说这是判断是否是父类的,其实也可以判断是否是他的子类. 为了验证是否正确,我写了一个demo验证一下.1. Animal...
  • 源代码: package tiaoshi; class Fu{ public void show() { System.out.println(“Fu show”); } } class Zi extends Fu{ public void show() { System.out.println(“Zi show”);...System.out.prin...
  • 子类为airplane 拥有一个fly()方法 而父类transportation则没有这个方法 ... public class initial { public static void main(String[] args) { ...父类的引用指向子类对象时,父类不能调用子类方法。 父
  • 父类的引用指向子类的对象,要调用的就是父类的方法而不是子类方法,比如说定义一个父类animal类,一个子类 鸟类,鸟类有个独有的方法飞行。现在的情况是 Animal animal = new Bird (); 你要调用 animal.fly();...
  • 多态情况下,父类的引用调用和子类同名的普通成员变量,使用的是父类自己的成员变量 ...多态情况下,父类的引用不能调用子类特有的成员变量。 参考https://bbs.csdn.net/topics/391822759 总结就是,成员变量是静态...
  • 多态情况下如果需要调用子类特有的成员,那么需要进行强制类型转换。 基本数据类型: 小数据类型-----&gt;大数据类型 自动类型转换 大数据类型-----&gt;小数据类型 强制类型转换。 引用数据类型...
  • java中是不能通过多态访问子类特有的成员的,这时候可以使用instanceof和强制类型转换。 instanceof: java 中的instanceof 运算符是用来在运行时指出对象是否是特定类的一个实例。instanceof通过返回一个布尔...
  • 一、多态1、多态的三个前提 1)、存在继承关系 2)、子类重写父类方法 3)、父类数据类型的引用指向子类对象2、多态成员访问的特点 Animal am = new Cat(); 1)、成员变量:编译看左边(父类),运行看左边...
  • linkedlist 是list的实现类,但是其中的特有方法 不能通过List list = new LinkedList();来操作 会出现编译的异常 linkedlist 是个双向的链表,查询慢,但是删除快,和数组刚好是相反的 常用的子类中的操作的方法 ...
  • 如下错误代码: import java.util.LinkedList; import java.util.List; public class Demo2 { public static void main(String[] args) { List link = new LinkedList<...方法removeFirst()为单列集

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 28,011
精华内容 11,204
关键字:

多态调用子类特有方法