大陆各运营商IP段统计

3.9、接口（重点）

接口是一个特殊的类，在Java中接口是由抽象方法和全局常量组成。

在Java中使用interface定义一个接口

interface A{
    public static final String INFO = "CHINA"； //全局常量
    public abstract void print();	//抽象方法
    public abstract void fun(); 	//抽象方法
}

在接口中定义了如下两个抽象方法，一个全局常量。那么接口与抽象类一样，需要有子类，那么子类此时不再成为继承类，而是实现接口。通过implements关键字完成。

interface A{
    public static final String INFO = "CHINA"； //全局常量
    public abstract void print();	//抽象方法
    public abstract void fun(); 	//抽象方法
}
class B implements A{
    public void print(){
        System.out.println("HELLO WORLD！！！");
    }
    public void fun(){
        System.out.println("INFO");
    }
}
public class Demo02 {
    public static void main(String args[]) {
        B b = new B();
        b.print();
        b.fun();
    }
}

进一步研究以上程序：

• 既然接口从定义上已经明确的要求是由抽象方法和全局常量组成，那么在接口定义的时候可以简化操作：

interface A{
   // public static final String INFO = "CHINA"； 
    String INFO = "CHINA"；	//全局常量
  // public abstract void print();
    void print();	//抽象方法
   // public abstract void fun(); 	
    public void fun(); 	//抽象方法
}

• 一个类虽然只能继承一个父类，但是一个类可以同时实现多个接口，使用接口完成多继承的能力

interface A{
   // public static final String INFO = "CHINA"； 
    String INFO = "CHINA"；	//全局常量
  // public abstract void print();
    void print();	//抽象方法
   // public abstract void fun(); 	
    public void fun(); 	//抽象方法
}
interface C{
    public void funA();
}
class B implements A,C{
    public void print();{	//实现抽象方法
        System.out.println("HELLO WORLD!!");	
    }
    public void fun(){	
        System.out.println(INFO);	//输出全局常量
    }
     public void funA(){	//实现抽象方法
        System.out.println("信息：" + INFO);
    }
}
public class Demo{
    public static void main(String args[]){
        B b = new B();
        b.print();
        b.fun();
        b.funA();
    }
}

如果一个类既要实现接口又要继承抽象类的话，则必须按照以下的形式完成：

class 子类 extends 抽象类 implements 接口A,接口B,...{
}

interface A{
    public void printA();
}
interface B{
    public void printB();
}
abstract class C{
    public abstract void printC();
}
class X extends C implements A,B{
    public void printA(){}
    public void printB(){}
    public void printC(){}
}

一个抽象类可以实现多个接口，但是一个接口不能继承一个抽象类

interface A{
    public void printA();
}
interface B{
    public void printB();
}
abstract class C implements A,B{
    public abstract void printC();
}
class X extends C{
    public void printA(){}
    public void printB(){}
    public void printC(){}
}

一个接口虽然不可以继承一个抽象类，但是一个接口却可以同时继承多个接口。

• 这一点在高级开发中经常看到

interface A{
    public void printA();
}
interface B{
    public void printB();
}
interface Z extends A,B{
    public void printZ();
}
abstract class C{
    public abstract void printC();
}
class X extends C implements Z{
    public void printA(){}
    public void printB(){}
    public void printC(){}
    public void printZ(){}
}

---

转载请注明来源