java面向对象程序设计(三)

抽象类的应用：

   设计模板

接口的应用：

   定制标准
设计模式

interface USB
{
    public void start();
    public void stop();
}

class Computer
{
    public static void plugin(USB usb)
    {
        usb.start();
        System.out.println("========= USB设备=========");
        usb.stop();
    }
};
class Flash implements USB
{
    public void start()
    {
        System.out.println("U 盘开始工作");
    }
    public void stop()
    {
        System.out.println("U盘停止工作");
    }
};
class Print implements USB
{
    public void start()
    {
        System.out.println("printer start to work.");
    }
    public void stop()
    {
        System.out.println("printer stop to work.");
    }
};
public class Main {
    public static void main(String[] args) {

              Computer.plugin(new Flash());
             Computer.plugin(new Print());
     }
}
输出结果：
      U 盘开始工作
      ========= USB设备=========
     U盘停止工作
     printer start to work.
     ========= USB设备=========
     printer stop to work.
 

 

    工厂设计模式：

    代理设计模式：
       由代理主题操作真实主题，真实主题执行具体的业务操作，代理主题负责相同的业务处理
       interface Network
{
    public void browse();
};
class Real implements Network
{
    public void browse(){
        System.out.println("上网浏览信息");
    }
};
class Proxy implements Network
{
    private Network network;
    public Proxy(Network network){
        this.network = network;
    }
    public void check(){
        System.out.println("检查用户是否合法");
    }
    public void browse(){
        this.check();
        this.network.browse();
    }
};
public class Main {
    public static void main(String[] args) {

   适配器设计模式

            在接口和实现接口的类中间再定义用来过渡的抽象类(常称为适配器类)，在这抽象类中实现若干方法(方法体为空)，实现接口的类再继承此抽象类，可以有选择地重写所需要的方法，而不必实现所有方法。
         interface Window//定义window接口
{
    public void open();
    public void close();
    public void activated();
    public void iconified();
    public void deiconified();
};
//定义抽象类(适配器类)实现接口，在此类中重写方法，但所有方法为空
abstract class WindowAdapter implements Window
{
    public void activated(){}   //重写activated()方法，方法体为空
    public void close(){}
    public void deiconified(){}
    public void iconified(){}
    public void open(){}
};
//定义通过继承适配器类实现接口的子类
class WindowImpl extends WindowAdapter
{
    public void open()
    {
        System.out.println("窗口打开.");
    }
    public void close()
    {
        System.out.println("窗口关闭");
    }
};
public class Main {
    public static void main(String[] args) {

             Window win = new WindowImpl();//实现接口对象
             win.open();
             win.close();   }
}
输出结果：
       窗口打开.
       窗口关闭

 

抽象类和接口的区别：

序号	区别点	抽象类	接口
1	定义	包含至少一个抽象方法	抽象方法和全局常量的集合
2	组成	构造方法、抽象方法、普通方法、常量、变量	常量、抽象方法
3	使用	子类继承抽象类(extends)	子类实现接口(implements)
4	关系	抽象类可以实现多个接口	接口不能继承抽象类，但可以继承多个接口
5	常见设计模式	模板设计	工厂设计、代理设计
6	对象	都通过对象的多态性产生实例化对象
7	局限性	抽象类只可以单继承	接口可以单继承也可多继承
8	实际	作为一个模板	作为一个标准
9	选择	如果抽象类和接口都可以使用，则优先使用接口，避免单继承的局限
10	特殊	一个抽象类中可以包含多个接口，一个接口中可以包含多个抽象类

 interface IA
{
    public abstract void printA();//定义抽象方法
    //定义内部抽象类
    abstract class IB{
        public abstract void printB();
    };
};
class IX implements IA
{
    public void printA()//实现接口的抽象方法
    {
        System.out.println("Hello-->A");
    }
    //在实现接口(A)的类(X)中定义内部类(Y)，这个内部类(Y)继承接口(A)中的内部抽象类(B)
    class IY extends IB
    {
        public void printB()
        {
            System.out.println("Hello-->B");
        }
    };
};
public class Main {
    public static void main(String[] args) {
        //接口中包含抽象类
        IA.IB b = new IX().new IY();
        b.printB();
    }
}
输出结果：Hello-->B

              Network net = null;
              net = new Proxy(new Real());
              net.browse();   
   }
}
           输出结果：
              检查用户是否合法
              上网浏览信息