|
一.单例设计模式 1.定义 Singleton是一种创建型模式，指某个类使用了Singleton模式，则这个类被创建后，只能产生一个实例供外部访问，并且提供一个全局的访问点。单例设计模式指的就是无论程序如何运行，采用单例设计模式的类（Singleton）永远都只会有一个实例化对象产生。 2.具体实现步骤 1).在其内部产生该类的实例化对象，并将其封装成private static类型；
2).将采用单例设计模式的类的构造方法私有化；
3).定义一个静态方法返回该类的实例。 3.代码示例 [Java] 纯文本查看 复制代码 [/size][/align][align=left][size=2]class Singleton{
// 1.在内部产生本类的实例化对象
private static Singleton instance = new Singleton();
// 2.将构造方法封装为私有化
private Singleton(){
}
// 3.通过静态方法返回instance对象
public static Singleton getInstance(){
return instance;
}
public void print(){
System.out.println("hello world!");
}
}
public class Singleton_Summary {
public static void main(String[] args) {
// 声明三个对象
Singleton st1 = null;
Singleton st2 = null;
Singleton st3 = null;
st1 = Singleton.getInstance();
st2 = Singleton.getInstance();
st3 = Singleton.getInstance();
st1.print();
st2.print();
st3.print();
System.out.println("st1==st2==st3: " + (st1 == st2));
}
}
单例模式的实现一： 饿汉式，线程安全，但效率比较低。 代码示例： [Java] 纯文本查看 复制代码 [/align][align=left]class SingletonTest01{
private static final SingletonTest01 instance = new SingletonTest01();
private SingletonTest01(){
}
public static SingletonTest01 getInstance(){
return instance;
}
}
public class Singleton01_Ehan {
public static void main(String[] args) {
}
}
单例模式的实现二：
懒汉式，非线程安全 代码示例： [Java] 纯文本查看 复制代码 [/align][align=left]class SingletonTest02{
private static SingletonTest02 instance;
private SingletonTest02(){
}
public static SingletonTest02 getInstance(){
if(instance == null){
instance = new SingletonTest02();
}
return instance;
}
}
懒汉式线程安全，但是效率非常低 [Java] 纯文本查看 复制代码 [/align][align=left]class SingletonTest03{
private static SingletonTest03 instance;
private SingletonTest03(){
}
public static synchronized SingletonTest03 getInstance(){
if(instance == null){
instance = new SingletonTest03();
}
return instance;
}
}懒汉式线程安全，并且效率高 [Java] 纯文本查看 复制代码 [/align][align=left]class SingletonTest04{
private static SingletonTest04 instance;
private SingletonTest04(){
}
public static SingletonTest04 getInstance(){
if(instance == null){
synchronized (SingletonTest04.class) {
if(instance == null){
instance = new SingletonTest04();
}
}
}
return instance;
}
}
二.工厂设计模式 1.定义 主要用来实例化有共同接口的类，工厂模式可以动态决定应该实例化那一个类。具体做法即程序在接口和子类之间加入了一个过渡端，通过此过渡端可以动态取得实现了共同接口的子类实例化对象。 2.工厂模式主要有以下几种形态： 1）简单工厂（SimpleFactory）； 2）工厂方法（FactoryMethod）； 3）抽象工厂（AbstractFactory）；
3.代码示例 [Java] 纯文本查看 复制代码 [/align][align=left]interface Animal{
public void say();
}
class Cat implements Animal{
public void say() {
System.out.println("我是cat，hello world！");
}
}
class Dog implements Animal{
public void say() {
System.out.println("我是dog，no bug!");
}
}
class Factory{ // 定义工厂类
public static Animal getInstance(String className){
Animal a = null; // 定义接口对象
if("Cat".equals(className)){ // 判断是哪个子类的标记
a = new Cat(); // 通过Cat类实例化接口
}
if("Dog".equals(className)){
a = new Dog(); // 通过Dog类实例化接口
}
return a;
}
}
public class FactoryDemo01 {
public static void main(String[] args) {
Animal a = null;
a = Factory.getInstance("Cat"); // 通过工厂获取一个实例
if(a != null){
a.say();
}
}
}
三.代理设计模式 1.定义 指由一个代理主题来操作真实主题，真实主题执行具体的业务操作，而代理主题负责其他相关业务的处理。 比如生活中的通过代理访问网络，客户通过网络代理连接网络（具体业务），由代理服务器完成用户权限和访问限制等与上网相关的其他操作（相关业务）。
2.代码示例 [Java] 纯文本查看 复制代码 [/align][align=left]interface Network{ // 定义Network接口
public void browse(); // 定义浏览的抽象方法
}
class Server 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(); // 调用真实的上网操作
}
}
四.观察者设计模式 1.定义 观察者设计模式，比如：现在许多购房者都密切观察者房价的变化，当房价变化时，所有的购房者都能观察到，以上的购房者属于观察者，这就是观察者设计模式。 java中可以借助Observable类和Observer接口轻松实现以上功能，当然此种模式并不仅仅局限于采用这两个类。
2.代码示例 [Java] 纯文本查看 复制代码 [/align][align=left]class House extends Observable{
private float price;
public House(float price){
this.price = price;
}
public void setPrice(float price){
this.setChanged(); // 设置变化点
this.notifyObservers(price); // 通知所有观察者变化改变
this.price = price;
}
public float getPrice(){
return this.price;
}
public String toString(){
return "房子的价格为：" + this.price;
}
}
class HousePriceObserver implements Observer{
private String name;
public HousePriceObserver(String name){
super();
this.name = name;
}
// 只要改变了，Observable 对象就调用此方法；
public void update(Observable o, Object arg) {
if(arg instanceof Float){
System.out.println(this.name + "观察的价格更改为：" + ((Float) arg).floatValue());
}
}
}
public class ObserverDemo01 {
public static void main(String[] args) {
// 通过构造方法给房子价格赋值
House house = new House(1000000);
// 输出房子价格
System.out.println("价格未修改时:\n" + house);
// 实例化观察者
HousePriceObserver hpo1 = new HousePriceObserver("瑞文");
HousePriceObserver hpo2 = new HousePriceObserver("亚索");
HousePriceObserver hpo3 = new HousePriceObserver("剑圣");
// 给房子注册观察者
house.addObserver(hpo1);
house.addObserver(hpo2);
house.addObserver(hpo3);
// 修改房价，会触发update(Observable o, Object arg) 方法通知购房者新的房价信息；
house.setPrice(2000000);
System.out.println("价格修改之后:" + house);
}
}
五.适配器设计模式 1.定义 如果一个类想要实现一个有很多抽象方法的接口，但是本身只需要实现接口中的部分方法就可以达成目的，因此，此时就需要一个中间过渡类。但此过渡类又不希望直接使用，因此将此过渡类定义为抽象类最为合适，再让以后的子类直接继承该抽象类便可以选择性覆盖所需要的方法，而此抽象类便是适配器类。
2.代码示例 [Java] 纯文本查看 复制代码 [/align][align=left]interface Window{
public void open(); // 窗口打开
public void close(); // 窗口关闭
public void iconified(); // 窗口最小化
public void deiconified(); // 窗口恢复
public void activated(); // 窗口活动
}
/*
* 定义抽象类实现接口，在此类中重写方法，但是所有方法体为空
*/
abstract class WindowAdapter implements Window{
public void open() { // 窗口打开
}
public void close() { // 窗口关闭
}
public void iconified() { // 窗口最小化
}
public void deiconified() { // 窗口恢复
}
public void activated() {
}
}
/*
* 子类继承WindowAdapter抽象类，选择性实现需要的方法
*/
class WindowImpl extends WindowAdapter{
public void open(){
System.out.println("窗口打开！");
}
public void close(){
System.out.println("窗口关闭！");
}
}
public class AdapterDemo01 {
public static void main(String[] args) {[/align][align=left]
Window win = new WindowImpl();[/align][align=left]
win.open();[/align][align=left]
win.close();
}
}
| 
收藏
淘帖
踩
