抽象类

public abstract   class Uncle {
    private String name;
    private int age;

    //抽象方法
    public  abstract void faHongbao();


}

子类一：

public class UncleOne  extends Uncle {
    public void faHongbao(){
        System.out.println("打就发红包，还送酒");
    }
}

子类二：

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

关键点：

语法：1 .抽象类的前边需要adstract关键字声明

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

         3 .抽象方法需要adstract关键字

接口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 chenghu = "舅舅";

    //在接口中声明方法
   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("二舅送红包，松烟");
    System.out.println(chenghu);
    }

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

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

//多（重） 继承  extends  Uncle  ，Father  ，GrandFather

public interface Temp extends Uncle ,Father, GrandFather{
}

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

    @Override
    public void faHongbao() {

    }
    
    public void zhaogulaoren(){
        
    }
}

抽象类与接口的对比

案例：

//爷爷类  抽象的 有一个钓鱼的抽象类方法没有实现

public abstract class YeYe {
    public abstract void diaoyu();
}

//爸爸类  抽象的  从爷爷继承来的抽象方法可以不实现， 也可以实现


public abstract class BaBa extends YeYe {
    public abstract void tangtou();
}

// 叔叔类  标准的实体类  不是抽象类  继承的父类中所有的抽象方法必须全部实现


public class ShuShu extends YeYe {

    @Override
    public void diaoyu() {

    }
}

//孙子类 标准实体类  ， 需要实现全部类父类中累计没有实现的抽象方法

public class Sunzi extends BaBa {
    @Override
    public void tangtou() {

    }

    @Override
    public void diaoyu() {

    }

}