《java学习笔记》之面向对象--抽象类与接口

抽象类与接口

抽象类的基础语法

public class Test01 {
    public static void main(String[] args) {
        //抽象类是无法实例化的，无法创建对象的，所以抽象类是用来被子类继承的。
        //'A' is abstract; cannot be instantiated
        //A a =new A();

        C c =new C();
        D d =new D();
        //属性
        System.out.println(c.abc);//null
        c.abc = "abc";
        System.out.println(c.abc);//abc

        //方法
        //静态方法
        c.b();
        //实现的抽象方法
        c.c();

        d.b();
        d.c();
        d.d();

        /*A b
          C c
          A b
          D c
          D d
          */
    }
}

//创建一个抽象类
abstract class A{
    //属性,前面不能用abstract修饰
    //Modifier 'abstract' not allowed here
    //abstract int n;
    String abc;

    //构造方法
    //抽象类虽然无法实例化，但是抽象类有构造方法，这个构造方法是供子类使用的。
    public A() {
    }

    public A(String abc) {
        this.abc = abc;
    }

    //普通静态方法方法
    //静态方法不重写
    public static void a(){
        System.out.println("A a");
    }

    //普通实例方法
    public void b(){
        System.out.println("A b");
    }

    //抽象方法
    //特点1：没有方法体，以分号结尾。
    //特点2：前面修饰符列表中有abstract关键字。
    abstract public void c();
}

//抽象类的子类可以是抽象类
abstract class B extends A{
    //B的抽象方法
    abstract public void d();
}

//抽象类也不支持多继承
//抽象类的子类也可以是普通类
//一个非抽象的类继承抽象类，必须将抽象类中的 抽象方法 实现了。
class C extends A{

    @Override
    public void c() {
        System.out.println("C c");
    }

    //无参构造
    public C() {
        //调用父类的无参构造
        super();
    }

    //有参构造
    public C(String a) {
        //调用父类的有参构造
        super(a);
    }
}

class D extends B{

    //A的抽象方法
    @Override
    public void c() {
        System.out.println("D c");
    }

    //B的抽象方法
    @Override
    public void d() {
        System.out.println("D d");
    }

}

抽象类的运用

//抽象类的应用
public class Test02 {
    public static void main(String[] args) {
        //多态
        Animal f = new Fish();
        Animal b = new Bird();

        f.move();
        b.move();
        /*
        fish is swimming
        Bird can fly
        */
    }
}

abstract class Animal{
    //Animal可以跑，要让子类实现这个抽象方法
    abstract public void move();
}

class Fish extends Animal{

    @Override
    public void move() {
        System.out.println("fish is swimming");
    }
}

class Bird extends Animal{

    @Override
    public void move() {
        System.out.println("Bird can fly");
    }
}

接口的基本语法

//接口基础语法
public class Test01 {
    public static void main(String[] args) {
        //接口是完全抽象的，不能new对象
        //'A' is abstract; cannot be instantiated
        //A a =new A();

        E e =new E();
        G g =new G();
        //访问接口的常量
        System.out.println(A.PI);
        System.out.println(A.text);
        System.out.println(C.PI);
        System.out.println(E.PI);
        //方法
        e.a();
        g.a();
        g.f();
        /*3.1415926535
          abc
          3.1415926535
          3.1415926535
          E a
          G a
          G f

          */
    }
}

//接口中所有的元素都是public修饰的。（都是公开的。）

//抽象类的定义
interface A{
    //接口中只包含两部分内容，一部分是：常量。一部分是：抽象方法。
    // 接口中没有其它内容了。只有以上两部分。

    //接口中的常量的public static final可以省略。
    double PI = 3.1415926535;
    String text = "abc";
    //接口中的抽象方法定义时：public abstract修饰符可以省略。
    void a();
}

interface B{

}

//接口支持多继承，一个接口可以继承多个接口。
interface C extends A,B{

}

//类和类之间叫做继承，类和接口之间叫做实现。
//抽象类实现接口
abstract class D implements C{

}
当一个非抽象的类实现接口的话，必须将接口中所有的抽象方法全部实现
class E implements C{

    @Override
    public void a() {
        System.out.println("E a");
    }
}


//一个普通的抽象类
abstract class F{
    //一个普通的抽象方法
    public abstract void f();
}

//继承和实现都存在的话，代码应该怎么写？
//先继承再实现
class G extends F implements C{

    @Override
    public void a() {
        System.out.println("G a");
    }

    @Override
    public void f() {
        System.out.println("G f");
    }
}

接口的转型问题

//接口的转型
public class Test02 {
    public static void main(String[] args) {
        //多态
        //class F1 implements D1
        //interface D1 extends A1
        A1 f =new F1();

        //类型转换
        //没有继承关系编译器会报错。（这句话不适用在接口方面。）
        //很明显两个没有继承关系
        // java.lang.ClassCastException
        C1 h = (H1)f;
    }
}

interface A1{

}

interface B1{

}

interface C1{

}
//--------------------------------
interface D1 extends A1{

}
//---------------------------------
//多继承
interface E1 extends A1,B1{

}
//---------------------------------
class F1 implements D1{

}

class G1 implements E1{

}

class H1 implements C1{

}

接口的应用
设计模拟一个点餐项目
要求：

• 提供菜单接口
• 厨师要有中餐和西餐的
• 顾客类
• 用Test来模拟点餐

//设计模拟一个点餐项目
/*要求：
* 提供菜单接口
* 厨师要有中餐和西餐的
* 顾客类
* 用Test来模拟点餐*/
public class InterfaceTest05 {
    public static void main(String[] args) {
        //创建厨师对象
        FoodMenu chinaCook =new ChinaCook();
        FoodMenu americanCook =new AmericanCook();
        //创建客户对象
        Customer customer =new Customer(chinaCook);
        //客户点餐
        customer.order();
    }
}

//菜单接口
//抽象的
interface FoodMenu{
    //炒鸡蛋
    void chaoegg();
    //牛排
    void friedSteak();
}

//中国厨师实现菜单
class ChinaCook implements FoodMenu{

    @Override
    public void chaoegg() {
        System.out.println("中国厨师炒鸡蛋");
    }

    @Override
    public void friedSteak() {
        System.out.println("中国厨师煎牛排");
    }
}
//美国厨师实现菜单
class AmericanCook implements FoodMenu{

    @Override
    public void chaoegg() {
        System.out.println("美国厨师炒鸡蛋");
    }

    @Override
    public void friedSteak() {
        System.out.println("中国厨师煎牛排");
    }
}

//顾客类
class Customer{
    //顾客有菜单
    //has a
    // 记住：以后凡是能够使用 has a 来描述的，统一以属性的方式存在。
    // 实例变量，属性
    // 面向抽象编程，面向接口编程。降低程序的耦合度，提高程序的扩展力。

    private FoodMenu foodMenu;

    //构造方法
    public Customer() {
    }

    public Customer(FoodMenu foodMenu) {
        this.foodMenu = foodMenu;
    }

    //提供点菜功能方法
    public void order(){
        // 先拿到菜单才能点菜
        foodMenu.chaoegg();
        foodMenu.friedSteak();
    }
}