JAVA中的接口_java interfacedemo demo = new interfacedemoimpl();-CSDN博客

本文链接：https://blog.csdn.net/ckinghan58/article/details/68942845

接口不能被实例化，代码如下：

//被interface关键字修饰的类称为接口 ，且不能实例化
interface InterfaceDemo{
	//在接口中，定义的变量称为常量，会隐式的自动加入public static final关键字，值无法改变
	String ALIPAY_APPID = "WXWEREO555WE";
	//接口中的方法如果没有显示加入abstract关键字，系统会隐式加入这个关键字，所以接口中的方法都是抽象方法，不能有方法体
	public  void sleep();
	public  void outPrint();
}

class Test{
	public static void main(String[] args){
		//接口不能被实例化
		InterfaceDemo demo = new InterfaceDemo();
		
	}
}

执行结果如下：

InterfaceDemo.java:13: 错误: InterfaceDemo是抽象的; 无法实例化
                InterfaceDemo demo = new InterfaceDemo();
                                     ^
1 个错误

== 接口定义的变量，默认被staic final修饰的常量，代码如下：

//被interface关键字修饰的类称为接口 ，且不能实例化
interface InterfaceDemo{
	//在接口中，定义的变量称为常量，会隐式的自动加入public static final关键字，值无法改变
	String ALIPAY_APPID = "WXWEREO555WE";
	//接口中的方法如果没有显示加入abstract关键字，系统会隐式加入这个关键字，所以接口中的方法都是抽象方法，不能有方法体
	public  void sleep();
	public  void outPrint();
}

class InterfaceImpl implements InterfaceDemo{
	public void sleep(){
		System.out.println("实现接口中的sleep方法");
	}
	
	public void outPrint(){
		System.out.println("实现接口中的outPrint方法");
	}
}

class Test{
	public static void main(String[] args){
		//接口中定义的变量称为常量，系统默认隐式加入了public static final关键字
		InterfaceImpl demo = new InterfaceImpl();
		
		System.out.println("常量可以通过对象名.常量名访问："+demo.ALIPAY_APPID);
		
		System.out.println("常量可以直接通过类名.常量名访问："+InterfaceDemo.ALIPAY_APPID);
		
		System.out.println("常量不可以更改值:");
		
		//InterfaceDemo.ALIPAY_APPID = "55546546";
	}
}

运行结果如下：

常量可以通过对象名.常量名访问：WXWEREO555WE
常量可以直接通过类名.常量名访问：WXWEREO555WE
常量不可以更改值:

如果将

InterfaceDemo.ALIPAY_APPID = "55546546";

放开后，就会报错，运行结果如下：

InterfaceDemo.java:31: 错误: 无法为最终变量ALIPAY_APPID分配值
                InterfaceDemo.ALIPAY_APPID = "55546546";
                             ^
1 个错误

== 接口中的方法必须全部重写，否则会报错，代码如下：

//被interface关键字修饰的类称为接口 ，且不能实例化
interface InterfaceDemo{
	//在接口中，定义的变量称为常量，会隐式的自动加入public static final关键字，值无法改变
	String ALIPAY_APPID = "WXWEREO555WE";
	//接口中的方法如果没有显示加入abstract关键字，系统会隐式加入这个关键字，所以接口中的方法都是抽象方法，不能有方法体
	public  void sleep();
	public  void outPrint();
}

class InterfaceImpl implements InterfaceDemo{
	//接口中的所有方法都必重写
	public void sleep(){
		System.out.println("实现接口中的sleep方法");
	}
	//这个方法不重写会报错
	/*public void outPrint(){
		System.out.println("实现接口中的outPrint方法");
	}*/
}

class Test{
	public static void main(String[] args){
		//接口中的方法必须全部重写，否则 会报错
		InterfaceImpl demo = new InterfaceImpl();
	}
}

运行结果如下：

InterfaceDemo.java:10: 错误: InterfaceImpl不是抽象的, 并且未覆盖InterfaceDemo中的抽象方法outPrint()
class InterfaceImpl implements InterfaceDemo{
^
1 个错误

== 实现接口的范例代码如下：

//被interface关键字修饰的类称为接口 ，且不能实例化
interface InterfaceDemo{
	//在接口中，定义的变量称为常量，会隐式的自动加入public static final关键字，值无法改变
	String ALIPAY_APPID = "WXWEREO555WE";
	//接口中的方法如果没有显示加入abstract关键字，系统会隐式加入这个关键字，所以接口中的方法都是抽象方法，不能有方法体
	public  void sleep();
	public  void outPrint();
}

class InterfaceImpl implements InterfaceDemo{
	//接口中的所有方法都必重写
	public void sleep(){
		System.out.println("实现接口中的sleep方法");
	}
	//这个方法不重写会报错
	public void outPrint(){
		System.out.println("实现接口中的outPrint方法");
	}
}

class Test{
	public static void main(String[] args){
		InterfaceImpl demo = new InterfaceImpl();
		demo.sleep();
		demo.outPrint();
	}
}

运行结果如下：

实现接口中的sleep方法
实现接口中的outPrint方法

== 显示的将public static final、public abstract写出来，与上面的效果是一样的。

//被interface关键字修饰的类称为接口 ，且不能实例化
interface InterfaceDemo{
	//在接口中，定义的变量称为常量，会隐式的自动加入public static final关键字，值无法改变
	public static final String ALIPAY_APPID = "WXWEREO555WE";
	//接口中的方法如果没有显示加入abstract关键字，系统会隐式加入这个关键字，所以接口中的方法都是抽象方法，不能有方法体
	public abstract void sleep();
	public abstract void outPrint();
}

class InterfaceImpl implements InterfaceDemo{
	//接口中的所有方法都必重写
	public void sleep(){
		System.out.println("实现接口中的sleep方法");
	}
	//这个方法不重写会报错
	public void outPrint(){
		System.out.println("实现接口中的outPrint方法");
	}
}

class Test{
	public static void main(String[] args){
		InterfaceImpl demo = new InterfaceImpl();
		demo.sleep();
		demo.outPrint();
	}
}

运行结果如下：

实现接口中的sleep方法
实现接口中的outPrint方法

== 接口可以实现单继承，但从1.7开始，也支持了多继承，代码如下：

interface A{
	public void printA();
}
//接口可以实现单继承
interface B extends A{
	public void printB();
}

interface C{
	public void printC();
}

/*
	在JDK1.7之前，接口只能实现单继承，
	从JDK1.7开始，接口即可以实现单继承，也可以实现多继承
*/
interface D extends B , C{
	public void printD();
}

class E implements B{
	public void printA(){
		System.out.println("实现的A");
	}
	public void printB(){
		System.out.println("实现B");
	}
}

class Test{
	public static void main(String[] args){
		E demo = new E();
		demo.printA();
		demo.printB();
	}
}

运行结果：

实现的A
实现B

接口：

被interface修饰的类叫接口
接口不能被实例化
接口中定义的变量叫常量，必需有初始值，且如果没有显示定义public static final，系统也会默认隐式加上。接口中的变量在调用时，可以直接接口名.变量名
接口中的方法都是抽象方法，不能有方法体，如果没有显示定义public abstract，系统会默认加上
接口想要使用，接口中的抽象方法必须被实现，包括抽象类实现了接口，也要实现接口的方法
继承和实现接口可以并存，且继承只能有一个，实现接口可以有多个，以,分隔
接口不能与private static final三个关键字组合使用。