java 接口 interface 内部类

接口 interface

接口相当于特殊的抽象类，定义方式。组成部分都与抽象类相似 但接口不是类
接口只能定义公开静态常量，公开抽象方法 ( public static final abstract ) 关键字可以省去，但依旧是公开的 静态的 最终的 抽象的

接口中不写变量 阿里规范

与抽象类的异同：
同：
  1. 可编译成字节码文件
  2. 不能创建对象
  3. 可以作为引用类型
  4. 具备Object类中定义的方法
不同：
  1. 所有属性都是公开的静态常量，隐式使用 public static final 修饰
  2. 所有方法都是公开抽象方法，隐式使用public abstract 修饰
  3. 没有构造方法，动态代码块，静态代码块。
接口微观概念：接口是一种能力和约定。
接口的定义：代表了某种能力
方法的定义： 能力的具体要求

java为单继承，当父类的方法种类无法满足子类需求时，可实现接口扩充子类的能力

接口支持多实现，可以为类扩充多种能力 implements 接口1，接口2,…

接口也可以继承接口，

类与类是单继承，接口与接口可以多继承

标识接口：Serializable序列化（实现对文件的持久化操作） cloneable克隆

接口中是空的，只是一个标识

内部类：

内部类：在一个类内部在定义一个完整的类
特点：

​ 内部类在编译为.class文件时，文件名会有$符号，代表。的内部类。

​ 内部类可以直接访问外部类的私有成员，而不破坏封装

​ 可为外部类提供必要的内部功能组件

  1. 成员内部类

    在类的内部定义，与实例变量，实例方法同级别的类

    当外部类，内部类存在重名属性时，会优先访问内部类属性

    成员内部类不能定义静态成员,但可以定义静态常量

    创建成员内部类的对象，必需依赖外部类对象

public class Out {
	public static void main(String[] args) {
		// Inner inner = new Out().new Inner(); //两种都可以
		Out out = new Out();
		Out.Inner inner = out.new Inner();
	}

	class Inner {
		public Inner() {
			System.out.println("aaa");
		}
	}

}
  1. 静态内部类

静态内部类的创建，不依赖外部类的对象，可直接创建或通过类名访问

只能直接访问外部类的静态成员(实例成员需要实例化外部类对象)

public class Out {
	public static void main(String[] args) {
		// 静态内部类
		Out.Inner inner = new Out.Inner();
		inner.show();
		Out.Inner.aaa();
	}

	// 静态内部类
	static int a = 10;

	static class Inner {
		public static void aaa() {
			System.out.println("aaa");
		}

		public void show() {
			System.out.println(a);
		}
	}

}
  1. 局部内部类

定义在外部类方法中，作用范围和创建对象范围仅限于当前方法

局部内部类访问外部类当前方法中的局部变量时，必需修饰为final

限制类的使用范围

public class Out {
	public static void main(String[] args) {

		//局部内部类
		Out out = new Out();
		out.show();
	}
	//局部内部类
	public void show(){
		final int a =10;
		class Inner{
			public Inner(){
				System.out.println(a);
			}
		}
		Inner inner = new Inner();
	}
}
  1. 匿名内部类

没有类名的局部内部类，一切特征都与局部内部类相同

必需继承一个父类或者实现一个接口

定义类，实现类，创建对象的语法合并，只能创建一个该类的对象

public class Out {
	public static void main(String[] args) {
		// 匿名内部类
		Animal2 animal = new Animal2() {// 继承Animal接口，并实现接口中的方法

			@Override
			public void eat() {
				System.out.println("匿名内部类——实现接口");
			}
		};
		animal.eat();

		Person2 person2 = new Person2() {  //匿名内部类——继承类

		};
		person2.eat();

		Person3 person3 = new Person3() {  //匿名内部类——继承抽象类

			@Override
			void eat() {
				System.out.println("匿名内部类——继承抽象类");
			}
		};
		person3.eat();

	}


}


interface Animal2 {

	void eat();

}

class Person2 {
	void eat() {
		System.out.println("匿名内部类——继承类");
	}
}

abstract class Person3 {
	abstract void eat();
}