抽象类

抽象类提供抽象方法，只有方法的签名而没有具体的实现方法。好比做一份番茄炒蛋，抽象类仅仅只是提供一个“番茄炒鸡蛋”这个做法，但是不提供具体怎么操作，“去皮番茄炒蛋”、“原汁原味番茄炒蛋”、“老少皆宜炒蛋”等这种具体做法就在实例里面实现。

• 抽象类必须要用abstract修饰符来定义，抽象类里面可以没有抽象方法。如public abstract class shape{}。不能使用new来调用构造器创建抽象类实例。
• 抽象类可以包含成员变量、方法、构造器、初始化块、内部类，主要用于被其子类调用。
• 只能被类或抽象类继承
• 不支持多重继承

举个例子

package test1;

public abstract class student {
    
    {
    
        System.out.println("执行student的初始化块");
    }
    private String name;
    public abstract double getSum();//不用写具体实现方式
    public abstract String getSex();//不用写具体实现方式
    public student(){
    }
    public student(String name){
    
        System.out.println("执行student的构造器");
        this.name = name;
    }
}

package test1;

public class Zss extends student{
    
    private double a;
    private double b;
    private double c;
    public Zss(String sex,double a,double b,double c){
    
        super(sex);
        this.setSides(a,b,c);
    }
    public void setSides(double a,double b,double c){
    
        this.a = a;
        this.b = b;
        this.c = c;
    }
    public double getSum(){
    
        return a + b + c;
    }
    public String getSex(){
    
        return "男";
    }
}

package test1;
public class Lss extends student{
    
    double maths;
    public Lss(String sex,double maths){
    
        super(sex);
        this.maths = maths;
    }
    public void setMath(double maths){
    
        this.maths = maths;
    }
    public double getSum(){
    
        return maths;
    }
    public String getSex(){
    
        return "女";
    }
    public static void main(String[] args) {
    
        student s1 = new Zss("男",90,89,94);
        student s2 = new Lss("女",100);
        System.out.println(s1.getSum());
        System.out.println(s1.getSex());
        System.out.println(s2.getSum());
        System.out.println(s2.getSex());
    }
}

继承抽象类的子类必须要有父类的相应抽象方法的实现方式，否则会报错。

接口

接口（interface）是更加特殊的抽象类，接口里不能包含普通方法，所有方法都是抽象方法。它是一种规范，规定这批类里必须提供某些方法，否则就会不满足要求而报错。

• 要用interface关键字而不用class关键字。如
  修饰符 interface jieKou{}。而修饰符可以是public，也可以省略默采用包权限访问控制符，即只有在相同包结构下才可以访问接口
• 必须是public、static和final字段
• 只含抽象方法且必须是public的
• 既可以被接口继承，也能被类或抽象类继承
• 可以继承多个父接口

举个例子

package test2;

public interface output {
    
    int MAX_N = 50;
    void out();
    void getData(String text);
    default void print(String ... texts){
    
        for (String text : texts){
    
            System.out.println(text);
        }
    }
    default void test(){
    
        System.out.println("默认的test()方法");
    }
    static String staticTest(){
    
        return "接口里的类方法";
    }
}

package test2;

public class outPutTest {
    
    public static void main(String[] args) {
    
        System.out.println(output.MAX_N);
        System.out.println(output.staticTest());
    }
}

接口可以多重继承，及多个同时继承，但是类的继承只能单个继承

interface interFace1{
    
    int Test_a = 114514;
    void testa();
}
interface interFace2{
    
    int Test_b = 2333;
    void testb();
}
interface interFace3 extends interFace1,interFace2{
    
    int Test_c = 7;
    void testc();
}
public class InterTest {
    
    public static void main(String[] args) {
    
        System.out.println(interFace1,Test_a);
        System.out.println(interFace2,Test_b);
        System.out.println(interFace3,Test_c);
    }
}

接口与抽象类

共同点

• 都不能被实例化
• 都可以包含抽象方法

不同点

• 接口体现的是一种规范，它制定了系统各个模块都应该遵循的标准，规定了实现者必须以方法的形式提供哪些服务，调用者可以调用哪些服务以及如何调用服务。
• 抽象类作为多个子类的共同父类，体现的是一种模板设计。