抽象类和接口

接口

1，默认的修饰符是 public abstract；不可以使用private或者protected修饰；
2，接口中的变量会默认public static final修饰，无法使用protected,private,没有成员变量
3，接口中所有方法都是抽象方法，无法重载,接口中抽象方法无法使用protected，private，默认public abstract

package com.huanglk;

//默认的修饰符是 public abstract；不可以使用private或者protected修饰。
public abstract interface People {


    //接口中的变量会默认public static final修饰，无法使用protected,private,没有成员变量
    public static final String time = "time";

    //无构造器，不能实例化
    //    public People();

    //接口中所有方法都是抽象方法，无法重载,接口中抽象方法无法使用protected，private，默认public abstract
    public abstract String eat();
}

抽象类

1，可以有成员变量，可以有变量的get、set方法
2，可以有常量值；
3，abstract抽象方法，只有方法名没有方法实现，抽象方法必须在抽象类中，不能重载，只能使用，public，protected修饰
4，抽象类可以有普通方法，普通方法可以重载
5，抽象类有普通方法,有构造其，但不能被实例化

package com.huanglk;

//抽象类
public abstract class Action {

    //可以有成员变量
    String time;

    //可以有常量值
    static final String length = "100";

    //abstract抽象方法，只有方法名没有方法实现，抽象方法必须在抽象类中，不能重载
    protected abstract void doSomeThing();

    //abstract抽象方法，只能使用，public，protected修饰
    abstract String run();

    //抽象类有普通方法
    public String eat() {
        return "eat";
    }

    //抽象类有普通方法,有构造其，但不能被实例化
    public Action(String time) {
    }
    //普通方法可以重载
    public Action(String time,int i) {
    }
    //抽象类有普通方法,有构造其，但不能被实例化
    public Action() {
        System.out.println("Action");
    }

    //可以有变量的get、set方法
    public String getTime() {
        return time;
    }

    public void setTime(String time) {
        this.time = time;
    }
}

常见使用方法子类

1，先继承抽象类，再实现接口
2，如果抽象类中有接口的实现方法则不需要重写,但如果抽象类和接口有相同名称但返回值不同的方法是则会报错

package com.huanglk;

//先继承抽象类，再实现接口
//如果抽象类中有接口的实现方法则不需要重写,但如果抽象类和接口有相同名称但返回值不同的方法是则会报错
public class Child extends Action implements People{
    @Override
    protected void doSomeThing() {
        System.out.println("child doSomeThing");
    }

    @Override
    String run() {
        return "child run";
    }
//    String eat(String test) {
//        return "child run";
//    }
    //可以实现抽象类和接口的方法
    @Override
    public String eat() {
        return "child eat";
    }
}

常见运行及使用

package com.huanglk;

public class Main {

    public static void main(String[] args) {
        //如果一个类中没有其抽象方法则为Action action = new Action(){};具体化并像常规类一样使用

        //抽象类要实例化必须实现其抽象方法
        Action action = new Action(){
            @Override
            public void doSomeThing() {
                System.out.println("doSomeThing");
            }

            @Override
            public String run() {
                return "run";
            }
        };
        System.out.println(action.eat());
        action.setTime("1000");
        System.out.println(Action.length);
        action.doSomeThing();
        System.out.println(action.run());


        //
        Child child = new Child();
        child.eat();
    }


}