接口的基本概念

/* 接口的基本概念

接口是Java 中只要的概念之一，它可以理解为一种特殊的类，是有全局常量和公共的抽象方法做组成

接口的定义格式：} */
interface  接口名称{
	全局变量；
	抽象变量；
}
/* 在接口中的抽象方法必须定义为public访问权限。在接口中即使不屑public关键字也是public访问权限。
与抽象类一样，接口若要使用必须通过子类，子类通过implements关键字实现接口：class 子类 implements 接口a，接口b，接口c，，，，，，{}   一个子类可以同时实现多个接口，这就实际上摆脱了Java 的单继承局限*/
//实现接口
interface A{                              //定义接口A
	public String XM = "LZ";         //定义全局常量
	public void print();                //定义抽象方法
	public String getInfo();           //定义抽象方法
}
interface B{                         //定义接口A
	public void say();              //定义抽象方法
}
class C implements A,B{             //同时实现两个接口
	public void say(){               //覆写B接口方法
		System.out.println("你好，大家好");
	}
	public String getInfo(){        //覆写A接口方法
		return "110";
	}
	public void print(){          //覆写A接口方法
		System.out.println("人物：" +　XM);
	}
}
public class InterfaceDemo001{
	public static void main(String[] args){
		X x = new X();      //实例化对象
		x.say();            //调用覆写方法
		x.print();          //调用覆写方法
		System.out.println( c.getInfo()); //打印返回的值
	}
}

/* 一个子类同时实现了两个接口，这样在子类中就必须同时覆写两个接口中的全部抽象方法 */

//如果一个子类既要实现接口又要继承抽象类，可以按照以下格式定义：
class 子类 extends 抽象类 implements 接口A，接口B----{}
//范例 子类同时继承抽象类和实现接口

interface A{     //定义接口A
	public String XM = "李正";  //定义全局变量
	public void print();   //定义抽象方法
	public String getInfo(); //定义抽象方法
}
abstract class B{ //定义抽象类B
	public abstract void say();
}
class C extends B implements A{  //子类同时也实现接口
	public void say(){   //覆写
		System.out.println("大家好");
	}
	public String getInfo(){   //覆写
		return "110";
	}
	public void print(){   //覆写
		System.out.println("姓名：" + XM);
	}
	
}
public class InterfaceDemo002{
	public static void main(String[] args){
		C c = new C();   //调用覆写方法
		c.say();     //调用覆写方法
		c.print();   //调用覆写方法
        System.out.println( c.getInfo());		
	}
}
//因为抽象类和接口本身都有抽象方法，所以实现类中必须覆写3个抽象方法
//Java中允许一个抽象实现多个接口
//抽象类实现接口
interface A{    //定义接口
	public String XM = "李正"; //定义全局变量
	public void print();       //定义抽象方法
	public String getInfo();   //定义抽象方法
}
abstract class B implements A{  //定义抽象类 实现接口
	public abstract void say(); //定义抽象方法，一共有3个抽象方法
}
class C extends B{  //继承抽象类
	public  void say(){   //覆写
		System.out.println("大家好");
	}
	public String getInfo(){  //覆写
		return "110";
	}
	public void print(){   //覆写
		System.out.println("姓名：" + XM);
	}
}
public class InterfaceDemo003{
	public static void main(String[] args){
		C c = new C();   //实例化
		c.say();         //调用被覆写的方法
		c.print();       //调用被覆写的方法
        System.out.println( c.getInfo());		
	}
}



/* 接口的继承
Java不允许接口继承抽象类，但是允许一个接口继承多个接口 */

interface A{    //定义接口
	public String XM = "李正"; //定义全局变量
	public void printA();       //定义抽象方法
}
interface B{  //定义接口
	public  void printB(); 
}
interface C extends A,B{  //定义接口C,同时继承接口A,B
	public  void printC(); 
}
class D implements C{  //子类继承接口
	public  void printA(){   //覆写
		System.out.println("大家好");
	}
	public void printB(){  //覆写
		System.out.println("大家好2");
	}
	public void printC(){   //覆写
		System.out.println("大家好3");
	}
}
public class InterfaceDemo004{
	public static void main(String[] args){
		D d = new D();   //实例化
		d.printA();         //调用被覆写的方法
		d.printB();       //调用被覆写的方法
        d.printC(); 		
	}
}
/*接口C继承了接口a和b 这样接口C就同时存在3个抽象方法，子类D实现接口C后就必须同时覆写3个抽象方法 */