Java抽象方法，抽象类，接口

抽象方法：

概念：被abstract修饰，且没有{}的方法就是一个抽象方法。

定义一个抽象方法：

public abstract void AbstractMethod();

抽象类：

概念：如果一个类中，没有包含足够的信息来描述一个具体的对象，这种类就称为抽象类。
定义一个抽象类：

abstract class TestClass{

    public int testNum;

    public TestClass(int testNum) {
        this.testNum = testNum;
    }

    public static void StaticMethod(){
        System.out.println("抽象类的静态方法");
    }

    public void Method(){
        System.out.println("抽象类的普通方法");
    }

    public abstract void AbstractMethod();

}

抽象类注意点：

抽象类可以像普通类一样定义成员变量和成语方法。
抽象类的意义就是被其它类继承。
抽象类中可以不存在抽象方法。
抽象类继承抽象类则可以不重写抽象方法。
抽象类不可以进行实例化。
抽象类的构造方法是提供给子类实例化时使用。
抽象类不能被final和private修饰。

抽象类不可以被实例化解释：

写一个TestExtend类继承上面的抽象类，重写抽象方法。

class TestExtend extends TestClass{

    public String TestStr;

    public TestExtend(int testNum,String testStr) {
        super(testNum);
        this.TestStr=testStr;
    }

    @Override
    public void AbstractMethod() {
        System.out.println("子类重写的抽象方法");
    }
}

在main方法中进行测试：

   public static void main(String[] args) {
        TestClass testClass= new TestClass(1) {
            @Override
            public void AbstractMethod() {
                System.out.println("实例化抽象类对象时重写的抽象方法");
            }
        };
        TestClass testClass1=new TestExtend(1, "1");
    }

testClass通过new关键字，重写AbstractMethod()方法得到。
testClass1通过向上转型得到的是子类的对象。
编译后查看字节码文件的main方法。

我们可以看到testClass是作为当前测试类的一个内部类，而testClass1则是TestExtend类的对象。

接口：

原因：java是单继承的方式，使用implements关键字实现多个接口来弥补这一缺点。
概念：接口就是公共的行为规范，可看作一种引用数据类型，面向接口编程是一种思想。
定义一个接口：

interface ITestInterface{
    //接口的成员变量默认为public static final
    int testInt = 1;
    public static final double testDouble=1.1;
    //接口可以定义默认方法 default
    default public void testDefault(){
        System.out.println("接口中的默认方法");
    }
    //接口可以定义静态方法 static
    public static void testStatic(){
        System.out.println("接口中的静态方法");
    }
    //抽象方法
    public abstract int testAbstract(int a);
}

实现接口：

class TestInterface implements ITestInterface{

    //可以选择性的重写默认方法
    @Override
    public void testDefault() {
        System.out.println("实现类重写接口的默认方法");
    }
    //必须重写抽象方法
    @Override
    public int testAbstract(int a) {
        return a;
    }
}

测试：

public static void main(String[] args) {

        //接口可以直接调用自己的静态方法和变量
        ITestInterface.testStatic();
        System.out.println(ITestInterface.testInt);

        //实现类可以调用接口的变量
        System.out.println(TestInterface.testDouble);

        //实现类的对象可以调用接口的默认方法
        //如果该实现类 重写了接口的默认方法 ，则执行重写的方法
        //如果该实现类 没有重写 接口的默认方法 ，则执行 接口的默认方法
        TestInterface testInterface=new TestInterface();
        testInterface.testAbstract(1);
        testInterface.testDefault();

        //接口的引用执行实现类的对象
        ITestInterface iTestInterface=new TestInterface();
        iTestInterface.testDefault();

        
    }

接口注意点：

接口可以定义静态方法默认方法。
接口的默认方法可以被实现类重写。
接口的引用可以执行实现类的对象。
接口的变量默认被public static final修饰。
接口间使用extends继承。
接口不可以被实例化。

接口间关系：

interface a{
    void a();
}

interface b extends a{
    void b();
}

interface c extends b{
    void c();
}

class TestABC implements c{

    @Override
    public void a() {

    }

    @Override
    public void b() {

    }

    @Override
    public void c() {

    }
}