java抽象类与接口——设计模式

古城微笑少年丶 2022-07-12 11:45 183阅读 0赞

1、工厂模式

先看程序1：

package com.java.abs;
    
    interface Fruit {// 定义一个接口水果
    	public void eat();
    }
    
    class Apple implements Fruit {
    
    	public void eat() {
    		System.out.println("吃苹果");
    	}
    
    }
    
    class Orange implements Fruit {
    
    	public void eat() {
    		System.out.println("吃橘子");
    	}
    
    }
    
    public class InterfaceCaseDemo1 {
    
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		Fruit f = new Apple();// 实例化接口
    		f.eat();
    	}

分析代码：主方法应该表示一个客户端，主方法的代码越少越好，此时，直接在主方法中指定了解要操作的子类，如果要更换子类，就要修改客户端，就表示跟特定的子类紧密耦合在一起了。

JVM的工作原理：程序→JVM→操作系统

图1![图1][1]

此过渡段就称为工厂设计

改进后的程序

package com.java.abs;
    
    interface Fruit {// 定义一个接口水果
    	public void eat();
    }
    
    class Apple implements Fruit {
    
    	public void eat() {
    		System.out.println("吃苹果");
    	}
    
    }
    
    class Orange implements Fruit {
    
    	public void eat() {
    		System.out.println("吃橘子");
    	}
    
    }
    
    class Factory {// 定义工厂类 public static Fruit getInstance(String className) { Fruit f = null; if ("Apple".equalsIgnoreCase(className)) { /* * 一般字符串比较，不写成className.equalsIgnoreCase("Apple") * 因为className为空时，空的对象无法调用方法，即产生空指针异常！ */ f = new Apple(); } if ("Orange".equalsIgnoreCase(className)) { f = new Orange(); } return f; } }
    
    public class InterfaceCaseDemo1 {
    
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		Fruit f = Factory.getInstance(args[0]);// 实例化接口args[0]通过初始化参数设置。在dos下运行才可以设置
    		if (f != null) {
    			f.eat();
    		}
    	}
    }

2、代理模式

package com.java.abs;
    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 InterfaceCaseDemo2 {
    
    
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		Network net = null;
    		net = new Proxy(new Real());// 制定代理操作    构造方法的参数是 new Real
    		net.browse();
    	}
    
    
    }

图2 ![图2][2]

3、适配器模式（多用于java图形化界面）  
对于java程序来说：如果要实现一个接口，则肯定要覆写接口中的全部抽象方法，那么如果，接口中方法太多，但是子类有用不到那么多的抽象方法，则很麻烦，此时需要一个中间过渡，但是此过渡类有不希望被直接使用，所以将此过渡类定义成抽象类比较合适，即一个接口首先被一个抽象类（称作适配器类），并在此抽象类中实现若方法（方法体为空），则以后的子类直接继承此抽象类，就可以有选择的覆写所需要的方法了。

图3![图3][3]

package com.java.extend;
    
    interface Windows {
    	public void open();
    
    	public void close();
    
    	public void activated();
    
    	public void iconified();
    
    	public void deiconified();
    
    }
    
    abstract class WindowAdapter {
    	public void open() {
    	}
    
    	public void close() {
    	}
    
    	public void activated() {
    	}
    
    	public void iconified() {
    	}
    
    	public void deiconified() {
    	}
    }
    
    class WindowsImpl extends WindowAdapter {
    
    	public void open() {
    		System.out.println("打开窗口");
    	}
    
    	public void close() {
    		System.out.println("关闭窗口");
    	}
    }
    
    public class AdapterDemo {
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		WindowsImpl wd = new WindowsImpl();
    		wd.open();
    		wd.close();
    	}
    }

抽象类与接口杂谈——内部类的扩展

在一个抽象类中定义一个接口，用内部类来继承并实现内部接口。反之，在一个接口中也可以定义一个抽象类程序2，但是实际中并不常见！

程序1：

package com.java.extend;
    
    abstract class A2 {
    	public abstract void printA();
    
    	interface B {
    		public void printB();
    	}
    }
    
    class X extends A2 {
    	public void printA() {
    		System.out.println("打印A1");
    	}
    
    	class Y implements B {
    		public void printB() {
    			System.out.println("打印B");
    		}
    	}
    }
    
    public class InnerExtend extends X {
    	public static void main(String args[]) {
    		A2.B b = new X().new Y();
    		b.printB();
    	}
    }

程序2

package com.java.extend;
    
    
    interface AA {
    	public abstract void printA();
    
    
    	abstract class B {
    		public abstract void printB();
    	}
    }
    
    
    class X1 implements AA {
    	public void printA() {
    		System.out.println("打印A1");
    	}
    
    
    	class Y extends B {
    		public void printB() {
    			System.out.println("打印B");
    		}
    	}
    }
    
    
    public class InnerExtend2 extends X1 {
    	public static void main(String args[]) {
    		B b = new X1().new Y();
    		b.printB();
    	}
    }

**抽象类和接口的关系**

**![图4][4]**

**接口和抽象类是使用普通子类，子类必须覆写全部抽象方法，写出方法体；**

[1]: /images/20220710/c9572abd7b214be5a3c75017e762fd65.png
[2]: /images/20220710/f981fde7a5b4412c81712ea7c63ccde3.png
[3]: /images/20220710/f0916a990f1b4e1bb8a2a6ca3f421e33.png
[4]: /images/20220710/8c2dfba34ea047f0b6c0b7c2651a5d9c.png