java-接口interface

接口定义使用interface

定义使用interface ,调用使用implements。
举个栗子吧

/这个是定义接口
public interface MyInterface {
    
    
	//属性
	int NUM = 10 ;
	//方法
	void func();
	
}

接口中定义属性和方法。

接口中的属性和方法

属性都是public static final修饰的，表示公有的常量。定义时就要赋初值
方法都是public abstract修饰的，表示公有的抽象方法。不能有方法体
这些关键字都不用我们敲上去，系统自己会识别为该类型。

接口中可以有静态方法

public interface MyInterface {
    
    
	//属性
	int num = 10 ;
	//静态方法
	public static void func() {
    
    
		System.out.println("这个是接口中的静态方法，方法名前有static修饰，直接采用接口名.方法名（参数列表）调用");
	}
}

因为静态方法是类名调用

接口和抽象类的区别

1. 属性：接口中都是public static final默认修饰，也就是常量；抽象类中属性可以随意定义。
2. 方法：接口中方法都是public abstract 默认修饰的，也就是抽象方法；抽象类中既可以有抽象方法也可以有实例方法。
3. 构造方法：接口中一定不能定义，因为接口中方法都是抽象的并且构造方法不能被子类继承；抽象类可以有构造方法，但是没有意义，因为抽象类不能创建对象。

接口的概念和作用

接口就是为了实现多继承。
一个类可以实现多个接口，接口间用逗号分隔，实现
一个类可以实现多个接口，实现接口的关键字为implements，当实现接口时，必须实现所有的接口中的所有抽象方法，否则必须将该类设置抽象类。

类实现接口，就要重写接口的所有抽象方法。

例如有两个接口，一个类去实现两个接口，两个接口之间用逗号隔开。
定义的一个接口

public interface MyInterface {
    
    
	void m();
	void m2();
}

定义的第二个接口

public interface MyInterface2 {
    
    
	void n1();
	void n2();
}

实现接口的类

public class Demo1 implements MyInterface , MyInterface2{
    
    
	int NUM = 15 ;

	@Override
	public void m() {
    
    
		// TODO Auto-generated method stub
		System.out.println("重写接口里面的抽象方法m");
	}

	@Override
	public void m2() {
    
    
		// TODO Auto-generated method stub
		System.out.println("重写接口里面的抽象方法m2");
	}

	@Override
	public void n1() {
    
    
		// TODO Auto-generated method stub
		System.out.println("重写接口里面的抽象方法n1");
	}

	@Override
	public void n2() {
    
    
		// TODO Auto-generated method stub
		System.out.println("重写接口里面的抽象方法n2");
	}

}

再写给main方法，接口的引用指向实现类的对象，只能调用接口里面定义的方法，因为实现类重写了接口里面的方法，那么就调用实现里面重写的方法。

public class DemoMain {
    
    

	public static void main(String[] args) {
    
    
		// TODO Auto-generated method stub
		MyInterface my = new Demo1();
		//可以写接口的引用创建实现类的对象。
		my.m();
		my.m2();
	}

}

常量接口

就是接口里面全部是属性，即常量，因为属性全部是public static final 修饰的。

public interface State {
    
    
	int DONG_JIE = 1;
	int ZHONG_DU = 2;
	int ZHUO_SHAO = 3;
	int CHEN_MO = 4;
	double PI = 3.1415926;
	String FILE_PATH = "C:\\myfile\\";
}

接口可以继承（extends）其他接口

在我看原码的时候发现一个接口extends 另外一个接口，我一脸的蒙蔽，之前从来没有看过。
上结论接口和接口之间的关系就只能是继承extends，不可能实现implements

• 接口可以继承接口
• 一个接口可以继承多个接口
• 作用我觉得就是看起来简化一个java文件中的代码，本质上并没有简化过程，因为继承那么就会继承里面的非私有的属性和方法。

举个栗子
两个接口，一个接口继承另外一个接口，然后写个实现类来实现接口里面的方法。

接口：MyInterface02

public interface MyInterface02 {
    
    
	//定义一些常量属性
	 Integer num = 15 ;
	 String name = "root" ;
	 
	//定义一些抽象方法，没有方法体
	 int getNum( int num) ;
	 
	 void inputName() ;
}

接口：MyInterface01 来继承接口MyInterface02

public interface MyInterface01 extends MyInterface02 {
    
     //接口只能继承接口
	 
	 //定义一些属性
	 int id = 123456 ;
	 //定义一些方法
	 void add() ;
}

实现类：TestClass实现接口，那么就要重写接口里面的所有抽象方法

public class TestClass implements MyInterface01{
    
    

	@Override
	public int getNum(int num) {
    
    
		// TODO Auto-generated method stub
		return 0;
	}

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

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