精华内容
下载资源
问答
  • Java 多态,向上造型

    千次阅读 2017-07-17 09:30:22
    首先我们来定义四个类, 分别是动物类、猫类、狗类、动物信息类, 猫类动物类都继承了动物类,并且都有自己单独的属性。但是在动物信息类中我们定义了一个是动物类的ArrayList,每次new进去的是猫或者狗,但系统...

    首先我们来定义四个类, 分别是动物类、猫类、狗类、动物信息类,  猫类和动物类都继承了动物类,并且都有自己单独的属性。但是在动物信息类中我们定义了一个是动物类的ArrayList,每次new进去的是猫或者狗而不是animal的对象,但系统知道这是什么,,就是说我一各动物列表,里面可以方任何动物,我也可以管理任何动物,当然是需要重写父类方法的,不然要报错,任何动物的属性都在这里得到保留。

    Java的多态变量:

    1 Java的对象变量是多态的,他们能保存不止一种类型对象

    2 它可以保存申明类型的变量,或申明类型的子类的对象

    3 把子类的对象赋到父类的变量的时候就发生了向上造型

    多态条件: 

    1,有继承的存在。
    2,子类重写父类方法。
    3,父类引用指向子类对象。
    动物类:
    package DuoTai;
    
    public class Animal {
    	private String name;
    	private int sex;
    	public void voice(){
    		System.out.println("普通动物叫声");
    	}
    	public Animal(String name, int sex) {
    		super();
    		this.name = name;
    		this.sex = sex;
    	}
    }
    
    猫类:
    package DuoTai;
    
    public class Cat extends Animal{
    	private String maojiao;
    	public void voice(){
    		System.out.println("喵喵喵");
    	}
    	public Cat(String name, int sex, String maojiao) {
    		super(name, sex);
    		this.maojiao = maojiao;
    	}
    }
    
    狗类:
    package DuoTai;
    
    public class dog extends Animal{
    	public dog(String name, int sex, String jiao) {
    		super(name, sex);
    		this.jiao = jiao;
    	}
    	public void voice(){
    		System.out.println("汪汪汪"+jiao);
    	}
    	private String jiao ;
    }
    动物信息类:
    package DuoTai;
    
    import java.util.ArrayList;
    
    public class DataAnimal {
    	private ArrayList<Animal> animal = new ArrayList<Animal>();
    	public void add(Animal a){
    		animal.add(a);
    	}
    	public void list(){
    		for(Animal a : animal){
    			a.voice();
    		}
    	}
    	public static void main(String[] args) {
    		dog d = new dog("白狗",1,"汪汪汪");
    		Cat c = new Cat("黄猫",0,"喵喵喵");
    		add(d);
    		add(c);
    		list();
    	}
    }
    
    
    话说,多态的单词是:polymorphism 
    
    

    展开全文
  • 多态:代码在编译中多种状态的展示 ...--向上造型 4、多态中,成员方法编译看左边,运行看右边 就是编译申明变量的时候 a是Animal 而在运行的时候 a是dog 多态中的成员访问特点: A:成员变量 ...

    多态:代码在编译中多种状态的展示

    1、 多态的前提是1是发生继承关系

    2、 多态的前提是2是要有方法的重写

    3、 父类引用指向子类对象,如:Animal a = new Dog();--向上造型

    4、 多态中,成员方法编译看左边,运行看右边   就是编译申明变量的时候 a是Animal 而在运行的时候 a是dog

    多态中的成员访问特点:
    A:成员变量
    编译看左边,运行看左边。
    B:构造方法
    创建子类对象的时候,访问父类的构造方法,对父类的数据进行初始化。
    C:成员方法
    编译看左边,运行看右边。
    D:静态方法
    编译看左边,运行看左边。
    (静态和类相关,算不上重写,所以,访问还是看左边的)
    由于成员方法存在方法重写,所以它运行看右边。

    5.父类申明对象,由子类来实际创建,可以调用那些方法看父类,具体方法的执行看啊可能子类。可以把多态想成一本书,父类是目录 子类是正文

     

     

    多态的好处

    1、 多态可以让我们不用关心某个对象到底是什么具体类型,

    就可以使用该对象的某些方法。 

    2、 提高了程序的扩展性和可维护性

    3.解耦合(多个模块之间的关联) 高内聚低耦合

     

     

    现在我采用时期来展示代码的多态 分为编译时期多态和运行时期多态 判断是否是运行时期多态要看是不是运行时期绑定的代码

    在编译时期不知道要传入的是什么对象,只有在把实参给定的时候要传入的是什么对象。

    编译时期: ----编译时多态---编译时期绑定代码  下面两个函数 参数不一样那么就是在编译时期m方法展现出多种状态

    public static void m(){}
    public static void m(int i,int j){}

    运行时期多态 -重写,向上转型

     

    public static void main(String[] args) {
    A12 a=new B12();
    a.m();
    System.out.println(a.i);
    }
    
    }
    
    class A12{
        int i=100;
         void m() {
        System.out.println("f");
    
        }
    }
    class B12 extends A12{
        int i=1000;
        void m() {
        System.out.println("z");
    
        }

    结果是100 z  向上转型时 属性是父类的,方法是执行的是子类的。

     

    java类加载顺序

    JAVA类首次装入时,会对静态成员变量或方法进行一次初始化,但方法不被调用是不会执行的, 静态成员变量和静态初始化块级别相同,非静态成员变量和非静态初始化块级别相同。

    先初始化父类的静态代码--->初始化子类的静态代码-->
    初始化父类的非静态代码--->初始化父类构造函数--->
    初始化子类非静态代码--->初始化子类构造函数

    转载于:https://www.cnblogs.com/xuwangqi/p/11085340.html

    展开全文
  • 可扩展性 3)怎么使用多态 3.1)定义父类 3.2)定义子类继承父类 3.3)子类重写父类方法 3.4)子类对象赋给父类引用 3.5)使用父类引用调用 子类重写后的方法 2.强制类型转换 1)什么是类型转换 就是将一个类型的引用, ...

    1.多态
    1)什么是多态
    同一父类的不同子类对象
    对同一方法调用,产生的不同行为
    2)为什么使用多态
    减少代码冗余,增强程序的可维护性
    和可扩展性
    3)怎么使用多态
    3.1)定义父类
    3.2)定义子类继承父类
    3.3)子类重写父类方法
    3.4)子类对象赋给父类引用
    3.5)使用父类引用调用
    子类重写后的方法
    2.强制类型转换
    1)什么是类型转换
    就是将一个类型的引用,
    转换成拎另一个类型
    2)为什么需要类型转换
    父类引用无法调用到子类特有的成员
    如果必须要调用,就需要类型转换
    3)怎么类型转换
    (<类型>)<引用>
    Pet p=xxx;
    (Dog)p
    4)强制类型转换的注意事项
    如果将一个A子类的引用强转成
    B子类,会发生类型转换异常
    ClassCastException
    为了防止这样的异常发生
    在强转前,
    一般要先判断一下实际的类型

    多态的两种形式:
    1.方法的重载与重写(继承,接口)
    2.对象的多态性:向上转型、向下转型

    多态存在的三个必要条件
    继承
    重写
    父类引用指向子类对象

    向上转型:父类 父类对象=子类实例
    (父类只能调用自己的方法,父类中的方法如果被子类覆写则调用的是覆写过得方法{这就是为什么要向上转型方便父类使用子类中覆写的方法})

    向下转型: 父类 父类对象=子类实例
    子类 子类对象=(子类)父类实例
    (子类可以使用父类中的各种方法)

    1.向上造型
    1)什么是向上造型
    子类对象赋给父类引用
    父类引用指向子类对象
    2)为什么需要向上造型
    子类对象可以放入父类类型的数组中
    父类数组同一管理所有子类对象
    减少代码冗余
    3)向上造型的格式
    <父类类型> <引用>=<子类对象>;
    Pet p=new Dog(…);
    4)向上造型的特性
    4.1)向上造型后的父类引用
    只能调用到父类中的成员
    不能调用到子类特有的成员

    展开全文
  • 多态

    2019-09-15 16:57:20
    运行时多态,顾名思义,就是在程序运行的过程中才会被发现的多态,动多态需要三要素:继承、方法重写向上造型 ①继承 Java的类之间的继承关系只能是单继承,而不能是多重继承,否则会出现棱形继承的结果,可能存在...

    Java的多态

    多态可分为编译时多态即静多态和运行时多态即动多态

    1. 静多态
      方法的重载,方法名相同但是返回值或者参数列表不同
    2. 动多态
      运行时多态,顾名思义,就是在程序运行的过程中才会被发现的多态,动多态需要三要素:继承、方法重写、向上造型
      ①继承
      Java的类之间的继承关系只能是单继承,而不能是多重继承,否则会出现棱形继承的结果,可能存在重复定义现象,有重复的变量存在,作为Java语言的四大特征之一,继承关系遍及各个Java常用类,不过所有的类的源都是Object类
      基类->派生类
      父类->子类
      Super关键字和this关键字
      构造方法默认调用父类的无参构造super()
      super()调用父类的构造方法
      super 和 this
      this :调用自身构造方法,通过方法的重载和this关键字在无参构造调用有参构造
      super :调用父类构造方法,JVM默认调用super(),即调用无参的构造方法;如果父类不存在无参构造,则需要显示调用,如 super(name);括号内为参数
      super()必须位于构造方法里有效代码第一行
      一个构造方法不能调用多个super();
      也可以用 super.变量名 调用父类里面定义的变量和方法
      继承类的加载顺序:
      父类的静态变量,
      父类的静态代码块,
      子类的静态变量,
      子类的静态代码块,
      父类的实例变量,
      父类的实例块,
      父类的构造方法快,
      子类的实例变量,
      子类的实例代码块,
      子类的构造方法块
      ②方法重写
      简单的来说就是子类重写父类的方法,尤其是在该类继承或实现抽象类和接口时为实现具体的类而重写方法以使用,重写方法必须保持函数名,参数列表相同,返回值类型必须小于或等于父类的方法返回值类型,访问控制符也必须大于或等于父类的访问修饰符。
      方法重写的原理:
      地址覆盖,将子类在堆上的内存中的对象头中的class对象指向的方法表中原来父类的方法实现地址覆盖
      RTTI
      RTTI,英文全称Run-Time Type Identification,即运行时类型识别,我们常用的多态就是基于RTTI实现的。RTTI的功能主要有Class类实现。
      在Java中,所有的类都是在对其第一次使用时,动态加载到JVM中的。当程序创建第一个对类的静态成员的引用是,就会加载这个类,所以构造器也是静态的,即使它并没有声明成static。
      在程序运行时,类加载器会先检查这个类的Class对象是否已经加载。如果没有加载,默认的类加载器就会根据类名查找.class文件,将其加载进内存,然后用它来创建对象。
      获取Class对象的方法:
      Class.forName(包名.对象名)
      类名.class
      对象.getClass(
      访问控制符
      默认的 子类访问不到,但是在同一个包中的可以访问到,如
      Public 公共的,通过.访问即可访问
      private 只有在同一个类中才可以访问到
      protected 子类可以访问到
      ③向上造型
      基类的引用指向派生类的对象,可以用于方法的参数列表上,在几个继承于同一个类的派生类需要用的方法时可以使用向上造型只需要写一个方法即可,而不用通过方法的重载写多个方法,节省空间。

    重写和重载的区别:
    1 首先重载和重写他们所处的作用域范围不同。 重载是在同一个类中进行方法的定义, 重写是在父子类中进行方法的定义。
    2 其次, 他们的定义方式也不同。 重载是方法名相同, 参数列表不同。 而重写是方法名相同参数列表也相同。

    展开全文
  • C++ 多态

    2021-02-04 15:39:33
    1. 函数的重写和多态的概念 virtual 修饰基类成员函数, 子类中对应函数自动变虚。没有virtual, 就没有多态 向上造型的产物:指向子类对象的基类类型指针,引用子类对象的基类类型引用。 通过指向子类对象的基类...
  • 向上造型&访问控制符

    2020-12-17 23:30:05
    1.多态:向上造型/重载… 一种事物多种表现形式 1.1 要有继承实现关系–重写 1.2 重载 案例:早餐店卖包子 1.来早餐店买包子有哪些人? 美女,猛男, 2.去早餐店买 包子店 3.包子店卖包子—>人 public void sale...
  • Java多态总结

    2019-01-02 15:28:03
    Java多态总结 1、介绍 在面向对象的程序设计语言中,多态是继数据抽象继承之后的第三种基本特征。...3)父类引用引用派生类对象(向上造型) 静多态条件: 1)方法重载(作用域相同、方法...
  • 面向对象编程里的重要的一个概念就是多态,比如引用为接口,或者为超类,而实现类为不同的类型,就可以重写不同的行为。...当引用相同时,如果实现类不同就是向上造型的原型; /** * @Author Xu Deb...
  • 封装、继承、多态

    2021-01-08 15:07:52
    2.向上造型3.发生多态的条件 封装 1.封装的定义 封装(Encapsulation)是面向对象方法的重要原则,就是把对象的属性操作(或服务)结合为一个独立的整体,并尽可能隐藏对象的内部实现细节。 什么是封装?封装把...
  • Java中的多态

    2019-08-13 18:03:11
    多态是指一种事物表现出多种形态的特征。 java中的多态的体现: 1、方法的重载(Overload) 2、方法的覆盖(Override) ...向上转型后的父类类型的对象,调用重写的方法,调用的是子类中的重写后的...
  • 多态、代码块与变量1 、向上造型与向下造型1.1向上造型就是多态,为了标准化,向超类类看起:1.2向下造型 ,为了使用派生类特有的扩展的功能(很少用)2 、 静态代码块,构造代码块,局部代码块3 、 静态变量实例...
  • 多态 多态是同一个行为具有多个不同表现形式...实际上方式二、方式三基于的都是方式一的方法重写以及我们的向上造型机制,这里我们不再详细论述,仅以代码简单表示 public class Demo { public static void main(Str...
  • 一、向上造型 二、重载与重写 三、方法重写后的动态绑定 四、JVM的结构与常量池 五、java的方法调用方式 六、方法表与方法调用 七、接口调用 八、多态的依附性 多态 Think in java(version 4) P148: 多态...
  • 向上转型(上溯造型) 在继承中,子类对象可以转为父类对象 1、会丢失子类所独有的属性方法 2、覆盖的方法,如果转型之后的父类对象调用被覆盖了的方法,执行的是子类中的重写的方法。 向...
  • 多态的条件是方法的重载,动多态的条件是继承,重写和向上造型 重载:函数名相同;参数列表不同;同一个作用域,返回值,参数类型可以不同 重写:函数名相同,参数列表相同,不同作用域,返回值参数类型相同 向上造型...
  • 内存管理面向对象

    2017-11-27 23:28:32
    面向对象的三大特征1.封装1.1类:封装对象的属性行为1.2方法:封装特定的业务功能实现1.3访问控制...多态3.1意义:行为的多态,对象的多态3.2向上造型、强制类型转换、instanceof3.3多态的形式:3.3.1重写:依据对...
  • java基础概要(面试)

    2020-05-26 17:04:06
    JAVA基础部分(面试) 8b java的三大特性; a)....1)类:封装的是对象的属性行为 2)方法:封装的是具体的业务逻辑功能 ...2)向上造型、强制类型转换、instanceof 3)多态的表现形式: 3.1)重写:主要是依据对象 3.2)
  • 多态多态①:什么是多态②:多态的好处③:多态的用途④:方法重写⑤:对象的向上造型和向下造型⑥:编译期类型运行期类型⑦:静态绑定动态绑定⑧:多态的使用⑨:多态的instanceof关键字⑩:多态总结 多态 同一...
  • 面向对象的三大特征

    2020-03-24 21:23:51
    1.封装 类:封装的是对象的属性行为 方法:封装的是一段特定的业务逻辑功能 访问控制修饰符:封装的是具体的访问权限。一般属性私有,行为公开 ...向上造型,强制类型转换 多态的表现形式 重写:根...
  • 面向对象三大特征

    2020-09-03 08:46:21
    面向对象三大特征: 1.封装: 1)类:封装的是对象的属性行为 2)方法:封装的是具体的业务逻辑功能实现 3)访问控制修饰符:封装的是具体的访问...2)向上造型、强制类型转换、instanceof判断 3)多态的表现形式: 3.1)重写
  • 1.封装: 1)类:封装的是对象的属性行为; 2)方法:封装一段特定的业务逻辑功能实现; 3)访问控制修饰符:封装具体的访问权限。...2)向上造型,强制类型转换,instanceof判断; 3)多态的表现形式:重写。 ...
  • 面向对象oop

    2019-12-28 09:43:45
    1.三大特征 封装性,把类当中的属性实现细节隐藏,提供程序的安全...多态,增强软件的灵活性重用性,具体表现有重载、重写向上造型; 2.类对象 类指的是一个事物抽象的样子,也就是他们大概的样子, 可以...
  • 多态向上造型 1.要有继承实现关系–重写 2.重载 案例:早餐店卖包子 a.来早餐店买包子有哪些人?美女,猛男… b.去早餐店买 c.包子店卖包子—人 要求: a.猛男,美女都是人的子类 b.都必须重写父类的方法 public void...
  • 大数据预科班8

    2017-09-12 23:01:46
    面向对象的特征:封装、继承、多态封装--体现形式:函数、属性私有化----复用性、安全性继承--extends,支持单继承---复用性、安全性、结构多态--重载、向上造型重写(两等两小一等)权限修饰符:public、...
  • 1、什么是类对象?什么是面向对象程序设计? 2、局部变量、实例变量静态变量(类变量...6、向上造型表现形式? 7、static、final修饰的成员变量成员方法各有什么用法?8、&amp;&amp;&amp;,||...
  • Java面向对象 1. 面向对象的三大特性? 2. 抽象类接口的区别?...6. 向上造型的含义? 7. Final,finally, finalize分别什么作用? 8. 数组是否有length()方法? 9. String,stringBuffer,StringB...
  • Java基础入门-详细总结

    千次阅读 2021-01-13 19:46:53
    面向对象2.1方法2.2面向对象2.3内存管理2.4继承2.5向上造型2.6方法重写2.7成员变量2.8接口2.9多态 一.java基础 1.1 java基础知识 java是高级计算机编程语言——计算机只能识别01; Java语言编译运行过程(跨平台...

空空如也

空空如也

1 2
收藏数 30
精华内容 12
关键字:

多态重写和向上造型