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

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

此过渡段就称为工厂设计

改进后的程序

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

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

图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();
	}
}

抽象类和接口的关系

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