面向对象4

1、多态

thinking in java3中的多态

People are often confused by other, non-object-oriented features of Java, like method overloading, which are sometimes presented as object-oriented. Don't be fooled: If it isn't late binding, it isn't polymorphism

按文面翻译

人们总是被java的另一种非面向对象的特性所困惑,就像方法重载,有时候它以面向对象而存在,请不要犯傻,如果没有后期绑定(也就是运行期的动态绑定),它就不是多态.

所以,这段话要表达的意思就是说,多态要有动态绑定,否则就不是多态,方法重载也不是多态(因为方法重载是编译期决定好的,没有后期也就是运行期的动态绑定)

多态存在的三个必要条件

• 继承
• 重写
• 父类引用指向子类对象

比如：

Parent p = new Child();

多态的实现方式

方式一：重写：

方式二：接口

• 1. 生活中的接口最具代表性的就是插座，例如一个三接头的插头都能接在三孔插座中，因为这个是每个国家都有各自规定的接口规则，有可能到国外就不行，那是因为国外自己定义的接口类型。

• 2. java中的接口类似于生活中的接口，就是一些方法特征的集合，但没有方法的实现。具体可以看 java接口 这一章节的内容。

方式三：抽象类和抽象方法

多态的好处：提高代码的重用性，降低模块之间的耦合度

package LESSON6;

class Animal1{
    String name;
}
class Food1{
    String name;
}
class Feeder1{
    String name;
    public void  feed(Animal1 animal,Food1 food){
        System.out.println(name+"给"+animal.name+"喂"+food.name);        
    }
}
class Rabbit1 extends Animal1{}
class Dog1 extends Animal1{}
class Bone1 extends Food1{}
class Carrot1 extends Food1{}

public class DEMO8 {

    /**
     * @param args
     */
    public static void main(String[] args) {
        //多态的好处：提高代码的重用性，降低模块之间的耦合度
        Feeder1 feeder=new Feeder1();
        feeder.name="jack";
        
        Animal1 rabbit=new Rabbit1();
        rabbit.name="小白兔";
        Animal1 dog=new Dog1();
        dog.name="牧羊犬";
        Food1 bone=new Bone1();
        bone.name="大骨头";
        Food1 carrot=new Carrot1();
        carrot.name="胡萝卜";
        feeder.feed(rabbit, carrot);
        feeder.feed(dog, bone);

    }

}

package LESSON6;
class Animal{
    public String name;
    public void eat(){
        System.out.println("动物具有吃的能力");
    }    
}
class Food{
    public String type;
}
class Feeder{
    public void feed(String name,String type){
        System.out.println("喂"+name+"吃"+type);        
    }    
}
class Dog extends Animal{
    //重写
    public void eat(){
        System.out.println("我喜欢吃骨头");
    }    
    //子类独有方法
    public void watchdoor(){
        System.out.println("看门");        
    }    
}
class Rabbit extends Animal{
    public void eat(){
        System.out.println("我喜欢吃胡萝卜");
    }
}
public class DEMO6 {

//    多态：指对象的多种形态
//  多态的前提：继承关系中
//  多态的表现：向上转型和向下转型

    public static void main(String[] args) {
        //1 引用多态
        Animal animal=new Animal();//父类的引用指向本类对象
        Animal dog=new Dog();//父类引用指向子类对象(向上转型：子类对象->>父类对象)
        dog.name="狗";//通过父类的引用变量调用父类属性

        Dog dog1=(Dog)dog;//向下转型：父类对象->>子类对象（前提是先进行向上转型）
        Dog dog2=(Dog)Animal;//java.lang.ClassCastException类型转化异常（未进行向上转型）


        //2 方法多态
        animal.eat();//创建本类对象时，调用的方法为本类方法。
        //输出  动物具有吃的能力
        dog.eat();//创建子类对象时，调用的方法为子类重写的方法或者继承的方法。
        //输出   我喜欢吃骨头
        
        
        //dog.watchdoor()  //不能通过父类的引用调用子类独有的方法
        Food food=new Food();
        food.type="骨头";
        
        
        Feeder Feed=new Feeder();
        Feed.feed(dog.name,food.type);
    }

}

2、抽象类，抽象方法

在面向对象的概念中，所有的对象都是通过类来描绘的，但是反过来，并不是所有的类都是用来描绘对象的，如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。

抽象类除了不能实例化对象之外，类的其它功能依然存在，成员变量、成员方法和构造方法的访问方式和普通类一样。

由于抽象类不能实例化对象，所以抽象类必须被继承，才能被使用。也是因为这个原因，通常在设计阶段决定要不要设计抽象类。

父类包含了子类集合的常见的方法，但是由于父类本身是抽象的，所以不能使用这些方法。

在Java中抽象类表示的是一种继承关系，一个类只能继承一个抽象类，而一个类却可以实现多个接口。

package LESSON7;

//抽象类：[修饰符] abstract class 类名
 abstract class Shape{
     //抽象方法：[修饰符] abstract 返回值类型 方法名 ([参数列表]);
     public abstract void area();
    
     //如果一个类中声明了抽象方法，该类必须是抽象类
     //抽象类中可以声明普通方法和抽象方法
     
     public void test(){
         System.out.println("test");
     }
      
  }
 class Circle extends Shape{
     public double r;
     public final double PI=3.14;
     
     public Circle(double r) {
        this.r=r;
    }
     @Override
    public void area() {
        System.out.println("该圆的面积是"+PI*r*r);
        
    }
 }

public class demo {
    public static void main(String[] args) {
        Shape c=new Circle(2);
        c.area();
    }
}

3、接口

接口多实现

package LESSON7;
interface A{
    public abstract void a();    
}
interface B{
    public abstract void b();    
}
interface C{
    public abstract void c();
}
//接口可以多实现，类只能单继承但可以多重继承
class D implements A,B,C{
    @Override
    public void a() {
        System.out.println("a");
        
    }
    @Override
    public void b() {
        System.out.println("b");
        
    }
    public void c() {
        System.out.println("c");
        
    }
}
public class demo2 {
    public static void main(String[] args) {
        D d=new D();
        d.a();
        d.b();
        d.c();
        
        A d2=new D();
        d2.a();//只能调用a方法

    }

}

接口多继承