接口
接口的基本定义
接口严格来讲属于一个特殊的类，而且这个类里面只有抽象方法与全局变量。
在java里面可以使用interface关键字来实现接口的定义。
例：定义接口
interface A{ //定义接口
public static final String MSG="Hello World"; //全局变量
public abstract void print(); //抽象方法
}
接口的使用原则：
1.接口必须要有子类，但是此时一个子类可以用implements关键字实现多个接口，避免单继承局限；
2.接口的子类(如果不是抽象类)，必须要覆写接口中的全部抽象方法；
3.接口的对象可以利用子类对象的向上转型进行实例化操作。
例：实现接口
interface A9{
public static final String MSG="Hello World";
public abstract void print();
}
interface B9{
public abstract void get();
}
class X1 implements A9,B9{
public void print(){
System.out.println("A接口的抽象方法");
}
public void get(){
System.out.println("B接口的抽象方法");
}
}
public class Test1_1_4_3 {
public static void main(String args[]){
X1 x=new X1();
A9 a=x;
B9 b=x;
a.print();
b.get();
System.out.println(A9.MSG);
}
}
//结果
//A接口的抽象方法
//B接口的抽象方法
//Hello World
如果一个子类既要继承抽象类又要实现接口，那么应该采用先继承后实现接口的顺序完成。
例：子类继承抽象类并实现接口
interface A9{ //定义接口
public abstract void print(); //抽象方法
}
interface B9{
public abstract void get();
}
abstract class C9{
public abstract void change();
}
class X1 extends C9 implements A9,B9{ //X1类继承了抽象类C9，实现了A9和B9两个接口
public void print(){ //覆写A9中的方法
System.out.println("A接口的抽象方法");
}
public void get(){
System.out.println("B接口的抽象方法");
}
public void change(){ //覆写抽象类C9的方法
System.out.println("C类的抽象方法");
}
}
public class Test1_1_4_3 {
public static void main(String args[]){
X1 x=new X1();
A9 a=x;
B9 b=x;
C9 c=x;
a.print();
b.get();
c.change();
}
}
//结果
//A接口的抽象方法
//B接口的抽象方法
//C类的抽象方法
例：接口的多继承
interface A{ //定义父接口
public void funA();
}
interface B{ //定义父接口
public void funB();
}
interface C extends A,B{ //利用extends，实现接口多继承
public void funC();
}
class X implements C{ //实现C接口子类要覆写全部抽象方法
public void funA(){} //A接口定义的方法
public void funB(){} //B接口定义的方法
public void funC(){} //C接口定义的方法
}
虽然从接口本身的概念上来讲只能够由抽象方法和全局变量组成，但是所有的内部结构不受这些要求的限制，也就是说在接口里面可以定义普通内部类、抽象内部类、内部接口。
例：在接口里定义抽象类
interface A{
public void funA();
abstract class B{ //定义接口中的抽象类
public abstract void B();
}
}
class X implements A{ //X实现了A接口
public void funA(){
System.out.println("Hello World");
}
class Y extends B{ //内部抽象类的子类，可以选择型继承
public void funB(){}
}
}
在一个接口内部如果使用static去定义一个内部接口，该接口就表示是一个外部接口。
例：
interface A{
public void funA();
static interface B{ //外部接口
public void funB();
}
}
class X implements A.B{ //X实现了A接口
public void funB(){}
}
接口的实际应用——标准
例：定义USB标准
interface USB{ //定义标准一定就是接口
public void start(); //USB设备开始工作
public void stop(); //USB设备停止工作
}
例：定义计算机类
class Computer{
public void plugin(USB usb){ //插入USB接口设备(子类对象)
usb.start(); //开始工作
usb.stop(); //停止工作
}
}
例：定义U盘子类
class Flash implement USB{
public void start(){
System.out.println("U盘开始使用");
}
public void stop(){
System.out.println("U盘停止使用");
}
}
public class Test{
public static void main(String args[]){
Computer com=new Computer(); //实例化计算机类
com.plugin(new Flash); //插入USB接口设备
}
}
接口的应用——工厂设计模式
interface Fruit{
public void eat();
}
class Apple implements Fruit{
public void eat(){
System.out.println("吃苹果");
}
}
class Orange implements Fruit{
public void eat(){
System.out.println("吃橘子");
}
}
class Factory{ //定义工厂类，此类不提供属性
public static Fruit getInstance(String className){
if ("apple".equals(className)){
return new Apple();
}
else if("orange".equals(className)){
return new Orange();
}
else{
return null;
}
}
}
public class Test1_1_4_4 {
public static void main(String args[]){
Fruit f=Factory.getInstance("orange"); //通过工厂类取得指定标记的对象
f.eat(); //调用接口方法
}
}
有了该工厂类，就可以不用每次都要去修改实例化接口的子类。
抽象类与接口的区别
注意：如果是自己写的接口，那么绝对不要使用关键字new直接实例化接口子类，应该使用工厂类完成。
