类与类的关系（is - a、has - a/use/need - a）重写和重载，多态，抽象类，接口

类与类之间的关系

1. 泛化（继承 、实现）is - a
2. 包含（组合、聚合、关联）has - a
3. 依赖（依赖）use / need - a

继承(is - a)

• 子类可以继承父类，通过extends关键字继承；
• 子类可以调用父类中非private的属性、方法；
• 子类可以添加自己特有的属性或者方法；
• 构造方法不能继承；
• 静态方法不存在继承；
• 子类里面可以重写父类的方法；
  　　　方法的重写：重写父类方法大括号内的内容，权限修饰符大于等于父类的权限修饰符，返回值小于等于父类的返回值，方法名是相同的，参数也是相同的；
  　　　重写和重载
  　　　
  关于继承类的加载顺序：
  　　 1. 父类，静态元素（属性，方法，代码块）；
  　　 2. 子类，静态元素（属性，方法，代码块）；
  　　 3 .父类，非静态元素（属性，方法，代码块，构造方法）；
  　　 4. 子类，非静态元素（属性，方法，代码块，构造方法）；

包含（has - a）

• 将一个类当做这个类的属性；

依赖（use/need - a）

• 一个类中使用到了另一个类的对象;

多态

• 特点：
  　　（１）多态的前提必须要有继承和重写；
  　　（２）多态就是用父类的引用指向子类；
  
  首先定义一个父类：Animal

public class Animal {
    public String name = "Animal";
    public String color = "Animal's color";
    public void eat(){
        System.out.println("这是animal的吃饭方法");
    }
    public void sleep(){
        System.out.println("这是animal的睡觉方法");
    }
}

设计一个Animal的子类Person

public class Person extends Animal {
    public String  name = "Person";
    public String color = "Person's color";
    public void eat(){
        System.out.println("这是重写的Person的吃饭方法");
    }
    public void talk(){
        System.out.println("这是person独有的说话方法");
    }
}

设计一个Animal的子类Dog

public class Dog extends Animal {
    public void talk(){
        System.out.println("dog独有的汪汪汪方法");
    }
}

设计一个Person的子类Student

public class Student extends Person {
    public void talk(){
        System.out.println("学生重写的说话方法");
    }
    public void study(){
        System.out.println("学生独有的学习方法");
    }
}

设计一个Person的子类Teacher

public class Teacher extends Person {
    @Override
    public void talk() {
        System.out.println("这是Teacher重写的说话方法");
    }
    public void teach(){
        System.out.println("这是Teacher独有的教书方法");
    }
}

最后，主方法

public class Test {
    public static void main(String[] args) {
        Student student = new Student();
        System.out.println(student.color);//person
        System.out.println(student.name);//person
        student.study();//student
        student.talk();//student
        student.eat();//person
        student.sleep();//animal
        Person person = new Student();//自动向上转型
        System.out.println(person.color);//person
        System.out.println(person.name);//person
        person.eat();//person
        person.sleep();//Animal
        person.talk();//student
        if (person instanceof Student) {
            Student s = (Student) person;//向下转型，铸型
            s.study();//student
        }
    }
}

输出结果：

抽象类

• 特点：
  　　（１）用abstract修饰的类就是抽象类；
  　　（２）抽象类里面可以没有抽象方法；
  　　（３）有抽象方法的类一定是抽象类；
  　　（４）抽象类的继承：抽象类的子类必须重写抽象类里面的所有抽象方法；如果补重写，那么此类也必须是抽象类；
  　　（５）抽象类不能直接创建对象，可以通过子类对象去访问它的成员；

接口

1. 概念：抽象类里面含有的全部是抽象方法，用interface代替class；public interface Test（）{}
2. 特点：
   　　（1）属性：只能是公有的，静态的常量；public static final，可以省略，默认是它们三个；
   　　（2）方法：只能是公有的抽象的方法；
   　　（3）程序块：接口内部不含有程序块；
   　　（4）构造方法：接口内部不含有构造方法，因为接口不能创建对象；
   　　（5）如何创建对象：通过子类多实现（implements）来做事；
   　　抽象类可以多实现接口；
   　　具体类不可以多实现接口（必须将接口中的抽象方法具体化，自己变成抽象类）
   　　接口多继承接口，可以直接多实现；
   　　接口不能实现接口；