java接口理解

/*
接口：初步理解，可以认为是抽象类，当所有方法都是抽象方法时，的另一种表示方式。

接口的定义格式和类差不多，接口的名字也需要大写。
Interface 接口名
{
....//接口定义。
}

接口中的一般内容有：常量、抽象方法
接口中的成员都是由固定的修饰符修饰的。

常量：public static final (全局常量，用类名引用)
抽象方法：public abstract

接口中在定义成员时，可以不带修饰符，因为接口中的成员修饰符都是固定的，少什么修饰符，系统就会默认添加
什么修饰符。即成员修饰符可以省略，但是在实际开发中，最好全部都带着，这样程序的阅读性会更好。

接口中的实现的含义，对于成员方法而言，就是覆盖（覆写）。

接口和抽象类的不同：
接口中的方法都必须是公共的，且抽象的
抽象类中的方法的权限可以使自己设定，且可以是抽象的，也可以不是抽象的。
接口中的成员变量都是常量，且都是全局常量，用类名就可以访问
抽象类中的成员变量权限，静态与否，是否是常量可以由自己来定义。

接口与类之间的关系是实现：用关键字implements表示。
用实现而不用继承，就是要和抽象类做出区分，子类继承父类，是说明父类中的某些方法可以直接拿过来使用
不必去覆盖（覆写 <=> 实现）。而对于子类实现接口而言，需要将接口中的所有方法全部都实现。所以就用
实现以示区分。本质上实现一个接口相当于对于全部方法都是抽象方法的抽象类的继承。子类拥有接口的所有
内容，并且对于接口中定义的抽象方法要全部实现，才能创建子类的实例（对象），若只实行实现（覆盖、覆写
）接口中的部分内容，则子类必须定义成抽象类，因为子类实现了接口，其内有了一部分抽象方法。

接口被编译后也会形成.class文件，.class文件名和接口名一致。即接口是以类的形式体现的。

接口从某种意义上可以看成抽象类，而实现相当于继承。

接口和接口之间存在多继承。
接口和接口之间可以有多继承的，原因是接口中的方法都是抽象方法，只有方法声明，没有方法体，所以
当接口C继承接口A，接口B时，A,B中即时有一模一样的方法存在，也只相当于在C中存在一个即可。类D实现
接口C的时候，只需要在类定义中覆盖（覆写、实现）一次，就可以覆盖(覆写、实现)A,B中的两个方法。
但是也不允许出现这样的情况：
即接口A，接口B中存在两个函数名称，参数列表完全一样，但是返回值不一样的函数。
因为覆盖（覆写、实现）的特性要求，覆盖函数和被覆盖函数必须是一模一样（包括返回值、函数名、参数列表）
，覆盖函数的权限大于等于被覆盖函数的权限。
所以当类D实现接口C时，在类D的定义中就需要存在两个函数名，参数列表一模一样的函数，但是这样就会出错。
所以这种情况也是不允许出现的，否则编译器报错。

接口可以被类多实现，即一个类A可以实现多个接口（接口B，接口C，接口D...）。
一个类可以实现多个接口的原因：类C可以同时实现接口A，接口B。因为即使A,B中存在一模一样的方法，也只需要在
类C的定义中覆盖一次就可以了。类C的对象在调用的时候并不会出现问题。归根结底就是A,B中没有方法体，只有
方法定义。类C可以随便实现（覆盖、覆写）。
当然也允许出现下面的情况：
即接口A、B中出现除了返回值类型外其他都一模一样的方法。因为这样的话类C中就会有两个除了返回值不同外，
其他都相同的两个一模一样的方法了。这是不允许的，JAVA编译器会报错。

java中类和类之间只能有单继承（可以有多层继承），但是不能有多继承。
原因是：当子类C继承父类A，父类B时，若
父类A和父类B中存在着一模一样的方法，或者方法名和参数列表相同，返回值不同的方法时，则子类C的对象在调用时
，会出现问题。所以Java中不允许有多继承。

接口的多实现（即一个类可以实现多个接口）是类之间的多继承在JAVA中的体现。JAVA用类的多实现来代替类与类的多
多继承。
接口用来增加类的功能。一个类可以在继承另一个类的同时实现多个接口。

*/

 

interface Inter
{

    public static final int NUM = 4;
    public abstract void show();

}

class Test implements Inter
{
    public void show()
    {
    }
//	public void speak();函数括号（）后面，要么是;要么是{}，当是;时，必须声明为抽象函数。
//	一个类中的一个方法，要么有方法体，要么是抽象。不允许存在没有方法体的非抽象函数。
// 在任意{}后面跟着;也是正确的写法，但一般都省略。
}

interface A
{
    public abstract void methodA();
}
interface B	//extends A
{
    public abstract void methodB();
}
interface C	extends B,A
{
    public abstract void methodC();
}
class D implements C
{
    public void methodA(){}
    public void methodB(){}
    public void methodC(){}
}

interface InterA
{
    public abstract void show();
}
interface InterB
{
    public abstract void show();
}
interface InterC extends InterA,InterB
{
    public abstract void speak();
}
class TestD implements InterC
{
    public void show(){}
    public void speak(){}
}
/*
错误示例：
interface A
{
    public abstract int show();
}
interface B
{
    public abstract boolean show();
}
class C implements A,B
{
    public int show(){}
    public boolean show(){}
}
class D
{
    public static void main(String[] args)
    {
        C c = new C();
    }
}

*/

 

class InterfaceDemo
{
    public static void main(String[] args)
    {
        Test t = new Test();
        System.out.println(t.NUM);
    }
}