1、接口中不能包含普通方法，所有方法均为抽象方法，允许在接口中定义默认方法，默认方法可以提供方法实现
2、接口中不包含构造器和初始化块定义
成员变量（只能是静态常量）总是public static final修饰
方法（只能是抽象实例方法、类方法、或者默认方法），如果不是默认方法或类方法（这俩一定要有方法体），系统自动添加abstract
内部类（内部接口或者枚举）
权限均为public

public interface ex extends 接口1，接口2...{//public可以省略，默认是包内可访问，可以有多个父接口但是不能继承类
常量定义；
抽象方法定义；
内部类、接口、枚举定义；
默认方法或类方法定义；
}
package practice;
import java.util.*;
public interface outPut{
	int Max=50;
	void out();
	void getData(String msg);
	default void print(String...msgs) {//在接口中定义默认方法需要用default
		for(String msg:msgs) {
			System.out.println(msg);
		}
	}
	default void test() {
		System.out.println("默认方法");//默认方法没有static要通过接口的实现类的实例来调用默认方法
	}
	static String staticTest(){
		return "接口里的类方法";//可以直接用接口来调用
	}
}

接口可以被当做特殊的类，一个Java源文件只能有一个public接口，如果源文件定义了定义了一个public接口，则文件名要与该接口名字相同
接口的继承

package practice;
import java.util.*;
interface A{
	int a=1;
	void testa();
}
interface B{
	int b=2;
	void testb();
}
interface C extends A,B{
	int c=3;
	void testc();
}
public class Main{
	public static void main(String[] args) {
		System.out.println(C.a);
		System.out.println(C.b);
	}
}

接口的使用
1、定义变量，也可用于强制转换
2、调用接口中定义的常量
3、被其他类实现
一个类可以实现多个接口实现关键字：implements
一个类必须重写所有该接口里的抽象方法
Collection接口里的操作集合元素方法
books跟c的实现类虽然不同，但是这些都是Collection可用的方法，所以不要紧

package practice;
import java.lang.*;
import java.util.*;
public class Main{
	public static void main(String[] args) {
		Collection c=new ArrayList();
		c.add("孙悟空");//添加元素
		c.add(6);
		System.out.println("c集合里有几个元素"+c.size());
		c.remove(6);
		System.out.println("c集合里有几个元素"+c.size()+c.contains("孙悟空"));//是否包含孙悟空这个元素
		c.add("疯狂Java");
		System.out.println("c集合里的元素"+c);
		Collection books=new HashSet();
		books.add("轻量级");
		books.add("疯狂");
		System.out.println("c是否包含books合集"+c.containsAll(books));
		c.removeAll(books);//用c集合除去books集合里的元素
		System.out.println(c);
		c.clear();//删除c的所有元素
		books.retainAll(c);//books中只剩下c中也包含的元素
	}
}

当使用System.out.println©时输出的是集合全部元素，是因为Collection所有实现类都重写了toString（）

Iterator主要用于遍历（即迭代访问）Collection集合中的元素，Iterator对象也称为迭代器
Iterator接口中定义了四种方法
1、boolean hasNext（）：如果被迭代的集合元素还没有被遍历完，则返回true
2、Object next（）：返回集合里的下一个元素
3、void remove（）：删除集合里上一次next方法返回的元素

Set集合
1、不能记住元素添加顺序
2、不允许包含相同元素
HashSet类
1、不能保证元素的排列顺序，顺序可能与添加顺序不同
2、HashSet不是同步的，如果有多线程同时访问一个HashSet必须通过代码来保证其同步
3、集合元素值可以是null
4、判断元素相等equals要返回true，hashCode也要一样
当存入一个元素时，会先调用该对象的hashCode（）方法来得到该对象的hashCode值，然后根据值决定储存位置，如果两个元素equal是相等的，但是hashCode不相等，两者都可以存入HashSet

package practice;
import java.lang.*;
import java.util.*;
class A{
	public boolean equals(Object obj) {
		return true;
	}
}
class B{
	public int hashCode() {
		return 1;
	}
}
class C{
	public int hashCode(){
		return 2;
	}
	public boolean equals(Object obj) {
		return true;
	}
}
public class Main{
	public static void main(String[] args) {
		HashSet books=new HashSet();
		books.add(new A());
		books.add(new A());
		books.add(new B());
		books.add(new B());
		books.add(new C());
		books.add(new C());
	}
}

重写hashCode方法的要求
1、同一对象多次调用该方法返回值相同
2、当连个对象equals返回true时，hashCode（）也返回相同

package practice;
import java.lang.*;
import java.util.*;
class R{
	int count;
	public R(int count) {
		this.count=count;
	}
	public String toString() {//重写表达式，影响println
		return "R[count:"+count+"]";
	}
	public boolean equals(Object obj) {
		if(this==obj)
		return true;
		if(obj!=null&&obj.getClass()==R.class) {//如果obj属于R这一类里
			R r=(R)obj;
			return this.count==r.count;//得到相同的hashCode
		}
		return false;
	}
	public int hashCode() {
		return this.count;
	}
}
public class Main{
	public static void main(String[] args) {
		HashSet hs=new HashSet();
		hs.add(new R(5));
		hs.add(new R(-3));
		hs.add(new R(9));
		hs.add(new R(-2));
		System.out.println(hs);
		Iterator it=hs.iterator();
		R first=(R)it.next();//添加可变对象
		first.count=-3;
		System.out.println(hs);//输出重复元素
		hs.remove(new R(-3));
		System.out.println(hs);
	}
}

List集合方法

{
books.add(1,new String("疯狂"));
books.remove(2);
books.set(1,new String("疯狂"));//将第二个元素进行替换
books.indexOf(new String("疯狂"));//判断指定元素在集合里的位置
books.suList(1,2);//截取成子集合
}

List判断对象相等的标准是equals返回true