精华内容
下载资源
问答
  • Java的多态表现在哪里

    千次阅读 2019-02-18 15:03:14
    多态要有动态绑定,否则就不是多态,方法重载也不是多态(因为方法重载是编译期决定好的,没有后期也就是运行期的动态绑定) 当满足这三个条件 1.有继承 2,有重写 3要有父类引用指向子类对象 ...

    多态要有动态绑定,否则就不是多态,方法重载也不是多态(因为方法重载是编译期决定好的,没有后期也就是运行期的动态绑定)

    当满足这三个条件

    1.有继承

    2,有重写

    3要有父类引用指向子类对象 

    展开全文
  • java的多态表现在哪里

    千次阅读 2019-04-14 21:52:33
    多态是同一个行为具有多个不同表现形式或形态的能力。 多态就是同一个接口,使用不同的实例而执行不同操作。 比如同一个打印机,可以打印黑白的纸张也可以打印彩色的,同样是人,却有黑人白人之分。 ...

    多态是同一个行为具有多个不同表现形式或形态的能力。
    多态就是同一个接口,使用不同的实例而执行不同操作。
    比如同一个打印机,可以打印黑白的纸张也可以打印彩色的,同样是人,却有黑人白人之分。

    展开全文
  • C/C++继承类的多态表现

    千次阅读 2016-12-29 16:14:48
    学过C++和Java的人都知道,他们二者由于都可以进行面向对象编程,而面向对象编程的三大特性就是封装、继承、多态,所有今天我们就来简单了解一下C++和Java在多态这方面的不同。 首先我们各看一个案例。 C++ //...

    学过C++和Java的人都知道,他们二者由于都可以进行面向对象编程,而面向对象编程的三大特性就是封装、继承、多态,所有今天我们就来简单了解一下C++和Java在多态这方面的不同。

    首先我们各看一个案例。

    C++

    //测试继承与多态
    class Animal {
    
    public:
    	char name[128];
    	char behavior[128];
    
    	void outPut() {
    		cout << "Animal" << endl;
    	}
    
    	void outPutAnimal() {
    		cout << "Father" << endl;
    	}
    
    	Animal() {
    		strcpy(name, "Animal");
    		strcpy(behavior, "Call");
    	}
    };
    
    class Dog: public Animal {
    
    public:
    	//子类定义一个和父类相同的属性
    	char name[128];
    	char sex;
    
    	//子类重写父类方法
    	void outPut() {
    		cout << "Dog" << endl;
    	}
    
    	void outPutDog() {
    		cout << "Son" << endl;
    	}
    
    	Dog() {
    		strcpy(name, "Dog");
    		sex = 'M';
    	}
    };
    

    以上两个类都很简单,我们来看一下其测试代码和结果。

    /*
    没有多态的情况下测试结果和Java相同
    	Dog dog;
    	cout << dog.name << endl;
    	cout << dog.sex << endl;
    	cout << dog.behavior << endl;
    	dog.outPut();
    	dog.outPutAnimal();
    	dog.outPutDog();
    	
    	//可通过如下方式访问父类的行为
    	dog.Animal::outPut();
    */
    
    //多态的情况下:
    	Animal *dog = new Dog;
    
    	cout << dog->name << endl;
    	cout << dog->behavior << endl;
    	dog->outPut();
    	dog->outPutAnimal();
    
    //测试结果
    Animal
    Call
    Animal
    Father
    

    可以看出所有的表现都是父类的行为,无论是相同的属性还是重写的方法。在这里需要说明一下,**如果子类隐藏了父类的成员函数,则父类中所有同名的成员函数(重载的函数)均被隐藏。**如果想要访问父类中被隐藏的函数,需要通过父类名称来访问(dog.Animal::outPut();)。
    在多态的情况下我们访问的都是父类的行为,那怎样才能访问到子类的函数呢?答案是通过定义虚函数来实现,这个我们后面的博文讲解。

    现在我们在来看一下Java的表现。

    Java

    //父类
    public class Animal {
    
    	public String name = "Animal";
    	public String behavior = "Call";
    	
    	public void outPut() {
    		System.out.println("Animal");
    	}
    
    	public void outPutAnimal() {
    		System.out.println("Father");
    	}
    }
    
    //子类
    public class Dog extends Animal{
    	
    	public String name = "Dog";
    	public char sex = 'M';
    
    	public void outPut() {
    		System.out.println("Dog");
    	}
    
    	public void outPutDog() {
    		System.out.println("Son");
    	}
    }
    

    子类也是定义了一个和父类相同的属性,同时也重写了父类的一个方法,我们看一下其测试方法和测试结果。

    public static void main(String[] args) {
    
    	Animal dog = new Dog();
    
    	System.out.println(dog.name);
    	System.out.println(dog.behavior);
    	dog.outPut();
    	dog.outPutAnimal();
    
    }
    
    //测试结果
    Animal//父类行为
    Call
    Dog//表现的是子类的行为
    Father
    

    从这里可以看出,Java和C++还是有区别的,Java的属性表现的是父类的行为,但是重写的方法却是子类的行为,而C++全部都是父类的行为。

    Python

    class Animal:
        name = 'Animal'
        ani_b = 'Animal b'
        __ani_c = 'Animal c'
    
        def run(self):
            print('Animal is running')
    
    class Dog(Animal):
        name = 'Dog'
        dog_d = 'Dog d'
    
        def run(self):
            print('Dog is running')
    
        def eat(self):
            print('Dog eat')
    
    class Cat(Animal):
        name = 'Cat'
        __cat_c = 'Cat e'
        
        def run(self):
            print('Cat is running')
    
        def sleep(self):
            print('Cat sleep')
    
    def run_twice(mal):
        mal.run()
    
    
    ani = Animal()
    dog = Dog()
    cat = Cat()
    print('--------------------')
    ani.run()
    dog.run()
    cat.run()
    dog.eat()
    cat.sleep()
    print('--------------------')
    print(ani.name)
    print(dog.name)
    print(cat.name)
    print('--------------------')
    print(ani.ani_b)
    print(dog.ani_b)
    print(cat.ani_b)
    print('--------------------')
    # print(ani.__ani_c)
    print(dog.dog_d)
    # print(cat.__cat_c)
    print('--------------------')
    print(isinstance(dog, Dog))
    print(isinstance(dog, Animal))
    print(isinstance(dog, Cat))
    print('--------------------')
    run_twice(dog)
    run_twice(cat)
    run_twice(ani)
    
    --------------------
    Animal is running
    Dog is running
    Cat is running
    Dog eat
    Cat sleep
    --------------------
    Animal
    Dog
    Cat
    --------------------
    Animal b
    Animal b
    Animal b
    --------------------
    Dog d
    --------------------
    True
    True
    False
    --------------------
    Dog is running
    Cat is running
    Animal is running
    

    总结

    Java的属性表现的都是父类的行为,但是重写的方法却是子类的行为,
    C++全部都是父类的行为,但是virtual函数会表现出子类的行为。

    展开全文
  • 向上转型实现的父类的方法 向下转型实现的是子类和父类的方法 Father { private String name; public String getName() { return this.name; } public void print() { System.out.println("父亲被覆写的方法...

    向上转型实现的父类的方法
    向下转型实现的是子类和父类的方法

     Father {
        private String name;
    
        public String getName() {
            return this.name;
        }
        public void print() {
            System.out.println("父亲被覆写的方法");
        }
    
        public void print1() {
            System.out.println("父亲未被覆写的方法");
        }
    }
    class Son extends Father {
        private String name;
    
        public void print() {
            System.out.println("儿子覆写了的方法");
        }
    
        public void SonMethod() {
            System.out.println("son独有的方法");
        }
    }
    public class ReverObject {
        public static void main(String[] args) {
            //核心你使用的是哪一个子类(new在哪里),而且调用的方法是否被子类所覆写了。
    
            //这个时候父类只能调用父类非私有的方法,如果被覆写了就输出覆写的方法
            // 如果父类的方法没有被覆写的话输出的是父亲的方法
            Father father = new Son();
            father.print();//此时输出的是:"儿子覆写了的方法"
            father.print1();//输出的是:“父亲未被覆写的方法”
    
            //error 父类里面没有这个方法
            //father.SonMethod();
    
            //此时就继续向下转型,让父类可以调用子类的方法,也可以调用父类的方法
            if (father instanceof Son) {
                Son son = (Son) father;
                son.SonMethod();// son独有的方法
                 son.print();//儿子覆写了的方法
                 son.print1();//父亲未被覆写的方法
            }
        }
    }
    
    

    Father father = new Son();
    father可以访问的是

    • 父类Father独有的public、protected方法,static修饰的方法可以访问,private方法不可以被访问
    • Son独有的但是父类没有的都不可以被访问
    • 本来要访问父类的方法,但是如果方法被Son覆写了那么father访问的就是覆写后的方法
      private方法永远无法被外界直接访问,被覆写
      总结
    1. 对象多态性的核心在于方法的覆写。
    2. 通过对象的向上转型可以实现接收参数的统一,向下转型可以实现子类扩充方法的调用(一般不操作向下转型,有安全隐患)。
    3. 两个没有关系的类对象是不能够进行转型的,在转型之前先进行instanceof看能否转型的判断一定会产生ClassCastException。
    展开全文
  • JAVA中的多态表现形式

    2012-06-13 18:18:06
    表现形式。 我看thinking in java3中的多态 People are often confused by other, non-object-oriented features of Java, like method overloading, which are sometimes presented as object-oriented. Don’t ...
  • “晚上好”是父类方法的输出,而“子类”是子类方法的输出,这是由于greeting是一个静态方法,它没有运行时多态的特性,它的调用在s声明时就已经确定好了 造成这种区别的原因很简单,实例方法总是和某个对象绑定在...
  • 先看一段代码 public class Test1 { /** * @param args */ public static void main(String[] args) { // TODO Auto-generated method stub Parent p = new Child(); System.out
  • 这是由于greeting是一个静态方法,它没有运行时多态的特性,它的调用在s声明时就已经确定好了 造成这种区别的原因很简单,实例方法总是和某个对象绑定在一起,而静态方法则没有与某个对象绑定在一起也就无从查找...
  • 多态

    2021-01-05 14:51:36
    1、概念: 一个事物的多种形态。父类类型引用指向子类...(2)子类重写父类方法,多态多态表现是重写。 (3)父类类型引用指向子类对象,多态语法。 4、代码示例 class Pet { String name; public void eat() { Syst
  • 多态表现形式

    千次阅读 2019-01-02 16:14:53
    1.多态的定义 2.多态的三种形式 3.多态的编译和运行 4.多态的转型 5.多态的好处 6.多态的弊端 1.多态的定义 多态、封装和继承是面向对象的三大特性。多态需满足三个条件:(1)有继承;(2)有重写;(3)有...
  • 多态表现

    2020-08-04 21:50:53
  • 多态1)、什么是多态多态指的是同一种类型的事物,不同的形态2)、多态的目的“多态” 也称之为 “多态性”,目的是为了 在不知道对象具体类型的情况下,统一对象调用方法的规范(比如:名字)3)、多态的三种表现形式① ...
  • [TOC]## 多态多态指的是一类事物有多种形态,比如动物有多种形态:人,狗,猪~~~import abcclass Animal(metaclass=abc.ABCMeta): #同一类事物:动物@abc.abstractmethoddef talk(self):passclass People(Animal): #...
  • 多态表现特点

    2016-05-02 14:40:53
    多态的定义:是指允许不同类的对象对同一个消息作出不同的响应,即同一个消息可以根据发送对象的不同,采取多种不同的行为方式。  (发送消息即是方法的调用)  其中多态实现:属于动态绑定的一种。比如:一个...
  • Java中多态表现形式

    千次阅读 2019-02-06 20:28:25
    概念:同一个类实例的相同方法在不同情形下有不同的表现形式 方法多态: 方法重载:同一个方法名称可以根据参数的类型或个数不同调用不同的方法体 方法覆写:同一个父类的方法可以根据实例化子类的不同也有不同的...
  • Java之多态表现形式

    2017-11-02 23:02:49
    多态: 字面意思是多种形态。在Java中,方法的多种不同实现方式就是多态多态分为两类: 编译时多态:在编译期,编译器会根据方法名和参数列表来绑定程序想要运行的是哪个方法。 方法重载 方法重载的注意事项: ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 4,633
精华内容 1,853
关键字:

多态表现