JAVA11——接口_回调_内部类_java11接口调整-CSDN博客

本文链接：https://blog.csdn.net/qiao39gs/article/details/107288797

接口

其它：extends和implements区别

回调(CallBack/Hook)

内部类（innerclasses）

接口

为什么需要接口？接口和抽象类的区别？
- 接口就是比“抽象类”还“抽象”的“抽象类”，可以更加规范地对子类进行约束。全面地专业地实现了：规范和具体实现的分离
- 接口就是规范，定义的是一组规则，体现了现实世界中“如果你是···则必须能···”的思想。
- 接口的本质是契约，就像我们人间的法律一样。制定好后大家都遵守。
- 项目的具体需求是多变的，我们必须以不变应万变才能从容开发，此处的“不变”就是“规范”。因此开发项目往往都是面向接口编程
子类通过 implements来实现接口中的规范
接口不能创建实例，但是可用于声明引用变量类型
一个类实现了接口，必须实现接口中所有的方法，并且这些方法只能是 public的
接口支持多继承

接口中只有常量和抽象方法
接口中定义常量时默认前缀是public static final，可写或不写
接口中定义方法时封装是public abstract，可写或不写

定义格式：

[访问修饰符] interface 接口名 [extends 父接口1,父接口2...]{

常量定义 //总是public static final

方法定义 //总是public abstract

}

eg:

创建：

public interface MyInterface {
	String MAX_GREAD = "BOSS";
	int MAX_SPEED = 120;
	
	public void test01();
	public int test02(int a,int b);
}

实现：

public class MyClass implements MyInterface {

	@Override
	public void test01() {
		System.out.println("test01");
	}

	@Override
	public int test02(int a, int b) {
		System.out.println("test01");
		return a+b;
	}
	
}

其它：extends和implements区别

extends与implements的不同

1、在类的声明中，通过关键字extends来创建一个类的子类。

一个类通过关键字implements声明自己使用一个或者多个接口。

extends 是继承某个类, 继承之后可以使用父类的方法, 也可以重写父类的方法;

implements 是实现多个接口, 接口的方法一般为空的, 必须重写才能使用

2、extends是继承父类，只要那个类不是声明为final或者那个类定义为abstract的就能继承

Java中不支持多重继承，但是可以用接口来实现，这样就要用到implements，继承只能继承一个类，

但implements可以实现多个接口，用逗号分开就行了比如：

class A extends B implements C,D,E

接口实现的注意点：

a.实现一个接口就是要实现该接口的所有的方法(抽象类除外)。

b.接口中的方法都是抽象的。

c.多个无关的类可以实现同一个接口，一个类可以实现多个无关的接口。

与Extends的不同
extends，可以实现父类，也可以调用父类初始化 this.parent()。而且会覆盖父类定义的变量或者函数。这样的好处是：架构师定义好接口，让工程师实现就可以了。整个项目开发效率和开发成本大大降低。 implements，实现父类，子类不可以覆盖父类的方法或者变量。即使子类定义与父类相同的变量或者函数，也会被父类取代掉。
这两种实现的具体使用，是要看项目的实际情况，需要实现，不可以修改implements，只定义接口需要具体实现，或者可以被修改扩展性好，用extends。

回调(CallBack/Hook)

在代码中间有一个方法不知道怎么实现时使用回调函数，将不确定怎么实现的方法交给别人来做

好处：代码、功能分离

eg:（模板—方法模式）
PaintFrame.java

public class PaintFrame {
	public static void drawFrame(MyFrame f){
		System.out.println("启动线程");
		System.out.println("增加循环");
		System.out.println("查看消息栈");
		
		//画窗口
		f.paint();
		
		System.out.println("启动缓存，增加效率");

	}
	
	public static void main(String[] args) {
		drawFrame(new GameFrame01());
	}
}

class GameFrame01 extends MyFrame {
	public void paint(){
		System.out.println("GameFrame01.paint()");
		System.out.println("画窗口");
	}
}
class GameFrame02 extends MyFrame {
	public void paint(){
		System.out.println("GameFrame02.paint()");
		System.out.println("画窗口");
	}
}

MyFrame.java

public class MyFrame {
	public void paint() {
		System.out.println("把自己窗口画出来");
	}
}

将不确定的方法设成回调，运行时将需要运行的方法所在的类GameFrame01传入，这个类继承MyFrame类，重写了MyFrame类的paint方法在运行drawFrame()方法时，将重写paint方法后的类传参到PaintFrame中，f.paint()调用的是重写后的方法。

若希望子类全部重写则设置该类为抽象类

内部类（innerclasses）

一般情况下，类是独立的单元。有些情况下，一个类放在另一个类的内部定义为内部类。

内部类的作用：
- 内部类提供了更好的封装。只能让外部类直接访问，不允许同一个包中的其他类直接访问。
- 内部类可以直接访问外部类的私有属性，内部类被当成其外部类的成员。但外部类不能访问内部类的内部属性。
内部类的使用场合：
- 由于内部类提供了更好的封装特性，并且可以很方便的访问外部类的属性。所以，通常内部类在只为所在外部类提供服务的情况下优先使用。
内部类的分类
- 成员内部类（可以使用 priate、 protected、pubc任意进行修饰。类文件：外部类$内部类.class）
  一、非静态内部类（外部类里使用非静态内部类和平时使用其他类没什么不同）
  1.非静态内部类必须寄存在一个外部类对象里。因此，如果有一个非静态内部对象那么一定存在对应的外部类对象。非静态内部对象单独属于外部的某个对象。
  2.非静态内部尖可以使用外部类的成员，但是外部类不能直接访问非静态内部类成员。
  3.非静态内部类不能有静态方法、静态属性、静态初始化块。
  4.静态成员不能访问非静态成员：外部类的静态方法、静态代码块不能访问非静态内部类，包括不能使用非静态内剖类定义变量、创建实例。
  5.成员变量访问要点：
  ·内部类里方法的局部变量：变量名
  ·内部类属性：ths变量名
  ·外部类属性：外部类名.this变量名
  6.内部类的访问：
    外部类中定义内部类：new Inner Class
    外部类以外的地方使用非静态内类：
  Outer.inner varname = OuterObject.new Inner();
  二、静态内部类
  1.定义方式
  static class ClassName{
  //类体
    }
  2.使用要点
    ·当个静态内部类对象存在，并不一定存在对应的外部类对象。因此，静态内部类的实例方法不能直接访问外部类的实例方法。
  ·静态内部类看做外部类的一个静态成员。因此，外部类的方法中可以通过：静态内部类.名字访问静态内部类的静态成员。通过new静态内部类() 访问静态内部类的实例。
  3.在外部类的外面创建静态内部类：
  Face.TestStaticInner aInner = new Face.TestStaticInner();
- 匿名内部类
  适合那种只需要使用一次的类。比如：键监听操作等等。语法：
  new 父类构造器(实参类表) 实现接口(){
  //匿名内部类类体
  }
- 局部内部类
  定义在方法内部。作用域只限于本方法。

eg:创建子类对象

方法一

import demo0711.Face.Nose;

public class Outer {
	public static void main(String[] args) {
		Face f = new Face();
		Nose n = f.new Nose();
	}
}

class Face{
	int type;
	
	class Nose{
		String type;
		
		void breath(){
			System.out.println("呼吸");
		}
	}
}

方法二

public class Outer {
	public static void main(String[] args) {
		Face f = new Face();
		Face.Nose n = f.new Nose();
	}
}

class Face{
	int type;
	
	class Nose{
		String type;
		
		void breath(){
			System.out.println("呼吸");
		}
	}
}

在内部类中调用外部类的属性：

public class Outer {
	public static void main(String[] args) {
		Face f = new Face();
		Face.Nose n = f.new Nose();
		n.breath();
	}
}

class Face{
	int type = 3;
	
	class Nose{
		int type = 2;
		
		void breath(){
			System.out.println(Face.this.type);
		}
	}
}

当内部类与外部类变量不重名，调用只用type