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

    2017-03-14 10:37:27
    * 父类中不存在该方法,向上转型后,父类是不能引用该方法的 * @param a * @return void */ public void fun1(String a){ System.out.println( "JNC 的 Fun1..." ); fun2(); } /** * 子类...
    public class Wine {
        public void fun1(){
            System.out.println("Wine 的Fun.....");
            fun2();
        }
        
        public void fun2(){
            System.out.println("Wine 的Fun2...");
        }
    }
    
    public class JNC extends Wine{
        /**
         * @desc 子类重载父类方法
         *        父类中不存在该方法,向上转型后,父类是不能引用该方法的
         * @param a
         * @return void
         */
        public void fun1(String a){
            System.out.println("JNC 的 Fun1...");
            fun2();
        }
        
        /**
         * 子类重写父类方法
         * 指向子类的父类引用调用fun2时,必定是调用该方法
         */
        public void fun2(){
            System.out.println("JNC 的Fun2...");
        }
    }
    
    public class Test {
        public static void main(String[] args) {
            Wine a = new JNC();
            a.fun1();
        }
    }
    -------------------------------------------------
    Output:
    Wine 的Fun.....
    JNC 的Fun2...
    
    
    转至http://www.cnblogs.com/chenssy/p/3372798.html
    展开全文
  • 一、什么是多态?举例说明如下:public class Animal{//成员public void eat(){System.out.println("动物在吃!");}}public class Cat extends Animal{//重写public void eat(){System.out.println("猫吃鱼");}//Cat...

    一、什么是多态?

    举例说明如下:

    public class Animal{

    //成员

    public void eat(){

    System.out.println("动物在吃!");

    }

    }

    public class Cat extends Animal{

    //重写

    public void eat(){

    System.out.println("猫吃鱼");

    }

    //Cat特有的方法.

    public void move(){

    System.out.println("猫走猫步!");

    }

    }

    public class Dog extends Animal{

    //重写

    public void eat(){

    System.out.println("狗啃骨头!");

    }

    }

    public class Test{

    public static void main(String[] args){

    //向上转型又被称作:自动类型转换.

    //父类型的引用指向子类型对象.

    //程序分两个阶段:编译阶段,运行阶段。

    //程序编译阶段只知道a1是一个Animal类型。

    //程序在运行的时候堆中的实际对象是Cat类型。

    Animal a1 = new Cat();

    //程序在编译阶段a1被编译器看做Animal类型.

    //所以程序在编译阶段a1引用绑定的是Animal类中的eat方法.(静态绑定)

    //程序在运行的时候堆中的对象实际上是Cat类型,而Cat已经重写了eat方法。

    //所以程序在运行阶段对象的绑定的方法是Cat中的eat方法.(动态绑定)

    a1.eat(); //猫吃鱼

    //向下转型:强制类型转换

    Animal a2 = new Cat(); //向上转型.

    //要执行move方法,怎么做?

    //只能强制类型转换,需要加强制类型转换符

    Cat c1 = (Cat)a2;

    c1.move();

    //判断以下程序运行的时候会出什么问题?

    //Animal a3 = new Dog(); //向上转型.

    //强制类型转换

    //Cat c2 = (Cat)a3; //会抛出异常: java.lang.ClassCastException

    //在做强制类型转换的时候程序是存在风险的!

    //为了避免ClassCastException的发生,java引入了 instanceof

    用法:

    1. instanceof运算符的运算结果是 boolean类型

    2. (引用 instanceof 类型) --> true/false

    例如:(a instanceof Cat) 如果结果是true表示:a引用指向堆中的java对象是Cat类型.

    Animal a3 = new Dog();

    System.out.println(a3 instanceof Cat); //结果是:false

    //推荐:在做向下转型的时候要使用instanceof运算符判断,避免ClassCastException

    if(a3 instanceof Cat){

    Cat c2 = (Cat)a3;

    }

    }

    }

    关于java语言中向上转型和向下转型

    1.向上转型(upcasting) :  子--->父

    2.向下转型(downcasting) :  父--->子

    注意:无论是向上转型还是向下转型,两个类之间必须要有继承关系。

    public class Test{

    public static void main(String[] args){

    //向上转型又被称作:自动类型转换.

    //父类型的引用指向子类型对象.

    //程序分两个阶段:编译阶段,运行阶段。

    //程序编译阶段只知道a1是一个Animal类型。

    //程序在运行的时候堆中的实际对象是Cat类型。

    Animal a1 = new Cat();

    //程序在编译阶段a1被编译器看做Animal类型.

    //所以程序在编译阶段a1引用绑定的是Animal类中的eat方法.(静态绑定)

    //程序在运行的时候堆中的对象实际上是Cat类型,而Cat已经重写了eat方法。

    //所以程序在运行阶段对象的绑定的方法是Cat中的eat方法.(动态绑定)

    a1.eat(); //猫吃鱼

    //向下转型:强制类型转换

    Animal a2 = new Cat(); //向上转型.

    //要执行move方法,怎么做?

    //只能强制类型转换,需要加强制类型转换符

    Cat c1 = (Cat)a2;

    c1.move();

    //判断以下程序运行的时候会出什么问题?

    //Animal a3 = new Dog(); //向上转型.

    //强制类型转换

    //Cat c2 = (Cat)a3; //会抛出异常: java.lang.ClassCastException

    //在做强制类型转换的时候程序是存在风险的!

    //为了避免ClassCastException的发生,java引入了 instanceof

    用法:

    1. instanceof运算符的运算结果是 boolean类型

    2. (引用 instanceof 类型) --> true/false

    例如:(a instanceof Cat) 如果结果是true表示:a引用指向堆中的java对象是Cat类型.

    Animal a3 = new Dog();

    System.out.println(a3 instanceof Cat); //结果是:false

    //推荐:在做向下转型的时候要使用instanceof运算符判断,避免ClassCastException

    if(a3 instanceof Cat){

    Cat c2 = (Cat)a3;

    }

    }

    } 二、多态的好处 1.使用多态可以使代码之间的耦合度降低。 2.项目的扩展能力增强。

    展开全文
  • 主要介绍了简单了解Java多态向上转型相关原理,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • 多态的定义与使用格式多态的定义格式:就是父类的引用变量指向子类对象父类类型 变量名 = new 子类类型();变量名.方法名();普通类多态定义的格式父类 变量名 = new 子类();如: class Fu {}class Zi extends Fu {}//...

    多态的定义与使用格式

    多态的定义格式:就是父类的引用变量指向子类对象

    父类类型  变量名 = new 子类类型();

    变量名.方法名();

    普通类多态定义的格式

    父类 变量名 = new 子类();

    如: class Fu {}

    class Zi extends Fu {}

    //类的多态使用

    Fu f = new Zi();

    式抽象类多态定义的格

    抽象类 变量名 = new 抽象类子类();

    如: abstract class Fu {

    public abstract void method();

    }

    class Zi extends Fu {

    public void method(){

    System.out.println(“重写父类抽象方法”);

    }

    }

    //类的多态使用

    Fu fu= new Zi();

    接口多态定义的格式

    接口 变量名 = new 接口实现类();

    如: interface Fu {

    public abstract void method();

    }

    class Zi implements Fu {

    public void method(){

    System.out.println(“重写接口抽象方法”);

    }

    }

    //接口的多态使用

    Fu fu = new Zi();

    注意事项

    同一个父类的方法会被不同的子类重写。在调用方法时,调用的为各个子类重写后的方法。

    如 Person p1 = new Student();

    Person p2 = new Teacher();

    p1.work(); //p1会调用Student类中重写的work方法

    p2.work(); //p2会调用Teacher类中重写的work方法

    当变量名指向不同的子类对象时,由于每个子类重写父类方法的内容不同,所以会调用不同的方法。

    public classPerson {public voideat() {

    System.out.println("人吃饭");

    }

    }

    public class Student extendsPerson{public voideat() {

    System.out.println("学生吃饭");

    }

    }

    public abstract classAnimal {public abstract voidsleep() ;

    }

    public class Cat extendsAnimal{public voidsleep() {

    System.out.println("猫趴着睡觉");

    }

    }

    public interfaceDrinking {public abstract voiddrink();

    }

    public class Pig implementsDrinking{public voiddrink() {

    System.out.println("小猪喝酒");

    }

    }

    public classDemo01 {public static voidmain(String[] args) {//1.多态:子类对象指向父类引用变量(普通类之间的多态)

    Person p=newStudent();

    p.eat();//2.抽象类与普通类的多态(抽象类可利用多态创建普通对象)

    Animal a=newCat();

    a.sleep();//3.接口与普通类之间的多态(子类必须是普通类)

    Drinking d=newPig();

    d.drink();

    }

    }

    展开全文
  • 向上转型:符合“is a”,是安全的,子类向上到父类,多余的属性和方法会丢弃向下转型:不安全的,用instanceof提前判断一下,以免抛出异常instanceof用法:result = object instanceof classresult:布尔类型object...

    向上转型:符合“is a”,是安全的,子类向上到父类,多余的属性和方法会丢弃

    向下转型:不安全的,用instanceof提前判断一下,以免抛出异常

    instanceof用法:

    result = object instanceof class

    result:布尔类型

    object:必选项,任意对象表达式

    class:必选项,任意已定义的对象类

    说明: 如果object是class或者其子类的一个实例,则instanceof运算符返回true,如果不是或者object是null,则返回false

    public class AnimalDemo {

    public static void main(String[] args) {

    // TODO Auto-generated method stub

    Animal animal1 = new Dog("旺财");//向上转型

    Animal animal2 = new Cat("招财猫");

    animal1.eat();

    //animal1.sleep();因为向上转型,所以子类的sleep()丢弃了

    //父类的引用变量只能调用父类中有的方法,或者是子类重写父类的方法

    animal2.eat();

    //向下转型不安全,需要提前用instanceof判断一下,防止异常抛出

    if(animal2 instanceof Cat){

    System.out.println("111");

    Cat cat = (Cat)animal2;

    cat.sleep();

    }

    }

    }

    class Animal{

    private String name;

    public Animal(String name) {

    this.name = name;

    }

    public void eat() {//子类要重写

    System.out.println(name);

    }

    }

    class Dog extends Animal{

    public Dog(String name) {

    super(name);

    }

    public void eat() {

    System.out.println("吃狗粮");

    }

    public void sleep() {

    System.out.println("sleep");

    }

    }

    class Cat extends Animal{

    public Cat(String name) {

    super(name);

    }

    public void eat() {

    System.out.println("吃猫粮");

    }

    public void sleep() {

    System.out.println("sleep");

    }

    }

    展开全文
  • 初识JAVA-多态向上转型与向下转型 多态: 程序定义的引用变量所指向的具体的类和通过该变量发出的方法调用,在编程时并不确定,在程序运行时期间才被确定。 条件: 1.首先要有继承或接口的实现 2.子类要对父类的方法...
  • 前言:在看完狂神说Java的关于重写 多态 向上转型和向下转型的视频之后,我感到了极大的困惑和难以理解,于是我去看了很多不同的视频,最终总结出一套究极容易理解和运用的模式 用心看完,你也应该会有很大的收获 PS...
  • 这篇文章主要介绍了简单了解Java多态向上转型相关原理,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下多态性是面向对象的第三大特征。多态的优点改善代码的组织...
  • A:向上转型:当有子类对象赋值给一个父类引用时,便是向上转型多态本身就是向上转型的过程。 使用格式:父类类型 变量名 = new 子类类型();如:Person p = new Student(); B:向下转型:一个已...
  • 文章目录面向对象多态多态向上转型和向下转型多态的好处和弊端 面向对象 多态 多态向上转型和向下转型 我们首先通过以下代码复习一下自动类型提升和强制类型转换: class BunnyAnimal0602 { public static void...
  • 1.多态 public class Fu /*extends Object*/ { int num = 10; public void showNum() { System.out.println(num); } public void method() { System.out.println("父类方法"); } ...
  • 多态 向上转型 向下转型 抽象类 抽象方法 类与接口的关系 匿名内部类 身边很多同学都说多态这部分是学java过程中遇到的第一个难点,里面很多抽象的内容很难理解。感觉这块还是得多看概念,不是所有代码学习都能只用...
  • Java 多态 向上转型

    2018-04-01 14:05:13
    1.多态时成员变量的特点:正常情况下:package cn.interace.com; class fu{ //创建一个父类 int n=3; //定义父类中变量n=3 void show () { //定义父类的show方法 System.out.println("fu&...
  • java 向上转型和向下转型 学习向上转型和向下转型怎么用没多难,但是为什么那样用,我搞了很多次没弄明白。没弄明白的原因是平时学习时之看例子,而例子一般都比较简单,没有对象之间的调用,一般就是一个对象调用...
  • public static void main(String[] args) { Artist artist; artist = new ...//(向上转型)ViolinArtist为子类,父类引用子类对象 损失自己特有的属性和方法 artist.make();//调用的子类的方法 //a...
  • 代码当中体现多台性,其实据说一句话 父类引用指向子类对象 格式: 父类名称 对象名=new 子类名称(); 或者 接口名称 对象名=new 实现类名称(); package duotai.lianxi;... //使用多态的写法...
  • 向上转型: 父类类型 变量名=new 子类类型(); //父类是animal,子类是cat Animal animal=new Cat(); 向下转型: 子类类型 变量名=(子类类型)父类变量名;(类似于强转) Cat c=(Cat) a; ...
  • 封装、继承、多态是面向对象的三大特征,在Java中什么是多态? Java引用变量有两种类型,分别是编译时类型和运行时类型。何为编译时类型,编译时类型就是由声明该变量时使用的类型决定,而运行时类型是由...
  • interface Animal { int a = 1; int eat(); } public class Test implements Animal{ public static void main(String[] args) { //向上转型 Animal animal = new Test();... //向上转型后可以
  • 多态:代码在编译中多种状态的展示 ...--向上造型 4、多态中,成员方法编译看左边,运行看右边 就是编译申明变量的时候 a是Animal 而在运行的时候 a是dog 多态中的成员访问特点: A:成员变量 ...
  • //向上转型,Animal具有多态性质 (子类对象转为父类对象) Animal animal = new Cat ( ) ; //错误情况 //Cat cat = new Animal(); //调用的是Cat的eat方法 animal . eat ( ) ; //向...
  • [javase]多态 向上转型

    2017-12-18 22:22:21
    JNC a = new JNC();  对于这个代码我们非常容易理解无非就是实例化了一个剑南春的对象嘛!...由于JNC是继承与Wine,所以JNC可以自动向上转型为Wine,所以a是可以指向JNC实例对象的。这样做存在一个非常大的好处,在
  • //类型提升,向上转型 // a.eat(); //如果想要调用猫的特有方法时,如何操作? //强制将父类的引用。转成子类类型。向下转型 // Cat c=(Cat)a; // c.catchMouse(); //千万不要出现这样的操作,就是将...

空空如也

空空如也

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

多态向上转型