老王学JAVA七周第二天

接口的默认方法定义：

从JAVA 8开始，接口里允许定义默认方法。
格式：
public default 返回值类型 方法名称（参数列表）{
方法体
}

备注：接口当中的默认方法，可以解决接口升级的问题。
还有今后学函数表达式 拼接等

public interface MyInterfaceDefault {

	
	//抽象方法
	public abstract void methodAbs();
	
	//新添加了一个抽象方法
//	public abstract void methodAbs2();
	
	// 新添加的方法，改成默认方法：
	public default void methodDefault(){
		System.out.println("这是新添加的默认方法");
	}
}

ublic class MyInterfaceDefaultA implements MyInterfaceDefault{

	@Override
	public void methodABS(){
		System.out.println("实现了抽象方法：AAA");
	}
}

public class MyInterfaceDefauitB implements MyInterfaceDefault{
	@Override
	public void methodABS(){
		System.out.println("实现了抽象方法：BBB");
	}
	
	@Override
	public default void methodDefault(){
		System.out.println("实现类B覆盖重写了接口的默认方法");
	}
}

接口的默认方法使用

1,接口的默认方法，可以通过接口实现类对象，直接调用。
2，接口的默认方法，也可以被接口实现类进行覆盖重写。

public class Demo02Interface {

	public static void main(String[] args){
		//默认方法会别你的实现类继承下去的
		//创建了实现类对象
		MyInterfaceDefaultA a = new MyInterfaceDefaultA();
		
		a.methodAbs();//调用抽象方法，实际运行的是右测的实现类（在继承关系或者实现关系new的是谁，运行的就是谁）
		
		
		
		//调用默认方法，如果实现类当中没有，会向上找接口的
		a.methodDefault();//这是新添加的默认方法
		System.out.println("======");
		
		
		MyInterfaceDefaultB b = new MyInterfaceDefaultB();
		b.methodAbs();
		b.methodDefault()://实现类B覆盖重写了接口的默认方法
		
	}
}

接口的静态方法使用

从java 8开始，接口当中允许定义静态方法。
格式：
public static 返回值类型 方法名称(参数列表){
方法体
}
提示：就是将abstract或者default换成static即可，带上方法体。

public interface  MyInterfaceStatic {
	
	public static void methodStatic(){
		System.out.println("这是接口的静态方法！");
	}
	

}

注意事项： 不能通过接口实现类的对象来调用接口当中的静态方法

正确用法：通过接口名称，直接调用其中的静态方法。
格式：
接口名称.静态方法名(参数)；

public class Demo03Interface {
	
	public static void mian(String[]args){
		//创建类类实现类对象
		MyInterfaceStaticImpl impl = new MyInterfaceStaticImpl();
		
		
		//错误写法。。
//		impl.methodStatic();
		
		//直接通过接口名称调用静态方法
		MyInterfaceStatic.methodStatic();
		
	}

}

实现类

public class MyInterfaceStaticImpl implements MyInterfaceStatic {

}

接口的私有方法使用
问题描述：
我们需要抽取一个公共方法，用来解决两个默认方法之间重复代码的问题。
但是这个共有方法不应该让实现类使用，应该是私有化的。

解决方案：
从java 9开始，接口当中允许定义私有方法。
1，普通私有方法 ： 解决多个默认方法之间重复代码问题
格式 ：
private 返回值类型 方法名称（参数列表）{
方法体
}
2，静态私有方法： 解决多个静态方法之间重复代码问题
格式：
private static 返回值类型 方法名称 （参数列表）{
方法体
}

普通方法

public interface MyInterfacePrivateA {
	public default void methodDefault1(){
		System.out.println("默认方法1");
//		//解决重复代码的问题，那么就调用
//		methodCommon();
	}
	
	public default void methodDefault2(){
		System.out.println("默认方法2");
//		//解决重复代码的问题，那么就调用
//		methodCommon();
	}
	
//	public default void methodCommon(){
	//把methodCommon 改成普通私有方法
	private void methodCommon(){
		System.out.println("AAA");      
		System.out.println("BBB");
		System.out.println("CCC");
		
	}

}

在这里插入代码片public class MyInterfacePrivateAImpl implements MyInterfacePrivateA{
	
	public void methodAnother(){
		//直接访问到了接口中的默认方法，这样是错误的！
//		methodCommon();
	}

}

接口静态方法

public interface MyInterfacePrivateB {
	public static void methodStatic1(){
		System.out.println("静态方法1");
		methodStaticCommon();

    }
	public static void methodStatic2(){
		System.out.println("静态方法1");
		methodStaticCommon();
		
	}
	
//	public static void methodStaticCommon(){
	//把public 换成private就成类静态私有化只有本类用
	private static void methodStaticCommon(){
		System.out.println("AAA");
		System.out.println("BBB");
		System.out.println("CCC");
	}
	
}

public class Demo04Interface {
	
	public static void main(String[]args){
		MyInterfacePrivateB.methodStatic1();
		MyInterfacePrivateB.methodStatic2();
		//错误写法
	//	MyInterfacePrivateB.methodStaticCommon();
	}

}

接口的常量定义和使用

接口当中也可以定义“成员变量”，但是必须使用public static final 三个关键字进行修饰。
从效果上看，这其实就是接口的【常量】 。
格式：
public static final 数据类型 常量名称 = 数据值；
备注：
一旦使用final关键字进行修饰，说明不可改变。

注意事项：
1.接口当中的常量，可以省略public static final, 注意：不写也照样是这样。
2.接口当中的常量，必须进行赋值，不能不赋值。（一旦写上final必须手动赋值）
3,接口中常量的名称，使用完全大写的字母，用下划线进行分割。（推荐命令规则）

public interface MyInterfaceConst {

	//这其实就是一个常量，一旦赋值，不可以修改
	public static final int NUM_OF_MY_CLASS = 12;

	
}

使用的话就直接点它就可以

public class Demo05Interface {
	
	public static void main(String[]args){
		
		//访问接口当中的常量
		System.out.println(MyInterfaceConst.NUM_OF_MY_CLASS);
	}

}

接口的内容小结
在Iava 9+版本中，接口的内容可以有：

1，成员变量其实是常量，（不能发生改变的量）格式：
[public ][static][ final ]数据类型 常量名称 = 数据值;
注意： 常量必须赋值，而且一旦赋值不能改变。
常量名称完全大写，用下划线进行分隔。

2，接口中最重要的就是抽象方法，格式：
[public] [abstract] 返回值类型 方法名称（参数列表）;
注意：实现类必须覆盖重写接口所有的抽象方法，除非实现类是抽象类。

3，从java 8+开始接口里允许定义默认方法，格式：
[public] default 返回值类型 方法名称（参数列表）{方法体}
注意：默认方法也可以被覆盖重写

4，从java 8开始，接口里允许定义静态方法，格式：
[public ]static 返回值类型 方法名称（参数列表）{方法体}
注意：应该通过接口名称进行调用，不能通过实现类对象调用接口静态方法

5，从java 9 开始，接口里允许私有方法，格式：
普通私有方法：private 返回值类型 方法名称（参数列表）{ 方法体 }
静态私有方法：private static 返回值类型 方法名称（参数列表）{ 方法体 }
注意：private 的方法只有接口自己才能调用，不能被实现类或别人使用。

一个类继承父类并实现多个接口：
使用接口的时候，需要注意：
1，接口是没有静态代码块或者构造方法的。
2,一个类的直接父类是唯一的，但是一个类可以同时实现多个接口。
格式：
public class MyInterfaceImpl implements MyInterfaceA, MyInterfaceB{
//覆盖重写所有抽象方法
}
3,如果实现类所实现的多个接口当中，存在重复的抽象方法，那么只需要覆盖重写一次即可。
4，如果实现类，没有覆盖重写所有接口当中的所有抽象方法，那么实现类就必须是一个抽象类。
5，如果实现类所实现的多个接口当中，存在重复的默认方法，那么实现类一定要对冲突的默认方法进行覆盖重写。
6,一个类如果直接父类当中的方法，和接口当中的默认方法产生了冲突，优先用父类当中的方法.

第6点调用

public class Demo01Interface {
	
	public static void main(String[]args){
		Zi zi = new Zi();
		zi.method();
	}
	
	

}

public class MyInterfaceImpl/* extends Object */implements MyInterfaceA, MyInterfaceB{
	
	@Override
	public void methodA(){
		System.out.println("覆盖重写了A方法");
		
	}
	
	@Override
	public void methodB(){
		System.out.println("覆盖重写了B方法");
		
	}
	
	@Override
	public void methodAbs(){
		System.out.println("覆盖重写了AB接口都有的抽象方法");
	}

	
	@Override
	public void methodDefault(){
		System.out.println("对多个接口当中冲突的默认方法进行了覆盖重写");
	}
}

       //在这里添加abstract关键字
public abstract class MyInterfaceAbstract implements MyInterfaceA, MyInterfaceB{

	@Override
	public void methodB() {
		// TODO Auto-generated method stub
		
	}

	@Override
	public void methodA() {
		// TODO Auto-generated method stub
		
	}

//	@Override
//	public void methodAbs() {
		// TODO Auto-generated method stub
		
//	}如果忘记了一个，那么就会报错，那么如果不想管这个抽象方法那么就的是abstract抽象类

	
	@Override
	public void methodDefault(){
		
	}
}

public class Fu {
	public void method(){
		System.out.println("父类方法");
	}

}

public class Zi extends Fu implements MyInterface{
	

}

public interface MyInterface {
	
	public default method(){
		System.out.println("接口的默认方法");
	}

}