java设计模式

最新推荐文章于 2023-03-06 19:15:56 发布

Luna_ll

最新推荐文章于 2023-03-06 19:15:56 发布

阅读量213

点赞数

分类专栏： JavaSE基础文章标签：设计模式

本文链接：https://blog.csdn.net/Luna_ll/article/details/78918232

版权

JavaSE基础专栏收录该内容

36 篇文章 1 订阅

订阅专栏

一.设计模式

1.设计模式（Design pattern）是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性。

2.设计模式的分类：

1)创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式（Singleton）、建造者模式（Builder）、原型模式（Prototype）。

2)结构型模式，共七种：适配器模式（Adapter）、装饰器模式（Decorator）、代理模式（Proxy）、外观模式（Facade）、桥接模式（Bridge）、组合模式（Composite）、共享元模式（Flyweight）。

3)行为型模式，共十一种：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。

3.静态工厂方法模式（简单工厂模式）：

提供一个静态类：工厂类（制造一些需要的对象）

特点：构造方法私有化，外界不能直接创建它的对象

提供静态功能，每一种静态都会产生所需要的对象

缺点：不利于后期维护

如果添加新的对象，需要创建它的类，还需要在静态工厂类提供一些功能！

package simplefactory;
//动物抽象类
public abstract class Animal {
	public abstract void eat();
}

package simplefactory;

public class Cat extends Animal {

	@Override
	public void eat() {
		System.out.println("cat eat mouse...");
	}
}

package simplefactory;

public class Dog extends Animal {

	@Override
	public void eat() {
		System.out.println("dog eat meat...");

	}
}

工厂类：

package simplefactory;

/**
 * 动物工厂类
 *
 *2017年12月28日 
 */
public class AnimalFactory {
	private AnimalFactory(){
		
	}
	
	//提供静态工能:返回的是具体的类
	public static Dog creatDog(){
		return new Dog();	
	}
	
	public static Cat creatCat(){
		return new Cat();
	}
}

测试类

package simplefactory;

public class AnimalDemo {

	public static void main(String[] args) {
		// 使用提供的静态工厂
		Dog d = AnimalFactory.creatDog();
		d.eat();
		
		Cat c = AnimalFactory.creatCat();
		c.eat();
	}
}

对于上述工厂类进行改善

package org.westos_01;
/**
 * 动物的工厂类
 * @author Apple
 */
public class AnimalFactory {
	
	//私有功能
	private AnimalFactory(){
		
	}
	
	//工厂改进:提供猫和狗这两种动物
	public static Animal createAnimal(String type){
		if("dog".equals(type)){
			return new Dog() ;  
		}else if("cat".equals(type)){
			return new Cat() ;
		}else {
			return null ;
		}
	}
}

package simplefactory;

public class AnimalDemo {

	public static void main(String[] args) {
		
		
		//使用改进的静态工厂
		Animal a = AnimalFactory.creatAnimal("dog") ;
		a.eat();
		
		a = AnimalFactory.creatAnimal("cat");
		a.eat();
		
		a = AnimalFactory.creatAnimal("pig") ;
		if(a!=null){
			a.eat() ;//不判断直接输出，会出现NullPointerException
		}else{
			System.out.println("目前工厂类没有提供该动物...");
		}
		
	}
}

4.工厂方法模式：

特点：需要提供一个抽象类，

工厂接口（该接口中的抽象方法的返回值是该抽象类）、

以及每个动物的具体类（重写该抽象类的方法）、

针对每个具体动物都提供一些对应的工厂类--->实现该接口--->返回值就是需要具体的动物对象

缺点：代码量多

package fatory_method;
//动物抽象类
public abstract class Animal {
	public abstract void eat();
}

package fatory_method;

public class Dog extends Animal {

	@Override
	public void eat() {
		System.out.println("dog eat meat...");

	}
}

package simplefactory;

public class Cat extends Animal {

	@Override
	public void eat() {
		System.out.println("cat eat mouse...");
	}
}

工厂接口

package org.westos_02;

//工厂的接口
public interface Factory {
	//就是用来提供常见具体动物的功能
	public abstract Animal createAnimal() ;
}

package fatory_method;

public class DogFactory implements Factory {

	@Override
	public Animal createAnimal() {
		return new Dog();
	}
}

package fatory_method;

public class CatFactory implements Factory {

	@Override
	public Animal createAnimal() {
		return new Cat();
	}
}

测试类

package fatory_method;

public class AnimalDemo {

	public static void main(String[] args) {
		// 需求：养一只狗
		Factory f = new DogFactory();
		Animal a = f.createAnimal();  //相当于 new Dog();
		a.eat();
		
		System.out.println("-----------");
		
		//养一只猫
		 f = new CatFactory();
		 a = f.createAnimal();		//相当于new Cat();
		 a.eat();	

	}
}

5.单例模式

单例模式可以保证一个类在内存中只存在一个实例，即一个类只有一个对象实例
单例模式分为两种：饿汉式、懒汉式
饿汉式

特点：当前某个类一加载就会创建一个对象

私有化该类的无参构造

成员变量位置创建该类的实例（static private 修饰）

提供公共的访问方法

package simpleexample;

public class SingleObject {
	//创建SingleObject的一个对象
	private static SingleObject instance = new SingleObject();
	
	//构造函数为private,这样该类不会被实例化
	private SingleObject(){
		
	}
	
	//获取唯一可用的对象
	public static SingleObject getInstance(){
		return instance;	
	}
}

package simpleexample;

public class SingletonPatternDemo {

	public static void main(String[] args) {
		// 不合法的构造函数
		//编译时错误：构造函数SingleObject()是不可实现的
		//SingleObject object = new SingleObject();
		
		//获取唯一可用的对象
		SingleObject object = SingleObject.getInstance();
		
		//显示信息
		object.showMessage();

	}
}

懒汉式
特点：在调用取得实例方法的时候才会实例化对象

1)懒加载（延迟加载）

2)线程的安全问题

检验标准：是否是多线程环境；是否有共享数据；是否有多条语句对共享数据进行操作
解决方法：使用同步代码块进行解决
优点：第一次调用才初始化，避免内存浪费

缺点：必须加锁synchronized才能保证单例，但加锁会影响效率

package simpleexample;

public class Singleton {
	private static Singleton instance;
	private Singleton(){}
	public static synchronized Singleton getInstance(){
		if(instance == null){
			instance = new Singleton();
		}
		return instance;
	}
}

6.装饰者设计模式
装饰器模式允许向一个现有的对象添加新的功能，同时又不改变其结构。这种类型的设计模式属于结构型模式，它是作为现有

的类的一个包装。

适用环境：

1)在不影响其他对象的情况下，以动态、透明的方式给单个对象添加职责。

2)当不能采用生成子类的方法进行扩充时。一种情况是，可能有大量独立的扩展，为支持每一种组合将产生

大量的子类，使得子类数目呈爆炸性增长。另一种情况可能是因为类定义被隐藏，或类定义不能用于生成子类。
参与者：

1.Component（被装饰对象的基类）

定义一个对象接口，可以给这些对象动态地添加职责。
2.ConcreteComponent（具体被装饰对象）

定义一个对象，可以给这个对象添加一些职责。

3.Decorator（装饰者抽象类）

维持一个指向Component实例的引用，并定义一个与Component接口一致的接口。

4.ConcreteDecorator（具体装饰者）

具体的装饰对象，给内部持有的具体被装饰对象，增加具体的职责。

Component

//Component 创建一个接口
//手机规则:打电话
public interface Phone {
	public abstract void call() ;
}

ConcreteComponent

//ConcreteComponent 

//具体的手机类(实现该接口)
public class IPhone implements Phone {

	@Override
	public void call() {
		System.out.println("手机可以打电话了....");
	}

}

Decorator

//Decorate
//创建实现Phone接口的抽象装饰类
public abstract class PhoneDecorate implements Phone {
	
	private Phone p ;
	
	
	public PhoneDecorate(Phone p){
		this.p = p ;
	}
	@Override
	public void call() {
		this.p.call() ;
	}

}

ConcreteDectrator

//ConcreteDectrator
//彩铃的修饰类
public class RingPhoneDecorate extends PhoneDecorate {

	public RingPhoneDecorate(Phone p) {
		super(p);
	}
	
	@Override
	public void call() {
		System.out.println("手机可以听彩铃了...");
		super.call();
	}

}

//ConcreteDectrator
//音乐的修饰类
public class MusicPhoneDecorate extends PhoneDecorate {

	public MusicPhoneDecorate(Phone p) {
		super(p);
	}
	
	@Override
	public void call() {
		super.call();
		System.out.println("手机可以听音乐了....");
	}

}

测试类

//测试类
public class PhoneDemo {

	public static void main(String[] args) throws Exception {
		
		//打电话
		Phone p = new IPhone() ;
		p.call() ;
		System.out.println("--------------");
		
		//打电话之前,听彩铃
		PhoneDecorate pd = new RingPhoneDecorate(p) ;
		pd.call() ;
		
		System.out.println("-----------------");
		
		//打完电话,听音乐...
		pd = new MusicPhoneDecorate(p) ;
		pd.call() ;
		System.out.println("------------------");
		
		//改进需求:先听彩铃-->打电话-->听音乐
		//装饰者设计模式:抽象类:--->一些抽象的子类
		//子类封装子类
		pd = new RingPhoneDecorate(new MusicPhoneDecorate(p)) ;
		pd.call() ;
		
		
	}
}

二.枚举类型

枚举类型可以替代以往定义常量的方式，同时枚举类型还赋予程序在编译时进行检查的功能

以往设置常量，通常将常量放置在接口中，在程序中可以直接使用，并且该常量不能被修改，

常量的修饰符为final和static

在接口Constants中定义常量

public interface Constants{
     public static final int Constants_A = 1;
     public static final int Constants_B = 12;
 }

枚举类型定义常量

public enum Constants{
     Constants_A,
     Constants_B,
     Constants_C

}

程序中使用该常量，可以使用Constants.Constants_A来表示

Luna_ll

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
java设计模式

一.设计模式1.设计模式（Design pattern）是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性。2.设计模式的分类：1)创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式（Singleton）、建造者模式（Builder）、原型模式（Prototype）。 2)结构型模式，共七种
复制链接

扫一扫