Java程序设计—面向对象0120

• 多态的思想：

　　　　1. 对象的类型具有两种：一种为编译类型（声明对象变量的类型），另一种是运行类型（对象的真实类型）。

class Animal{
    public void eat() {
        System.out.println("Eat food");
    }
}
class Dog extends Animal{
    public void eat() {
        System.out.println("Eat dog food");
    }
}

public class J2_OOP_Polymorphic {
    public static void main(String[] args) {
        Animal obj=new Dog();//编译类型为animal,运行类型为Dog()
    }
}

　　　　2. 当编译类型和运行类型不同的时候，多态就出现了。编译类型必须是运行类型的父类。

　　　　3. 所谓多态，指对象可以有不同的形态，拥有多种形式。

　　　　4. 多态可以是：类与类的关系，更多的是：接口和实现类的关系。

　　　　5. 多态的出现是当子类对象运行的时候，表现出自身的特征。

• 多态的好处：屏蔽不同子类之间的差异，达到通用编程。例如下面的代码，通过创建animal子父类体系，当feeder需要喂不同的animal子类的时候，将形参设为父类，当任意子类调用时，自动调用该子类。

class Animal{
    private String name;
    Animal(String name){
        this.name=name;
    }
    public void eat() {
        System.out.println("Eat food");
    }
    public String showName() {
        return this.name;
    }

}

class Dog extends Animal{
    Dog(String name){
        super(name);
    }
    public void eat() {
        System.out.println("Eat dog food");
    }
}

class Cat extends Animal{
    private String name;//not used
//    Cat(String name){
//        this.name=name;
//    }//exception!!!
    Cat(String name){
        super(name);
    }
    public void eat() {
        System.out.println("Eat cat food");
    }
    
}
class feeder{
    public void feed(Animal a) {//Animal a will automatically convert into its subclass object while calling this method.
        System.out.println("feed food to "+a.showName());
        a.eat();
    }
}
public class J2_OOP_Polymorphic {
    public static void main(String[] args) {
        Animal d=new Dog("Dog");
        Animal c=new Cat("Cat");
        feeder f=new feeder();
        f.feed(d);
        f.feed(c);
    }
}

• 基本数据类型转换
  • 显示(强制）：大类型的数据赋值给小类型的数据。 e.g. short s=10; int i=s;//exception!!!损失精度。强转 int i=(short) s;
  • 隐式（自动）：小类型的数据赋值给大类型的数据 e.g. byte B=12; int i=B.
 引用类型的转换：大和小是父类与子类的关系
• 显示（强制）：

class Animal{
}   
class Cat extends Animal{
}
//main中

Animal a=new Cat();
Cat c=a;//无法转，需要强制转
Cat c=(Cat) a;

• 有时候强制转换，可以结合instanceof运算符来完成。如下，父类子类声明略过。

class feeder{
    public void feed(Animal a) {//Animal a will automatically convert into its subclass object while calling this method.
        System.out.println("feed food to "+a.showName());
        a.eat();
        if(a instanceof Dog) {
            ((Dog) a).bark();//强制转换，将a转成Dog类
        }
        else if(a instanceof Cat) {
            ((Cat) a).playBall();//强制转换，将a转成Cat类
        }
    }
}

• 隐式（自动）：多态的转换，子类的对象赋值给父类变量。

class Animal{
}   
class Cat extends Animal{
}
//main中

Animal a=new Cat();

• 总体来说，继承会破坏封装，因为子类可以修改父类的信息。