015-抽象类（老杜）

目录

接口基础语法

Test01.java

Test02.java

Test03.java

Test04.java

接口在开发中的作用

Customer.java

FoodMenu.java

ChinaCooker.java

AmericCooker.java

Test.java

AbstractTest01.java

AbstractTest02.java

---

接口基础语法

Test01.java

/*
    接口：
        1、接口也是一种“引用数据类型”。编译之后也是一个class字节码文件。
        2、接口是完全抽象的。（抽象类是半抽象。）或者也可以说接口是特殊的抽象类。
        3、接口怎么定义，语法是什么？
            [修饰符列表] interface 接口名{}
        4、接口支持多继承，一个接口可以继承多个接口。
        5、接口中只包含两部分内容，一部分是：常量。一部分是：抽象方法。接口中没有其它内容了。只有以上两部分。
        6、接口中所有的元素都是public修饰的。（都是公开的。）
        7、接口中的抽象方法定义时：public abstract修饰符可以省略。
        8、接口中的方法都是抽象方法，所以接口中的方法不能有方法体。
        9、接口中的常量的public static final可以省略。
*/
public class Test01{
    public static void main(String[] args){

        // 访问接口的常量。
        System.out.println(MyMath.PI); // 3.1415926

        // 常量能重新赋值吗？
        //错误: 无法为最终变量PI分配值
        //MyMath.PI = 3.1415928;

        //错误: 无法为最终变量k分配值
        //MyMath.k = 111;
    }
}

// 定义接口
interface A{

}

// 接口支持继承
interface B extends A{

}

// 一个接口可以继承多个接口（支持多继承）
interface C extends A, B{
}

// 我的数学接口
interface MyMath{

    // 常量
    //public static final double PI = 3.1415926;

    // public static final可以省略吗？
    double PI = 3.1415926;

    // k是不是常量？？？？是。
    // 接口中随便写一个变量就是常量。
    // 常量：值不能发生改变的变量。
    int k = 100;

    // 抽象方法
    //public abstract int sum(int a, int b);

    // 接口当中既然都是抽象方法，那么在编写代码的时候，public abstract可以省略吗？
    int sum(int a, int b);

    // 接口中的方法可以有方法体吗？
    // 错误: 接口抽象方法不能带有主体
    /*
    void doSome(){
    
    }
    */

    // 相减的抽象方法
    int sub(int a, int b);

}

Test02.java

/*
    接口的基础语法：
        1、类和类之间叫做继承，类和接口之间叫做实现。
        别多想：你仍然可以将"实现"看做“继承”。
        继承使用extends关键字完成。
        实现使用implements关键字完成。

        2、五颗星（*****）：当一个非抽象的类实现接口的话，必须将接口中所有的
        抽象方法全部实现（覆盖、重写）。
*/
public class Test02{
    public static void main(String[] args){
        //错误: MyMath是抽象的; 无法实例化
        //new MyMath();

        // 能使用多态吗？可以。
        //Animal a = new Cat();

        // 父类型的引用指向子类型的对象
        MyMath mm = new MyMathImpl();
        // 调用接口里面的方法（面向接口编程。）
        int result1 = mm.sum(10, 20);
        System.out.println(result1); // 30

        int result2 = mm.sub(20, 10);
        System.out.println(result2); // 10
    }
}

// 特殊的抽象类，完全抽象的，叫做接口。
interface MyMath{
    double PI = 3.1415926;
    int sum(int a, int b);
    int sub(int a, int b);
}

// 这样没问题
/*
abstract class MyMathImpl implements MyMath {
}
*/

// 编写一个类（这个类是一个“非抽象”的类）
// 这个类的名字是随意的。
//错误: MyMathImpl不是抽象的, 并且未覆盖MyMath中的抽象方法sub(int,int)
/*
class MyMathImpl implements MyMath {
}
*/

//修正
class MyMathImpl implements MyMath {

    //错误：正在尝试分配更低的访问权限; 以前为public
    /*
    int sum(int a, int b){
        return a + b;
    }
    */

    // 重写/覆盖/实现 接口中的方法（通常叫做实现。）
    public int sum(int a, int b){
        return a + b;
    }

    public int sub(int a, int b){
        return a - b;
    }
}

Test03.java

/*
    接口和接口之间支持多继承，那么一个类可以同时实现多个接口吗？

        对于计算机来说，一个机箱上有多个接口，一个接口是接键盘的，
        一个接口是接鼠标的，一个接口是接电源的，一个接口是接显示器的.....
    

    重点（五颗星*****）：一个类可以同时实现多个接口。

    这种机制弥补了java中的哪个缺陷？
        java中类和类只支持单继承。实际上单继承是为了简单而出现的，现实世界中
        存在多继承，java中的接口弥补了单继承带来的缺陷。
    
    接口A和接口B虽然没有继承关系，但是写代码的时候，可以互转。
    编译器没意见。但是运行时可能出现：ClassCastException

    之前有一个结论：
        无论向上转型还是向下转型，两种类型之间必须要有继承关系，
        没有继承关系编译器会报错。（这句话不适用在接口方面。）
        最终实际上和之前还是一样，需要加：instanceof运算符进行判断。
        向下转型养成好习惯。转型之前先if+instanceof进行判断。
*/
public class Test03{
    public static void main(String[] args){
        // 多态该怎么用呢？
        // 都是父类型引用指向子类型对象
        A a = new D();
        //a.m2(); // 编译报错。A接口中没有m2()方法。
        B b = new D();
        C c = new D();

        // 这个编译没问题，运行也没问题。
        // 调用其他接口中的方法，你需要转型（接口转型。）
        B b2 = (B)a;
        b2.m2(); // m2 ....

        // 直接向下转型为D可以吗？可以
        D d = (D)a;
        d.m2(); // m2 ....

        M m = new E();
        // 经过测试：接口和接口之间在进行强制类型转换的时候，没有继承关系，也可以强转。
        // 但是一定要注意，运行时可能会出现ClassCastException异常。
        // 编译没问题，运行有问题。
        //K k = (K)m;
        if(m instanceof K){
            K k = (K)m;
        }
    }
}

interface K{
}

interface M{
}

class E implements M{
}

// --------------------------------------------------------------------

interface X{
}
interface Y{
}
interface Z extends X,Y{ //接口和接口支持多继承。
}

//------------------------------------------------------------------

interface A{
    void m1();
}

interface B{
    void m2();
}

interface C{
    void m3();
}

// 实现多个接口，其实就类似于多继承。
class D implements A,B,C{
    // 实现A接口的m1()
    public void m1(){
        
    }
    // 实现B接口中的m2()
    public void m2(){
        System.out.println("m2 ....");
    }
    // 实现接口C中的m3()
    public void m3(){
    
    }
}

Test04.java

/*
    继承和实现都存在的话，代码应该怎么写？
        extends 关键字在前。
        implements 关键字在后。
*/
public class Test04{
    public static void main(String[] args){
        // 创建对象（表面看Animal类没起作用！）
        Flyable f = new Cat(); //多态。
        f.fly();

        // 同一个接口
        Flyable f2 = new Pig();
        // 调用同一个fly()方法，最后的执行效果不同。
        f2.fly();

        Flyable f3 = new Fish();
        f3.fly();
    }
}

// 动物类：父类
class Animal{
}

// 可飞翔的接口（是一对翅膀）
// 能插拔的就是接口。（没有接口你怎么插拔。）
// 内存条插到主板上，他们之间有接口。内存条可以更换。
// 接口通常提取的是行为动作。
interface Flyable{
    void fly();
}

// 动物类子类：猫类
// Flyable是一个接口，是一对翅膀的接口，通过接口插到猫身上，让猫变的可以飞翔。
class Cat extends Animal implements Flyable{
    public void fly(){
        System.out.println("飞猫起飞，翱翔太空的一只猫，很神奇，我想做一只猫！！");
    }
}

// 蛇类，如果你不想让它飞，可以不实现Flyable接口
// 没有实现这个接口表示你没有翅膀，没有给你插翅膀，你肯定不能飞。
class Snake extends Animal{
}

// 想飞就插翅膀这个接口。
class Pig extends Animal implements Flyable{
    public void fly(){
        System.out.println("我是一只会飞的猪！！！");
    }
}

// 鱼（默认实际上是存在继承的，默认继承Object。）
/*
class Fish extends Object implements Flyable{
}
*/
class Fish implements Flyable{ //没写extends，也是有的，默认继承Object。
    public void fly(){
        System.out.println("我是六眼飞鱼（流言蜚语）！！！");
    }
}

/*
运行结果：
飞猫起飞，翱翔太空的一只猫，很神奇，我想做一只猫！！
我是一只会飞的猪！！！
我是六眼飞鱼（流言蜚语）！！！
*/

接口在开发中的作用

Customer.java

// 顾客
public class Customer{
    // 顾客手里有一个菜单
    // Customer has a FoodMenu!（这句话什么意思：顾客有一个菜单）
    // 记住：以后凡是能够使用 has a 来描述的，统一以属性的方式存在。
    // 实例变量，属性
    // 面向抽象编程，面向接口编程。降低程序的耦合度，提高程序的扩展力。
    private FoodMenu foodMenu; 
    
    // 如果以下这样写，就表示写死了（焊接了。没有可插拔了。）
    // 中餐厨师
    //ChinaCooker cc;

    // 西餐厨师
    //AmericCooker ac

    // 构造方法
    public Customer(){
    }
    public Customer(FoodMenu foodMenu){
        this.foodMenu = foodMenu;
    }

    // setter and getter
    public void setFoodMenu(FoodMenu foodMenu){
        this.foodMenu = foodMenu;
    }
    public FoodMenu getFoodMenu(){
        return foodMenu;
    }

    // 提供一个点菜的方法
    public void order(){
        // 先拿到菜单才能点菜
        // 调用get方法拿菜单。
        //FoodMenu fm = this.getFoodMenu();
        // 也可以不调用get方法，因为在本类中私有的属性是可以访问
        foodMenu.shiZiChaoJiDan();
        foodMenu.yuXiangRouSi();
    }
}

/*
    Cat is a Animal，但凡满足is a的表示都可以设置为继承。
    Customer has a FoodMenu，但凡是满足has a的表示都以属性的形式存在。
*/

/*
class Address{
    String city;
    String street;
    String zipcode;
}

class User{
    int id;

    // 和这个一样。
    // String是一个类。
    // name是变量名。
    // name是一个引用。
    String name;

    // Address是一个类名。
    // 这就是一个变量。
    // 实例变量。
    Address addr; // addr是一个引用。是一个变量。

    public static void main(String[] args){
        // 局部变量
        //Address addr;
        //addr = new Address();

        // 合并。
        Address addr = new Address();

        User u = new User();
        u.id = 100;
        u.name = "zhangsan";
        u.addr = new Address();

        System.out.println(u.addr.city); // null
        System.out.println(u.addr.street); // null
        System.out.println(u.addr.zipcode); // null
    }
}

//“自己”类
// MySelf has a Friend;
class MySelf{
    // 你这个对象，应该有一个朋友对象的电话号码。
    // 电话号码就是一个对象的内存地址。联系你朋友的时候，打电话。
    // f是一个引用。f默认值是null，是null表示，你没有朋友。
    Friend f;

    public MySelf(){
    
    }
    //通过构造方法能不能给你一个朋友对象。
    public MySelf(Friend f){
        this.f = f;
    }

    public static void main(String[] args){
        // 创建朋友对象
        Friend f = new Friend(); //朋友对象有了

        // 创建对象的同时交朋友。
        MySelf m2 = new MySelf(f);

        // 创建自己对象
        // 目前还没有交朋友。
        MySelf m = new MySelf(); //自己对象
        // 交朋友
        m.f = f; // 把朋友的地址给了你。
    }
}

// “朋友”类
class Friend{

}

*/

FoodMenu.java

/*
    接口：菜单，抽象的
*/
public interface FoodMenu{

    // 西红柿炒蛋
    void shiZiChaoJiDan();

    // 鱼香肉丝
    void yuXiangRouSi();

}

ChinaCooker.java

//中餐厨师
// 实现菜单上的菜
// 厨师是接口的实现者。
public class ChinaCooker implements FoodMenu{

    // 西红柿炒蛋
    public void shiZiChaoJiDan(){
        System.out.println("中餐师傅做的西红柿炒鸡蛋，东北口味！");
    }

    // 鱼香肉丝
    public void yuXiangRouSi(){
        System.out.println("中餐师傅做的鱼香肉丝，东北口味！");
    }
}

AmericCooker.java

//西餐厨师
// 实现菜单上的菜
// 厨师是接口的实现者。
public class AmericCooker implements FoodMenu{

    // 西红柿炒蛋
    public void shiZiChaoJiDan(){
        System.out.println("西餐师傅做的西红柿炒鸡蛋！");
    }

    // 鱼香肉丝
    public void yuXiangRouSi(){
        System.out.println("西餐师傅做的鱼香肉丝！");
    }
}

Test.java

public class Test{
    public static void main(String[] args){

        // 创建厨师对象
        //FoodMenu cooker1 = new ChinaCooker();
        FoodMenu cooker1 = new AmericCooker();

        // 创建顾客对象
        Customer customer = new Customer(cooker1);

        // 顾客点菜
        customer.order();
    }
}

/*
运行结果：
西餐师傅做的西红柿炒鸡蛋！
西餐师傅做的鱼香肉丝！
*/

AbstractTest01.java

/*
    
    类到对象是实例化。对象到类是抽象。

    抽象类：
        1、什么是抽象类？
            类和类之间具有共同特征，将这些共同特征提取出来，形成的就是抽象类。
            类本身是不存在的，所以抽象类无法创建对象《无法实例化》。

        2、抽象类属于什么类型？
            抽象类也属于引用数据类型。

        3、抽象类怎么定义？《能把基础语法先学会》
            语法：
                [修饰符列表] abstract class 类名{
                    类体;
                }
        
        4、抽象类是无法实例化的，无法创建对象的，所以抽象类是用来被子类继承的。

        5、final和abstract不能联合使用，这两个关键字是对立的。

        6、抽象类的子类可以是抽象类。也可以是非抽象类。

        7、抽象类虽然无法实例化，但是抽象类有构造方法，这个构造方法是供子类使用的。

        8、抽象类关联到一个概念：抽象方法。什么是抽象方法呢？
            抽象方法表示没有实现的方法，没有方法体的方法。例如：
                public abstract void doSome();
                抽象方法特点是：
                    特点1：没有方法体，以分号结尾。
                    特点2：前面修饰符列表中有abstract关键字。
        
        9、抽象类中不一定有抽象方法，抽象方法必须出现在抽象类中。
*/
public class AbstractTest01{ 
    public static void main(String[] args){
        // 错误: Account是抽象的; 无法实例化
        //Account act = new Account();
    }
}

// 银行账户类
//错误: 非法的修饰符组合: abstract和final
/*
final abstract class Account{

}
*/

abstract class Account{
    /*
    public Account(){
    
    }
    public Account(String s){
    
    }
    */
    // 非抽象方法
    public void doOther(){
    
    }

    // 抽象方法
    public abstract void withdraw();
}

// 子类继承抽象类，子类可以实例化对象
/*
class CreditAccount extends Account{
    public CreditAccount(){
        super();
    }
}
*/

// 抽象类的子类可以是抽象类吗？可以
/*
abstract class CreditAccount extends Account{

}
*/

AbstractTest02.java

/*
    抽象类：

        1、抽象类中不一定有抽象方法，抽象方法必须出现在抽象类中。

        2、重要结论：重要结论五颗星*****（必须记住）
            一个非抽象的类继承抽象类，必须将抽象类中的抽象方法实现了。
            这是java语法上强行规定的，必须的，不然编译器就报错了。
            
            这里的覆盖或者说重写，也可以叫做实现。（对抽象的实现。）

*/
public class AbstractTest02{
    public static void main(String[] args){
        // 能不能使用多态?
        // 父类型引用指向子类型对象。
        Animal a = new Bird();  // 向上转型。（自动类型转换）

        // 这就是面向抽象编程。
        // 以后你都是调用的a.XXXX
        // a的类型是Animal，Animal是抽象的
        // 面向抽象编程，不要面向具体编程，降低程序的耦合度，提高程序的扩展力。
        // 这种编程思想符合OCP原则。
        /*
            分析以下：
                编译的时候这个move()方法是谁的？
                运行的时候这个move()方法又是谁的？
        */
        a.move(); // 鸟儿在飞翔！

        // 多态（当对多态不是很理解的时候，以后写代码能用多态就用多态。慢慢就理解了。）
        Animal x = new Cat();
        x.move(); // 猫在走猫步！
    }
}

// 动物类（抽象类）
abstract class Animal{

    // 抽象方法
    public abstract void move();
}

// 子类（非抽象的）
// 错误: Bird不是抽象的, 并且未覆盖Animal中的抽象方法move()
/*
class Bird extends Animal{
}
*/

class Bird extends Animal{
    // 需要将从父类中继承过来的抽象方法进行覆盖/重写，或者也可以叫做“实现”。
    // 把抽象的方法实现了。
    public void move(){
        System.out.println("鸟儿在飞翔！");
    }
}

class Cat extends Animal{
    public void move(){
        System.out.println("猫在走猫步！");
    }
}

// 如果Bird是抽象类的话，那么这个Animal中继承过来的抽象方法也可以不去重写/覆盖/实现。
/*
abstract class Bird extends Animal{
}
*/
    

/*
    有些内容不要死记硬背，讲讲道理。
    分析：
        Animal是父类，并且是 抽象的。
        Animal这个抽象类中有一个抽象方法move。

        Bird是子类，并且是 非抽象的。
        Bird继承Animal之后，会将抽象方法继承过来。

*/