1.工厂方法模式(Factory Method) 将程序中创建对象的操作,单独出来处理,创建一个产品的工厂接口,把实际的工作转移到具体的子类。大大提高了系统扩展的柔性,接口的抽象化处理给相互依赖的对象创建提供了最好的抽象模式。
2.单例模式(Singleton) 改善全局变量和命名空间的冲突,可以说是一种改良了的全局变量。这种一个类只有一个实例,且提供一个访问全局点的方式,更加灵活的保证了实例的创建和访问约束。系统中只有一个实例,因此构造方法应该为私有 饿汉式:类加载时直接创建静态实例 懒汉式:第一次需要时才创建一个实例,那么newInstance方法要加同步 饿汉式比懒汉式要好,尽管资源利用率要差。但是不用同步。
3.抽象工厂模式(Abstract Factory) 针对多个产品等级的情况,而工厂方法模式针对单一产品等级的情况。
4.原型模式(ProtoType) 通过一个原型对象来创建一个新对象(克隆)。Java中要给出Clonable接口的实现,具体类要实现这个接口,并给出clone()方法的实现细节,这就是简单原型模式的应用。 浅拷贝:只拷贝简单属性的值和对象属性的地址 深拷贝:拷贝本对象引用的对象,有可能会出现循环引用的情况。可以用串行化解决深拷贝。写到流里再读出来,这时会是一个对象的深拷贝结果。
5.适配器模式(Adapter) 在原类型不做任何改变的情况下,用一个适配器类把一个接口转成另一个接口,扩展了新的接口,灵活且多样的适配一切旧俗。这种打破旧框框,适配新格局的思想,是面向对象的精髓。以继承方式实现的类的 Adapter模式和以聚合方式实现的对象的Adapter模式,各有千秋,各取所长。
6.组合模式(Composite) 把整体和局部的关系用树状结构描述出来,使得客户端把整体对象和局部对象同等看待。
7.模板方法(Template Method) 准备一个抽象类,把部分确定的逻辑定义在某些方法中,用其他抽象方法实现剩余的逻辑。不同子类对这些逻辑有不同的实现。 用法:定义多个抽象操作,定义并实现一个模板方法,将步骤放在这个具体方法里,推迟到子类实现。子类可以改变父类的可变部分,但不能改变模板方法所代表的顶级逻辑。
8.迭代器模式(Iterator) 类似于集合中的Iterator,使用迭代器来统一不同集合对象的遍历方式。在绝大多数的系统中,都会用到数组、集合、链表、队列这样的类型,关心迭代模式的来龙去脉非常有必要。在遍历算法中,迭代模式提供了遍历的顺序访问容 器,GOF给出的定义为:提供一种方法访问一个容器(container)对象中各个元素,而又不需暴露该对象的内部细节。.NET中就是使用了迭代器来 创建用于foreach的集合。
9..状态模式(State) 在对象内部状态改变时改变其行为。把所研究的对象的行为封装在不同的状态对象中。
public class TestFactoryMethod {
public static void main(String[] args) {
AnimalFactory af=new DogFactory();
Animal1 a=af.getAnimal();
}
}
abstract class Animal1{}
class Dog1 extends Animal1{}
class Cat1 extends Animal1{}
abstract class AnimalFactory{
public abstract Animal1 getAnimal();
}
class DogFactory extends AnimalFactory{
public Animal1 getAnimal(){
System.out.println("Dog");
return new Dog1();
}
}
class CatFactory extends AnimalFactory{
public Animal1 getAnimal(){
System.out.println("Cat");
return new Cat1();
}
}
2.单例模式(Singleton) 改善全局变量和命名空间的冲突,可以说是一种改良了的全局变量。这种一个类只有一个实例,且提供一个访问全局点的方式,更加灵活的保证了实例的创建和访问约束。系统中只有一个实例,因此构造方法应该为私有 饿汉式:类加载时直接创建静态实例 懒汉式:第一次需要时才创建一个实例,那么newInstance方法要加同步 饿汉式比懒汉式要好,尽管资源利用率要差。但是不用同步。
public class TestSingleton {
public static void main(String[] args) {
}
}
class ClassA{ //饿汉式
private static ClassA i=new ClassA();
public static ClassA newInstance(){
return i;
}
private ClassA(){}
}
class ClassB{ //懒汉式
private static ClassB i=null;
public static synchronized ClassB newInstance(){
if (i==null) i=new ClassB();
return i;
}
private ClassB(){}
}
3.抽象工厂模式(Abstract Factory) 针对多个产品等级的情况,而工厂方法模式针对单一产品等级的情况。
import java.awt.*;
import javax.swing.*;
import java.awt.event.*;
public class TestAbstractFactory {
public static void main(String[] args) {
GUIFactory fact=new SwingFactory();
Frame f=fact.getFrame();
Component c1=fact.getButton();
Component c2=fact.getTextField();
f.setSize(500,300);
f.setLayout(new FlowLayout());
f.add(c1);
f.add(c2);
f.setVisible(true);
f.addWindowListener(new WindowAdapter(){
public void windowClosing(WindowEvent e){
System.exit(0);
}
});
}
}
abstract class GUIFactory{
public abstract Component getButton();
public abstract Component getTextField();
public abstract Frame getFrame();
}
class AWTFactory extends GUIFactory{
public Component getButton() {
return new Button("AWT Button");
}
public Frame getFrame() {
return new Frame("AWT Frame");
}
public Component getTextField() {
return new TextField(20);
}
}
class SwingFactory extends GUIFactory{
public Component getButton() {
return new JButton("Swing Button");
}
public Frame getFrame() {
return new JFrame("Swing Frame");
}
public Component getTextField() {
return new JTextField(20);
}
}
4.原型模式(ProtoType) 通过一个原型对象来创建一个新对象(克隆)。Java中要给出Clonable接口的实现,具体类要实现这个接口,并给出clone()方法的实现细节,这就是简单原型模式的应用。 浅拷贝:只拷贝简单属性的值和对象属性的地址 深拷贝:拷贝本对象引用的对象,有可能会出现循环引用的情况。可以用串行化解决深拷贝。写到流里再读出来,这时会是一个对象的深拷贝结果。
import java.io.*;
public class TestClonealbe {
public static void main(String[] args) throws Exception {
Father f=new Father();
User u1=new User("123456",f);
User u2=(User)u1.clone();
System.out.println(u1==u2);
System.out.println(u1.f==u2.f);
}
}
class User implements Cloneable,Serializable{
String password;
Father f;
public User(String password,Father f){
this.password=password;
this.f=f;
}
public Object clone() throws CloneNotSupportedException {
//return super.clone();
ObjectOutputStream out=null;
ObjectInputStream in=null;
try {
ByteArrayOutputStream bo=new ByteArrayOutputStream();
out = new ObjectOutputStream(bo);
out.writeObject(this);
out.flush();
byte[] bs=bo.toByteArray();
ByteArrayInputStream bi=new ByteArrayInputStream(bs);
in = new ObjectInputStream(bi);
Object o=in.readObject();
return o;
} catch (IOException e) {
e.printStackTrace();
return null;
} catch (ClassNotFoundException e) {
e.printStackTrace();
return null;
}
finally{
try {
out.close();
in.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
class Father implements Serializable{}
5.适配器模式(Adapter) 在原类型不做任何改变的情况下,用一个适配器类把一个接口转成另一个接口,扩展了新的接口,灵活且多样的适配一切旧俗。这种打破旧框框,适配新格局的思想,是面向对象的精髓。以继承方式实现的类的 Adapter模式和以聚合方式实现的对象的Adapter模式,各有千秋,各取所长。
public class TestAdapter {
public static void main(String[] args) {
USB mouse=new Mouse();
PC pc=new PC();
//pc.useMouse(mouse);
PS2 adapter=new USB2PS2Adapter(mouse);
pc.useMouse(adapter);
}
}
interface PS2{
void usePs2();
}
interface USB{
void useUsb();
}
class Mouse implements USB{
public void useUsb(){
System.out.println("通过USB接口工作");
}
}
class PC{
public void useMouse(PS2 ps2Mouse){
ps2Mouse.usePs2();
}
}
class USB2PS2Adapter implements PS2{
private USB usb;
public USB2PS2Adapter(USB usb) {
this.usb = usb;
}
public void usePs2(){
System.out.println("把对usePS2的方法调用转换成对useUSB的方法调用");
usb.useUsb();
}
}
6.组合模式(Composite) 把整体和局部的关系用树状结构描述出来,使得客户端把整体对象和局部对象同等看待。
import java.util.*;
public class TestComposite {
public static void main(String[] args) {
Node n1=new LeafNode(3);
Node n2=new LeafNode(4);
Node n3=new LeafNode(6);
Node n4=new LeafNode(5);
Node n5=new LeafNode(2);
Node n6=new LeafNode(9);
Node n7=new LeafNode(12);
Node n8=new LeafNode(7);
Node n9=new LeafNode(8);
Node c1=new CompositeNode(n1,n2,n3);
Node c4=new CompositeNode(n8,n9);
Node c3=new CompositeNode(n5,c4);
Node c2=new CompositeNode(n4,c3);
Node c5=new CompositeNode(n6,n7);
Node root=new CompositeNode(c1,c2,c5);
System.out.println(root.getValue());
}
}
abstract class Node{
public abstract int getValue();
}
class LeafNode extends Node{
int value;
public LeafNode(int value){
this.value=value;
}
public int getValue(){
return value;
}
}
class CompositeNode extends Node{
private List children=new ArrayList();
public CompositeNode(Node... nodes){
for(Node n:nodes){
children.add(n);
}
}
public int getValue(){
int result=0;
for(Node n:children){
result+=n.getValue();
}
return result;
}
}
7.模板方法(Template Method) 准备一个抽象类,把部分确定的逻辑定义在某些方法中,用其他抽象方法实现剩余的逻辑。不同子类对这些逻辑有不同的实现。 用法:定义多个抽象操作,定义并实现一个模板方法,将步骤放在这个具体方法里,推迟到子类实现。子类可以改变父类的可变部分,但不能改变模板方法所代表的顶级逻辑。
public class TestTemplateMethod {
public static void main(String[] args) {
XiaoPin xp=new DaPuKe();
xp.act();
}
}
abstract class XiaoPin{
public abstract void jiaoLiu();
public abstract void xuShi();
public abstract void gaoXiao();
public abstract void shanQing();
public final void act(){
jiaoLiu();
xuShi();
gaoXiao();
shanQing();
}
}
class DaPuKe extends XiaoPin{
public void jiaoLiu(){
System.out.println("顺口溜");
}
public void xuShi(){
System.out.println("火车除夕,老同学见面");
}
public void gaoXiao(){
System.out.println("名片当作扑克");
}
public void shanQing(){
System.out.println("马家军");
}
}
8.迭代器模式(Iterator) 类似于集合中的Iterator,使用迭代器来统一不同集合对象的遍历方式。在绝大多数的系统中,都会用到数组、集合、链表、队列这样的类型,关心迭代模式的来龙去脉非常有必要。在遍历算法中,迭代模式提供了遍历的顺序访问容 器,GOF给出的定义为:提供一种方法访问一个容器(container)对象中各个元素,而又不需暴露该对象的内部细节。.NET中就是使用了迭代器来 创建用于foreach的集合。
public class TestIterator {
public static void main(String[] args) {
Stack s=new Stack();
s.push("Liucy");
s.push("Huxz");
s.push("George");
LinkedList l=new LinkedList();
l.addFirst("Liucy");
l.addFirst("Huxz");
l.addFirst("George");
print(l.iterator());
}
public static void print(Itr it){
while(it.hasNext()){
System.out.println(it.next());
}
}
}
interface Itr{
boolean hasNext();
Object next();
}
class Stack{
Object[] os=new Object[10];
int index=0;
private void expand(){
Object[] os2=new Object[os.length*2];
System.arraycopy(os,0,os2,0,os.length);
os=os2;
}
public void push(Object o){
if (index==os.length) expand();
os[index]=o;
index++;
}
public Object pop(){
index--;
Object o=os[index];
os[index]=null;
return o;
}
private class StackItr implements Itr{
int cursor=0;
public boolean hasNext(){
return cursor}
public Object next(){
return os[cursor++];
}
}
public Itr iterator(){
return new StackItr();
}
}
class LinkedList{
private class Node{
Object o;
Node next;
public Node(Object o){
this.o=o;
}
public void setNext(Node next){
this.next=next;
}
public Node getNext(){
return this.next;
}
}
Node head;
public void addFirst(Object o){
Node n=new Node(o);
n.setNext(head);
head=n;
}
public Object removeFirst(){
Node n=head;
head=head.getNext();
return n.o;
}
class LinkedListItr implements Itr{
Node currentNode=head;
public boolean hasNext(){
return this.currentNode!=null;
}
public Object next(){
Node n=currentNode;
currentNode=currentNode.getNext();
return n.o;
}
}
public Itr iterator(){
return new LinkedListItr();
}
}
9..状态模式(State) 在对象内部状态改变时改变其行为。把所研究的对象的行为封装在不同的状态对象中。
import static java.lang.System.*;
public class TestState {
public static void main(String[] args) {
BBSUser u=new BBSUser();
u.setState(new GuestState());
u.publish();
u.setState(new NormalState());
u.publish();
u.setState(new BlockedState());
u.publish();
u.setState(new NewComerState());
u.publish();
}
}
class BBSUser{
private State state;
public void setState(State state){
this.state=state;
}
public void publish(){
state.action();
}
}
abstract class State{
public abstract void action();
}
class GuestState extends State{
public void action(){
out.println("您处在游客状态,请先登录");
}
}
class NormalState extends State{
public void action(){
out.println("您处在正常状态,文章发表成功");
}
}
class BlockedState extends State{
public void action(){
out.println("您处在被封状态,文章发表失败");
}
}
class NewComerState extends State{
public void action(){
out.println("您是新手,请先学习一下,3天后再来");
}
}
class StateFactory{
public static State createState(int i){
if (i==1) return new GuestState();
else return new NormalState();
}
}