java中的接口

1 /**
2  * java中定义接口
3  */
4 public interface JavaInterfaces {
5 
6 }

  1 package javastudy.summary;
  2 
  3 /**
  4  * 这里定义了接口：Painter。 在Painter接口里面定义了paint()和eat()这两个抽象方法。
  5  * 
  6  * @author gacl
  7  * 
  8  */
  9 interface Painter {
 10     public void eat();
 11 
 12     public void paint();
 13 }
 14 
 15 /**
 16  * 这里定义了两个接口：Singer 在Singer接口里面定义了sing()和sleep()这两个抽象方法。
 17  * 
 18  * @author gacl
 19  * 
 20  */
 21 interface Singer {
 22     public void sing();
 23 
 24     public void sleep();
 25 }
 26 
 27 /**
 28  * 类Student实现了Singer这个接口
 29  * 
 30  * @author gacl
 31  * 
 32  */
 33 class Student implements Singer {
 34 
 35     private String name;
 36 
 37     public Student(String name) {
 38         this.name = name;
 39     }
 40 
 41     public String getName() {
 42         return name;
 43     }
 44 
 45     public void setName(String name) {
 46         this.name = name;
 47     }
 48 
 49     /**
 50      * 实现接口中定义的sing方法
 51      */
 52     @Override
 53     public void sing() {
 54         System.out.println("student is singing");
 55     }
 56 
 57     /**
 58      * 实现接口中定义的sleep方法
 59      */
 60     @Override
 61     public void sleep() {
 62         System.out.println("student is sleeping");
 63     }
 64 
 65     public void study() {
 66         System.out.println("Studying...");
 67     }
 68 
 69 }
 70 
 71 /**
 72  * Teacher这个类实现了两个接口：Singer和Painter。 这里Teacher这个类通过实现两个不相关的接口而实现了多重继承。
 73  * 
 74  * @author gacl
 75  * 
 76  */
 77 class Teacher implements Singer, Painter {
 78 
 79     private String name;
 80 
 81     public Teacher(String name) {
 82         this.name = name;
 83     }
 84 
 85     /**
 86      * 在Teacher类里面重写了这两个接口里面的抽象方法，
 87      * 通过重写抽象方法实现了这两个接口里面的抽象方法。
 88      */
 89     @Override
 90     public void eat() {
 91         System.out.println("teacher is eating");
 92     }
 93 
 94     public String getName() {
 95         return name;
 96     }
 97 
 98     @Override
 99     public void paint() {
100         System.out.println("teacher is painting");
101     }
102 
103     public void setName(String name) {
104         this.name = name;
105     }
106 
107     @Override
108     public void sing() {
109         System.out.println("teacher is singing");
110     }
111 
112     @Override
113     public void sleep() {
114         System.out.println("teacher is sleeping");
115     }
116 
117     public void teach() {
118         System.out.println("teaching...");
119     }
120 }
121 
122 public class TestInterfaces {
123 
124     public static void main(String[] args) {
125         /**
126          * 这里定义了一个接口类型的变量s1
127          */
128         Singer s1 = new Student("le");
129         s1.sing();
130         s1.sleep();
131         Singer s2 = new Teacher("steven");
132         s2.sing();
133         s2.sleep();
134         Painter p1 = (Painter)s2;
135         p1.paint();
136         p1.eat();
137     }
138 }

  1 package javastudy.summary;
  2 
  3 /**
  4  * 把“值钱的东西”这个类定义成一个接口Valuable。在接口里面定义了一个抽象方法getMoney()
  5  * @author gacl
  6  *
  7  */
  8 interface Valuable {
  9     public double getMoney();
 10 }
 11 
 12 /**
 13  * 把“应该受到保护的东西”这个类定义成一个接口Protectable。
 14  * 在接口里面定义了一个抽象方法beProtected();
 15  * @author gacl
 16  *
 17  */
 18 interface Protectable {
 19     public void beProteced();
 20 }
 21 
 22 /**
 23  * 这里是接口与接口之间的继承，接口A继承了接口Protectable，
 24  * 因此自然而然地继承了接口Protectable里面的抽象方法beProtected()。
 25  * 因此某一类去实现接口A时，除了要实现接口A里面定义的抽象方法m()以外，
 26  * 还要实现接口A从它的父接口继承下来的抽象方法beProtected()。
 27  * 只有把这两个抽象方法都实现了才算是实现了接口A。
 28  * @author gacl
 29  *
 30  */
 31 interface A extends Protectable {
 32     void m();
 33 }
 34 
 35 /**
 36  * 这里定义了一个抽象类Animal。
 37  * @author gacl
 38  *
 39  */
 40 abstract class Animal {
 41     private String name;
 42     /**
 43      * 在Animal类里面声明了一个抽象方法enjoy()
 44      */
 45     abstract void enjoy();
 46 }
 47 
 48 /**
 49  * 这里是为了实现了我们原来的语义：
 50  * “金丝猴是一种动物”同时“他也是一种值钱的东西”同时“他也是应该受到保护的东西”。而定义的一个类GoldenMonKey。
 51  * 为了实现上面的语义，这里把“值钱的东西”这个类定义成了一个接口Valuable，
 52  * 把“应该受到保护的东西”这个类也定义成了一个接口Protectable。这样就可以实现多继承了。
 53  * GoldenMonKey类首先从Animal类继承，然后GoldenMonKey类再去实现Valuable接口和Protectable接口，
 54  * 这样就可以实现GoldenMonKey类同时从Animal类，Valuable类，Protectable类继承了，即实现了多重继承，
 55  * 实现了原来的语义。
 56  * @author gacl
 57  *
 58  */
 59 class GoldenMonKey extends Animal implements Valuable,Protectable {
 60 
 61     /**
 62      * 在GoldenMoKey类里面重写了接口Protectable里面的beProtected()这个抽象方法，
 63      * 实现了接口Protectable。
 64      */
 65     @Override
 66     public void beProteced() {
 67         System.out.println("live in the Room");
 68     }
 69 
 70     /**
 71      * 在GoldenMoKey类里面重写了接口Valuable里面的getMoney()这个抽象方法，实现了接口Valuable。
 72      */
 73     @Override
 74     public double getMoney() {
 75         return 10000;
 76     }
 77 
 78     /**
 79      * 这里重写了从抽象类Animal继承下来的抽象方法enjoy()。
 80      * 实现了这抽象方法，不过这里是空实现，空实现也是一种实现。
 81      */
 82     @Override
 83     void enjoy() {
 84         
 85     }
 86     
 87     public static void test() {
 88         /**
 89          * 实际当中在内存里面我们new的是金丝猴，在金丝猴里面有很多的方法，
 90          * 但是接口的引用对象v能看到的就只有在接口Valuable里面声明的getMoney()方法，
 91          * 因此可以使用v.getMoney()来调用方法。而别的方法v都看不到，自然也调用不到了。
 92          */
 93         Valuable v = new GoldenMonKey();
 94         System.out.println(v.getMoney());
 95         /**
 96          * 把v强制转换成p，相当于换了一个窗口，通过这个窗口只能看得到接口Protectable里面的beProtected()方法
 97          */
 98         Protectable p = (Protectable)v;
 99         p.beProteced();
100     } 
101 }
102 
103 /**
104  * 这里让Hen类去实现接口A，接口A又是从接口Protectable继承而来，接口A自己又定义了一个抽象方法m()，
105  * 所以此时相当于接口A里面有两个抽象方法：m()和beProtected()。
106  * 因此Hen类要去实现接口A，就要重写A里面的两个抽象方法，实现了这两个抽象方法后才算是实现了接口A。
107  * @author gacl
108  *
109  */
110 class Hen implements A {
111 
112     @Override
113     public void beProteced() {
114         
115     }
116 
117     @Override
118     public void m() {
119         
120     }
121     
122 }
123 
124 /**
125  * java中定义接口
126  */
127 public class JavaInterfacesTest {
128 
129     public static void main(String[] args) {
130         GoldenMonKey.test();
131     }
132 }