最新Java基础系列课程--Day08-面向对象高级（二）

public abstract class Animal {
    private String name;
    //动物叫的行为：不具体，是抽象的
    public abstract void cry();
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
}

public class Dog extends Animal{
    public void cry(){
        System.out.println(getName() + "汪汪汪的叫~~");
    }
}

public class Cat extends Animal{
    public void cry(){
        System.out.println(getName() + "喵喵喵的叫~~");
    }
}

public class Test2 {
    public static void main(String[] args) {
        // 目标：掌握抽象类的使用场景和好处.
        Animal a = new Dog();
        a.cry();  //这时执行的是Dog类的cry方法
    }
}

public class Pig extends Animal{
    @Override
    public void cry() {
        System.out.println(getName() + "嚯嚯嚯~~~");
    }
}

public class Test2 {
    public static void main(String[] args) {
        // 目标：掌握抽象类的使用场景和好处.
        Animal a = new Pig();
        a.cry();  //这时执行的是Pig类的cry方法
    }
}

1.用抽象类可以把父类中相同的代码，包括方法声明都抽取到父类，这样能更好的支持多态，一提高代码的灵活性。
2.反过来用，我们不知道系统未来具体的业务实现时，我们可以先定义抽象类，将来让子类去实现，以方便系统的扩展。

// 模板方法设计模式
public abstract class C {
    // 模板方法
    public final void sing(){
        System.out.println("唱一首你喜欢的歌：");
        doSing();
        System.out.println("唱完了!");
    }
    public abstract void doSing();
}

public class A extends C{
    @Override
    public void doSing() {
        System.out.println("我是一只小小小小鸟，想要飞就能飞的高~~~");
    }
}

public class B extends C{
    @Override
    public void doSing() {
        System.out.println("我们一起学猫叫，喵喵喵喵喵喵喵~~");
    }
}

public class Test {
    public static void main(String[] args) {
        // 目标：搞清楚模板方法设计模式能解决什么问题，以及怎么写。
        B b = new B();
        b.sing();
    }
}

第1步：定义一个抽象类，把子类中相同的代码写成一个模板方法。
第2步：把模板方法中不能确定的代码写成抽象方法，并在模板方法中调用。
第3步：子类继承抽象类，只需要父类抽象方法就可以了。

public interface 接口名{
    //成员变量（常量）
    //成员方法（抽象方法）
}

public interface A{
    //这里public static final可以加，可以不加。
    public static final String SCHOOL_NAME = "黑马程序员";
    //这里的public abstract可以加，可以不加。
    public abstract void test();
}

public class Test{
    public static void main(String[] args){
        //打印A接口中的常量
        System.out.println(A.SCHOOL_NAME);
        //接口是不能创建对象的
        A a = new A();
    }
}

public interface B {
    void testb1();
    void testb2();
}

public interface C {
    void testc1();
    void testc2();
}

// 实现类
public class D implements B, C{
    @Override
    public void testb1() {
    }
    @Override
    public void testb2() {
    }
    @Override
    public void testc1() {
    }
    @Override
    public void testc2() {
    }
}

public class Test {
    public static void main(String[] args) {
        // 目标：认识接口。
        System.out.println(A.SCHOOL_NAME);
        // A a = new A();
        D d = new D();
    }
}

class Student{
}
interface Driver{
    void drive();
}
interface Singer{
    void sing();
}
//A类是Student的子类，同时也实现了Dirver接口和Singer接口
class A extends Student implements Driver, Singer{
    @Override
    public void drive() {
    }
    @Override
    public void sing() {
    }
}
public class Test {
    public static void main(String[] args) {
        //想唱歌的时候，A类对象就表现为Singer类型
        Singer s = new A();
        s.sing();
        //想开车的时候，A类对象就表现为Driver类型
        Driver d = new A();
        d.drive();
    }
}