Java：接口

一、接口的概念

“接口“在生活中并不陌生，比如插座接口，设备接口，USB接口…不管是什么样的接口，都是一个公共规范。Java中的’‘接口’‘是一个很抽象（abstract）的概念，它是多个类的公共规范，也就像是电脑充电器插头和手机充电器插头都能使用一个接口一样，它们都有共同的规范标准。在Java中，接口是一种引用数据类型，在接口中，最重要的是抽象方法。接口和实现类之间有一种继承的关系。
1、接口的定义格式：

public interface 接口名称{
			接口常量；
			抽象方法；
			默认方法；
			静态方法；
			.......
}

抽象方法的定义格式：

public abstract 返回值类型 方法名();

public:公共的；abstract：抽象的

在接口中，public可以省略

abstract 返回值类型 方法名();

abstract可以省略

public 返回值类型 方法名();

public 和 abstract 都可以省略

返回值类型 方法名();

抽象方法是没有方法体的，需要实现类去重写抽象方法。

2、接口中的默认方法：
因为在接口中的所有的抽象方法都要被重写，那么默认方法的作用是不用必须被重写（可以被重写）的方法，可以直接实现类调用。
定义格式：

public default 返回值类型 方法名(){
			方法体;
	}

default：默认的

3、接口中的静态方法
静态方法可以直接被接口调用。
定义格式：

public static 返回值类型 方法名{
				方法体；
	}

调用格式：

接口名.静态方法名;

4、Java JDK9以上的接口特性
①可以有私有的默认方法和静态方法，是为了解决多个默认方法或者多个静态方法之间的代码冗余的问题
②可以定义常量
私有的默认方法：
私有方法无法被继承。
私有默认方法的定义格式：

private 返回值类型 方法名(){
		方法体;
	}

应用场景：

//普通私有方法
	private void privateMethod() {
		System.out.println("AAA");
		System.out.println("BBB");
		System.out.println("CCC");
		System.out.println("DDD");
	}
	public default void methodDefault1(){
		System.out.println("这是一个使用普通私有方法的默认方法");
		privateMethod();
	}
	public default void methodDefault2(){
		System.out.println("这是一个接口中使用普通私有方法的默认方法");
		privateMethod();
	}

分析：privateMethod 是一个私有的默认方法，methodDefault1和methodDefault2 是普通的默认方法。methodDefault1和methodDefault2调用privateMethod之后，会分别执行privateMethod方法体中的语句。也就是说，在普通默认方法中不用写多个私有默认方法中的语句，直接调用即可。

私有静态方法也是如此：

//静态私有方法
	private static void staticPrivateMethod() {
		System.out.println("AAA");
		System.out.println("BBB");
		System.out.println("CCC");
		System.out.println("DDD");
	}
	public static void staticMethod1() {
		System.out.println("这是一个接口中使用私有静态方法的静态方法");
		staticPrivateMethod();
	}
	public static void staticMethod2() {
		System.out.println("这是一个接口中的静态方法");
		staticPrivateMethod();
	}

接口常量：
定义格式：

public static final 数据类型 常量名 = 数值;

常量名的命名规范:由大写字母组成，多个单词之间用”_“进行连接。
接口常量可直接用接口名进行调用。
调用格式:

接口名.常量名;

final关键字：
final:最终的
使用场景：
①修饰类：表示该类不能被继承

class fianl Student{

	}

②修饰方法：表示该方法不能被重写

权限修饰符 final 返回值类型 方法名(){

	}

③修饰变量：表示该变量的字面值不能被修改，并且必须手动赋值。

final 数据类型 变量名 = 数值；

final关键字不能修饰接口，因为接口必须被继承才有意义。

二、接口的实现

接口不能被实例化，不能用接口来创建对象，必须要有实现类来实现这个接口。

public class 实现类名称 implements 接口名称{
	}

实现类实现这个接口，就必须重写接口中的所有抽象方法，落下一个抽象方法都会报错。
例如：

//接口类
public interface MyInterface{
	//定义两个抽象方法：
	public abstract void abstractMethod1();
	public abstract void abstractMethod2();
}
//实现类
public class Realize implements MyInterface{
	//重写MyInterface接口中的两个抽象方法
		public abstract void abstractMethod1(){
				方法体;
		}
	public abstract void abstractMethod2(){
				方法体;
		}
	}

三、接口的案例

模拟发红包案例：
分析：需要有四个类：用户类（User），群主类（Manager），成员类（Members）和测试类（Demo）。User是Manager和Members的父类，包含着两个子类共有的
属性和方法。
群主负责发红包，发红包时要考虑到钱包余额、红包总额和分发红包数量。
成员负责收红包，收红包只管收红包就好了，收到的红包纳入钱包即可。

实现：
用户类：

public class User {
	private String name;//用户名
	private int money;//钱包余额
	
	public User() {
		//空参构造器
	}

	public User(String name, int money) {
	//有参构造器，给成员变量赋值
		this.name = name;
		this.money = money;
	}
	
	public void show() {
	//查看用户名和其对应的钱包余额
	System.out.println("用户名：" + name +" " + "余额为：" + money);
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public int getMoney() {
		return money;
	}

	public void setMoney(int money) {
		this.money = money;
	}	
}

群主类：

import java.util.ArrayList;//导入数组集合包
//群主发红包
public class Manager extends User {
	public Manager() {
		
	}
	public Manager(String name, int money) {
		super(name, money);
		// TODO 自动生成的构造函数存根
	}
	
	//totalMoney:红包总额
	public ArrayList<Integer> send(int totalMoney,int count){
		//用一个集合来存储若干个红包的金额
		ArrayList<Integer> redList = new ArrayList<Integer>();
		//群主余额
		int leftMoney = super.getMoney();
		if(totalMoney > leftMoney) {
			System.out.println("余额不足");
			return redList;//返回空集合
		}
		
		//扣钱，重新设置余额
		super.setMoney(leftMoney - totalMoney);
		
		//发红包,平均分成count份
		 int avg = totalMoney / count;
		 //考虑余数
		 int mod = totalMoney % count;//剩下的零头。把余数放于最后一份红包中
		 
		 //把红包放入集合中
		 for (int i = 0; i < count - 1; i++) {
			 redList.add(avg);
		}
		
		int last = avg + mod;//最后一个红包的金额
		redList.add(last);
		return redList;
	}
}

成员类：

import java.util.ArrayList;
import java.util.Random;

//普通成员
public class Members extends User {
	public Members() {
		
	}
	public Members(String name, int money) {
		super(name, money);
		// TODO 自动生成的构造函数存根
	}
	
	public void receive(ArrayList<Integer> list) {
		//从多个红包中随机抽取一个给一个成员
		//生成随即对象，范围时list的最大容量
		int index = new Random().nextInt(list.size());
		//根据索引，从集合中删除，并且得到被删除的红包给成员
		int delta = list.remove(index);
		//获取成员原来余额
		int money = super.getMoney();
		super.setMoney(money + delta);
	}
}

测试类：

import java.util.ArrayList;

public class Demo {
	public static void main(String[] args) {
		Manager manager = new Manager("群主",100);
		Members one = new Members("成员",0);
		Members two = new Members("成员",0);
		Members three = new Members("成员",0);
		
		manager.show();
		one.show();
		two.show();
		three.show();
		System.out.println("*******************************");
		
		//群主总共发20元，分成3份
		ArrayList<Integer> redList = manager.send(20, 3);
		
		//三个普通成员的红包
		one.receive(redList);
		two.receive(redList);
		three.receive(redList);
		
		manager.show();
		one.show();
		two.show();
		three.show();
		
	}
}