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();
}
}
}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();
}
}
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();
}
}
抽象类和接口的关系
接口和抽象类是使用普通子类，子类必须覆写全部抽象方法，写出方法体；
