接口

  1 接口:比抽象类更抽象的类,是一种规范标准。可以表示一种能力,定义不同层之间的操作标准。
  2       在进行某些公共操作的时候一定要定义出接口
  3       接口和类都是类型
  4       如果没有继承关系,就要用接口(优先考虑)
  5       ★接口必须要有子类★
  6 范例:
  7 public interface A{
  8 /*接口里面只能是抽象方法*/
  9     public static final String MSG = "Hello";    //全局变量
 10     public abstract void print();    //抽象方法
 11 }
 12 接口存在抽象方法,所以接口对象★★★不能new进行实例化★★★的操作
 13 
 14 注意:
 15     一个子类可以实现(implements)多个接口
 16     ◆一个接口可以extends多个接口◆
 17     ★类和接口之间  不能(extends),只能(implements)★
 18     ★类和类,接口和接口可以继承(extends)★
 19     子类一定要实现(implements)接口的●所有●的方法【重写全部的抽象方法,向上转型】
 20 范例:
 21 /*接口A*/
 22 public interface A {    //定义了接口
 23     String MSG = "Hello";    //全局常量
 24     void print();    //抽象方法,不写访问修饰符默认是public
 25 }
 26 
 27 /*接口B*/
 28 public interface B {
 29     public void get();    //这里是抽象方法,可以省略abstract
 30 }
 31 
 32 //X类实现了 A和B两个接口
 33 public class X implements A,B{
 34     public void print(){
 35         System.out.println("A接口的抽象方法");
 36     }
 37     
 38     public void get(){
 39         System.out.println("B接口的抽象方法");
 40     }
 41 }
 42 
 43 public class TestX{
 44     public static void main(String[] args) {
 45         X x = new X();//接口A,B不能实例化    实例化子类对象
 46         A a = x;
 47         B b = x;
 48         a.print();
 49         b.get();
 50         System.out.println(b instanceof A);    /*多个栈空间可以指向同一个堆空间*/
 51         System.out.println(a instanceof B);    /*一个栈空间【不可以】指向多个堆空间*/
 52     }
 53 }
 54 
 55 如果X不想实现print方法,就定义X为抽象类,print()为抽象方法,再写一个其非抽象类的子类实现即可
 56 如果既有继承,又有实现,那么先写extends,再写implements,它们的所有抽象方法都要重写
 57 接口里面可以定义普通内部类,抽象内部类,内部接口
 58     如果内部类,内部接口有static,此时内部类称为外部类,或外部接口
 59 范例:
 60 public interface A {
 61     public void fun1();
 62     
 63     abstract class B{//内部类
 64         abstract void fun2();
 65     }
 66 }
 67 //看不到内部类B
 68 class H implements A{
 69 
 70     @Override
 71     public void fun1() {
 72         System.out.println("A的抽象方法");
 73     }
 74 }
 75 
 76 //调用A所有的方法
 77 class D extends A.B implements A{
 78 
 79     @Override
 80     public void fun1() {
 81         System.out.println("A的抽象方法");
 82     }
 83 
 84     @Override
 85     void fun2() {
 86         System.out.println("B的抽象方法");
 87     }
 88 }
 89 
 90 //调用内部类B
 91 class E extends A.B{
 92 
 93     @Override
 94     void fun2() {
 95         System.out.println("B的抽象方法");
 96     }
 97 }
 98 
 99 应用:USB
100 /*定义USB接口*/
101 public interface UsbInterFace {
102     void start();
103     void stop();
104 }
105 
106 /*要做的事情computer*/
107 public class Computer{
108     public void plugIn(UsbInterFace usbInterface) {
109         usbInterface.start();
110         usbInterface.stop();
111     }
112 }
113 
114 /*USB的类型1,实现USB*/
115 public class UDisk implements UsbInterFace {
116     @Override
117     public void start() {
118         System.out.println("U盘开始工作了");
119     }
120 
121     @Override
122     public void stop() {
123         System.out.println("U盘停止工作了");
124     }
125 }
126 
127 /*USB的类型2,实现USB*/
128 public class UsbFan implements UsbInterFace{
129     @Override
130     public void start() {
131         System.out.println("电风扇开始工作了");
132     }
133 
134     @Override
135     public void stop() {
136         System.out.println("电风扇停止工作了");
137     }
138 }
139 
140 /*测试类*/
141 public class TestComputer {
142     public static void main(String[] args) {
143         Computer computer = new Computer();
144         computer.plugIn(new UsbFan());
145         computer.plugIn(new UDisk());
146     }
147 }
148 
149 【工厂设计模式】
150     普通:在Factory类的方法中加if
151     高级:修改配置
152 范例1:
153 /*Fruit接口*/
154 public interface Fruit {
155     void eat();
156 }
157 
158 /*实现子类1*/
159 public class Apple implements Fruit {
160     @Override
161     public void eat() {
162         System.out.println("吃苹果");
163     }
164 }
165 
166 /*实现子类2*/
167 public class Orange implements Fruit {
168     @Override
169     public void eat() {
170         System.out.println("吃橘子");
171     }
172 }
173 
174 /*工厂类,批量生产实现子类*/
175 public class Factory {
176     public static Fruit getInstance(String className){
177         //有多少子类就写多少子类
178         if ("apple".equalsIgnoreCase(className)) {
179             return new Apple();
180         } else if("orange".equalsIgnoreCase(className)){
181             return new Orange();
182         } else {
183             return null;
184         }
185     }
186 }
187 
188 /*测试类*/
189 public class TestFruit {
190     public static void main(String[] args) {
191         Fruit f = Factory.getInstance("orange");【工厂类.(静态方法)getInstance(“用户输入的实现子类的名称”)】
192         f.eat();
193     }
194 }
195 
196 范例2:
197 /**
198  * 墨盒类
199  */
200 public interface Ink {
201     public String getColor();
202     /*接口内的抽象方法,可以有返回值,也可以没有返回值*/
203 }
204 
205 /**
206  * 纸张类
207  */
208 public interface Paper {
209     public String getSize();
210 }
211 
212 public class MyColorInk implements Ink {
213     @Override
214     public String getColor() {
215         return "暗金色";
216     }
217 }
218 
219 public class MyColorInkV3 extends MyColorInk {
220     @Override
221     public String getColor() {
222         return "暗红色";
223     }
224 }
225 
226 public class LaojiuPaper implements Paper{
227     @Override
228     public String getSize() {
229         return "A6L";
230     }
231 }
232 
233 public class LaojiuPaper implements Paper{
234     @Override
235     public String getSize() {
236         return "A6L";
237     }
238 }
239 
240 import java.io.IOException;
241 import java.util.Properties;
242 
243 /**
244  * 配置类
245  */
246 public class Config {
247     public static Properties props = new Properties();
248     //静态块-生命周期在整个应用程序运行之前
249     static{
250         //加载配置文件
251         try {
252             props.load(Config.class.getClassLoader().
253                     getResourceAsStream("MyConfig.properties")
254             );
255         } catch (IOException e) {
256             e.printStackTrace();
257         }
258     }
259     
260     /**
261      * 根据传入的名称得到相应实现类的实例(使用反射技术)
262      * @param name
263      * @return 
264      * @throws ClassNotFoundException
265      * @throws InstantiationException
266      * @throws IllegalAccessException
267      */
268     public static Object getInstance(String name) throws ClassNotFoundException, InstantiationException, IllegalAccessException{
269         //根据接口名得到实现类的全称
270         String fullName = getProperty(name);
271         if(null == fullName) return null;
272         //得到实现类
273         Class objClass = Class.forName(fullName);
274         //返回实现类的实例
275         return objClass.newInstance();
276     }
277     
278     /**
279      * 根据键得到配置文件中对应的值
280      * @param key 
281      * @return
282      */
283     public static String getProperty(String key){    //key == 对象
284         return props.getProperty(key);
285     }
286 }
287 
288 ★同一个java projiect中的MyConfig.properties记事本★(控制台输出的结果MyColorInk,LaojiuPaper)
289 ink=com.ljxy.kenny.printerdemo.MyColorInk
290 paper=com.ljxy.kenny.printerdemo.LaojiuPaper
291 
292 【代理设计模式】
293 范例:
294 public interface Subject {  //整个操作的核心主题
295     public void make();     //整个主题的核心功能
296 }
297 /*实现子类1*/
298 public class RealSubject implements Subject {    //真正执行核心功能的人
299     public void make() {
300         System.out.println("皇帝陛下正在XX。");
301     }
302 }
303 /*实现子类2-代理*/
304 public class ProxySubject implements Subject {    
305     private Subject subject;
306     /*代理的带参构造方法*/
307     public ProxySubject(Subject subject){
308         this.subject=subject;
309     }
310     
311     @override
312     public void make() {
313         this.prepare();
314         this.subject.make();
315         this.destory();
316     }
317     
318     public void prepare(){
319         System.out.println("为临幸做准备!");
320     }
321     
322     public void destory(){
323         System.out.println("把娘娘搬走了,皇帝伺候睡觉了!");
324     }
325 }
326 
327 public class TestDemo {
328     public static void main(String args[]){
329         Subject sub=new ProxySubject(new RealSubject());//实际实施临幸的RealSubject
330         sub.make();         //调用的是代理主题操作
331     }
332 }

 

posted @ 2016-03-19 18:21  Ivy_Xu  阅读(200)  评论(0编辑  收藏  举报