精华内容
下载资源
问答
  • 多态表现形式

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

    目录

     

    1.多态的定义

    2.多态的三种形式

    3.多态的编译和运行

    4.多态的转型

    5.多态的好处

    6.多态的弊端


    1.多态的定义

    多态、封装和继承是面向对象的三大特性。多态需满足三个条件:(1)有继承;(2)有重写;(3)有父类引用指向子类对象。最终多态体现为父类引用可以指向子类对象:父类类型 变量名 = new 子类类型()。

    2.多态的三种形式

    (1)普通类多态定义的格式:父类类型 变量名 = new 子类类型()。

    class Father {
        int num = 4;
    }
    
    class Son extends Father {
        int num = 5;
    }
    
    //普通类多态形式
    Father father = new Son();

    (2)抽象类多态定义的格式

    abstract class Father {
        abstract void method();
    }
    
    class Son extends Father {
        public void method() {
            System.out.println("abstract");
        }
    }
    
    //抽象类多态表现形式
    Father father = new Son();

    (3)接口多态定义的格式

    interface Father {
        public void method();
    }
    
    class Son implements Father{
        public void method() {
            System.out.println("implements")
        }
    }
    
    //接口多态的表现形式
    Father father = new Son();

    3.多态的编译和运行

    (1)成员变量:编译和运行都看左边。

    (2)成员方法:编译看左边,运行看右边。

    4.多态的转型

    (1)向上转型:子类对象赋值给父类对象引用。

    使用格式:父类类型 变量名 = new 子类类型()

    (2)向下转型:父类对象引用强制转换为子类对象引用。

    使用格式:子类类型 变量名 = (子类类型)父类类型

    5.多态的好处

    (1)向上转型:隐藏了子类类型,提高代码的扩展性。

    (2)向下转型:可以使用子类特有功能。

    6.多态的弊端

    (1)向上转型:只能使用父类共性的内容,无法使用子类特有功能。

    (2)向下转型:容易发生类型转换异常(ClassCastException)。

    展开全文
  • 多态表现形式有哪些?

    千次阅读 2019-08-28 08:42:23
    1.方法重载 通常在一个类中,相同的方法对应着不同的方法实现,这些方法名相同的方法其区别在于方法参数不同。 2.方法重写 ...在多态机制中,接口比抽象类使用起来更方便,而抽象类组成的集合就是接...

    1.方法重载

    通常在一个类中,相同的方法对应着不同的方法实现,这些方法名相同的方法其区别在于方法参数不同。

    2.方法重写

    方法重写主要用于父类和子类之间,子类重写父类的方法,只是对用方法的实现不同,方法名和参数相同。

    3.抽象类

    在Java语言中,一个类中的方法中给出了标准,而没有给出具体的实现方法,这样的类就是抽象类。

    4.接口

    在多态机制中,接口比抽象类使用起来更方便,而抽象类组成的集合就是接口。

    展开全文
  • Java中多态表现形式

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

    概念:同一个类实例的相同方法在不同情形下有不同的表现形式

    在Java中,对于多态的核心表现主要有以下两点:

    1. 方法多态:

    ① 方法重载:同一个方法名称可以根据参数的类型或个数不同调用不同的方法体

    ② 方法覆写:同一个父类的方法可以根据实例化子类的不同也有不同的实现

    方法多态之前的文章里面详细阐述过,在此不再赘述。

    2. 对象多态:

    ① 向上转型(90%):

    天然发生,认爹过程,指的是将子类对象变成父类对象

    语法:父类 父类引用 = 子类实例;,例如Person per = new Student();

    class Person {
        public void print() {
            System.out.println("父类");
        }
    }
    class Student extends Person {
        public void print() {
            System.out.println("子类");
        }
    }
    public class XiangShangZhuanXing {
        public static void main(String[] args) {
            Person per = new Student();
            per.print();
        }
    }
    

    在这里插入图片描述

    • 结论:不管是否发生了向上转型,核心本质还是在于:你使用的是哪一个子类(new在哪里),而且调用的方法是否被子类所覆写了。

    应用场景:参数统一化

    例如:要求定义一个方法,这个方法可以接收Person类的所有子类实例,并调用Person类的方法。

    class Person {
        public void print() {
            System.out.println("1.我是人类!");
        }
    }
    class Student extends Person {
        public void print() {
            System.out.println("2.我是学生!");
        }
    }
    class Worker extends Person {
        public void print() {
            System.out.println("3.我是工人!");
        }
    }
    public class CanShuTongYiHua {
        public static void main(String[] args) {
            //Person per = new Student();
            WhoYouAre(new Student());
            //Person per = new Worker();
            WhoYouAre(new Worker());
        }
        public static void WhoYouAre(Person per) {
            per.print();
        } 
    }
    

    在这里插入图片描述

    ② 向下转型(1%):

    需要强转,指的是将父类对象变成子类对象

    语法:子类 子类实例 = (子类)父类实例;,例如Student stu = (Student) per;

    • 问题:向下转型存在的意义或者为什么我们需要向下转型?
    class Person {
        public void print() {
            System.out.println("父类");
        }
    }
    class Student extends Person {
        public void print() {
            System.out.println("子类");
        }
        public void fun() {
            System.out.println("只有子类有");
        }
    }
    public class XiangXiaZhuanXing {
        public static void main(String[] args) {
            Person per = new Student();
            per.print();
            System.out.println("==========");
            Student stu = (Student) per;
            stu.fun();
        }
    }
    

    在这里插入图片描述

    • 结论:在上述代码中父类能调用的就只有本类定义好的方法,并没有Student类中的fun()方法,如果父类要想调用fun()方法就只能进行向下转型处理,总的来说就是当需要子类扩充操作的时候就要采用向下转型。

    应用场景:发生在父类引用需要调用子类扩充方法时,才发生向下转型变为子类引用调用其扩充方法

    注意:并不是所有的父类对象都可以向下转型 ,如果要想进行向下操作之前,前提是一定要首先发生向上转型,否则在转型时会出现ClassCastException(运行时异常,类型转换异常,发生在两个毫无关系的两个类之间的强转时)

    观察错误转型:

    class Person {
        public void print() {
            System.out.println("父类");
        }
    }
    class Student extends Person {
        public void print() {
            System.out.println("子类");
        }
        public void fun() {
            System.out.println("只有子类有");
        }
    }
    public class XiangXiaZhuanXing {
        public static void main(String[] args) {
            Person per = new Person();
            per.print();
            System.out.println("==========");
            Student stu = (Student) per;
            stu.fun();
        }
    }
    

    在这里插入图片描述

    • 结论:上述代码进行向下转型之前Person per = new Person();没有先进行向上转型,所以出现类型转换异常这个错误。
    • 问题 :如果向下转型存在安全隐患,那么如何转型才靠谱呢?

    最好的做法就是先进行判断,而后再进行转型,那么就可以依靠关键字instanceof实现。

    引用对象 instanceof 类:表示该引用能指向该类,返回true表示可以指向,返回flase表示不能指向。

    因此,向下转型的标准格式为:

    if(!(per instanceof Student)) {
    	per = new Student();   // 先建立起联系
    }
    Student stu = (Student) per;
    

    观察instanceof操作:

    class Person {
        public void print() {
            System.out.println("父类");
        }
    }
    class Student extends Person {
        public void print() {
            System.out.println("子类");
        }
        public void fun() {
            System.out.println("只有子类有");
        }
    }
    public class XiangXiaZhuanXing {
        public static void main(String[] args) {
            Person per = new Person();
            //避免ClassCastException
            if(!(per instanceof Student)) {
                per = new Student();
            }
            Student stu = (Student) per;
            stu.fun();
        }
    }
    

    在这里插入图片描述

    • 结论:我们可以看到加上instanceof之后就算没有先向上转型,向下转型依然是可以进行的。
    总结:
    • 对象的多态性(向上转型或向下转型)本质在于方法的覆写。
    • 通过对象的向上转型可以实现接收参数的统一,向下转型可以实现子类扩充方法的调用(一般不操作向下转型,有安全隐患)。
    • 两个没有关系的类对象是不能够进行转型的,一定会出现ClassCastException。
    展开全文
  • [TOC]## 多态多态指的是一类事物多种形态,比如动物多种形态:人,狗,猪~~~import abcclass Animal(metaclass=abc.ABCMeta): #同一类事物:动物@abc.abstractmethoddef talk(self):passclass People(Animal): #...

    [TOC]

    ## 多态

    多态指的是一类事物有多种形态,比如

    动物有多种形态:人,狗,猪

    ~~~

    import abc

    class Animal(metaclass=abc.ABCMeta): #同一类事物:动物

    @abc.abstractmethod

    def talk(self):

    pass

    class People(Animal): #动物的形态之一:人

    def talk(self):

    print('say hello')

    class Dog(Animal): #动物的形态之二:狗

    def talk(self):

    print('say wangwang')

    ~~~

    ## 多态性

    ### **什么是多态动态绑定(多态性)**

    多态性是指在不考虑实例类型的情况下使用实例,多态性分为静态多态性和动态多态性

    * 静态多态性:如任何类型都可以用运算符+进行运算

    * 动态多态性:如下

    ~~~

    peo=People()

    dog=Dog()

    pig=Pig()

    #peo、dog、pig都是动物,只要是动物肯定有talk方法

    #于是我们可以不用考虑它们三者的具体是什么类型,而直接使用

    peo.talk()

    dog.talk()

    pig.talk()

    #更进一步,我们可以定义一个统一的接口来使用

    def func(obj):

    obj.talk()

    ~~~

    ### **为什么要用多态性**

    从上面多态性的例子可以看出,python本身就是支持多态性的,这么做的好处是什么呢?

    1. 增加了程序的灵活性

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

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

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

    ~~~

    >>> 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)

    ## 鸭子类型

    Python崇尚鸭子类型,即‘如果看起来像、叫声像而且走起路来像鸭子,那么它就是鸭子’

    python程序员通常根据这种行为来编写程序。例如,如果想编写现有对象的自定义版本,可以继承该对象,也可以创建一个外观和行为像,但与它无任何关系的全新对象,后者通常用于保存程序组件的松耦合度。

    * 例1:

    利用标准库中定义的各种‘与文件类似’的对象,尽管这些对象的工作方式像文件,但他们没有继承内置文件对象的方法

    ~~~

    #二者都像鸭子,二者看起来都像文件,因而就可以当文件一样去用

    class TxtFile:

    def read(self):

    pass

    def write(self):

    pass

    class DiskFile:

    def read(self):

    pass

    def write(self):

    pass

    ~~~

    * 例2:序列类型有多种形态:字符串,列表,元组,但他们直接没有直接的继承关系

    ~~~

    #str,list,tuple都是序列类型

    s=str('hello')

    l=list([1,2,3])

    t=tuple((4,5,6))

    #我们可以在不考虑三者类型的前提下使用s,l,t的len方法

    s.__len__()

    l.__len__()

    t.__len__()

    ~~~

    展开全文
  • 概念:多态是同一个行为具有多个不同表现形式或形态的能力。多态就是同一个接口,使用不同的实例而执行不同操作。 多态性是对象多种表现形式的体现,同一个事件发生在不同的对象上会产生不同的结果。 优点: 消除...
  • 在Java中多态表现形式

    千次阅读 2012-07-29 18:08:00
    Java多态表现形式有方法重载,方法改写,多态变量和泛型。重载是一种静态的多态性,在程序编译时确定被调用的方法,称为早绑定。而多态变量和改写相结合后,方法的调用在运行时才能确定,是动态的多态性,称为晚...
  • 多态的四种表现形式

    千次阅读 2019-07-24 10:56:41
    直到看了一篇文章,才反应过来多态有四种表现形式。cpp-polymorphism 运行时多态(虚函数) 编译时多态(模板) 重载 类型转换 运行时多态(Subtype Polymorphism/Runtime Polymorphism) 运行时多态就是派生类重写基类...
  • 多态是面向对象编程的一个重要特性,父类中的属性方法被子类继承之后,可以具有不同的数据类型和表现出不同的行为,这可以让同一方法在其父类及其各个子类中具有不同含义 很简单,打个比方, Father 父类和 Son ...
  • java的多态表现在哪里

    千次阅读 2019-04-14 21:52:33
    多态是同一个行为具有多个不同表现形式或形态的能力。 多态就是同一个接口,使用不同的实例而执行不同操作。 比如同一个打印机,可以打印黑白的纸张也可以打印彩色的,同样是人,却黑人白人之分。 ...
  • 多态意味着变量并不知道引用的对象是什么,根据引用对象的不同,表现不同的行为方式。 在处理多态对象时,只需要关注他的接口即可。 同一个操作作用于不同的对象,可以不同的解释,产生不同的执行结果。 注意:...
  • 2)在C++中,多态性分为两种:①静态多态 ②动态多态3)函数重载和运算符重载属于静态多态。函数重载:相同函数名可以完成不同功能。运算符重载:相同运算符完成不同功能。4)动态多态是指:程序执行过程中确定的...
  • 一个类表现出的多种状态:通过继承来实现的在Java中的表现:在一个函数中需要给参数指定数据类型,如果这个地方可以接收两个以上类型的参数,那么这些类型应该一个父类,这个父类是所有子类对象的类型。...
  • 自学Python5.6-面向对象三大基本特征_多态1.1 初识多态多态指的是一类事物多种形态。python语言天生支持多态。# 举例在其他语言里面代码class Alipay():def pay(self,money):print('已经用支付宝支付了%s元' % ...
  • Java语言的三大特点就是:封装、继承、多态。Java语言是纯面向对象的语言。封装:就是把客观事物封装成类,把自己的数据和方法只让可以相信的类或者对象操作。封装是面向对象的特征之一,是对象和类概念的主要特性。...
  • 什么是多态:由不同的类实例化得到的对象,...类的继承两层意义:1.改变 2.扩展多态就是类的这两层意义的一个具体的实现机制即,调用不同的类实例化得对象下的相同的方法,实现的过程不一样python中的标准类型就是...
  • 为了能编写出C语言程序,必须具备以下的认知和能力:(1)要正确的解题思路,就是学会设计算法,否则无从下手。(2)掌握C语言的语法,知道怎样使用C语言提供的功能编写出一个完整的、正确的程序。(3)在写算法和编写...
  • 摘要 诸如 BERT 的预训练的神经模型在微调以执行自然语言推理(NLI)时,常常在标准数据集上展现出了高度准确性,但在受控的挑战集上,它们却表现出对语序敏感度的出奇缺乏。我们假设此问题并不主要因为预训练模型的...
  • 多态

    2019-05-06 20:41:31
    1、多态就是一个行为具有多个不同表现形式或形态的能力 2、多态就是一个接口,使用不同的实例而执行不同的操作 3、多态是多种表现形式的体现 4、一句话描述多态 : 相同的行为,不同的实现 静态多态 **概念** ...

空空如也

空空如也

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

多态表现形式有