抽象类

什么是抽象类

/*
        类————>对象 ：实例化     对象————>类 ：抽象

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

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

        3、抽象类怎么定义？
            语法：
                [修饰符列表] abstract class 类名{
                    类体;
                }

        4、抽象类是无法实例化的，无法创建对象的，所以抽象类是用来被子类继承的。

        5、final 和 abstract 不能联合使用
           理解：abstract抽象类是用来被继承的，final修饰的类不允许被继承，所以两个关键字不能修饰同一个类

        6、抽象类的子类可以是抽象类
            抽象类可以不停的抽象下去。

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

        8、抽象类关联到一个概念：抽象方法。什么是抽象方法呢？
           抽象方法表示：没有实现的方法，没有方法体的方法。例如：
               public abstract void doSome();
           抽象方法的特点：
               1、没有方法体，以分号(;)结尾。
               2、前面修饰符列表中有abstract关键字。

        9、抽象类中不一定有抽象方法。非抽象类中 不得出现 抽象方法
 */
public class AbstractText01 {
    public static void main(String[] args) {
        //编译报错：Error: Account是抽象的; 无法实例化
        //Account a = new Account();
    }
}

//银行账户类

        /*   final abstract class Account{} 
           	 Error: 非法的修饰符组合: abstract和final。
             理解：abstract抽象类是用来被继承的，final修饰的类不允许被继承，所以两个关键字不能修饰			   同一个类			*/

abstract class Account{
    int i;
    String s;
    public Account(){

    }

    public Account(int i, String s) {
        this.i = i;
        this.s = s;
    }

    //非抽象方法
    public void doSome(){

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

//子类继承抽象类，子类可以实例化对象

        //抽象类的子类也可以是抽象类
        //abstract class CreditAccount extends Account{}

//class CreditAccount extends Account{
//
//}

非抽象类继承抽象类，该抽象类中有抽象方法，非抽象子类中一定要对该抽象方法进行实现，否则报错

/*
    抽象类：
        1、抽象类中不一定有抽象方法，非抽象类中不得出现抽象方法。

        2、重要结论：
            一个非抽象类继承抽象类，如果该抽象类中有抽象方法，在子类中必须将该抽象方法“实现”了。
            这是java语法上强制规定的，必须的，否则会报错。
            因为子类继承父类，将该抽象方法继承过来了，而非抽象类中不得出现抽象方法。
            抽象方法在非抽象子类中的覆盖/重写，也叫做“实现”。(对抽象的实现)
 */
public class AbstractText02 {
    public static void main(String[] args) {
        //这里可以使用多态。
        //父类型引用指向子类型对象。
        Animal a = new Bird(); //向上转型(子--->父)。 自动类型转换。

        /*
        这就是面向抽象编程。
        调用时都是a.xxx,a的类型是Animal，Animal是抽象的。
        面向抽象编程，不要面向具体编程。可以降低程序的耦合度，提高程序的扩展力。
        这种编程思想符合OCP原则。

        分析：
            编译时：move()方法是Animal的
            运行时：move()方法是Bird的
         */

        a.move();
    }
}

//动物类(抽象类)
abstract class Animal{
    //抽象方法
    public abstract void move();

}
        /*  分析：
                Animal是父类，并且是一个抽象类
                Animal这个抽象类中有一个抽象方法move

                Bird是子类，非抽象类
                class Bird extends Animal{}
                Bird继承Animal类后，会将抽象方法也继承过来，但是因为他是非抽象类，非抽象类中不得出现抽象方法
                    所以编译报错：
                        Error: Bird不是抽象的, 并且未覆盖Animal中的抽象方法move()        */

//鸟类(非抽象类)
class Bird extends Animal{
    //解决方法:
    //需要将从父类中继承过来的抽象方法进行覆盖/重写，或者叫做“实现”：把抽象方法实现。
    //去掉abstract，然后加上大括号{}，去掉分号(;)
    public void move(){
        System.out.println("鸟儿在煽动翅膀");
    }
}

//Cat0类是抽象类，抽象类继承抽象类，则从抽象父类中继承过来的抽象方法也可以不用重写/覆盖/实现。
abstract class Cat0 extends Animal{

}

面试判断题：java中凡是没有方法体的方法都是抽象方法。错误的

判断：java中凡是没有方法体的方法都是抽象方法。
错误

原因：
- Object类中就有很多方法都没有方法体，都是以“;”结尾的，但是他们都不是抽象方法，例如：
- public native int hashCode();
  这个方法底层调用了C++的动态链接数据库程序。
- 前面修饰符列表中没有abstract，有一个native，表示JVM本地程序。

接口

接口的基础语法

/*
    接口：
        1、接口也是一种“引用数据类型”，编译之后也是一个class字节码文件。

        2、接口是完全抽象的(抽象类是半抽象)，或者也可以说：接口是特殊的抽象类。

        3、接口怎么定义？语法是什么？
            [修饰符列表] interface 接口名{}

        4、接口支持多继承，一个接口可以继承多个接口

        5、接口中只包含两部分内容：常量 、 抽象方法

        6、接口中所有的元素都是public修饰的(都是公开的)

        7、接口中的方法定义时：public abstract 修饰符可以省略
            理解：接口中的方法都是抽象方法，所以可以省略。

        8、接口中的常量的public static final 可以省略
               理解：常量中的元素都是public修饰的，而常量中属性相关的又只有常量，所以定义时可以省略。
               常量名的规范写法：全部字母大写。即使你定义的小写他也是常量。这只是一个规范。

        9、接口中的方法不能有方法体。
            理解：接口中的方法都是抽象方法，所以接口中的方法都不能有方法体。
 */
public class Text01 {
    public static void main(String[] args) {
        System.out.println(MyMath1.D);
        //MyMath1.D = 8.8;
        //Error:无法为最终变量D分配值
        //MyMath1接口中的常量定义时， public static final 是省略了的。
        //在这里D不能修改，反向证明接口中定义常量时public static final 可以省略。

    }
}

//定义接口
interface A3{

}

//接口支持继承
interface B3 extends A3{

}

//一个接口可以继承多个接口。(支持多继承。)
interface C3 extends A3,B3{

}

//我的数学接口
interface MyMath1{
    //常量
    public static final double PI = 3.1415926;
    //常量中的元素都是public修饰的，而常量中属性相关的又只有常量，所以定义时，public static final 可以省略。
    double D = 9.9;

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

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

    //接口中的方法可以有方法体吗？ 不可以，因为接口中的方法都是抽象方法。
    //Error: 接口抽象方法不能带有主体
    //void doOther(){}

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

基础语法2

10、一个非抽象的类，实现接口的时候，必须将接口中的方法加以实现
11、一个类中可以有多个接口
12、extends 和implements 可以共存，extends在前，implements在后
13、使用接口写代码的时候，可以使用多态(父类型的引用指向子类型的对象)

非抽象的类实现接口，要将接口中的所有的方法实现。

/*
    接口的基础语法：
        1、类和类之间的关系叫做继承，类与接口之间叫“实现”（仍然可以将“实现”看作“继承”）
            继承使用 extends关键字 完成
            实现使用 implements关键字 完成。
        2、 ★结论:当一个非抽象的类实现接口时，必须将该接口中的所有抽象方法全部实现(覆盖/重写)
 */
public class Text02 {
    public static void main(String[] args) {
        //new MyMath2();
        //Error: MyMath2是抽象的; 无法实例化

        //这里可以使用多态，即父类型的引用指向子类型的对象。
        MyMath2 mm = new MyMath2Impl();
        //调用接口里面的方法(面向接口编程)
        //编译时在接口里找方法，运行时实际运行的是子类中的那个方法。
        System.out.println(mm.sum(10,5));
        System.out.println(mm.sub(10,5));

    }
}

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

//这是一个“非抽象”的类，类的名字是随意的。
            //abstract class MyMath2Impl implements MyMath2{}
            //这样是没问题的，因为他前面加了一个abstract，他也是抽象的。

            //class MyMath2Impl implements MyMath2{}
            //Error: MyMath2Impl不是抽象的, 并且未覆盖MyMath2中的抽象方法sub(int,int)

//修正
class MyMath2Impl implements MyMath2{
    //重写/覆盖/实现 接口中的方法(通常叫做实现。)
    /*
        int sum(int a,int b){
            return a+b;
          }
    Error: MyMath2Impl中的sum(int,int)无法实现MyMath2中的sum(int,int)
          正在尝试分配更低的访问权限; 以前为public


     */

    //在类中重写时，补充上抽象方法的修饰符public(在非抽象类中重写时去掉abstract)，因为有返回值类型，所以加上return
    public int sum(int a,int b){
     return a+b;
    }
    public int sub(int a,int b){
        return a-b;
    }


}

一个类可以实现多个接口，以及接口转型

/*
    接口和接口之间支持多继承，那么一个类可以同时实现多个接口吗？   可以。
        对于计算机来说，一个机箱上有多个接口，一个接口是接键盘的，一个接口接鼠标，一个接口接电源，一个接显示器....

    ★★：一个类可以同时实现多个接口

    这种机制弥补了java中的一个缺陷：
        java中类和类只支持单继承。实际上单继承是为了简单而出现的，现实世界中存在多继承
        java中的接口弥补了单继承带来的缺陷

    接口A与接口B虽然没关系，但是写代码的时候，可以互相转换。
    编译可以通过，但是运行时可能出现：ClassCastException异常(类型转换异常)

    之前的一个结论
        无论向上转型/向下转型，两个类之间必须有继承关系，没有继承关系在这里会报错。(这句话不适用在接口方面)
        最终实际上还是需要和之前一样，需要加：instanceof运算符进行判断。
        向下转型养成好习惯。转型之前先加if + instanceof进行判断。
        instanceof  运行阶段动态判断


 */
public class Text03 {
    public static void main(String[] args) {
        //使用多态：父类型引用指向子类型对象。
        A4 a = new D4();
        B4 b = new D4();
        C4 c = new D4();

        //a.m2();     
        //编译报错。A接口中没有m2()方法。

            //这里编译时a本来是A4类型对象，强制转换给B4.
            //运行时始终是D4类型对象。在D4中找m2方法，可以找到。所以编译和运行都没问题。
        //调用其他接口中的方法，需要转型(接口转型)
//        B4 a2 = (B4)a;
//        a2.m2();
        if (a instanceof B4){
            B4 a2 = (B4)a;
            a2.m2();
        }


        //直接向下转型为D4可以吗？可以
        //如果a是D4类型的，才会进行向下转型。
        if (a instanceof D4){
            D4 d =(D4)a;
            d.m2();
        }

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

}
interface Y{

}
class Z implements Y{

}
//-----------------------------------------------------------------------
interface A4{
    void m1();
}

interface B4{
    void m2();
}

interface C4{
    void m3();
}

class D4 implements A4,B4,C4{
    //实现A4中的接口
    public void m1(){

    }
    //实现B4中的接口
    public void m2(){
        System.out.println("m2");
    }
    //实现4中的接口
    public void m3(){

    }
}

继承与实现共存时，extends在前，implements在后。

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

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

        Flyable f3 = new fish();
        f3.fly();

    }
}

//动物类：父类
class Animal2{

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

//动物类子类：猫类
//Flyable是一个接口，是一对翅膀的接口，通过接口插到猫身上，让猫变得可以飞翔
class Cat2 extends Animal2 implements Flyable{
    public void fly(){
        System.out.println("啊飞猫");
    }
}

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

}

//猪类， 想飞就插上翅膀这个接口
class Pig extends Animal2 implements Flyable{
    public void fly(){
        System.out.println("我是一只会飞的猪，我真了不起！！！");
    }
}

//鱼类(默认是存在继承的，继承Object类)
//class fish extends Object implements Flyable{ public void fly(){}}
class fish implements Flyable{//没写extends ,也是有继承的，默认继承Objext。
    public void fly(){
        System.out.println("我是六眼飞鱼(流言蜚语)！！");
    }
}

接口在开发中的作用

    注意：接口在开发中的作用，类似于多态在开发中的作用

    多态：面向抽象编程，不要面向具体编程。面向抽象编程可以降低程序的耦合度，提高程序的扩展力
    接口是完全抽象的，而我们以后正好要求面向抽象编程。面向抽象编程这句话以后可以修改为：面向接口编程。
    有了接口就有了可插拔，可插拔表示扩展力很强。不是焊死的。

    主板和内存条之间有插槽，这个插槽就是接口，内存条坏了，可以重新买一个换下来，这叫做：高扩展性(低耦合度)

    接口在现实世界中到处都是
        螺栓和螺母之间有接口、灯泡和灯口之间有接口、笔记本电脑和键盘之间有接口(USB接口，这个接口是计算机协会制定的协议/规范)
        接口有什么用？扩展性好，可插拔。接口是一个抽象的概念。

    分析：
        中午去饭馆吃饭，这个过程中有接口吗？
        接口是抽象的。
            菜单就是一个接口。(菜单上有一个抽象的照片：西红柿炒鸡蛋)
            谁面向接口调用？(顾客，面向菜单点菜，调用接口。)
            谁负责实现这个接口？(后台的厨师，负责做好菜。是接口的实现者)

            这个接口有什么用呢？
                这个饭馆的“菜单”让“顾客”和“厨师”之间解耦合了(顾客和厨师之间的耦合度降低。)
                顾客不用找后厨，后厨不用找顾客。他们之间完全依靠这个抽象的菜单沟通

    总结：(解耦合)
        面向接口编程，可以降低程序的耦合度，提高程序的扩展力。符合OCP开发原则，接口的使用离不开多态机制。
        (接口+多态 才可以达到降低耦合度)

        接口可以解耦合，解开的是谁和谁的耦合？
            任何一个接口都有调用者和实现者。接口可以将调用者和实现者解耦合。
            调用者面向接口调用，实现者面向接口编写实现。

        以后进行大的项目开发，一般都是将项目分离成一个模块一个模块的，模块和模块之间采用接口衔接，来降低耦合度。

/*
        本项目
            菜单接口写出来后，可同时写调用和实现。写调用的只关心菜单，跟厨师无关，写实现的只关心菜单，跟顾客也无关
            都是只关心菜单，从而降低了耦合度，提高开发效率(调用和实现可以交给不同的人同时编写。)
 */
public class Text05 {
    public static void main(String[] args) {

        //创建厨师对象
        FoodMenu cook1 = new ChinaCook();
        //创建顾客对象    //java中有个名言：想要什么就new个什么，然后传进去。
        Customer1 customer = new Customer1(cook1);
        customer.order();

        //创建西餐厨师对象
        FoodMenu cook2 = new AmericanCook();
        Customer1 customer2 = new Customer1(cook2);
        customer2.order();
    }
}


//接口：菜单 抽象的
interface FoodMenu {
    //西红柿炒鸡蛋
    void fanQieCJiDan();
    //鱼香肉丝
    void yuXiangRouSi();
}

class Customer1{
    //顾客手里有一个菜单
    //Customer has a FoodMenu (这句话什么意思：顾客有一个菜单。)
    //凡是能够使用has a 来描述的，统一以属性的方式存在。
    //实例变量，属性
    //面向抽象编程、面向接口编程。降低程序的耦合度，提高程序的扩展力
    private FoodMenu foodMenu;//要养成封装的好习惯，封装后提供set和get方法

    //构造方法
    public Customer1(){

    }
    public Customer1(FoodMenu foodMenu){
        this.foodMenu = foodMenu;
    }
    public FoodMenu getFoodMenu(){
        return foodMenu;
    }
    public void setFoodMenu(FoodMenu foodMenu){
        this.foodMenu = foodMenu;
    }

    //提供一个点菜的方法
    public void order(){
        //先拿到菜单才能点菜
        //调用get方法拿菜单
        //FoodMenu fm =this.getFoodMenu();

        //也可以不调用get方法，因为私有的属性在本类中是可以访问的
        this.foodMenu.fanQieCJiDan();
        //this.表示本对象的，可以省略
        this.foodMenu.yuXiangRouSi();
    }

    //如果以下这样写，就表示写死了(焊接了，不能可插拔了)。只能吃中餐的/西餐的
    //中餐厨师
//    ChinaCook cc;
//    AmericanCook ac;


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


}

//中餐厨师 实现菜单上的菜
//厨师是接口的实现者
class ChinaCook implements FoodMenu{
    public void fanQieCJiDan(){
        System.out.println("西红柿炒鸡蛋");
    }
    public void yuXiangRouSi(){
        System.out.println("鱼香肉丝");
    }
}

//西餐厨师
class AmericanCook implements FoodMenu{
    public void fanQieCJiDan(){
        System.out.println("Scrambled egg with tomato");
    }
    public void yuXiangRouSi(){
        System.out.println("Yu-Shiang Shredded Pork");
    }
}

类与类之间的关系： is a(继承) 、 has a(关联) 、 like a(实现)

类和类之间的关系：
    is a(继承) 、 has a(关联) 、 like a(实现)

    is a :
Cat is a Animal（猫是一个动物）
    凡是能够满足is a 的表示“继承关系”
    A extends B

    has a:
I has a Pen （我有一支笔）
    凡是能够满足has a 的表示“关联关系”
    A{
    B b;
}

like a:
Cook like a FoodMenu （厨师像一个菜单一样）
    这里的“像”，不是表面上的像，而是厨师能做出菜单中的菜，厨师把菜单里的菜做了出来。
    凡是能够满足like a 关系的表示“实现关系”
    实现关系通常是：类实现接口
    A implements B

抽象类与接口有什么区别：

在这里我们只说一下抽象类和接口在语法上的区别。至于以后用抽象类还使用接口，通过项目去体会/学习

抽象类是半抽象的
接口是完全抽象的

抽象类中有构造方法
接口中没有构造方法

接口和接口之间支持多继承
类和类之间只能单继承

一个类可以同时实现多个接口
一个抽象类只能继承一个类(单继承)

接口中只允许出现常量和抽象方法。

以后接口使用的比抽象类多，一般抽象类使用的少。
接口一般都是对“行为”的抽象。抽象类既可以抽象“行为”，又可以抽象“数据”