面向对象编程（五）多态--对象上下转型，动态绑定和静态绑定，应用

多态

概念：指同一操作作用于某一类对象，可以有不同的解释，产生不同的执行结果;

存在的必要条件

①   需要存在继承和实现关系;

②   同样的方法调用而执行不同操作，运行不同代码（重写操作）;

③   在运行时父类或者接口的引用变量可以引用其子类的对象;

作用

①   多态通过分离做什么和怎么做，从另一个角度将接口和实现进行分离;

②   “多态”则消除了类型之间耳朵耦合关系;

③   多态的存在提高了程序的扩展和后期的可维护性;

public class AnimalDemo{
    public static void main(String []args){
        //父类的引用变量可以引用其子类对象
        Animal animal1=new Dog("旺财");
        animal1.eat();
        
        Animal animal2=new Cat("招财");
        animal2.eat();
        
    }
}

class Animal{
    private String name;
    public Animal(String name){
        this.name=name;
    }
    
    //这是一个通用的方法，实现没有太大的意义
    //只是告诉其子类去实现它
    public void eat(){
        
    }
}

class Dog extends Animal{
    public Dog(String name){
        super(name);
    }
    
    //对父类的方法进行重写
    public void eat(){
        System.out.println("啃骨头");
    }
}

class Cat extends Animal{
    public Cat(String name){
        super(name);
    }
    
    //对父类的方法进行重写
    public void eat(){
        System.out.println("吃鱼");
    }
}

对象上下转型

①   由子类转型成父类，在继承图上是向上移动的，一般称为向上转型;

②   向上转型是从一个较专用类型像较通用类型转型，所以总是安全的，也就是说，子类是父类的一个超集;

③   向上转型过程中，类接口中唯一可能发生的事情就是丢失方法，而不是获取方法;

④   与之相反的操作是向下转型，不安全（可能需要instanceof操作符协助）;

⑤   LSP(liskov替换原则)：子类型必须能够替换掉它们的基类型;

⑥   安全的上转和LSP的实施，充分体现继承的“is-a”关系;

 

上面的demo就是向上转型

public class AnimalDemo{
    public static void main(String []args){
        //父类的引用变量可以引用其子类对象
        Animal animal1=new Dog("旺财狗");//向上转型
        //向上转型首先是安全的，但可能会导致子类方法的丢失
        //父类的引用变量只能调用父类中有的方法，或子类中重写的方法
        animal1.eat();
        //animal1.sleep();//在dog中的特有方法不能使用
        
        Animal animal2=new Cat("招财猫");
        animal2.eat();
        
        
        //向下转型是不安全的
         //Cat cat=(Cat)animal1;//转换异常
        
    }
}

class Animal{
    private String name;
    public Animal(String name){
        this.name=name;
    }
    
    //这是一个通用的方法，实现没有太大的意义
    //只是告诉其子类去实现它
    public void eat(){
        
    }
}

class Dog extends Animal{
    public Dog(String name){
        super(name);
    }
    
    //对父类的方法进行重写
    public void eat(){
        System.out.println("啃骨头");
    }
    
    public void sleep(){
        System.out.println("睡觉");
    }
}

class Cat extends Animal{
    public Cat(String name){
        super(name);
    }
    
    //对父类的方法进行重写
    public void eat(){
        System.out.println("吃鱼");
    }
}

instanceof运算符用来在运行时通过返回一个布尔值来指出对象是否是特定类或者是它的子类的一个实例;

用法：

         result=object instanceof calss

         result:布尔类型

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

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

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

典型使用场合：在对对象做下转型之前，没有其它有关对象类型信息时务必使用instanceof来判断一下，以免抛出ClassCastException异常;

public class AnimalDemo{
    public static void main(String []args){
        //父类的引用变量可以引用其子类对象
        Animal animal1=new Dog("旺财狗");//向上转型
        //向上转型首先是安全的，但可能会导致子类方法的丢失
        //父类的引用变量只能调用父类中有的方法，或子类中重写的方法
        animal1.eat();
        //animal1.sleep();//在dog中的特有方法不能使用
        
        Animal animal2=new Cat("招财猫");
        animal2.eat();
        
        
        //向下转型是不安全的
         //Cat cat=(Cat)animal1;//转换异常
         
         //解决方法
         if(animal1 instanceof Cat){
             //未进入
             System.out.println("进入执行");
             Cat cat=(Cat)animal1;
         }
         
          if(animal2 instanceof Cat){
             //进入
             System.out.println("进入执行2");
             Cat cat=(Cat)animal2;
             cat.sleep();
         }
        
    }
}

class Animal{
    private String name;
    public Animal(String name){
        this.name=name;
    }
    
    //这是一个通用的方法，实现没有太大的意义
    //只是告诉其子类去实现它
    public void eat(){
        
    }
}

class Dog extends Animal{
    public Dog(String name){
        super(name);
    }
    
    //对父类的方法进行重写
    public void eat(){
        System.out.println("啃骨头");
    }
    
    public void sleep(){
        System.out.println("睡觉");
    }
}

class Cat extends Animal{
    public Cat(String name){
        super(name);
    }
    
    //对父类的方法进行重写
    public void eat(){
        System.out.println("吃鱼");
    }
    
    public void sleep(){
        System.out.println("睡觉");
    }
}

动态绑定和静态绑定

概念：

①   在程序执行前方法以及被绑定，针对Java简单的可以理解为程序编译期的绑定（静态绑定）java当中的方法是final，static，private和构造方法都是前期绑定的;

②   运行时，根据变量实际引用的对象类型决定调用哪个方法（动态绑定）;

静态绑定在编译期进行

         Person.sayHi();

动态绑定在运行期进行

         Person p=new Teacher();

         p.sayHi();

多态的概念基于对象引用的动态绑定特性;

 

多态应用

简单来说，多态是具有表现多种行为能力的特征;

同一个实现接口，使用不同的实例而执行不同操作;

不使用多态：

public class PrinterDemo{
    public static void main(String []args){
        ColorPrinter cp=new ColorPrinter("惠普");
        BlackPrinter bp=new BlackPrinter("戴尔");
        School school=new School();
        //school.setColorPrinter(cp);
        school.setBlackPrinter(bp);//新建的黑白打印时，要修改学习的打印方法
        school.print("hello java");
        
        /*以上每次调用不同的子类时特别麻烦，会影响到其他类中的代码修改*/
    }
}

class Printer{
    private String brand;
    
    public Printer(String brand){
        this.brand=brand;
    }
    
    public String getBrand()
    {
        return brand;
    }
    
    //打印方法应该由其子类来具体的实现
    public void print(String content){
        
    }
}


//开原原则：对修改是封闭的，对扩展是开放的
//可以使用多态解决这个问题，父类的引用变量可以引用其子类的对象
class School{
    private ColorPrinter cp=null;
    private BlackPrinter bp=null;
    private ZhenPrinter bp=null;
    
    //安装彩色打印机
    public void setColorPrinter(ColorPrinter cp){
        this.cp=cp;
    }    
    
    //安装黑白打印机
    public void setBlackPrinter(BlackPrinter bp){
        this.bp=bp;
    }
    
    //安装针式打印机
    public void setZhenPrinter(ZhenPrinter bp){
        this.bp=bp;
    }
    
    public void print(String content){
        //交给中心所安装的彩色打印机来打印
        //cp.print(content);
        //交给中心所安装的黑白打印机来打印
        bp.print(content);
    }
    
}

class ColorPrinter extends Printer{
    public ColorPrinter(String brand){
        super(brand);
    }
    //对父类的方法进行重写
    public void print(String content){
        System.out.println(getBrand()+"彩色打印:"+content);
    }
}

class BlackPrinter extends Printer{
    public BlackPrinter(String brand){
        super(brand);
    }
    //对父类的方法进行重写
    public void print(String content){
        System.out.println(getBrand()+"黑白打印:"+content);
    }
}

class ZhenPrinter extends Printer{
    public ZhenPrinter(String brand){
        super(brand);
    }
    //对父类的方法进行重写
    public void print(String content){
        System.out.println(getBrand()+"针式打印:"+content);
    }
}

使用多态：

public class PrinterDemo{
    public static void main(String []args){
        ColorPrinter cp=new ColorPrinter("惠普");
        BlackPrinter bp=new BlackPrinter("戴尔");
        ZhenPrinter zp=new ZhenPrinter("戴尔");
        School school=new School();
        
        school.setPrinter(zp);//这里的参数可以调用较灵活，使用cp，bp，zp都可以，而不用改school类中的方法
        school.print("hello java");

    }
}

class Printer{
    private String brand;
    
    public Printer(String brand){
        this.brand=brand;
    }
    
    public String getBrand()
    {
        return brand;
    }
    
    //打印方法应该由其子类来具体的实现
    public void print(String content){
        
    }
}


//开原原则：对修改是封闭的，对扩展是开放的
//可以使用多态解决这个问题，父类的引用变量可以引用其子类的对象
class School{
    private Printer p=null;//安装打印机
    
    //拿父类的引用变量作为参数，好处就是可以接受任何其子类的对象
    //越是抽象的东西就是越稳定的
    public void setPrinter(Printer p){
        this.p=p;
    }
    
    public void print(String content){
        //交给中心所安装的打印机来打印
        p.print(content);
    }
}

class ColorPrinter extends Printer{
    public ColorPrinter(String brand){
        super(brand);
    }
    //对父类的方法进行重写
    public void print(String content){
        System.out.println(getBrand()+"彩色打印:"+content);
    }
}

class BlackPrinter extends Printer{
    public BlackPrinter(String brand){
        super(brand);
    }
    //对父类的方法进行重写
    public void print(String content){
        System.out.println(getBrand()+"黑白打印:"+content);
    }
}

class ZhenPrinter extends Printer{
    public ZhenPrinter(String brand){
        super(brand);
    }
    //对父类的方法进行重写
    public void print(String content){
        System.out.println(getBrand()+"针式打印:"+content);
    }
}