接口

抽象类

/*
    abstract 抽象的
    修饰的方法，在抽象类中只写方法的声明，不需再实现
*/
public abstract  class Uncle {
    private String name;
    private int age;

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

子类一：extends 父类的名字

public class Uncleone extends Uncle {
    public void fahongbao(){
        System.out.println("大舅发红包，还送烟");
    }
}

子类二：

public class Uncletwo extends Uncle {
    public void fahongbao(){
        System.out.println("二舅发红包，还送烟");
    }
}

关键点：

语法：1抽象类的前面需要abstract关键字声明

        2 抽象类中至少有一个抽象方法

        3 抽象方法需要abstract关键字修饰

子类必须要实现抽象类中的抽象方法

接口interface

public interface Uncle {
       // 在接口中声明方法
    public void fahongbao();
}

子类一：implements 父类的名字

public class UncleOne implements Uncle{

    @Override
    public void fahongbao() {
        System.out.println("大舅发红包，还送烟");
    }
}

子类二：

public class UncleTwo implements Uncle {

    @Override
    public void fahongbao() {
        System.out.println("二舅发红包，还送酒");
    }
}

1 关键字 interface

2 接口中的方法只需要声明，不能有方法体，方法只能是共有的

3子类需要实现接口中的所有方法，实现的语法是implements接口名

例外

1 可以写公有的常量

2 可以写默认的方法default修饰

public interface Uncle {
    // 公有常量
    public String chenhu= "舅舅";

    // 在接口中声明方法
    public void fahongbao();

    // 不管那个舅舅都需要照顾老人，为了避免重复，写在接口中，default
    public default void zhaogulaoren(){
        System.out.println("每个舅舅都需要照顾老人");
    }
}

多实现 (多重实现)

// 多继承（多重继承）  多实现 （ 多充实现）
public class UncleTwo implements Uncle ,Father,GrandFather{

    @Override
    public void fahongbao() {
        System.out.println("二舅发红包，还送酒");
    }

    @Override
    public void yangjia() {
        System.out.println("二舅也是一位父亲，需要养家");
    }
}

多继承（多重继承） 只有接口才可以多重继承

// 多（重）继承 extends Uncle,Father,GrandFatherpublic interface Temp extends Uncle,Father,GrandFather{    }

public class UncleThree implements Temp {    @Override    public void yangjia() {    }    @Override    public void fahongbao() {    }    @Override    public void zhaogulaoren() {    }}

抽象类与接口的对比

案例

package edu.xcdq.demo01.demo04;// 爷爷类 抽象的 有一个钓鱼的抽象的方法没有实现public abstract class Yeye {    public abstract void diaoyu();}

package edu.xcdq.demo01.demo04;// 爸爸类 抽象的 从爷爷继承来的抽象方法可以不实现，也可以实现public abstract class Baba  extends Yeye{    public abstract void tangtou();}

package edu.xcdq.demo01.demo04;// 叔叔类 标准的实体类 不是抽象类 继承的父类中所有的抽象方法必须全部实现public class Shushu extends Yeye{    @Override    public void diaoyu() {        System.out.println("");    }}

package edu.xcdq.demo01.demo04;// 标准实体类 ，需要全部实现父类中累计没有实现的所有抽象方法public  class Sunzi extends Baba{    @Override    public void tangtou() {    }    @Override    public void diaoyu() {    }}