复用类

java 继承

可以基于已经存在的类构造一个新的类。继承已经存在的类就可以复用这个类的方法和域。在此基础上，可以添加新的方法和域，从而扩充新类的功能。

• 面向对象最重要的特点之一，就是可以实现对象的复用。
• 通过“继承”一个现有的类，可以使用已经定义的类中的方法和变量。
• 类的方法可以被继承，但是类的构造器和用private修饰的属性及方法不能被继承。

1. 继承的基本语法

父类

public class Father{
  ...//属性
  ...(){//方法
    ...
  }
}

子类

public class Son extends Father{

}

2. 继承的概念

继承是面向对象最显著的一个特征。继承是从以有的类中派生出的新类，新类能吸收已有类的数据属性和方法，并且扩展新的能力。

基本语法如下：

class 子类 extends 父类{}

java 继承的基本实现

clss Animal{
  private int weight;
  private int age;


  public int getWeight() {
           return weight;
       }

       public void setWeight(int weight) {
           this.weight=weight;
       }

       public int getAge() {
           return age;
       }

       public void setAge(int age) {
           this.age=age;
       }
}
class Dog extends Animal{  //Dog类继承了Animal类

}

public class ExtendsDemo{
  public static void main(String[] args){
    Dog dog=new Dog();
    dog.setAge(5);
    dog.setWeight(10);
    dog.speak();
System.out.println("age:"+dog.getAge+",weight:"+dog.getWeight);


  }
}

运行结果:

age:5,weight10

通过代码可以发现，子类（Dog）并没有定义任何的操作，而在主类中所使用的全部操作都是由 Animal 类定义的，这证明：子类即使不扩充父类，也能维持父类的操作。

在子类扩充父类的功能:

clss Animal{
  private int weight;
  private int age;


  public int getWeight() {
           return weight;
       }

       public void setWeight(int weight) {
           this.weight=weight;
       }

       public int getAge() {
           return age;
       }

       public void setAge(int age) {
           this.age=age;
       }
}
class Dog extends Animal{  //Dog类继承了Animal类
   private String color;

   public void speak(){
     System.out.println("wangwnagwang!!");
   }

   public String setColor(String color){
     this.color=color;
   }
   public void getColor(){
     return color;
   }

}

public class ExtndsDemo{
  public static void main(String[] args){
    Dog dog=new Dog();
    dog.setAge(5);
    dog.setWeight(10);
    dog.setColor("yellow");
    dog.speak();
System.out.println("age:"+dog.getAge+",weight:"+dog.getWeight+",color:"+dog.getColor);


  }
}

运行结果:

wangwangwang!!
age:5,weight10,yellow

3. java 继承的限制

• 限制一:java 只允许单继承
  即:

class A {}
class B extends A {}
class C extends B {}

• 限制二:
  在一个子类继承的时候，实际上会继承父类之中的所有操作（属性、方法），但是需要注意的是，对于所有的非私有（no private）操作属于显式继承（可以直接利用对象操作），而所有的私有操作属于隐式继承（间接完成）。
• 限制三:
  在继承关系之中，如果要实例化子类对象，会默认先调用父类构造，为父类之中的属性初始化，之后再调用子类构造，为子类之中的属性初始化，即：默认情况下，子类会找到父类之中的无参构造方法。

4. 动态绑定

• 1. 动态方法的绑定

将一个方法同一个方法主体连接在一起就称为绑定 (Binding)。若在运行运行前执行绑定，就称为“早期绑定”。上面的例子中，在只有一个 Dog 句柄的情况下，编译器不知道具体调用哪个方法。Java 实现了一种方法调用机制，可在运行期间判断对象的类型，然后调用相应的方法，这种在运行期间进行，以对象的类型为基础的绑定称为动态绑定。除非一个方法被声明为 final，Java 中的所有方法都是动态绑定的。

用一张图表示上溯造型的继承关系

用代码概括为：

Shape s = new Shape();

按照继承关系，将创建的 Circle 对象句柄赋给一个 Shape 是合法的，因为 Circle 属于 Shape 的一种。

当调用其中一个基础类方法时：

Shape s = new Shape();

此时，调用的是 Circle.draw(), 这是由于动态绑定的原因。

动态绑定代码示例:

class Person {
    void eat() {}
    void speak() {}
}
class Boy extends Person {
    void eat() {
        System.out.println("Boy.eat()");
    }
    void speak() {
        System.out.println("Boy.speak()");
    }
}
class Girl extends Person {
    void eat() {
        System.out.println("Girl.eat()");
    }
    void speak() {
        System.out.println("Girl.speak()");
    }
}
public class Persons {
    public static Person randPerson() {
        switch ((int)(Math.random() * 2)) {
        default:
        case 0:
            return new Boy();
        case 1:
            return new Girl();
        }
    }
    public static void main(String[] args) {
        Person[] p = new Person[4];
        for (int i = 0; i < p.length; i++) {
            p[i] = randPerson();    // 随机生成Boy或Girl
        }
        for (int i = 0; i < p.length; i++) {
            p[i].eat();
        }
    }
}

对所有从 Person 衍生出来的类，Person 建立了一个通用接口，所有衍生的类都有 eat 和 speak 两种行为。衍生类覆盖了这些定义，重新定义了这两种行为。在主类中，randPerson 随机选择 Person 对象的句柄。上溯造型是在 return 语句里发生的。return 语句取得一个 Boy 或 Girl 的句柄并将其作为 Person 类型返回，此时并不知道具体是什么类型，只知道是 Person 对象句柄。在 main 方法中调用 randPerson 方法为数组填入 Person 对象，但不知具体情况。当调用数组每个元素的 eat 方法时，动态绑定的作用就是执行对象的重新定义了的方法。

然而，动态绑定是有前提的，绑定的方法必须存在于基类中，否则无法编译通过。

class Person {
    void eat() {
        System.out.println("Person.eat()");
    }
}
class Boy extends Person {
    void eat() {
        System.out.println("Boy.eat()");
    }
    void speak() {
        System.out.println("Boy.speak()");
    }
}
public class Persons {
    public static void main(String[] args) {
        Person p = new Boy();
        p.eat();
        p.speak();  // The method speak() is undefined for the type Person
    }
}

如果子类中没有定义覆盖方法，则会调用父类中的方法：

复制代码
class Person {
    void eat() {
        System.out.println("Person.eat()");
    }
}
class Boy extends Person {
}
public class Persons {
    public static void main(String[] args) {
        Person p = new Boy();
        p.eat();
    }
}

【运行结果】:

Person.eat()

5. 静态方法的绑定

将上面的方法都加上 static 关键字，变成静态方法：

class Person {
    static void eat() {
        System.out.println("Person.eat()");
    }
    static void speak() {
        System.out.println("Person.speak()");
    }
}
class Boy extends Person {
    static void eat() {
        System.out.println("Boy.eat()");
    }
    static void speak() {
        System.out.println("Boy.speak()");
    }
}
class Girl extends Person {
    static void eat() {
        System.out.println("Girl.eat()");
    }
    static void speak() {
        System.out.println("Girl.speak()");
    }
}
public class Persons {
    public static Person randPerson() {
        switch ((int)(Math.random() * 2)) {
        default:
        case 0:
            return new Boy();
        case 1:
            return new Girl();
        }
    }
    public static void main(String[] args) {
        Person[] p = new Person[4];
        for (int i = 0; i < p.length; i++) {
            p[i] = randPerson();    // 随机生成Boy或Girl
        }
        for (int i = 0; i < p.length; i++) {
            p[i].eat();
        }
    }
}

【运行结果】：
Person.eat()
Person.eat()
Person.eat()
Person.eat()

结论:
观察结果，对于静态方法而言，不管父类引用指向的什么子类对象，调用的都是父类的方法。

方法绑定的总结

• 静态方法: 静态方法看父类
• 非静态方法：非静态方法看子类