精华内容
下载资源
问答
  • 计算机代码的可扩充性和可维护性指的是? 多态作用如何理解?
  • 对java多态作用的理解

    2020-08-10 11:15:19
    多态的理解 先引用某位博主的原话,再对以下话的理解:原文链接 看Java核心技术这本书时,多态的内容讲解的很少,只是举个例子告诉我们怎样使用多态,而没有明确说明为什么使用多态的问题。 谈到面向对象的编程...

    对多态的理解


    先引用某位博主的原话,再对以下话的理解原文链接
    看Java核心技术这本书时,多态的内容讲解的很少,只是举个例子告诉我们怎样使用多态,而没有明确说明为什么使用多态的问题。

    谈到面向对象的编程语言时不可避免的就会介绍继承,子类可以继承父类除private外的成员变量和方法,并且可以添加自己的成员变量与方法,以实现自己独特的功能。

    但是如果在实际的开发中发现某个类的方法可以做出某些改进,但由于工程已经交付给用户使用,就不想增加不必要的麻烦!但以后再次创建该类的对象时就需要改进过来。

    同时又不影响程序其他部分对该方法的调用。也就是说,如果再次创建该类的对象是不能做出改进的,应该由该类产生一个子类,并且子类将重写需要改进的方法,由于程

    序中其他地方需要调用该方法,所以对象的类型如果被创建成子类的类型的话将不能被有效调用,这就需要用到向上转换了即创建一个子类对象但是将其类型转换为父类的

    类型。这样做之后,程序的其他地方调用它时就能正确调用了,而且相应的方法也得到了改进。

    由上可知:多态的存在有3个条件,1)要有继承 2)要有重写3)父类引用指向子类对象

    个人理解
    打个比方有一个类A,在类B中得到引用,在类C中也得到引用

    class A {
    	public void go(){
    		System.out.println("我要打篮球")
    	}
    }
    class B {
    	public  void UseA(A a){
    		a.go()
    	}
    }
    class C {
    	public void UseA(A a){
    		a.go()
    	}
    }
    

    现在我想改一下A类中的go方法,但是根据七大设计原则,直接对A修改会违反开闭原则,所以我们最好写一个子类去继承A

    class AChild extends A {
    	@override
    	public void go(){
    		System.out.println("我要打乒乓球")
    	}
    } 
    

    假如没有多态,那我们想用A的子类AChild,那就必须在B和C中把引用类型修改成AChild,也就是说要把B、C类里面的UseA类修改,那就违背了开闭原则。所以有了多态以后,我们只要创建一个需要修改的类的子类,以其父类作为引用类型,子类作为引用对象,就可以在修改想要修改的方法的同时又不影响其他类对该类的引用。

    不知道我这样理解对不对,还请大佬们指出。

    展开全文
  • 序言 ‘ 其实和抽象类的概念配合使用 ’ 1.增加了程序的灵活性 以不变应万变,不论对象千变万化,使用者都是同一种形式去调用,如func(animal) ...多态例子(简易版) peo = People() dog = Dog() pi...

    序言 ‘ 其实和抽象类的概念配合使用 ’


    1.增加了程序的灵活性

    以不变应万变,不论对象千变万化,使用者都是同一种形式去调用,如func(animal)

    2.增加了程序额可扩展性

    通过继承animal类创建了一个新的类,使用者无需更改自己的代码,还是用func(animal)去调用  


    多态例子(简易版)

    peo = People()
    dog = Dog()
    pig = Pig()
    
    #peo、dog、pig都是动物,只要是动物肯定有talk方法
    #于是我们可以不用考虑它们三者的具体是什么类型,而直接使用
    peo.talk()
    dog.talk()
    pig.talk()
    
    #更进一步,我们可以定义一个统一的接口来使用
    def func(obj):
        obj.talk()
    
    
    '''
    这样我们新

    多态例子(联动)

    import abc
    class Animal(metaclass=abc.ABCMeta): #同一类事物:动物
        @abc.abstractmethod
        def talk(self):
            pass
    
    class Dog(Animal): #动物的形态之:狗
        def talk(self):
            print('say wangwang')
    
    class Cat(Animal): #属于动物的另外一种形态:猫
        def talk(self):
           print('say miao')
    
    def func(animal): #对于使用者来说,自己的代码根本无需改动
        animal.talk()
    
    cat1=Cat() #实例出一只猫
    func(cat1) #甚至连调用方式也无需改变,就能调用猫的talk功能
    # say miao
    
    '''
    这样我们新增了一个形态Cat,由Cat类产生的实例cat1
    使用者可以在完全不需要修改自己代码的情况下。
    使用和人、狗、猪一样的方式调用cat1的talk方法,即func(cat1)
    '''
    展开全文
  • 多态

    2019-05-12 15:22:18
    概念: 声明父类变量来引用子类对象,或者声明接口变量来引用实现类对象 ... 多态作用在返回值类型上,可以返回更多的数据类型 多态特点: 多态情况下,子类和父类存在同名的成员属(静态和非...

    概念:

    声明父类变量来引用子类对象,或者声明接口变量来引用实现类对象

    使用多态前提:

    必须有继承或者实现条件下才能使用多态

     

    语法规则:

    父类的引用(变量)可以指向子类的对象

    可以将子类的对象赋值给父类类型的变量

    多态优点:

    1. 多态作用在形参上,可以接受更多的数据类型
    2. 多态作用在返回值类型上,可以返回更多的数据类型

    多态特点:

    1. 多态情况下,子类和父类存在同名的成员属(静态和非静态)性时,访问的是父类的成员属性
    2. 多态情况下,子类和父类存在同名的非静态成员函数时,访问的是子类的非静态函数
    3. 多态情况下,子类和父类存在同名的静态成员函数时,访问的是父类的静态函数
    4. 多态情况下,接口和实现类中存在函数,调用时访问的是实现类的函数

    多态的调用:

    1、向上转型

    Teacher teacher=new  Teacher();

    //new 出来的称为对象的类型

    //声明出来的 称之引用的类型

    一般的情况: 对象类型和引用的类型是同一种数据类型

    向上转型是指: 子类对象  赋予 父类的引用,向上转型是非常的安全

    Person person=new Teacher();

    2.向下转型

    向下转型: 把父类引用 赋予子类引用

        Student student=new Person();//绝对错误

    这是错误是Type mismatch: cannot convert from Person to Student 类型不匹配:无法从个人转换为学生

        Student student2= (Student) person ;
            student2.home();//绝对错误

    这是错误是Teacher cannot be cast to duotai.Student    老师不能投给多台,学生

    Person person1=new Student();
    Student student1= (Student) person1 ;//
    //向下转型不安全,能否转型成功取决于父类引用中保存的是哪个子类对象
    student1.home();

    必须判断父类引用中到底保存的是哪个类型的对象才可以向下转型,否则报错

    instanceof

    nstanceof 如果是,返回 ture 否则是false

    写法格式:

    1. Person person2 =new Teacher();
    2.         if(person2 instanceof Teacher ){
    3.             Teacher teacher1 = (Teacher)person2;
    4.             teacher1.home();
    5.             
    6.         } 

    代码如下:

    public class Person {
    	public String name;
    	public String job;
    	public int age;
    	public char sex;
    	
    	public void present() {
    		System.out.println("人高高兴兴地度过每一天");
    	}
    	public void work() {
    		System.out.println("对工作认真地负责");
    	}
    }
    
    
    public class Teacher extends Person {
    
    	public void shool() {
    			super.name="王五";
    		job="师范大学";
    		System.out.println(name+"在"+job+"教Java课");
    	}
    	public void home() {
    		super.name="王五";
    		System.out.println(name+"的家家庭充满知识的气氛");
    	}
    }
    
    public class Student extends Person{
    	String name="小花";
    	protected void operating() {
    		age=17;
    		System.out.println(name+"在"+age+"上高三");
    	}
    	public void home() {
    		
    		System.out.println(name+"在家庭看书");
    	}
    
    }
    
    public class Test {
    
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		//	向上转型
    		Teacher teacher=new  Teacher();
    		teacher.shool();
    		//向下转型 把父类引用 赋予子类引用
    		// Type mismatch: cannot convert from Person to Student
    		Student student=new Student() ;
    		
    		//Dog dog = (Dog)animal;  //向下转型
    		student.operating();
    		Person person=new Teacher();
    		person.work();
    		
    		Person person1=new Student();
    		Student student1= (Student) person1 ;
    		student1.home();
    		
    		//instanceof 如果是,返回 ture 否则是false
    		Person person2 =new Teacher();
    		if(person2 instanceof Teacher ){
    			Teacher teacher1 = (Teacher)person2;
    			teacher1.home();
    			
    		} 
    
    	}
    	
    }
    

     

    展开全文
  • 多态作用

    2017-09-09 20:59:00
    我们知道面向对象有三大特性:封装、继承、多态。 1、封装的作用是隔离和代码重用。...下面主要介绍多态作用。 3、多态 多态其实就是接口重用。多态和继承是紧密联系的,没有继承就没有多态,而多态使...

    我们知道面向对象有三大特性:封装、继承、多态。

    1、封装的作用是隔离和代码重用。隔离其实是低耦合的考虑,使得模块之间的关连变小;代码重用就不用多讲了,就是多处需要同一个对象时不用重复实现。

    而继承

    2、继承的作用是代码重用。但我觉得除了代码重用,继承更大的用作就是为了多态的使用。下面主要介绍多态的作用。

    3、多态

    多态其实就是接口重用。多态和继承是紧密联系的,没有继承就没有多态,而多态使得继承更有意义。

    多态的实现是由虚函数实现的。

    我们可以看一个应用场景:

    比如在发帖之前,我们要做很多loader动作:比如封禁词审核、图片审核、userinfo。那么我们可以定义一个抽象类

    class interface{

    virtual void startLoader();

    }

    然后构建一个数组interface* arr[];将我们需要做loader动作的子类指针装进数组,之后我们就可以异步的调用相应的startLoader()

    for auto it : arr{

      pthread_create(&t_id,NULL,(void*)it->startLoader,NULL);

    }

    这样就可以实现一个接口多种不同的调用。

    转载于:https://www.cnblogs.com/coderht/p/7499294.html

    展开全文
  • 多态作用? 虚函数的作用? 实现多态。(预留:虚函数的实现原理) 多态是什么? “一个接口,多种表现/实现”,多态性是提供一种技术,这种技术允许将父类指针或引用赋值为子类的指针或引用,进行这种赋值之后,...
  • 看了大量的资料和视频之后,我终于搞清了多态作用了,废话不多说,直接上干货! 多态的好处: 1.提高了代码的可维护性 2.提高了代码的扩展性 多态作用: 可以当做形式参数,可以接受任意子类对象 多态...
  • java多态及其作用

    2018-01-16 16:01:30
    多态 多态:一个对象具备多种形态。(父类的引用类型变量指向了子类的对象)或者是接口 的引用类型变量指向了接口实现类的对象) 多态的前提:必须存在继承或者实现 关系。 动物 a = new 狗(); ...
  • Java20多态实际作用

    2021-01-12 21:13:17
    多态作用:降低程序的耦合度,提高程序的扩展力。能使用多态尽量使用多态。父类型引用指向子类型对象。 核心:面向抽象编程,尽量不要面向具体编程。 public class Test { public static void main(String[] ...
  • 面向对象编程有三大特性:封装、继承、多态。 封装隐藏了类的内部实现机制,可以在不影响使用的情况下改变类的内部结构,同时也保护了数据。对外界而已它的内部细节是隐藏的,暴露给外界的只是它的访问方法。 继承...
  • java特性之多态作用

    2019-04-23 16:52:03
    多态有什么作用呢?比如:编译时类型为父类,运行时类型为子类;为什么要这样用?有什么意义?父类有的子类都有,父类没有的子类还是有(除了重写的方法)。 结合面向接口编程的好处,不难理解多态作用。但我不能...
  • 一个例子 把不同的bai子类对象都当作父类来看,可以屏蔽不同子类对象之间的差异,写出通用的代码,做出通用的编程,以适应需求的不断变化。 赋值之后,父对象就可以根据当前赋值给它的子对象的特性以不同的方式运作...
  • C++ 多态作用

    2015-06-23 20:26:00
    在面向对象的程序设计中使用多态,能够增强程序的可扩充性,即程序需要修改或增加功能 的时候,需要改动或增加的代码较少。 转载于:https://www.cnblogs.com/aqing1987/p/4596234.html...
  • JAVA 多态作用

    2013-02-04 19:14:31
    多态是面向对象的重要特性,简单点说:“一个接口,多种实现”,就是同一种事物表现出的多种形态。 编程其实就是一个将具体世界进行抽象化的过程,多态就是抽象化的一种体现,把一系列具体事物的共同点抽象出来, 再...
  • java 多态作用

    2012-02-14 10:06:35
    一道面试题 : 多态作用 ? 摘录 网友的 回答! 多态有编译时多态 和运行时多态。 第一个是通过方法重载实现;第二个是通过方法覆盖实现(子类覆盖父类方法)。 第一种就是我们调用方法是不用区分参数类型,...
  • 在继承中,常常用到多态多态作用是什么啊,对于直接书写 之间的好处有那些啊?

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 7,344
精华内容 2,937
关键字:

多态作用