java基础(接口)

1：接口定义
接口是抽象方法的集合。

接口声明格式：接口继承接口

修饰符 interface 接口名称 [extends 其他接口名称] {
	//声明成员变量(只能是常量)
	//声明抽象方法
}

接口继承：

public interface MyInterface {
	public abstract void methodA();//接口中的抽象方法
	void methodB();//public abstract可以省略
}

2：接口的使用
接口不能直接使用，必须有一个接口实现类实现接口。
实现类要实现接口中所有的抽象方法。否则必须也是抽象类。

实现一个接口的格式：类实现接口

public class 实现类名称 implements 接口名称[, 其他接口名称, 其他接口名称..., ...]{}

接口的实现类必须覆盖接口的所有抽象方法
创建实现类对象，使用方法

public interface MyInterface {
	public abstract void methodA();//接口中的抽象方法
	void methodB();//public abstract可以省略
}
public class MyInterfaceIpm implements MyInterface{
	@Override
	public void methodA() {//实现类实现接口中所有的抽象方法。
		System.out.println("这是方法一");
	}
	@Override
	public void methodB() {
		System.out.println("这是方法二");
	}
}
public class InterTest {
	public static void main(String[] args) {
		//实例实现接口的类的对象
		MyInterfaceIpm ipm = new MyInterfaceIpm();
		ipm.methodA();
		ipm.methodB();
	}
}
//这是方法一
//这是方法二

3：java8开始，接口可以定义默认方法，解决升级问题。
接口中有以前定义的抽象方法，现在又添加了方法，接口的实现类要实现新增加的方法，实现接口抽象方法的类不能一个个都变，因此可以在接口中增加默认方法，这样实现接口的实现类都默认实现了新增加的默认方法。

public interface MyInterface {
	public abstract void methodA();//接口中的抽象方法
	void methodB();//public abstract 可以省略
	public default void methodC() {
		System.out.println("这里是默认方法");
		//在接口中默认又添加了一个方法，为了不变动所有实现它的类，可声明为默认方法。
	}
}
public class MyInterfaceA implements MyInterface{
	@Override
	public void methodA() {//实现类实现接口中所有的抽象方法。
		System.out.println("这是方法一");
	}
	@Override
	public void methodB() {
		System.out.println("这是方法二");
	}
}//这个类默认实现了接口中的默认方法
public class InterTest {
	public static void main(String[] args) {
		//实例实现接口的类的对象
		MyInterfaceA a = new MyInterfaceA();
		a.methodC();
		
		MyInterface b = new MyInterfaceA();//多态
	}
}
//这里是默认方法

4：接口可以定义静态方法。
不能使用接口实现类对象调用接口中的静态方法，必须使用接口名称调用接口的静态方法。

public interface MyInterface {
	public abstract void methodA();//接口中的抽象方法
	void methodB();//public abstract 可以省略
	public default void methodC() {
		System.out.println("这里是默认方法");
		//在接口中默认又添加了一个方法，为了不变动所有实现它的类，可声明为默认方法。
	}
	public static void methodD() {
		System.out.println("这里是静态方法");
	}
}
public class MyInterfaceA implements MyInterface{
	@Override
	public void methodA() {
		System.out.println("这是方法一");
	}
	@Override
	public void methodB() {
		System.out.println("这是方法二");
	}
}
public class InterTest {
	public static void main(String[] args) {
		//实例实现接口的类的对象
		MyInterfaceA ipm = new MyInterfaceA ();
		ipm.methodA();
		ipm.methodB();
		ipm.methodC();//实现类可以直接调用接口的默认方法
		//ipm.methodD();不使用接口实现类对象调用接口的静态方法，使用接口接口实现类名称调用。
		MyInterface.methodD();
		//因为一个实现类类可以实现多个接口，如果使用实现类对象调用接口的静态方法，就不知道调用的是哪个接口的静态方法，如果两个接口都有这个静态方法，所有直接用接口名.方法名不易产生冲突。
	}
}

5：java9开始，接口中可以有私有方法，只供接口内方法访问。
也可以在接口中声明静态私有方法。接口内静态方法用到了共有的静态方法，解决接口中代码重复问题。

public interface MyInterface {
	public default void method1{
		System.out.print("这是默认方法1");
		methodCommon();
	};
	public default void method2{
		System.out.print("这是默认方法2");
		methodCommon();
	};
	private void methodCommon() {
		System.out.print("AAA");//私有方法
	}
};
public class MyInterfaceA implement MyInterface {
	//接口中没有抽象方法，所以没有必要进行覆盖
};
public class Demo {
	public static void main (String[] args) {
	MyInterfaceA myI = new MyInterfaceA();
		myI.method1();
		myI.method2();
		//可以访问默认方法，不能访问到私有方法。
	}
}

public interface MyInterface {
	public static void method1{
		System.out.print("这是静态方法1");
		methodCommon();
	};
	public Static void method2{
		System.out.print("这是静态方法2");
		methodCommon();
	};
	private static void methodCommon() {
		System.out.print("AAA");//私有静态方法，接口中多个方法自己使用的。
	}
};

6：接口的继承
接口的继承使用extends关键字，子接口继承父接口的抽象方法。
接口中都是抽象方法，这里省略了abstract。

// 文件名: Sports.java
public interface Sports
{
   public void A(String name);
   public void B(String name);
}
 
// 文件名: Football.java
public interface Football extends Sports
{
   public void C(int points);
   public void D(int points);
   public void E(int quarter);
}

Football接口有5个类。
实现Football接口的类需要实现5个抽象方法，其中两个来自于Sports接口。

7：接口的多继承:

public interface Hockey extends Sports, Event

8：接口中的常量

• 接口中的常量，可以省略public static final。
• 接口中的常量，必须进行赋值。
• 接口中的常量必须完全使用大写字母和下划线组成。
• 访问的时候通过：接口名称.常量名访问。

9：接口中其他注意事项
如果实现类实现的多个接口中，存在重复的抽象方法，覆盖重写这个方法。
如果实现类没有覆盖重写接口中所有抽象方法，那么该类一定是抽象类。
如果实现类实现的多个接口中，存在重复的默认方法，一定要覆盖重写该方法。
一个类的父类如果跟实现的接口的默认方法产生冲突 ,优先父类。