Java学习的第十四天（JavaSE精英篇04_抽象类和接口）

一、实例引入01（构造方法的作用）

子类继承父类，将父类的非私有化变量全部继承过来了，所以成员变量必然要被初始化

package com.bianyiit.cast;

public class Demo1 {
    public static void main(String[] args) {
        System.out.println(new Son().age);
    }
}
class Father{
    private String name="父亲";
    int age=45;
    //无参构造：是给父类的成员变量初始化用的。
    public Father(){

    }
    public Father(String name,int age){
        this.name=name;
        this.age=age;
    }
}
//子类继承父类，将父类的非私有化变量全部继承过来了，所以成员变量必然要被初始化
class Son extends Father{

}

二、实例引入02（抽象类的诞生过程）

package com.bianyiit.cast;

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

    }
}
//同样父类也必须使用abstract修饰
abstract class Animal{
    //定义一个父类的成员方法
    public void eat(){
        System.out.println("我是一只动物！");
    }
    //由于继承的子类中方法很相似，只是实现的内容不同，那么抽取共性放在父类中，共性的方法只能有方法声明，没有具体的方法体
    //所以没有具体方法体就是抽象类,所以去掉方法体，然后加上abstract修饰
    public abstract void run();
}
class Dog extends Animal{
    //继承之后重写父类的方法
    @Override
    public void eat() {
        System.out.println("狗吃翔..");
    }
    //子类中自定义的方法
    public void run(){
        System.out.println("以每秒20迈的速度往前冲..");
    }
}
class Cat extends  Animal{
    @Override
    public void eat() {
        System.out.println("猫吃鱼..");
    }
    //子类中自定义的方法
    public void run(){
        System.out.println("飞一般的往前冲..");
    }
}

定义：不同的类中方法很相似，方法的具体实现内容不同，所以抽取共性放在父类中，共性的方法只能具有方法声明，没有具体的方法体
我们也可以称没有具体方法体的方法就是抽象方法，有抽象方法的类就是抽象类

格式要求：abstract class Animal{     //类和方法都需要使用abstract修饰
	public abstract void eat();   //没有具体方法体，也就是没有{}
}

三、抽象类的特点

1.抽象类里面有抽象方法
2.抽象类和抽象方法都需要使用abstract修饰
3.抽象类中可以有非抽象方法
4.一个类继承抽象类的时候，要么重写抽象类中所有的抽象方法，要么把自己变成一个抽象类（直接把抽象方法继承过来）

四、抽象类的成员特点

package com.bianyiit.cast;

public class Demo_AbstractTeZhen {
    /*那么抽象方法中的成员（成员变量和成员方法）有什么特点
        成员：成员变量、常量可以存着
        成员方法：抽象方法和非抽象方法都可以存在
    public static void main(String[] args) {
        //抽象类是不能创建对象的,也就是不能被实例化
        //new Animal1(18);
        System.out.println(new Dog1("拉布拉多").name);
        /*为什么抽象类不能实例化？？
            因为如果抽象类中可能有成员变量，而如果只有抽象方法时成员变量就失效了*/
        /*那既然抽象类都不能实例化了，构造方法还是存在的呢？
        *   抽象类中可能有成员变量，而构造方法时给成员变量初始化用的
        *   而构造方法是通过子类使用super关键字去调用父类的构造方法给name赋值*/

    }
}
abstract class Animal1{
    String name;
    final static int NUM=18;
    public abstract void eat();
    public void run(){}
    //无参构造
    public Animal1(){

    }
    //有参构造
    public Animal1(String name) {
        this.name = name;
    }
}
class Dog1 extends Animal1{
    @Override
    public void eat() {
        System.out.println("狗正在吃东西");
    }
    //默认调用了父类的有参构造
    public Dog1(String name) {
        super(name);
    }
}

五、抽象类不能与哪些关键字共存？

1.不能与private共存
	原因：因为抽象方法只要被private修饰，子类是无法继承过来然后重写抽象方法的，那么抽象方法就没有任何意义了，所以private不能与abstract共存
2.不能与final共存
	原因：final修饰的类不能被继承，抽象类中有抽象方法，这个时候意味着抽象方法不能被重写，也就没有存在的意义了；final修饰的方法不能被重写，那么也就意味着抽象方法就没有存在的意义了
3.不能与static共存
	原因：static修饰的方法可以直接通过类名来调用，而抽象方法没有具体的方法体，那么调用抽象方法是没有任何意义的，所以不能共存

六、接口（实例引入）

接口：比抽象类还要抽象的类（只能有抽象方法，不能有非抽象方法）
接口：Java中继承具有单一的局限性，所以为了解决这个问题，Java给我们提供了一种机制叫做接口 ---interface
格式：interface 接口名{}
类与接口的关系：一个类要去实现接口而不是继承接口（implements）

package com.bianyiit.cast;

public class Demo_Interface1 {
    public static void main(String[] args) {
        //接口：Java中继承具有单一的局限性，所以为了解决这个问题，Java给我们提供了一种机制叫做接口 ---interface
        //格式：interface 接口名{}
        //类与接口的关系：一个类要去实现接口而不是继承接口（implements）
        //接口：比抽象类还要抽象的类（只能有抽象方法，不能有非抽象方法）
        new BierGaiCi().money();
        new BierGaiCi().daima();
        new BierGaiCi().manage();
    }
}
//慈善家
interface CiShanJia{
    public abstract void money();
}
//程序员
interface ChengXuYuan{
    public abstract void daima();
}
//老板
interface Boss{
    public abstract void manage();
}
//定义一个比尔盖茨去实现这三个接口
class BierGaiCi implements CiShanJia,ChengXuYuan,Boss{
    @Override
    public void money() {
        System.out.println("我是一位慈善家");
    }

    @Override
    public void daima() {
        System.out.println("我是一位码农");
    }

    @Override
    public void manage() {
        System.out.println("我是一个老板");
    }
}

七、接口的特点

package com.bianyiit.cast;

public class Demo_AbstractInterface {
    public static void main(String[] args) {
    /*接口的特点
        1.接口和抽象类一样，也是不能实例化的（不能创建对象）
                 Father1 father1 = new Father1();  //错误示例
        2.接口中只能有抽象方法，不能有非抽象方法   注意：接口中的抽象方法默认是使用public abstract修饰的
        3.接口中只能有常量,不能有成员变量  注意：接口中的常量默认是使用public final static修饰
             原因:因为接口中只有抽象方法，木有非抽象方法，不能对变量进行二次赋值，所以不能存在变量
        4.接口中不能有构造方法
             原因：因为接口里面连成员变量都木有了，不需要构造方法对成员变量进行初始化了，所以没必要存在。
        总结：接口只能存在  抽象方法和常量*/
    }
}
interface Father1{
    //常量
    public final static String NAME="父亲";
    //抽象方法
    public abstract void eat();
}

八、类、抽象类、接口的关系

类与类的关系
     继承 extends  单一继承和多层继承
类与抽象类的关系
      也是继承的关系（重写父类中所有的抽象方法）
类与接口的关系
      实现关系  implements   多实现
	  1.当一个子类实现了接口，再定义一个类也只能继承这个子类，不能实现这个子类
               接口-->实现-->子类-->继承-->孙类
接口与接口的关系
      继承关系   (多继承)

九、为什么类与类之间只能单一继承，而接口与接口之间可以多继承？

课后作业（运动员案例，抽象类，类，接口的综合应用）

package com.bianyiit.cast;

public class Homework {
    public static void main(String[] args) {
        BaskerballSporter b1=new BaskerballSporter("小明",18,'男');
        System.out.println(b1.toString());
        b1.study();
        b1.studyEn();
        System.out.println();
        PingPangballSporter p1 = new PingPangballSporter("小白", 21, '男');
        System.out.println(p1.toString());
        p1.study();
        System.out.println();
        BasketballJianLian b2 = new BasketballJianLian("大明",45,'男');
        System.out.println(b2.toString());
        b2.Teach();
        b2.studyEn();
        System.out.println();
    }
}
class Person{
    String name;
    int age;
    char sex;
/*
    public Person() {
    }

    public Person(String name, int age, char sex) {
        this.name = name;
        this.age = age;
        this.sex = sex;
    }*/
}
abstract class Sporter extends Person{
    public abstract void study();

/*    public Sporter(String name, int age, char sex) {
        this.name = name;
        this.age = age;
        this.sex = sex;
    }*/
}
abstract class JiaoLian extends Person{
    public abstract void Teach();

/*    public JiaoLian(String name, int age, char sex) {
        this.name = name;
        this.age = age;
        this.sex = sex;
    }*/
}
interface StudyEnglish{
    public abstract void studyEn();
}
class BaskerballSporter extends Sporter implements StudyEnglish{
    @Override
    public void study() {
        System.out.println("学习扣篮..");
    }

    @Override
    public void studyEn() {
        System.out.println("学习英语..");
    }

    @Override
    public String toString() {
        return "BaskerballSporter{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", sex=" + sex +
                '}';
    }

    public BaskerballSporter(String name, int age, char sex) {
        this.name = name;
        this.age = age;
        this.sex = sex;
    }
}
class PingPangballSporter extends Sporter implements StudyEnglish{
    @Override
    public void study() {
        System.out.println("学习抽球..");
    }

    @Override
    public void studyEn() {
        System.out.println("学习英语..");
    }

    @Override
    public String toString() {
        return "PingPangballSporter{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", sex=" + sex +
                '}';
    }

    public PingPangballSporter(String name, int age, char sex) {
        this.name = name;
        this.age = age;
        this.sex = sex;
    }
}
class BasketballJianLian extends JiaoLian implements StudyEnglish{
    @Override
    public void Teach() {
        System.out.println("教扣篮");
    }

    @Override
    public void studyEn() {
        System.out.println("学习英语");
    }

    @Override
    public String toString() {
        return "BasketballJianLian{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", sex=" + sex +
                '}';
    }

    public BasketballJianLian(String name, int age, char sex) {
        this.name = name;
        this.age = age;
        this.sex = sex;
    }
}
class PingPangJiaoLian extends JiaoLian implements StudyEnglish{
    @Override
    public void Teach() {
        System.out.println("教抽球..");
    }

    @Override
    public void studyEn() {
        System.out.println("学习英语");
    }

    @Override
    public String toString() {
        return "PingPangJiaoLian{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", sex=" + sex +
                '}';
    }

    public PingPangJiaoLian(String name, int age, char sex) {
        this.name = name;
        this.age = age;
        this.sex = sex;
    }
}