Java基础32接口

接口：

如果一个抽象类里面的函数都是抽象函数 、那么这个类就是接口 (jdk8之前正确，jdk8之后不一定)
interface 来定义一个接口 注意：不要写class
abstract可以省略

1. 在interface中定义的变量必须给与初始值, 定义的变量相当于 static final int age = 10;
2. 接口中的所有方法都是public修饰的，所以在实现类中实现的方法必须要用public修饰，否则编译出错
3. 接口可以继承接口
4. jdk8 的新特性 在类中可以声明一个default的函数

interface Test{
						
	default void aaa(){
								
	}
							
}

细节
不能有构造函数
不能有（全局）普通变量（有争议）
只能是静态常量
所有方法都是public的，而且是抽象方法，不能是static修饰
可以继承多个接口

1.实现类会继承接口中的default方法

//A类
public interface A {
	public default void a(){
		System.out.println("这是A");
	}
}
//子类 实现类
public class Test implements A{
	
｝
//第三个类，执行main方法
public class Test2 {
	public static void main(String[] args) {
		Test t = new Test();
        //可以调用A接口的方法
		t.a();
	}
｝

2.如果一个类同时实现接口A和B，接口A和B中有相同的default方法，这时，该类必须重写接口中的default方法

//接口A
public interface A {
	public default void a(){
		System.out.println("这是A");
	}
}

//接口B
public interface B {
	public default void a(){
		System.out.println("这是B");
	}
}
//实现类实现多个接口
public class Test4 implements A,B{
    //需要重写a()方法
    @Override
	public void a() {
		// TODO Auto-generated method stub
		Test3.super.a();
	}
    
}

3.如果子类继承父类，父类中有b方法，该子类同时实现的接口中也有b方法（被default修饰），那么子类会继承父类的b方法而不是继承接口中的b方法

//接口A
public interface A {
	public default void b(){
		System.out.println("AAA");
	}
}

//父类C
public class C {
	public void b(){
		System.out.println("CCC");
    ｝
｝
        
//子类
public class Test extends C implements A{
	public static void main(String[] args) {
		Test a = new Test();
        //结果为父类C的方法
		a.b();
	}
}

Myinterface:

/**
 * 就是一个接口
 * 
 * @author admin
 *
 */

//public class Test1  普通类型的声明，声明的关键字是class
public abstract interface Myinterface {// 声明一个接口声明的关键字是interface abstract可以缺省
	// Myinterface是类型还是接口，主要看关键字。

	// 接口中还能定义变量
	int i = 0; // 接口中的变量默认加上了public static final，所以不初始化赋值的话会报错。

	// jdk8之前
	// 接口中的所有方法都是抽象方法
	public abstract void aaa();

	// 接口中定义的方法默认就是抽象方法和public。所以public abstract可以缺省
	public void bbb();

	// jdk8之后
	default void ccc() {
		System.out.println("ccc");
	}
}

Myinterface2:

public interface Myinterface2 extends Myinterface {
//Myinterface2会把Myinterface里面的抽象方法和属性一起继承过来

}

Myinterface3:

public interface Myinterface3 {
	default void ccc() {
		System.out.println("ccc");
	}
}

MyInterfaceFather:

public class MyInterfaceFather {
	public void ccc() {

		System.out.println("MyInterfaceFather-----------CCC");
	}
}

实现类：

/**
 * 实现类
 * 
 * 实现接口的类型，因为接口中所有的方法都是抽象方法，所以接口不能直接创建对象的，也没有方法具现的实现
 * 
 * 接口的具体的实现（业务逻辑），就体现在实现类中
 * 
 * @author admin
 *
 */

//implements 实现接口，可以  ，号实现多个接口
//java中只能单继承，可以多实现
public class MyInterfacelempl extends MyInterfaceFather implements Myinterface, Myinterface3 {
	// 实现类在同一时间实现2个接口，这两个接口有相同的default方法， 那么这个default方法就需要重写了。
	// 同样的，两个接口都有ccc方法，这个时候实现类就必须重写该方法，ccc

	// 抽象方法的特点，子类必须要重写父类中的抽象方法
	public static void main(String[] args) {

	}

	@Override
	public void aaa() {
		// TODO Auto-generated method stub
		System.out.println("你好，我是aaa");
	}

	@Override
	public void bbb() {
		// TODO Auto-generated method stub
		System.out.println("你好，我是bbb");
	}

	// 当实现类继承的父类也有ccc方法时，优先继承父类的ccc方法，不管接口的ccc方法
//	@Override
//	public void ccc() {
//		// TODO Auto-generated method stub
//		System.out.println("mYINTERFACE-----------CCC");
//	}

}

Test1：

public class Test1 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		// jdk8之前
		// 接口中的所有方法都是抽象方法
		// jdk8之后
		// 接口就可以有普通的默认方法

		// 接口可以有变量

		// 和向上转型相似
		Myinterface myinterface = new MyInterfacelempl();

		myinterface.aaa();
		myinterface.ccc();
	}

}

Test2：

public class Test2 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		// jdk8之前
		// 接口中的所有方法都是抽象方法
		// jdk8之后
		// 接口就可以有普通的默认方法

		// 接口可以有变量

		// 和向上转型相似
		MyInterfacelempl interfacelempl = new MyInterfacelempl();
		interfacelempl.ccc();//从接口中继承的ccc方法（default）
	}

}