zoukankan      html  css  js  c++  java
  • 接口

      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 }
  • 相关阅读:
    RabbitMQ系列2 RabbitMQ安装与基础入门
    RabbitMQ系列1 什么是MQ
    数据结构与算法系列1之数组介绍与动态数组实现
    数据结构与算法系列3之从内存角度分析数组与链表的区别
    Dubbo学习
    Can't locate Pod/Text.pm问题分析及解决
    “画饼”陷阱论
    自述
    结构光、立体视觉、ToF三种3D传感原理
    游侠郭解是如何被无脑粉坑死的?
  • 原文地址:https://www.cnblogs.com/ivy-xu/p/5295895.html
Copyright © 2011-2022 走看看