指一个类只有一个实例,且该类能自行创建这个实例的一种模式
1、单例类只有一个实例对象; 2、该单例对象必须由单例类自行创建; 3、单例类对外提供一个访问该单例的全局访问点;
单例类:包含一个实例且能自行创建这个实例的类。 访问类:使用单例的类。
案例
public class SingletonLazy
{
public static void main(String[] args)
{
President zt1=President.getInstance();
zt1.getName(); //输出总统的名字
President zt2=President.getInstance();
zt2.getName(); //输出总统的名字
if(zt1==zt2)
{
System.out.println("他们是同一人!");
}
else
{
System.out.println("他们不是同一人!");
}
}
}
class President
{
private static volatile President instance=null; //保证instance在所有线程中同步
//private避免类在外部被实例化
private President()
{
System.out.println("产生一个总统!");
}
public static synchronized President getInstance()
{
//在getInstance方法上加同步
if(instance==null)
{
instance=new President();
}
else
{
System.out.println("已经有一个总统,不能产生新总统!");
}
return instance;
}
public void getName()
{
System.out.println("我是美国总统:特朗普。");
}
}
定义一个创建产品对象的工厂接口,将产品对象的实际创建工作推迟到具体子工厂类当中。
用户只需要知道具体工厂的名称就可得到所要的产品,无须知道产品的具体创建过程; 在系统增加新的产品时只需要添加具体产品类和对应的具体工厂类,无须对原工厂进行任何修改,满足开闭原则;
1、抽象工厂(Abstract Factory):提供了创建产品的接口,调用者通过它访问具体工厂的工厂方法 newProduct() 来创建产品。 2、具体工厂(ConcreteFactory):主要是实现抽象工厂中的抽象方法,完成具体产品的创建。 3、抽象产品(Product):定义了产品的规范,描述了产品的主要特性和功能。 4、具体产品(ConcreteProduct):实现了抽象产品角色所定义的接口,由具体工厂来创建,它同具体工厂之间一一对应。
案例
package FactoryMethod;
import java.awt.*;
import javax.swing.*;
public class AnimalFarmTest
{
public static void main(String[] args)
{
try
{
Animal a;
AnimalFarm af;
af=(AnimalFarm) ReadXML2.getObject();
a=af.newAnimal();
a.show();
}
catch(Exception e)
{
System.out.println(e.getMessage());
}
}
}
//抽象产品:动物类
interface Animal
{
public void show();
}
//具体产品:马类
class Horse implements Animal
{
JScrollPane sp;
JFrame jf=new JFrame("工厂方法模式测试");
public Horse()
{
Container contentPane=jf.getContentPane();
JPanel p1=new JPanel();
p1.setLayout(new GridLayout(1,1));
p1.setBorder(BorderFactory.createTitledBorder("动物:马"));
sp=new JScrollPane(p1);
contentPane.add(sp, BorderLayout.CENTER);
JLabel l1=new JLabel(new ImageIcon("src/A_Horse.jpg"));
p1.add(l1);
jf.pack();
jf.setVisible(false);
jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); //用户点击窗口关闭
}
public void show()
{
jf.setVisible(true);
}
}
//具体产品:牛类
class Cattle implements Animal
{
JScrollPane sp;
JFrame jf=new JFrame("工厂方法模式测试");
public Cattle()
{
Container contentPane=jf.getContentPane();
JPanel p1=new JPanel();
p1.setLayout(new GridLayout(1,1));
p1.setBorder(BorderFactory.createTitledBorder("动物:牛"));
sp=new JScrollPane(p1);
contentPane.add(sp,BorderLayout.CENTER);
JLabel l1=new JLabel(new ImageIcon("src/A_Cattle.jpg"));
p1.add(l1);
jf.pack();
jf.setVisible(false);
jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); //用户点击窗口关闭
}
public void show()
{
jf.setVisible(true);
}
}
//抽象工厂:畜牧场
interface AnimalFarm
{
public Animal newAnimal();
}
//具体工厂:养马场
class HorseFarm implements AnimalFarm
{
public Animal newAnimal()
{
System.out.println("新马出生!");
return new Horse();
}
}
//具体工厂:养牛场
class CattleFarm implements AnimalFarm
{
public Animal newAnimal()
{
System.out.println("新牛出生!");
return new Cattle();
}
}
准备工作
package FactoryMethod;
import javax.xml.parsers.*;
import org.w3c.dom.*;
import java.io.*;
class ReadXML2
{
public static Object getObject()
{
try
{
DocumentBuilderFactory dFactory=DocumentBuilderFactory.newInstance();
DocumentBuilder builder=dFactory.newDocumentBuilder();
Document doc;
doc=builder.parse(new File("src/FactoryMethod/config2.xml"));
NodeList nl=doc.getElementsByTagName("className");
Node classNode=nl.item(0).getFirstChild();
String cName="FactoryMethod."+classNode.getNodeValue();
System.out.println("新类名:"+cName);
Class<?> c=Class.forName(cName);
Object obj=c.newInstance();
return obj;
}
catch(Exception e)
{
e.printStackTrace();
return null;
}
}
}
指在不改变现有对象结构的情况下,动态地给该对象增加一些职责(即增加其额外功能)的模式
1、采用装饰模式扩展对象的功能比采用继承方式更加灵活。 2、可以设计出多个不同的具体装饰类,创造出多个不同行为的组合
1、抽象构件(Component)角色:定义一个抽象接口以规范准备接收附加责任的对象。 2、具体构件(Concrete Component)角色:实现抽象构件,通过装饰角色为其添加一些职责。 3、抽象装饰(Decorator)角色:继承抽象构件,并包含具体构件的实例,可以通过其子类扩展具体构件的功能。 4、具体装饰(ConcreteDecorator)角色:实现抽象装饰的相关方法,并给具体构件对象添加附加的责任。
案例
package decorator;
import java.awt.*;
import javax.swing.*;
public class MorriganAensland
{
public static void main(String[] args)
{
Morrigan m0=new original();
m0.display();
Morrigan m1=new Succubus(m0);
m1.display();
Morrigan m2=new Girl(m0);
m2.display();
}
}
//抽象构件角色:莫莉卡
interface Morrigan
{
public void display();
}
//具体构件角色:原身
class original extends JFrame implements Morrigan
{
private static final long serialVersionUID = 1L;
private String t="Morrigan0.jpg";
public original()
{
super("《恶魔战士》中的莫莉卡·安斯兰");
}
public void setImage(String t)
{
this.t=t;
}
public void display()
{
this.setLayout(new FlowLayout());
JLabel l1=new JLabel(new ImageIcon("src/decorator/"+t));
this.add(l1);
this.pack();
this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
this.setVisible(true);
}
}
//抽象装饰角色:变形
class Changer implements Morrigan
{
Morrigan m;
public Changer(Morrigan m)
{
this.m=m;
}
public void display()
{
m.display();
}
}
//具体装饰角色:女妖
class Succubus extends Changer
{
public Succubus(Morrigan m)
{
super(m);
}
public void display()
{
setChanger();
super.display();
}
public void setChanger()
{
((original) super.m).setImage("Morrigan1.jpg");
}
}
//具体装饰角色:少女
class Girl extends Changer
{
public Girl(Morrigan m)
{
super(m);
}
public void display()
{
setChanger();
super.display();
}
public void setChanger()
{
((original) super.m).setImage("Morrigan2.jpg");
}
}
将一个类的接口转换成客户希望的另外一个接口,使得原本由于接口不兼容而不能一起工作的那些类能一起工作。
1、客户端通过适配器可以透明地调用目标接口。 2、复用了现存的类,程序员不需要修改原有代码而重用现有的适配者类。 3、将目标类和适配者类解耦,解决了目标类和适配者类接口不一致的问题。
1、目标(Target)接口:当前系统业务所期待的接口,它可以是抽象类或接口。 2、适配者(Adaptee)类:它是被访问和适配的现存组件库中的组件接口。 3、适配器(Adapter)类:它是一个转换器,通过继承或引用适配者的对象,把适配者接口转换成目标接口,让客户按目标接口的格式访问适配者。
案例
package adapter;
//目标:发动机
interface Motor
{
public void drive();
}
//适配者1:电能发动机
class ElectricMotor
{
public void electricDrive()
{
System.out.println("电能发动机驱动汽车!");
}
}
//适配者2:光能发动机
class OpticalMotor
{
public void opticalDrive()
{
System.out.println("光能发动机驱动汽车!");
}
}
//电能适配器
class ElectricAdapter implements Motor
{
private ElectricMotor emotor;
public ElectricAdapter()
{
emotor=new ElectricMotor();
}
public void drive()
{
emotor.electricDrive();
}
}
//光能适配器
class OpticalAdapter implements Motor
{
private OpticalMotor omotor;
public OpticalAdapter()
{
omotor=new OpticalMotor();
}
public void drive()
{
omotor.opticalDrive();
}
}
//客户端代码
public class MotorAdapterTest
{
public static void main(String[] args)
{
System.out.println("适配器模式测试:");
Motor motor=(Motor)ReadXML.getObject();
motor.drive();
}
}
准备工作
package adapter;
import javax.xml.parsers.*;
import org.w3c.dom.*;
import java.io.*;
class ReadXML
{
public static Object getObject()
{
try
{
DocumentBuilderFactory dFactory=DocumentBuilderFactory.newInstance();
DocumentBuilder builder=dFactory.newDocumentBuilder();
Document doc;
doc=builder.parse(new File("src/adapter/config.xml"));
NodeList nl=doc.getElementsByTagName("className");
Node classNode=nl.item(0).getFirstChild();
String cName="adapter."+classNode.getNodeValue();
Class<?> c=Class.forName(cName);
Object obj=c.newInstance();
return obj;
}
catch(Exception e)
{
e.printStackTrace();
return null;
}
}
}
来源:http://c.biancheng.net/view/1338.html