Java面向对象之接口interface 入门实例

一、基础概念

　　（一）接口可以简单的理解为，是一个特殊的抽象类,该抽象类中的方法都是抽象的。

　　　　　接口中的成员有两种：1.全局常量 2.抽象方法

　　　　　定义接口用关键字interface，接口中的成员都用固定的修饰符public来修饰。

　　（二）接口的特点：

　　　　1、接口不可以实例化。

　　　　2、接口的子类必须覆盖接口中的所有抽象方法后，才可以实例化。否则该子类是抽象类。

　　　　3、接口是用来被实现的。

　　（三）接口解决的问题：

　　　　1.因为多继承调用的不确定性，java中是不直接支持多继承的，但可以通过接口来解决，将多继承转换成多实现。

　　　　2.因为子类具备所属的父类体系的基本功能后，还想扩展一些其他功能。可以通过接口来完成。

　　　　3.避免单继承的局限性。一个类继承另一个类的同时，还可以实现多个接口。

　　（四）接口的思想：

　　　　1.接口的出现扩展了功能。

　　　　2.接口的出现其实就是暴露出来的规则。

　　　　3.接口的出现降低了耦合性。(用于解耦)

　　　　4.接口的出现，一方在使用接口，一方在实现接口。

　　（五）类与接口的区别：

　　　　1.类与类之间的关系是继承关系。

　　　　2.类与接口之间的关系是实现关系。

　　　　3.接口与接口的关系是继承关系，而且可以多继承。

　　　　4.抽象类中可以定义抽象和非抽象方法。子类可以直接使用，或者覆盖使用。接口中定义都是抽象方法，必须实现后才能使用。

　　　　5.类用于描述是事物的共性基本功能，接口用于定义的是事物的额外功能。

二、实例代码（一）

　　1.定义接口子类SubInter_1，进行接口InterA的实现

　　2.定义接口子类SubInter_2，进行接口InterA接口和InterB的多实现

　　3.定义接口子类SubInter_3，继承Fu类还进行接口InterA的实现

　　3.定义接口子类SubInter_4，继承Fu类还进行接口InterA和InterB的多实现

 //定义父类Fu
 class Fu
 {
     public void show1()
     {
         System.out.println("Fu show1 ......");
     }
 }

 //定义接口InterA
 interface InterA
 {
     public static final int num1 = 4;  //全局常量
     public abstract void show2();  //抽象方法
 }

 //定义接口InterB
 interface InterB
 {
     public static final int num2 = 6;
     public abstract void show3();
 }

 //定义接口子类SubInter_1，进行实现
 class SubInter_1 implements InterA//子类SubInter1实现 InterA接口
 {
     public void show2()
     {
         System.out.println("SubInter_1 InterA show2 ......");
     }
 }

 //定义接口的子类SubInter_2，进行多实现
 class SubInter_2 implements InterA,InterB//用子类SubInter2 多实现 InterA接口和Inter接口
 {
     public void show2()
     {
         System.out.println("SubInter_2 InterA show2 ......");
     }
     public void show3()
     {
         System.out.println("SubInter_2 InterB show3 ......");
     }
 }

 //SubInter_3类继承了Fu类的基本功能，还实现了InterA接口的基本功能。
 class SubInter_3 extends Fu implements InterA
 {
     public void show2()
     {
         System.out.println("SubInter_3 InterA show2 ......");
     }

 }

 //SubInter_4类继承了Fu类的基本功能，还实现了InterA接口和InterB接口的基本功能。
 class SubInter_4 extends Fu implements InterA,InterB
 {
     public void show2()
     {
         System.out.println("SubInter_3 InterA show2 ......");
     }

     public void show3()
     {
         System.out.println("SubInter_3 InterB show3 ......");
     }
 }

 class InterfaceDemo1
 {
     public static void main(String[] args)
     {
         //SubInter_1实例化 s1
         SubInter_1 s1 = new SubInter_1();
         System.out.println(s1.num1);
         System.out.println(SubInter_1.num1);
         s1.show2();

         //SubInter_2实例化 s2
         SubInter_2 s2 = new SubInter_2();
         System.out.println(s2.num1);
         System.out.println(s2.num2);
         System.out.println(SubInter_2.num1);
         s2.show2();
         s2.show3();

         //SubInter_3实例化 s3
         SubInter_3 s3 = new SubInter_3();
         System.out.println(s3.num1);
         System.out.println(SubInter_3.num1);
         s3.show1();
         s3.show2();

         //SubInter_4实例化 s4
         SubInter_4 s4 = new SubInter_4();
         System.out.println(s4.num1);
         System.out.println(s4.num2);
         System.out.println(SubInter_4.num2);
         s4.show1();
         s4.show2();
         s4.show3();
     }
 }

　　代码执行

　　

三、实例代码（二）

　　1.定义接口InterB,继承接口InterA。并实现InterB

　　2.定义接口InterD,继承接口InterB和接口InterC.并实现InterD

 //定义接口InterA
 interface InterA
 {
     public static final int num = 4;
     public abstract void show1();
 }

 //定义接口InterB,继承接口InterA
 interface InterB extends InterA
 {
     public abstract void show2();
 }

 //定义接口InterC
 interface InterC
 {
     public abstract void show3();
 }

 //定义接口InterD,继承接口InterB和接口InterC
 interface InterD extends InterB,InterC
 {
     public abstract void show4();
 }

 //定义接口子类SubInter，进行实现
 class SubInter_1 implements InterB
 {
     public void show1()
     {
         System.out.println("SubInter_1 InterA show1 ......");
     }

     public void show2()
     {
         System.out.println("SubInter_1 InterB show2 ......");
     }
 }

 //定义接口子类SubInter，进行实现
 class SubInter_2 implements InterD
 {
     public void show1()
     {
         System.out.println("SubInter_2 InterA show1 ......");
     }

     public void show2()
     {
         System.out.println("SubInter_2 InterB show2 ......");
     }

     public void show3()
     {
         System.out.println("SubInter_2 InterC show3 ......");
     }

     public void show4()
     {
         System.out.println("SubInter_2 InterD show4 ......");
     }
 }

 class InterfaceDemo2
 {
     public static void main(String[] args)
     {

         //SubInter_1实例化s1
         SubInter_1 s1 = new SubInter_1();
         System.out.println(s1.num);
         s1.show1();
         s1.show2();

         //SubInter_2实例化s2
         SubInter_2 s2 = new SubInter_2();
         System.out.println(s1.num);
         s2.show1();
         s2.show2();
         s2.show3();
         s2.show4();
     }
 }

　　代码执行

　　

四、实例代码（三）

　　接口Inter中有4个方法，子类只想用其中的一个方法。

　　用DemoA类实现接口Inter中的所有方法进行解决。

 interface Inter
 {
     public abstract void show1();
     public abstract void show2();
     public abstract void show3();
     public abstract void show4();
 }

 //为了方便创建Inter接口的子类对象，先创建一个DemoA类实现接口Inter。
 //因为Demo类创建对象没有意义。所以将该类抽象。
 abstract class DemoA implements Inter
 {
     public void show1(){}
     public void show2(){}
     public void show3(){}
     public void show4(){}
 }

 class DemoB extends DemoA
 {
     public void show1()
     {
         System.out.println("Inter show1 ......");
     }
 }

 class InterfaceDemo3
 {
     public static void main(String[] args)
     {
         DemoB s1 = new DemoB();
         s1.show1();
     }
 }

　　代码运行