接口与内部类

飞机、鸟和超人不能归于一个类属，但是具备有相同的特性：会飞的。所以引入了一个新概念叫做接口，可以用于
规范实现接口的类中必须实现接口中抽象方法。接口可以理解为一种契约
使用关键字interface定义接口

public interface 会飞的 {
public void 起飞(); //没有具体实现，也无法定义具体实现，这里是抽象方法
public void 巡航飞行();
public void 降落();
}

抽象类中的抽象方法不能省略abstract关键字，但是接口中的方法声明可以添加abstract，也可以不写
接口不能直接使用，必须有对应的实现类

public class 飞机类 implements 会飞的 { //共性是通过实现接口来表示的
private String name; //名称，这是类属的属性，这里可以定义字节类的成员，和接口无关
//如果当前类不是抽象类，则必须实现接口中的所有抽象方法
public void 起飞() {
System.out.println("使劲的跑，一抬头就飞起来了");
}
public void 巡航飞行() {
System.out.println("使劲的烧油...");
}
public void 降落() {
System.out.println("我对准...");
}
}

在Java中不直接支持多继承，因为会出现调用的不确定性，所以Java将多继承机制进行改良，在Java中变成了多实
现。一个类只能有一个直系双亲类，一个类可以实现多个接口，一个接口可以继承多个接口

interface IA{}
interface IB{}
interface IC extends IA,IB{} 正确的，其中IC中的方法等于IA+IB
class A implements IA,IB{}
IA a=new A();
IB b=new A();

没有构造器方法，不能定义静态或者非静态代码块

public interface IA{
public IA(){} //语法报错
}

没有属性，只能定义常量

public class Test {
public static void main(String[] args) {
System.out.println(IA.name); //常量可以直接使用
System.out.println(B.name); //实现类也可以直接访问常量
}
}
interface IA {
//private int age;语法报错，提示信息为Illegal modifier for the interface field
IA.name; only public, static & final are permitted
String name = "yanjun";// 接口中只能定义常量，不能定义属性，默认限定词public static
final，自定义限定词不能冲突
}
class B implements IA{} //访问常量既可以通过接口IA和实现类B名称的方式直接访问，例如
B.name。也可以通过B对象的方式进行访，例如new B().name

接口允许多重继承，也允许一个类实现多个接口

public class Person {
public static void main(String[] args) {
IC cc=new CImpl();
cc.pp();
}
}
interface IA{
public default void pp() {
System.out.println("this is IA.pp() default");
}
}
interface IB{
public default void pp() {
System.out.println("this is IB.pp() default");
}
}
//因为在两个父接口中都定义了pp方法的默认实现，则在子接口无法确定到底使用哪个，所以要求子接口必
须明确说明
interface IC extends IA,IB{
@Override
default void pp() { //在子接口中覆盖定义
System.out.println("this is IC.pp() default");
IA.super.pp();//调用IA接口所定义的pp方法
IB.super.pp();
}
}
class CImpl implements IC{}

public class Person {
public static void main(String[] args) {
IA cc=new CImpl();
cc.pp();
}
}
interface IA{
public default void pp() {
System.out.println("this is IA.pp() default");
}
}
interface IB{
public default void pp() {
System.out.println("this is IB.pp() default");
}
}
//报错的原因是IA和IB接口中有相同的方法定义，同时又有默认实现，则CImpl类不知道使用哪个默认实
现，所以要求类中必须明确说明
class CImpl implements IA,IB{
@Override
public void pp() {
System.out.println("可以定义自己的逻辑");
IA.super.pp();//也允许调用某个接口中的默认实现
IB.super.pp();
}
}

抽象方法必须在实现类中提供实现

class A2Impl implements IA2{ //在实现类中必须实现接口中的所有抽象方法，否则当前类只能是抽
象类
public int ee() {
return 0;
}
public void pp() {
System.out.println("A2Impl....");
}
public void cc() {
System.out.println("A2Impl.....");
}
//dd方法由于在接口中有默认实现，所以可以不用重新定义，也允许重新定义
}

**可以使用default关键字给抽象方法提供默认实现，有默认实现的方法在实现类中可以重新定义，也可以不重
新定义
报错原因：Java中不支持类的多重继承，一个类只能有一个双亲类
**
一个类在继承另一个类的同时，还可以实现多个接口

public class Person {
public static void main(String[] args) {
IA a1=new AImpl();
B a2=new AImpl();
a1.pp();
}
}
interface IA{
public void pp();
}
class B {
public void pp() {
System.out.println("this is B.pp()");
}
}
class AImpl extends B implements IA{ //AImpl类是通过继承B类实现了对接口IA中的抽象方法提供实现
}

public class Person {
public static void main(String[] args) {
IA a1=new AImpl();
a1.pp();
IB a2=new AImpl();
a2.pp();
}
}
interface IA{
public void pp();
}
interface IB {
public default void pp() {
System.out.println("this is B.pp()");
}
}
class AImpl implements IA,IB{ //不能因为IB中针对pp方法提供了默认实现，所以不在实现类中定义pp方
法
@Override
public void pp() {
System.out.println("添加的新的处理逻辑");
// IA.super.pp(); 因为IA接口中并没有提供pp的默认实现，所以不允许这样调用
IB.super.pp();
}
}

接口允许多重继承

interface IA1{
public void p1();
}
interface IA2{
public void p2();
}
interface IC extends IA1,IA2{
public void p3(); //继承父接口的同时也允许自定义方法
}//可以继承多个父接口,此时IC中实际有3个抽象方法

类是单根继承,不允许继承多个父类
允许一个类实现多个接口,但是每个接口的抽象方法都必须提供实现，否则是抽象类。提供的实现也可以是继承

public class A1{
public void p1(){}
}
public class A2 extends A1 implements IA1,IA2{
public void p2(){}
}
public abstract class A3 extends A1 implements IA1,IA2{}//因为p2方法没有实现

接口的出现避免了单继承的局限性，这样定义C接口则拥有A+B的所有定义，可以使用A和B接口以及父类D声明变
量类型，直接new T。但是约束时，用谁声明变量编译器系统识别就是谁这种类型，也就意味只能调用识别类型中
的方法，不能调用其他方法

interface A{
public void p1();
}
interface B{
public void p2();
}
interface C extents A,B{}
class D{
public void abc(){}
}
class T extends D implements C{
public void p1(){}
public void p2(){}
}
D d=new T();这里只能直接调用abc方法，如果使用其他方法则需要进行类型转换
A a=new T();这里只能直接调用A接口中声明的方法p1
B b=new T();这里只能直接调用B接口中声明的方法p2
C c=new T()

如果定义public接口，则规则和定义public类一致，要求接口名称和文件名称一致
外部的接口只能使用public、默认这两个范围限定词；如果定义内部接口则可以使用4大范围限定词
接口实际上提供了同一的操作界面（方法），如果是JDK1.8-版本则一个方法也不实现，等待某类或某几个类
去实现它的方法【接口中的所有方法必须是抽象的】。如果使用的是JDK1.8+允许使用default在接口中定义默
认实现，这个实现允许在实现类中重新定义覆盖

public class Test1 {
public static void main(String[] args) {
IA2 a2=new A2Impl();
a2.pp();
}
}
interface IA2 {
default void pp(){ //通过defaul在接口中定义方法的默认实现，则在实现类中可以覆盖定义，也
可以继承使用
System.out.println("this is pp....");
this.ff();

default默认方法实现使用的限制

public class Test1 {
public static void main(String[] args) {
IA2 a2 = new A2Impl();
a2.pp();
}
}
interface IA2 {
default void pp() {
System.out.println("this is No2 pp....");
}
}
interface IA3 {
default void pp(){
System.out.println("this is No3 pp");
}
}
class A2Impl implements IA2, IA3 {//如果IA2中有一个default实现的方法和IA3中的方法一致，则
必须在实现类中重新定义
public void pp() {
IA2.super.pp();//调用IA2接口中的pp方法的默认实现
IA3.super.pp();
}
}

接口和抽象类的异同点
相同点：都是不断向上抽取而来的
不同点：
抽象类需要被继承，而且只能单继承
接口需要被实现，而且可以多实现
抽象类中可以定义抽象方法和非抽象方法，子类继承后可以直接使用非抽象方法
接口中只能定义抽象方法，必须由子类去实现；JDK1.8+中允许接口中的方法有默认实现，实现类中可以直接
使用默认实现，允许覆盖定义
抽象类的继承是is a关系，在定义该体系的基本共性内容
接口的实现是like a关系，在定义体系额外功能
接口中只能定义常量，而且必须被初始化，抽象类中可以定义属性，允许在声明时直接初始化，也可以不初
始化，同时允许定义常量