接口

接口

1、概念：

​ 接口是一系列方法的声明，是一些方法特征的集合，一个接口只有方法的特征没有方法的实现，因此这些方法可以在不同的地方被不同的类实现，而这些实现可以具有不同的行为（功能）。

2、格式

interface:用来声明接口的关键字

声明格式：
  interface 接口名{
     静态常量；
     抽象方法；
  }
实现格式：
   class 类名 implements 接口名{
   
   }

3、特点：

（1）接口中的成员变量只能是静态常量，定义时必须初始化。默认修饰符：public static final

（2）接口中没有构造方法，因为接口不能实例化对象。

（3）接口中的成员方法只能是抽象方法，没有方法体。默认修饰符：public abstract

(4)接口的实现类必须重写接口方法，或者是一个抽象类（可以重写也可以不重写接口中的方法）

4、接口的声明和实现

interface play{
	// 常量，缺省修饰符：public static final
	int time = 10;
	// 抽象方法，缺省修饰符：public abstract
	void geme();
}
public class TestInterface3 implements play{
    // 重写接口中的方法
	@Override
	public void geme() {
		System.out.println("玩游戏");
	}
}

注意：接口的实现类必须重写接口中的方法

1、抽象类实现接口

注意：抽象类实现接口，可以选择性重写也可以不重写接口中的方法

interface servlet{
  void init();
  
  void service();
}

abstract class BaseServlet implements servlet{
     //重写init()方法
     @Override
     public void init(){
       System.out.println("初始化");
    }
}

class MyServlet extends BaseServlet {
	@Override
	public void service() {
		System.out.println("服务方法");
	}
}

public class Test {
	public static void main(String[] args) {
		new MyServlet().init();
		new MyServlet().service();
	}
}

2、类的接口多实现

注意：接口的实现类必须重写所以接口中的方法

interface Play {
	void playGame();
}

interface Eat {
	void eatNoodles();
}

public class TestInterface3 implements Play, Eat {

    // 重写Play类中的方法
	@Override
	public void playGame() {
		System.out.println("玩游戏");
	}

    // 重写Eat类中的方法
	@Override
	public void eatNoodles() {
		System.out.println("吃面条");
	}

}

3、接口的继承

注意：接口之间可以单继承，也可以多继承

interface Eat {
	void noodles();
}

interface Play {
	void happy();
}

// 单继承
interface Person extends Play {

}

// 多继承
interface Animal extends Play, Eat {

}

// 实体类实现Animal接口，重写所有方法
class Biology implements Animal {

	@Override
	public void happy() {
		System.out.println("玩得开心");
	}

	@Override
	public void noodles() {
		System.out.println("面条好吃");
	}
	
}

public class Test {
	public static void main(String[] args) {
		Biology biology = new Biology();
		biology.happy();	// 玩得开心
		biology.noodles();	// 面条好吃
	}
}

4、jdk1.8新特性：defaul关键字在接口中使用

注意：default修饰的接口可以不被重写

interface Function {
	void test();

	default void testDefault() {
		System.out.println("default修饰的接口可以有方法体");
	}
}

// default 修饰的接口可以不被重写
class Base implements Function {

	@Override
	public void test() {
		System.out.println("Base类重写Function接口中的方法");
	}
}

// default 修饰的接口也可以重写
class Boost implements Function {

	@Override
	public void test() {
		System.out.println("Boost类重写Function接口中的方法");
	}

	@Override
	public void testDefault() {
		System.out.println("Boost类重写Function接口中的default方法");
	}
}

public class TestInterface2 {
	public static void main(String[] args) {
		Base base = new Base();
		Boost boost = new Boost();
		base.test();		// Base类重写Function接口中的方法
		base.testDefault();	// default修饰的接口可以有方法体
		boost.test();		// Boost类重写Function接口中的方法
		boost.testDefault();// Boost类重写Function接口中的default方法
	}
}

5、static关键字在接口中的使用

interface Static{
	public static void function() {
		System.out.println("static Method");
	}
}
//子类不能重写方法
interface Base extends Static{
	
}
//实现类不能重写方法
class Implement implements Static{
	
}
public class StaticDemo_03 {
    public static void main(String[] args) {
//		Static.function();//通过类名直接调用
	}
}

# 总结

1、接口是对类的扩展，通过接口可以让类拥有更多更强的功能

2、接口中只有静态常量和抽象方法，所以不能实现实例化

3、接口的实现类必须重写所有方法，或者是个抽象类

4、接口可以多实现

5、接口可以单继承，也可以多继承

6、JDK1.8新特性，接口中被default修饰的方法，必须有方法体，且实现类不强制要求重写

7、JDK1.8新特性，接口中被static修饰的方法，必须有方法体，且子类和实现类不能重写