接口

[!quote] 接口

接口 就是一种公共的规范标准，只要符合规范，大家通用。 用 implements，而不是 extends

public interface jumping {
	……
}

public class cat implements jumping {  
	……
}

特点

• 接口中的变量都被 final 修饰 ：可以提高程序性能（因为常量在编译时就已经确定了）
• 接口中的变量都被 static 修饰 ：被 static 修饰表明了接口就是公共的规范标准
• 类与接口之间的关系是实现，可以多实现
• 接口之间的关系是继承，而且可以多继承

public interface inter1 extends inter2,inter3 {
	……
}

[!hint] 为什么 public 在接口中是冗余的 因为在接口中，方法和属性默认就是 public 的【因为接口的目的是定义行为和规范，而不是实现细节】

作用

可以在不改变整体继承结构的前提下，实现对类的统一管理

例如有个 animal 类，马、猫、狗、猴子继承了animal 类。现在要增加一个宠物的行为，我们有三种办法：

• 在 animal 里定义宠物 method()，但是马、猴子不是宠物，但是还是继承到了宠物方法，这样不好
• 在猫类里定义一个宠物 method()，在狗类里也定义一个宠物 method()，但是这样就没有统一管理了
• 重新定义一个宠物接口，让猫、狗都实现它

嵌套接口

[!quote] 嵌套接口 嵌套接口 是定义在一个 接口/类 内部的接口，它们通常用于定义一些与外部接口或类紧密相关的功能，但同时又保持了一定的封装性和组织性

// 定义
public interface OuterInterface {
    void outerMethod();

    interface NestedInterface {
        void nestedMethod();
    }
}

// 实现
public class MyClass implements OuterInterface.NestedInterface {
    @Override
    public void nestedMethod() {
        System.out.println("Nested method implementation");
    }
}

内部类

public class out {
	public class in {
	}
}

• 内部类可以直接访问外部类的成员【包括私有】
• 外部类不能直接访问内部类的成员【需要创建对象】

[!hint] 为什么要使用内部类 ？

• 实现间接的多继承【外部类继承一个，内部类继承一个】
• 增加可读性，把具有一定逻辑关系的类组织在一起
• 内部类可以实现隐藏【非内部类是不可以使用 private，protected 修饰的】

成员内部类

成员内部类 在外部类的方法外

public class OutClass {
	public void test() {
		……
	}

	class InnerClass {
		……
	}
}

[!hint] 非静态的成员内部类 不能包含 静态成员【变量，方法】 成员内部类是依赖于外部类的实例的，所以成员内部类中的属性和行为也是依赖于外部类的实例的。

但是，如果将成员内部类中的属性和方法声明为静态，那又是不依赖于外部类实例的。

这就产生了矛盾。

局部内部类

局部内部类在外部类的方法中

public class Animal {
	public static void bellow() {
		class Dog {
			……
		}
	}
}

[!hint] 局部内部类 不能被 权限修饰符修饰 因为局部内部类的作用域仅限于所在的方法内部，它对外部的代码是不可见的，所以不需要使用访问修饰符来限制它的访问范围

匿名内部类

匿名内部类 本质是一个对象，只是这个对象没有名字

interface MyInterface {
    void myMethod();
}

MyInterface myObject = new MyInterface() {
    @Override
    public void myMethod() {
        // 在这里定义匿名内部类的方法实现
    }
};

// 调用匿名内部类中的方法
myObject.myMethod();

[!hint] 为什么要使用匿名内部类 ？

减少 class类 的创建

比如现在我有一个动物类

public class Animal {
	public void bellow() {
		sout("动物吼叫");
	}
}

我需要一个狗类，并且这个狗我只使用一次，在其他地方不调用，我们有两个办法：

• 写一个 Dog类 继承 Animal类，并重写 bellow()，最后实例化 Dog，调用方法
• 使用匿名内部类

class Demo {
	psvm {
		Demo demo = new Demo();
		demo.getDogBellow(new Animal(){
			@Override
			public void bellow() {
				sout("汪汪汪");
			}
		});
	}

	public void getDogBellow(Animal animal) {
		animal.bellow();
	}
}