二十.接口的定义和使用

接口概念

java中的接口就像是一个蓝图，里面定义的都是不可改全局常量和公共的抽象方法，因为在接口中定义属性会默认加上static、final关键字，而方法会加上abstract。
为什么说接口像一个蓝图，因为接口定义的方法都是没有方法体的只有方法的特征，因此这些方法在不同的地方可以被不同类给实现。

接口基本定义

定义接口关键字：interface

interface CeShi {		//测试接口
	public static final String name = "2121";		//常量
	public abstract String get();					//声明方法，没有方法体
}

简化

interface CeShi {		//测试接口
	 String name = "2121";		//常量
	 String get();					//声明方法，没有方法体
}

接口里的属性和方法会默认加上修饰符，所以上面两个代码效果是一样的

• 属性：public static final
• 方法：public abstract

创建子类继承接口来实现方法

interface CeShi {		//测试接口
	
	public static final String name = "2121";		//常量
		
	public abstract String get();					//声明方法，没有方法体
	
	void show();
}

interface CeShi1{
	
}


class CeShiClass implements CeShi，CeShi1{

	public String get() {
		// TODO Auto-generated method stub
		return "小红";
	}

	public void show() {
		// TODO Auto-generated method stub
		
	}
}

class Test2{
	public static void main(String[] args) {
		CeShiClass ceShiClass = new CeShiClass();
		System.out.println(ceShiClass.get());		//小红
	}
}

子类继承接口必须实现全部方法不然会报错
类可以继承多个接口，这样可以弥补java的多继承，因为在java中类与类之间只能单继承或者多层继承，不能多继承。

接口定义加强

在接口定义公开方法实现，比如有很多子类继承了接口那么接口就要给这些方法定义一个公开的具体实现方法。

有两种方法可以做到

• 使用default可以在接口内定义普通方法
• 使用static定义一个公开的静态方法

interface CeShi {		//测试接口
	
	/**
	 * 用default修饰的
	 */
	public default void show(){
		System.out.println("你好");
	} 
	
	/**
	 * 静态方法
	 * @return
	 */
	public static CeShiClass sb(){
		return new CeShiClass();
	}

}

class CeShiClass implements CeShi{

}

class Test2{
	public static void main(String[] args) {
		CeShiClass ceShiClass = CeShi.sb();	
		ceShiClass.show();
	}
}

使用接口定义标准

在我们平常生活中也有着许多和接口一样的对象，比如usb接口，它可以连接键盘、鼠标、U盘等…接下来给大家演示一下

interface CeShi {		//测试接口
	
	public boolean getBool();	//是否使用

	public void show();			//动作
}
//键盘
class CeShiClass1 implements CeShi{

	@Override
	public boolean getBool() {
		// TODO Auto-generated method stub
		return true;
	}

	@Override
	public void show() {
		System.out.println("正在使用键盘");
	}

}
//鼠标
class CeShiClass2 implements CeShi{

	@Override
	public boolean getBool() {
		// TODO Auto-generated method stub
		return true;
	}

	@Override
	public void show() {
		System.out.println("正在使用鼠标");
	}
	
}

class CeShiTest{
	public void show(CeShi shi){
		if (shi.getBool()) {
			shi.show();
		}
	}
}

class Test2{
	public static void main(String[] args) {
		CeShiTest ceShiTest = new CeShiTest();
		ceShiTest.show(new CeShiClass1());
		ceShiTest.show(new CeShiClass2());
	}
}

输出结果

正在使用键盘
正在使用鼠标

我的命名规范都是很随意，因为都是写一些简单测试的代码，如果大家是在公司打码的话千万不要学我。

抽象类和接口的区别

• 抽象类可以有构造方法，接口中不能有构造方法。
• 抽象类中可以有普通成员变量，接口中没有普通成员变量
• 抽象类中可以包含非抽象的普通方法，接口中的所有方法必须都是抽象的，不能有非抽象的普通方法。
• 抽象类中的抽象方法的访问类型可以是public，protected和默认类型，但接口中的抽象方法只能是public类型的，并且默认即为public abstract类型。
• 抽象类和接口中都可以包含静态成员变量，抽象类中的静态成员变量的访问类型可以任意，但接口中定义的变量只能是public static final类型，并且默认即为public static final类型。
• 一个类可以实现多个接口，但只能继承一个抽象类。
• 抽象类定义类是有class的，而接口是没有class而是用interface。

工厂设计模式

什么是工厂模式？比如我有一间做车的工厂，当我要做一辆玛莎拉蒂直接跟工厂说一声就可以了，不用去管这个车子是在哪里做的。

优点：方便易扩展，只需要知道继承接口的子类名称就行了，不需要去了解创建过程，把关注点放到接口上就行了。

缺点：如每次添加一个子类都要手动去给它加一条new对象。

主要就是方便接口接口选择子类问题

//车接口
interface Small{
	public void show();
}

class Maserati implements Small{

	@Override
	public void show() {
		System.out.println("玛莎拉蒂");
	}
}

class Benz implements Small{

	@Override
	public void show() {
		System.out.println("奔驰");
	}
}

//工厂类
class Plant{
	public Small set(String name){
		if (name.equals("Maserati")) {
			return new Maserati();
		}else if(name.equals("Benz")){
			return new Benz();
		}
		return null;
	}
}

class Test3 {
	public static void main(String[] args) {
		Plant plant = new Plant();
		Small small1 = plant.set("Benz");
		small1.show();
		
		Small small2 = plant.set("Maserati");
		small2.show();
	}
}

结果

奔驰
玛拉莎蒂

代理设计模式

代理模式，就是由一个类去代理另外一个类去实现它的功能。
就比如我们生活中有某个公司的商品要卖，然后公司可以把这个商品交给其他人或者平台去卖。平台抽象了公司代卖。

优点：职责明确每个类负责自己的任务，智能化，扩展性高

缺点：由于在客户端和真实主题之间增加了代理对象，因此有些类型的代理模式可能会造成请求的处理速度变慢。

interface Small{
	public void show();
}

class Maserati implements Small{
	
	private String name;
	
	public Maserati(String name) {
		this.name = name;
		loadShow(name);
	}

	@Override
	public void show() {
		System.out.println("玛莎拉蒂show："+name);
	}
	
	private void loadShow(String name){
		System.out.println("玛莎拉蒂loadShow："+name);
	}

}

//代理类
class Benz implements Small{
	
	private Maserati maserati;
	private String name;
	
	public Benz(String name) {
		this.name = name;
	}

	@Override
	public void show() {
		if (maserati == null) {
			maserati = new Maserati(name);
		}
		maserati.show();
	}
}


class Test3 {
	public static void main(String[] args) {
		Small s = new Benz("限量版");
		s.show();
		System.out.println();
		s.show();
	}
}

结果

玛莎拉蒂loadShow：限量版
玛莎拉蒂show：限量版

玛莎拉蒂show：限量版

实例化对象一次就行了