精华内容
下载资源
问答
  • 对象多态性

    2015-11-27 09:38:28
    对象多态性主要分为两种类型: 向上转型:子类对象–>父类对象 对于向上转型,程序会自动完成 格式: 对象向上转型: 父类 父类对象 = 子类实例 ; 向下转型:父类对象–>子类对象 对于向下转型时:必须明确...

    对象多态性

    主要分为两种类型:
    向上转型:子类对象–>父类对象
    对于向上转型,程序会自动完成 格式:
    对象向上转型: 父类 父类对象 = 子类实例 ;
    向下转型:父类对象–>子类对象
    对于向下转型时:必须明确的指明要转型的子类类型。
    对象向下转型:子类 子类对象 = (子类)父类实例 ;

    1.1 向上转型

    格式 父类 父类实例 = 子类实例

    class A     //定义类A
    {
        public void fun1()  //定义fun1()方法
        {
            System.out.println("A--fun1()方法>") ;
        }
        public void fun2() //定义fun2()方法
        {
            this.fun1() ;   //调用fun1()方法
        }
    }
    class B extends A   //定义类B 继承 类A
    {
        public void fun1() //覆写父类方法
        {
            System.out.println("B-->fun1()方法") ;
        }
        public void fun3() //定义fun3()方法
        {
            System.out.println("B-->fun3()方法") ;
        }
    }
    public class PolDemo01
    {
        public static void main(String[] args)
        {
            B b = new B() ; //实例化子类B对象
            b.fun1() ;
            A a = b ;       //向上转型关系
            a.fun1() ;
            a.fun2() ;
        }
    }
    

    以上程序,是通过子类进行父类对象的实例化操作,则如果调用的方法被子类覆写过,则肯定调用被覆写过的方法。
    注意点:
    转型之后,操作的是父类对象,所以无法找到在子类中新增加的新方法。

    1.2 向下转型

    将父类对象变为子类对象,称为向下转型,向下转型需要采用强制的手段。 格式 子类 子类实例 = (子类) 父类实例

    class A     //定义类A
    {
        public void fun1()  //定义fun1()方法
        {
            System.out.println("A--fun1()方法>") ;
        }
        public void fun2() //定义fun2()方法
        {
            this.fun1() ;   //调用fun1()方法
        }
    }
    class B extends A   //定义类B 继承 类A
    {
        public void fun1() //覆写父类方法
        {
            System.out.println("B-->fun1()方法") ;
        }
        public void fun3() //定义fun3()方法
        {
            System.out.println("B-->fun3()方法") ;
        }
    }
    public class PolDemo02
    {
        public static void main(String[] args)
        {
            A a = new B() ;     //向上转型关系    父类 父类实例 = 子类实例
            B b = (B) a ;       //向下转型关系 子类 子类实例 = (子类)父类实例
            b.fun1() ;
            b.fun2() ;
            b.fun3() ;
        }
    }
    

    在子类B中存在三个方法,所以都可以调用 。
    注意点
    如果要产生对象的向下转型,必须先产生对象的向上转型关系 (A a = new B())表示建立关系。

    2.1对象多态性应用

    要求:设计一个方法,此方法可以接收A类的任意子类对象,并调用方法 。

    class A     //定义类A
    {
        public void fun1()  //定义fun1()方法
        {
            System.out.println("A--fun1()方法>") ;
        }
        public void fun2() //定义fun2()方法
        {
            this.fun1() ;   //调用fun1()方法
        }
    }
    class B extends A   //定义类B 继承 类A
    {
        public void fun1() //覆写父类方法
        {
            System.out.println("B-->fun1()方法") ;
        }
        public void fun3() //定义fun3()方法
        {
            System.out.println("B-->fun3()方法") ;
        }
    }
    class C extends A   //定义类B 继承 类A
    {
        public void fun1() //覆写父类方法
        {
            System.out.println("C-->fun1()方法") ;
        }
        public void fun4() //定义fun3()方法
        {
            System.out.println("C-->fun4()方法") ;
        }
    }
    public class PolDemo03
    {
        public static void main(String[] args)
        {
            A a = new B() ;     //向上转型关系    父类 父类实例 = 子类实例
            B b = (B) a ;       //向下转型关系 子类 子类实例 = (子类)父类实例
            C c = new C() ;     //实例化子类C对象
            run(b) ;
            run(c) ;
        }
        public static void run(A a)  //定义一个方法  向上转型
        {
            a.fun1() ;          //调用父类中方法
        }
    }
    

    以上代码 不管有多少子类,都可以简洁完成

    展开全文
  • 1. 多态性在面向对象中是一个重要的概念,在JAVA中面向对象主要有以下两种体现:  1.对方法的重载与覆写。... 对象多态性主要分为以下两种类型:  1.向上类型:子类对象--->父类对象  ...

    1. 多态性在面向对象中是一个重要的概念,在JAVA中面向对象主要有以下两种体现

           1.对方法的重载与覆写。

            2.对象的多态性。

         掌握对象多态性之后可以直接应用在抽象类的接口上。

    2. 对象的多态性

         对象多态性主要分为以下两种类型:

                 1.向上类型:子类对象--->父类对象

                                对于向上转型,程序会自动完成,格式:  

                                      对象向上转型: 父类 父类对象 =子类实例;

                  2.向下转型:父类对象--->子类对象

                                 对于向下转型时,必须明确的指明要转型的子类类型,格式:

                                       对于向下转型:子类 子类对象 =(子类) 父类实例;

        以上程序是通过子类进行父类对的实例化的操作,就是说如果调用调用的方法被子类覆写过,则

    调用的是被覆写过的方法。反之,若没有被子类覆写,则调用本类中的方法。

      注意:转型之后,因为操作的是父类对象,所以是无法找到在子类中定义的新方法。例如程序中的fun3。

                将父类对象变为子类对象,称为向下转型,向下转型需要强制转换 。

        在类B中存在三个方法,所以可以全部调用。

    但是,进行对象向下转型操作有一个注意点。

     

        上图是将之前的A a =new B();  改为A a= new a();

    编译时不会出现问题,但在执行时候会出现如下问题:

        上述错误是继空指向后,在开发中常见的问题,表示A不能转到B。

    此异常在对象转型时经常发生,如果两个没有关系的对象之间发生了转换关系,则肯定出现此异常。

        上程序中,若单看A类,不能确定A有那些子类,所以他们是没有关系的;而单看B类,可以明显的知道B类是A的子类,

    可以看出A,B两个类是有关系的。

         就是说,如果要想产生对象的向下转型,则必须先产生一个向上的转型关系。

    3.  instanceof 关键字

       在JAVA中可以使用instanceof关键字判断一个对象到底是那个类的实例

       格式:    对象 instanceof 类--->返回boolean类型

    例如: a instanceof B;   //判断实例a是否属于B

        在开发中一定要注意,对于向下转型操作最好增加验证,以保证转型时不会发生

    ClassCastException。

        如果要增加新的子类,则肯定要修改方法,如果这样程序就失去了灵活性,所以

    在程序的开发中设计的重点应该放在父类上,只要父类设计的足够合理,则开发肯

    定会非常的方便。

    注意:程序开发中,一个类一定不要继承已经实现好的类,只能继承抽象类或者实现接口,

     

    展开全文
  • Java对象多态性

    2019-03-31 15:59:50
    多态是面向对象的最后一个主要特征,它本身主要分为两个方面: · 方法的多态性:重载与覆写 |- 重载:同一个方法名称,根据不同的参数类型及个数可以完成不同的功能; |- 覆写:同一个方法,根据操作的子类不同,所...

    多态是面向对象的最后一个主要特征,它本身主要分为两个方面:
    · 方法的多态性:重载与覆写
    |- 重载:同一个方法名称,根据不同的参数类型及个数可以完成不同的功能;
    |- 覆写:同一个方法,根据操作的子类不同,所完成的功能也不同。
    · 对象的多态性:父子类对象的转换。
    |- 向上转型:子类对象变为父类对象,格式:父类 父类对象 = 子类实例,自动;
    |- 向下转型:父类对象变为子类对象,格式:子类 子类对象 = (子类) 父类实例,强制;

    class A{					// 定义类A
    	public void fun1(){		// 定义fun1()方法
    		System.out.println("A --> public void fun1(){}") ;
    	}
    	public void fun2(){
    		this.fun1() ;		// 调用fun1()方法
    	}
    };
    class B extends A{
    	public void fun1(){		// 此方法被子类覆写了
    		System.out.println("B --> public void fun1(){}") ;
    	}
    	public void fun3(){
    		System.out.println("B --> public void fun3(){}") ;
    	}
    };
    class C extends A{
    	public void fun1(){		// 此方法被子类覆写了
    		System.out.println("C --> public void fun1(){}") ;
    	}
    	public void fun5(){
    		System.out.println("C --> public void fun5(){}") ;
    	}
    };
    public class PolDemo04{
    	public static void main(String asrgs[]){
    		fun(new B()) ;	// 传递B的实例
    		fun(new C()) ;	// 传递B的实例
    	}
    	public static void fun(B b){
    		b.fun1() ;		// 调用覆写父类中的fun1()方法
    	}
    	public static void fun(C c){
    		c.fun1() ;		// 调用覆写父类中的fun1()方法
    	}
    };
    

    多态,子类自动向上转型父类

    class A{					// 定义类A
    	public void fun1(){		// 定义fun1()方法
    		System.out.println("A --> public void fun1(){}") ;
    	}
    	public void fun2(){
    		this.fun1() ;		// 调用fun1()方法
    	}
    };
    class B extends A{
    	public void fun1(){		// 此方法被子类覆写了
    		System.out.println("B --> public void fun1(){}") ;
    	}
    	public void fun3(){
    		System.out.println("B --> public void fun3(){}") ;
    	}
    };
    class C extends A{
    	public void fun1(){		// 此方法被子类覆写了
    		System.out.println("C --> public void fun1(){}") ;
    	}
    	public void fun5(){
    		System.out.println("C --> public void fun5(){}") ;
    	}
    };
    public class PolDemo05{
    	public static void main(String asrgs[]){
    		fun(new B()) ;	// 传递B的实例
    		fun(new C()) ;	// 传递B的实例
    	}
    	public static void fun(A a){
    		a.fun1() ;		// 调用覆写父类中的fun1()方法
    	}
    };
    
    展开全文
  • 对象多态性主要分为以下两种类型: (1)向上转型:子类对象 —> 父类对象 (2)向下转型:父类对象 —> 子类对象 对于向上转型,程序会自动完成,而对于向下转型时,必须明确的指明要转型的子类类型。...

    1. 基本概念

    1.1 在 Java 中面向对象的多态性主要有以下两种体现方式:

    1. 方法的重载与覆写。
    2. 对象的多态性。
    3. 而对象的多态性主要又分为以下两种类型:
      (1)向上转型:子类对象 —> 父类对象
      (2)向下转型:父类对象 —> 子类对象
      对于向上转型,程序会自动完成,而对于向下转型时,必须明确的指明要转型的子类类型。格式:
    对象向上转型:父类  父类对象 = 子类实例;
    对象向下转型:子类  子类对象 = (子类)父类实例;
    

    1.2 重载相关概念

    1. 方法重载就是方法名称相同,但参数类型(参数列表,即顺序不同)和参数个数不同(返回值类型可不同),通过传递参数个数和类型不同完成不同功能的方法调用,但是返回值类型不作为是否重载的标准,可以修改可见性。【方法名称相同,参数个数、次序、类型不同;重载对返回值没有要求,可以相同,也可以不同】
    2. 方法的参数类型和个数完全相同,但方法的返回值类型不同,这样的程序编译不通过,所以不是方法重载。
    3. 提示: System.out.println( ) 方法也属于重载方法。该方法可以打印数字、小数、字符、布尔类型等各种各样数据。

    1.3 覆写相关概念

    1. 所谓的方法覆写就是指子类定义了与父类中同名方法,但是在方法覆写时必须考虑到权限,即被子类覆写的方法不能拥有比父类更加严格的访问权限。(private < default < public)。
    2. 如果在父类中使用 public 定义的方法,子类的访问权限必须是 pulblic,否则程序无法编译。
    3. 只在子类中扩大访问权限,方法内容不做改变也属于覆写。
    4. 方法覆写时从 private 变为 default 不是方法的覆写。
    5. 方法的重写需要满足:三同一大一小(方法名、返回值类型、形参相同;访问权限>=重写前;抛出异常<=重写前)

    1.4 方法的重载与覆写的区别

    序号 区别点 重载 覆写
    1 单词 Overloading Overriding
    2 定义 方法名称相同,参数类型和参数个数不同 方法名称、参数类型、参数个数、返回值类型完全同
    3 定义 对权限没有要求 被覆写的方法不能拥有更严格的访问权限
    4 范围 发生在一个类中 发生在继承类中

    1.5 对象向上转型和向下转型代码实例

    对象向上转型实例代码:
    package self.learn.up;
    
    public class A {
    	public void fun1() {
    		System.out.println("A --> public void fun1(){}");
    	}
    	public void fun2() {
    		this.fun1();
    	}
    }
    
    
    package self.learn.up;
    
    public class B extends A {
    	public void fun1() {                  // 覆写父类中的 fun1()
    		System.out.println("B --> public void fun1(){}");
    	}
    	public void fun3() {                 // 子类自己定义的方法
    		System.out.println("B --> public void fun3(){}");
    	}
    }
    
    package self.learn.up;
    
    public class PolDemo1 {
    
    	public static void main(String[] args) {
    		B b = new B();        // 定义子类实列化对象
    		A a = b;              // 发生了向上转型 子类 ---> 父类
    		a.fun1();
    	}
    }
    
    运行结果截图:

    在这里插入图片描述
       由结果可知,此时虽然使用的是父类对象调用了 fun1() 方法,但实际上是调用被子类覆写过的方法,也就是说,==如果对象发生了向上转型关系,所调用的肯定是被子类覆写过的方法。==但是此时一定要注意,此时 a 对象是无法调用 B 类中的 fun3( ) 方法,因为此方法只在子类定义,而没有在父类定义,如果要想调用子类定义的其它方法,肯定要用子类实例,所以此时可以将对象向下转型。

    对象向下转型实例代码:
    package self.learn.up;
    
    public class A {
    	public void fun1() {
    		System.out.println("A --> public void fun1(){}");
    	}
    	public void fun2() {
    		this.fun1();
    	}
    }
    
    
    package self.learn.up;
    
    public class B extends A {
    	public void fun1() {                  // 覆写父类中的 fun1()
    		System.out.println("B --> public void fun1(){}");
    	}
    	public void fun3() {                 // 子类自己定义的方法
    		System.out.println("B --> public void fun3(){}");
    	}
    }
    
    package self.learn.up;
    
    public class PolDemo1 {
    
    	public static void main(String[] args) {
    		A a = new B();        // 发生了向上转型 子类 ---> 父类
    		B b = (B)a;           // 此时发生了向下转型关系
    		b.fun1();             // 调用被覆写过的方法
    		b.fun2();             // 调用父类方法
    		b.fun3();             // 调用子类自己的方法		
    	}
    }
    
    
    运行结果截图:

    在这里插入图片描述
       从结果中可以发现,如果想调用子类自己的方法,则只能用子类声明对象,另外在子类中调用了父类中继承而来的 fun() 方法,fun2() 方法要调用 fun1() 方法,由于此时 fun1() 方法已经被子类所覆写,所以此时调用的是被子类覆写过的方法。 在进行向下转型之前,必须首先向上转型,否则将出现对象转换异常。

    展开全文
  • 0012_对象多态性

    2016-06-08 10:15:41
    对象多态性主要分为以下两种类型: Ø 向上转型:子类对象­­→父类对象  对于向上转型,程序会自动完成,格式:  父类 父类对象 = 子类实例; Ø 向下转型:父类对象→子类对象  对于向下转型,必须明确地...
  • 对象多态性主要分为以下两种类型: (1) 向上转型:子类对象—》父类对象; (2) 向下转型:父类对象—》子类对象; 对于向上转型,程序会自动完成,而对于向下转型时,必须明确的指明要转型的子类类
  • C++的多态性定义 所谓多态性就是不同对象...多态性分为两种:一种是编译时的多态性主要通过函数重载和运算符重载实现。一种是运行时的多态性主要通过继承和虚函数来实现的。 这一部分,我们主要讲函数...
  • 多态性

    2018-09-01 11:37:21
    多态分为静态多态和动态多态,静态多态通过模板、函数重载和运算符重载实现,动态多态通过虚函数实现。  c++的三大特征:封装(Encapsulation)、继承(Inheritance)、多态(Polymorphism)。其中,多态主要是指...
  • C#类的多态性详解

    2021-01-20 06:39:52
    第一种:编译时的多态性,直接这样说不知道说啥?程序执行过程主要分为三步:编译,链接,运行。在编译时体现的多态性是通过方法的重载来实现的。方法的重载我们听过,就是一个类对象调用若干同名,但参数类型、个数...
  • C++的多态性

    2017-11-20 16:43:59
    多态性多态性的定义:只允许不同类的对象对同一消息作出相应反应,即同一消息可以根据发送对象的不同而采用的行为方式。这里的发送消息就是函数调用。 多态性分为:编译期多态(静态多态)和运行时多态(动态动态)...
  • JavaSE-Java多态性

    2016-01-19 18:31:00
    * 2)子类对象多态性主要) * 2.子类对象多态性使用的前提:1)发生类的继承 2)要有子类对父类方法的重写3)父类引用指向子类对象 * 3.程序分为编译状态和运行状态 * 1)对于多态性来说,编译时,“看左边...
  • 面向对象多态性主要分为两种:方法的多态性以及对象的多态性。 而其中方法的多态性又可以划分为:重载和覆写 No 区别 重载(Overloding) 覆写(Overriding) 1 定义 方法名称相同,参数类型及个...
  • Java多态性

    2020-03-10 09:10:34
    多态性是指在父类中定义的属性和方法被子类继承之后,可以具有不同的数据类型或表现出不同的行为,这使得同一个属性或方法在父类及其各个子类中具有不同的含义。 对面向对象来说,多态分为编译时多态和运行时多态。...
  • JAVA_多态性

    2010-04-21 00:06:00
    8.5.3 多态性 多态性是面向对象技术中最灵活的特性,主要是增强项目的可扩展性,提高代码的可维护性。 多态性依赖继承特性,可以把多态理解为继承性的扩展或者深入。 在这里把多态性分为两方面来进行介绍,对象...
  • 多态性与虚函数

    2018-03-16 22:30:00
    多态可分为编译时多态和运行时的多态,运算符重载就属于编译时多态,本章主要讨论函数重载和建立在虚函数基础上的运行时的多态。...面向对象程序设计中的多态性,指的是不同的对象在得到相同的消息时产生了不同的...
  • Java_多态性

    2013-04-12 13:54:00
    多态是面向对象的最后一个主要特征,它本身主要分为两个方面: · 方法的多态性:重载与覆写 |- 重载:同一个方法名称,根据不同的参数类型及个数可以完成不同的功能; |- 覆写:同一个方法,根据操作的子...
  • Java:多态性

    2019-06-07 19:03:16
    多态性是面向对象编程的又一个重要特征,它是指在父类中定义的属性和方法被子类继承之后,可以具有不同的数据类型或表现出不同的行为,这使得同一个属性或方法在父类及其各个子类中具有不同的含义。对面向对象来说,...
  • Java编程—多态性

    2009-01-05 17:46:00
    8.5.3 多态性 多态性是面向对象技术中最灵活的特性,主要是增强项目的可扩展性,提高代码的可维护性。 多态性依赖继承特性,可以把多态理解为继承性的扩展或者深入。 在这里把多态性分为两方面来进行介绍,对象类型...
  • C#类的多态性(非常重要)

    千次阅读 2012-09-17 17:02:45
    C#当中类的多态性总结 第一种:编译时的多态性,直接这样说不知道说啥?程序执行过程主要分为三步:编译,链接,运行。在编译时体现的多态性是通过方法的重载来实现的。方法的重载我们听过,就是一个类对象调用若干...
  • C++多态性

    2013-05-04 21:34:00
    C++中的多态分为四种 1.参数多态 这种多态包括函数模板和类模板 2.包含多态 这种多态就是C++面向对象...这里主要说的是C++面向对象编程的灵魂------包含多态。 C++中面向对象编程的一个颇具讽刺的地方是,不能...
  • 多态性是面向对象编程的又一个重要特征,它是指在父类中定义的属性和方法被子类继承之后,可以具有不同的数据类型或表现出不同的行为,这使得同一个属性或方法在父类及其各个子类中具有不同的含义。 对面向对象来说...
  • C++编程入门--多态性

    2019-10-21 15:35:26
    在C++中,对于多态性,一个要解决的主要问题就是如何把具体的操作和对象进行绑定(binding),也称联编,关联,绑定指得是程序如何为类的对象找到执行操作函数的程序入口的过程。。从系统实现的角度来看,多态可以...
  • Java编程那些事儿63—多态性 郑州游戏学院 陈跃峰 ... 8.5.3 多态性 多态性是面向对象技术中最灵活的特性,... 在这里把多态性分为两方面来进行介绍,对象类型的多态和对象方法的多态。 为了方便后续的讲解,首...
  • 多态性是面向对象编程的又一个重要特征,它是指在父类中定义的属性和方法被子类继承之后,可以具有不同的数据类型或表现出不同的行为,这使得同一个属性或方法在父类及其各个子类中具有不同的含义。 对面向对象来说...

空空如也

空空如也

1 2 3 4 5 ... 8
收藏数 158
精华内容 63
关键字:

对象多态性主要分为