Java后端_12

接口的使用

引入：Java的类不支持多继承，有了接口，就可以实现多继承的效果
接口是一种规范，定义了一组规则，接口的本质是契约，大家都要遵守。继承是一个”是不是“的关系（学生是人，学生子类，人是父类），接口实现的是”能不能“的关系（飞机能飞，风筝能飞，子弹能飞，则”飞“这个功能可以定义为接口）

一、接口使用interface来定义

二、Java中，接口和类是并列的两个结构

三、如何定义接口：定义接口中的成员

1.JDK7及以前：只能定义全局常量和抽象方法
全局常量：public static final…，但是书写时可以不写
抽象方法：public abstract…
如

interface Flyable{
	//全局常量
	public static final int MAX_SPEED = 7900;
	int MIN_SPEED = 1;//省略了public static final，但是还有
	
	//抽象方法
	public abstract void fly();
	void stop();//省略public abstract，但是还有
}

2.JDK8：除了定义全局常量和抽象方法，还可以定义静态方法、默认方法（声明方法前加一个default：public default void 方法名{方法体}）

public interface BaseInterface {
	public static void method1() {//public可以省略
		System.out.println("接口中的静态方法");
	}
	public default void method2() {
		System.out.println("接口中的默认方法");
	}
	default void method3() {
		System.out.println("接口");
	}
}

public class BaseClass {
	public void method3() {
		System.out.println("父类");
	}
}

class SubClass extends BaseClass implements BaseInterface {
	public void method2() {
		System.out.println("实现类重写接口中的默认方法");
	}
}

public class SubClassTest {
	public static void main(String[] args) {
		SubClass s = new SubClass();
		//实现类的对象可以调用接口中定义的默认方法
		//实现类可以重写接口中的默认方法但是要把default去掉。重写之后，实现类调用的就是实现类重写之后的方法
		s.method2();
		
		//接口中定义的静态方法，只能通过接口来调用
		BaseInterface.method1();
		
		//若干子类（实现类）继承的父类和实现的接口中声明了同名同参数的方法，那么子类在没有重写此方法的情况下
		//默认调用的是父类的方法--->称为类优先原则
		//但是如果是父类和接口有同名的属性，而子类没有声明这个同名的属性，则调用这个属性时不知道调用哪个，会出错
		s.method3();
	}
}

输出：

class SubClass implements BaseInterface,BaseInterface2 {
	public void method2() {
		System.out.println("实现类重写的中的默认方法");
	}
}
//如果实现类实现了多个接口，而这多个接口中定义了同名同参的方法，若实现类没有重写这个同名同参的方法，
//则编译器不知道调用哪个接口的方法，所以报错---->接口冲突
//为了避免接口冲突，要重写这个方法
s.method3();

class SubClass extends BaseClass implements BaseInterface,BaseInterface2 {
	public void method2() {
		System.out.println("实现类重写的中的默认方法");
	}
	@Override
	public void method3() {
		System.out.println("重写");
	}
	
	public void myMethod() {
		method3();//调用子类自己定义的method3方法
		super.method3();//调用父类定义的method3方法
		//可以通过"接口.super.方法"来调用接口的method3方法
		BaseInterface.super.method3();
	}
}

Java8之后，抽象方法没有方法体，但是默认方法和静态方法是有方法体的
一般接口中的抽象方法才让实现类去重写，默认方法和静态方法都是定义好让直接去调的，不用重写

四、接口中不能定义构造器，意味着接口不能实例化

五、开发中，接口都通过让类去实现（implements）的方式来使用：类实现接口

如果实现类覆盖了（重写）接口中的所有的抽象方法，则此实现类可以实例化
如果实现类没有覆盖接口中的所有的抽象方法，则此实现类仍是一个抽象类

class Plane implements Flyable{//类实现接口
	@Override
	public void fly() {
		System.out.println("通过发动机飞");
	}

	@Override
	public void stop() {
		System.out.println("驾驶员可以让其减速");
	}
}
Plane p = new Plane();
p.fly();

六、Java类可以实现多个接口，弥补了Java单继承性的局限性

格式：class A extends B implements C, D, E{};
如：

interface Attactable{
	void attact();
}
class Bullet extends Object implements Flyable,Attactable{
	@Override
	public void attact() {}
	@Override
	public void fly() {}
	@Override
	public void stop() {}
}

七、类与类之间是继承，类与接口之间是实现，接口与接口之间可以继承，而且可以多继承

interface A extends Flyable,Attactable{
	
}

八、接口的具体使用，体现多态性（因为接口不能实例化，只能通过实现类来实现，所以发生多态）

九、接口是一种规范（所以要面向接口编程）

匿名实现类

interface USB{}
class Flash implements USB{}
class Computer {
	public void transferData(USB usb) {
		usb.start();
		usb.stop();
	}
}
public class USBTest {
	public static void main(String[] args) {
		Computer computer = new Computer();
		//1.创建接口的非匿名实现类的非匿名对象
		Flash flash = new Flash();
		computer.transferData(flash);
		
		//2.创建接口的非匿名实现类的匿名对象
		computer.transferData(new Flash());
		
		//3.创建接口的匿名实现类的非匿名对象
		USB phone = new USB() {
			@Override
			public void stop() {
				System.out.println("手机开始工作");
			}
			@Override
			public void start() {
				System.out.println("手机结束工作");
			}
		};
		computer.transferData(phone);
		
		//4.创建接口的匿名实现类的匿名对象
		computer.transferData(new USB() {
			@Override
			public void start() {
				System.out.println("MP3开始工作");
			}
			@Override
			public void stop() {
				System.out.println("MP3结束工作");
			}
		});
	}
}

代理模式：

被代理类想访问一个接口，找到代理类，用代理类连接接口，然后把被代理类传入代理类中即可实现代理模式。
应用场景：安全代理、远程代理、延迟代理
分类：静态代理，动态代理

工厂设计模式：

实现创建者和调用者分离，即将创建对象和调用对象的过程屏蔽隔离起来，达到提高灵活性的目的
分类：工厂方法模式，抽象工厂模式

内部类

引入：一个类的内部还需要一个完整的结构来描述（属性和方法不足以描述）的时候，可以用内部类，比如：

一、Java中允许将一个类A声明在另一个类B中，则类A就是内部类，类B称为外部类

二、内部类分类：成员内部类（类内，同时在方法外，代码块外，构造器外），局部内部类（方法内，代码块内，构造器内）

public class WaiBuLei {
	int age;
	WaiBuLei() {
		class jiubu1{}//局部内部类
	}
	{
		class jiubu2{}//局部内部类
	}
	void fangfa() {
		class jiubu3{}//局部内部类
	}
	static class chengyuan1{}//静态成员内部类
	class chengyuan2{//非静态成员内部类
		int age;
		void test1(int age) {
			System.out.println(age);//方法的形参
			System.out.println(this.age);//内部类的属性
			System.out.println(WaiBuLei.this.age);//外部类的属性
		}
	}
}

三、成员内部类：

1.作为外部类的成员，

1）可以调用外部类的结构
2）可以被static修饰，这和外部类是不一样的
3）可以用private、protected等四种权限修饰，这和外部类是不一样的

2.作为一个类，

1）类内可以声明属性、方法、构造器等
2）可以用final修饰，表示此类不能被继承
3）可以被abstract修饰

四、有关内部类的3个小问题

1.如何实例化内部类的对象

//实例化静态内部类
WaiBuLei.chengyuan1 c1 = new WaiBuLei.chengyuan1();

//实例化非静态内部类:先实例化外部类，再实例化内部类
WaiBuLei w = new WaiBuLei();
WaiBuLei.chengyuan2 c2 = w.new chengyuan2();

2.如何在成员内部类中区分调用外部类的结构

如果没有重名，则可以直接调用，如果有重名：见上

3.开发中局部内部类的使用

方式一：

public class InnerClass {
	//返回一个实现Comparable接口的类的对象
	public Comparable getComparable() {
		//创建一个实现Comparable接口的类：局部内部类
		class MyComparable implements Comparable{

			@Override
			public int compareTo(Object o) {
				// TODO Auto-generated method stub
				return 0;
			}
			
		}
		
		return new MyComparable();
	}
}

方式二：

public class InnerClass {
	//返回一个实现Comparable接口的类的对象
	public Comparable getComparable() {
		//使用匿名实现类的匿名对象
		return new Comparable() {

			@Override
			public int compareTo(Object o) {
				// TODO Auto-generated method stub
				return 0;
			}
		};
	}
}