码迷,mamicode.com
首页 > 编程语言 > 详细

Java 对象转型、动态绑定、接口

时间:2018-04-06 16:45:50      阅读:202      评论:0      收藏:0      [点我收藏+]

标签:参数   技术   extend   dog   技术分享   eof   nta   形参   通过   

一、对象转型  Casting 

//对象转型Casting 
class Animal{
    public String name;
    Animal(String name){
        this.name = name;
    }
}

class Cat extends Animal{
    public String eyesColor;
    Cat(String n, String c){
        super(n);
        eyesColor = c;
    }
}

class Dog extends Animal{
    public String furColor;
    Dog(String n, String c){
        super(n);
        furColor = c;
    }
}

public class Casting{
    public static void main(String[]args){
        Animal a = new Animal("name");
        Cat c = new Cat("catname", "blue");
        Dog d = new Dog("dogname", "black");
        
        System.out.println(a instanceof Animal);
        System.out.println(c instanceof Animal);
        System.out.println(d instanceof Animal);
        System.out.println(a instanceof Cat);
        
        a = new Dog("bigyellow","yellow");
        System.out.println(a.name);
        //System.out.println(a.furColor);    wrong
        System.out.println(a instanceof Animal);
        System.out.println(a instanceof Dog);
        Dog d1 = (Dog)a;
        System.out.println(d1.furColor);
    }
}
技术分享图片
true
true
true
false
bigyellow
true
true
yellow
View Code

 

1、对象转型:父类引用指向子类对象,如上述代码中,Animal a = new Dog("bigyellow" , "yellow");    Animal 的引用类型变量a  指向子类对象Dog。

p.s.提及一下继承,子类继承父类时,子类对象中含有相应的父类对象 。如下图所示,但是 a 只能访问本身对象内的成员变量。(虽然引用指向Dog Obj ,但是只能看到Animal Obj的成员)不能访问furColor (图中打错。 = = )若要访问子类对象内的成员变量,进行强制类型转换。 Dog d1 = (Dog ) a ;  

            技术分享图片

2、 Advantage : 对象转型的引入,使得可扩展性提高。如某方法中,只是参数的类型不同(且参数继承同一父类),其他一致。避免了重复写结构一样,只是传递参数不同的代码,而且加入新的子类的话,只需定义新子类的属性和方法,使父类对象指向子类。若需执行子类的内部内容,进行强制类型转换再调用。  Casting 是 Dynamic Binding 的前提和基础!

  Disadvantage:只能访问父类的成员,子类的成员的访问需要强制类型转换。

 

二、动态绑定/多态  Dynamic Binding / Polymorph

abstract class Animal{
    public String name;
    Animal(String name){
        this.name = name;
    }
    
    /*
    public void enjoy(){
        System.out.println("yelling...");
    }
    */
    public abstract void enjoy();
}

class Cat extends Animal{
    private String eyesColor;
    Cat(String n, String c){
        super(n);
        eyesColor = c;
    }
    
    public void enjoy(){
        System.out.println("meow...");
    }
}

class Dog extends Animal{
    private String furColor;
    Dog(String n, String c){
        super(n);
        furColor = c;
    }
    
    public void enjoy(){
        System.out.println("Dog barking...");
    }
}

class Bird extends Animal{
    
    Bird(){
        super("bird");
    }
    
    public void enjoy(){
        System.out.println("bird screaming....");
    }
}

class Lady{
    private String name;
    private Animal pet; //define superclass reference
    
    Lady(String name, Animal pet){
        this.name = name;
        this.pet = pet;
    }
    
    public void myPetEnjoy(){
        pet.enjoy();
    }
}

public class TestPolymorph{
    public static void main(String [] args){
        Cat c = new Cat("catname","blue");
        Dog d = new Dog("dogname", "black");
        Bird b = new Bird();
        Lady L1 = new Lady("L1",c);
        Lady L2 = new Lady("L2",d);
        Lady L3 = new Lady("L3",b);
        L1.myPetEnjoy();
        c.enjoy();
        L2.myPetEnjoy();
        L3.myPetEnjoy();
    }
}
技术分享图片
meow...
meow...
Dog barking...
bird screaming....
View Code

 

1、动态绑定:根据实际传进来的对象调用其相应的方法。

Lady L1 = new Lady("L1" , c);     Lady 类中形参为Animal , 但实际传入为 Cat (Casting的实现)  根据最终结果,调用的为传入的Cat c 的重写方法。

动态:java在执行过程中(java 指令),会识别实际传入的Obj 的类型。  绑定:将原来Animal Obj 的 内部方法指针(类似C++中函数指针,存放Animal中方法在Code Segment 的地址,通过该指针可以找到方法,执行方法),改成传入Obj(即Cat 类型中定义的方法)  导致最后呈现的结果为Cat 的方法的调用。即 enjoy() 由原本的Animal 中enjoy() 改为Cat 的 enjoy()

            技术分享图片

 

Java 对象转型、动态绑定、接口

标签:参数   技术   extend   dog   技术分享   eof   nta   形参   通过   

原文地址:https://www.cnblogs.com/leafh/p/8723486.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!