interface接口的使用与理解，以及使用接口实现简单的设计方法（代理默认）后续会添加单例模式，常用的懒汉，饿汉默认

interface使用（eclipse）

什么是interface

接口的用途是用来定义现实世界不同类型事物的共同行为特征。

interface里的变量

因为eclipse的功能强大，我们很多时候都借助于eclipse的提示莫名其妙的将我们本以为编译错误的代码行显示编译正确
举个例子好了，让我们来输入变量

interface A{
	public static final int a=0;
	public int b=0;
	public static int c=0;
	int d = 0;
}
public class Test implements A{
	public static void main(String[] args) {
		Test eTest = new Test();
		d=d+1;
		//The final field A.d cannot be assigned这个注释显示的是d=d+1编译错误的原因，被final修饰的变量不允许被改变
		System.out.println(d);
		}
}

我们一次用public static final ，public static修饰变量
甚至到最后我连public都省略了直接写int d = 0；
因为编译器会自动帮我们添加这些修饰语句，所以我们可以忽略冗长的修饰前缀，偷下懒啦
在d=d+1里证明了final修饰的变量不可以被改变，可以简单的理解为完美格式，完美不需要改变

interface里的方法

interface Test{

public abstract void a();
	void b();
}

接口里的方法与变量一样，同样可以省略public和abstract两个关键词
编译器都会为我们做好添加修饰符的事情，因为接口里面的方法总是被public，abstract修饰，不会有什么例外
因为接口里面的方法都是抽象的，我们可以理解为
接口里面的方法是未完成，类似于有人信仰的神之类的，所以，既然是抽象的，模糊不清的，那么我们就不需要动他
若是有子类也想要解释他，就把这个方法推给子类就好了

interface的实现

interface的实现使用关键字implements完成的
例

interface A {
	public abstract void menu();
	public abstract void mm1();
}
public class Test implements A{
	public void menu(){
		System.out.println("实现接口的方法");
	}


	public static void main(String[] args) {
		Test eTest = new Test();
		eTest.menu();
	}

}

这里类Test就实现了接口A,并且实现里面的menu的方法
注意
若这个Test类没有能够实现所有的A接口里面的抽象方法，如图，也就是mm1方法没有处理
那么这个Test类就被认为是抽象方法

interface的继承

interface A{
	void t();
}
interface B{}
interface C{}
interface D extends A,B,C{}

如上所示
接口是可以继承其他接口的，也可以继承其他接口的抽象方法和变量
实现接口的类可以直接调用这个接口继承的接口里的抽象方法
很复杂吧，简单的来说
一个test类实现了D接口，因为D接口继承了A接口的关系，test类的可以直接实现A接口里的t()方法

interface日常使用注意

interface接口是无法实例化的，为了证明这句话的准确性，我们来尝试创建一个interface的对象

interface A {
	public A() {
		//Interfaces cannot have constructors
		//上一行注释显示的是编译器给出错误的原因，interface里面是不存在构造器的
		//那么我们创建对象调用无参构造方法的时候也就自然会出错了
	}
}
public class Test implements A{
	public static void main(String[] args) {
		A a =new A();//这里是错误的，原因看上面
	}

}

排错

interface A {
	int x = 0;
}

class B {
	int x = 1;
}

class C extends B implements A {
	public void pX() {
		System.out.println(x);//这里会出现编译错误，原因是因为编译器不知道我们要输出的x是继承的还是实现的
							  //我们可以用super.x表示父类的x，但是接口的就没有办法了，谁让人家是static final修饰的变量呢
		//System.out.println(super.x);
	}

	public static void main(String[] args) {
		new C().pX();
	}
}

代理模式

代理模式会用到接口，我就用几个通俗易懂的类来介绍一下这个使用接口的代理方法吧。大家记得要指导接口在这里的作用是什么

interface Heroer {	//我们定义一个类，是英雄
	//英雄能干什么呢，下面是模糊不清的方法，因为我们不知道什么东西可以执行这些英雄的方法
	public abstract void in();//进入召唤师峡谷
	public abstract void fight();//和其他英雄战斗
	public abstract void died();//英雄死了
}

class Caller implements Heroer{	//好了，英雄有了，那个谁来控制他们呢，当然是召唤师
	private Heroer hero;
	public Caller() {
		this.hero=new Yasuo();//默认情况下我们当然是要玩亚索，当然你也可以定义流浪法师，这里可以默认传入英雄的参数，有主函数创建对象时来传递
	}
	public Caller(Heroer hero) {
		this.hero=hero;//好了这种情况下，有谁玩谁把
	}
	public void in() {
		this.hero.in();//我怎么可能会英雄的技能，所以我只需要告诉他们,让他们去做这些动作
	}
	public void fight() {//我让英雄去打架，如果是我自己的话分分钟被搞死
		this.hero.fight();
	}
	public void died() {
		this.hero.died();//还是引用，毕竟英雄死了我也不会死，再说我坑队友怎么可能，那是网卡
	}
}

class Yasuo implements Heroer{	//我们要第一个准确的英雄，否则谁也不知道是哪个英雄出现在我们的视野，这里我们定义亚索
	public void in() {
		System.out.println("亚索已进入召唤师峡谷");
	}
	public void fight() {
		System.out.println("海塞给,亚索再战斗，他很快乐");
	}
	public void died() {
		System.out.println("树叶的一生，难道只是为了归根么");
	}	
}

class Liulang implements Heroer{//因为英雄列表里面有流浪法师，我们可以吧流浪法师看做英雄，反过来就不可以了，这里想不想父类与子类的关系
	public void in() {
		System.out.println("流浪法师进入召唤师峡谷");
	}
	public void fight() {
		System.out.println("流浪法师已经超神了！");
	}
	public void died() {
		System.out.println("我曾见证王国覆灭，终归无闻");
	}	//我们现在又定义了一名英雄：流浪法师
}

public class Computer {
	public static void main(String[] args) {
		//ok，我们来开始玩游戏吧
		//我们先来打开英雄列表,注意，是我打开，不是电脑打开
		Caller call = new Caller();
		call.in();
		call.fight();
		call.died();
		//好了，这样就由我们完成了这些动作，因为这个召唤师这个代理的存在，使我们更加方便
	}
}

代理模式代表的是一种解题思路，就好像你通过房东去认识房子一样，因为大家不了解房子，但房东了解，于是由他来代替我们去完成了解房子的这个方法，我们只需要确定好这个方法付钱就可以了
当然了，直接上门去看房的狼人当我没说过