享元模式
享元模式(Flyweight Pattern)又称为轻量模式,是对象池的一种实现。类似于线程池,线程池可以避免不停的创建和销毁多个对象,销毁性能。提供了减少对象数量从而改善应用所需的对象结构的方式。其宗旨是共享细粒度对象,将多个对同一对象的访问集中起来,不必为每个访问者创建一个单独的对象,以此来降低内存的消耗,属于结构型模式。
应用场景:
- 常常应用于系统底层的开发,以便解决系统的性能问题。
- 系统有大量相似对象,需要缓存池的场景。
利用缓存机制实现享元模式:
import java.util.Map;
import java.util.Random;
import java.util.concurrent.ConcurrentHashMap;
interface ITicket{
void showInfo(String bunk);
}
class TrainTicket implements ITicket{
private String from;
private String to;
private int price;
public TrainTicket(String from, String to) {
this.from = from;
this.to = to;
}
@Override
public void showInfo(String bunk) {
this.price = new Random().nextInt(500);
System.out.println(String.format("%s->%s: %s价格: %s 元",this.from,this.to,bunk,this.price));
}
}
class TicketFactory{
private static Map<String,ITicket> sTicketPool = new ConcurrentHashMap<>();
public static ITicket queryTicket(String from, String to){
String key = from + "->" + to;
if(TicketFactory.sTicketPool.containsKey(key)){
System.out.println("使用缓存:"+ key);
return TicketFactory.sTicketPool.get(key);
}
System.out.println("首次查询,创建对象:" + key);
ITicket ticket = new TrainTicket(from, to);
TicketFactory.sTicketPool.put(key,ticket);
return ticket;
}
}
JDK中Integer类型使用了享元模式,例如:。在Java中-128到127之间的数据在int范围类是直接从缓存中取值的。
public class Test {
public static void main(String[] args) {
Integer a = Integer.valueOf(100);
Integer b = 100;
Integer c = Integer.valueOf(1000);
Integer d = 1000;
System.out.println(a==b); //true
System.out.println(b==d); //false
}
}
组合模式
组合模式(Composite Pattern)也称为整体-部分模式,它的宗旨是通过将单个对象和组合对象用相同的接口进行表示,使得客户对单个对象和组合对象的使用具有一致性,属于结构型模式。
组合关系和聚合关系的区别:
- 组合关系:一只狗可以生多只小狗,但每只小狗只有一个妈妈(具有相同的生命周期)。
- 聚合关系:一个老师有很多学生,但每个学生又有多个老师(具有不同的生命周期)。
透明组合模式的写法:透明组合模式把所有的公共方法都定义在Component中,这样做的好处是客户端无需分辨是叶子节点和树枝节点,它们具备完全一致性的接口;缺点是叶子节点得到一些它所不需要的方法,这与设计模式 接口隔离相违背。
import lombok.Data;
import java.util.ArrayList;
import java.util.List;
abstract class CourseComponent{
public void addChild(CourseComponent catalogComponent){
throw new UnsupportedOperationException("不支持添加操作");
}
public void removeChild(CourseComponent catalogComponent){
throw new UnsupportedOperationException("不支持删除操作");
}
public String getName(CourseComponent catalogComponent){
throw new UnsupportedOperationException("不支持获取名称操作");
}
public double getPrice(CourseComponent catalogComponent){
throw new UnsupportedOperationException("不支持获取价格操作");
}
public void print(){
throw new UnsupportedOperationException("不支持打印操作");
}
}
@Data
class Course extends CourseComponent{
private String name;
private double price;
public Course(String name, double price) {
this.name = name;
this.price = price;
}
@Override
public void print() {
System.out.println(name + "(¥" + price + "元)");
}
}
class CoursePackage extends CourseComponent{
private List<CourseComponent> items = new ArrayList<>();
private String name;
private Integer level;
public CoursePackage(String name, Integer level) {
this.name = name;
this.level = level;
}
@Override
public void addChild(CourseComponent catalogComponent) {
items.add(catalogComponent);
}
@Override
public String getName(CourseComponent catalogComponent) {
return this.name;
}
@Override
public void removeChild(CourseComponent catalogComponent) {
items.remove(catalogComponent);
}
@Override
public void print() {
System.out.println(this.name);
for (CourseComponent catalogComponent : items){
if(this.level != null){
for(int i=0;i<this.level;i++){
System.out.print(" ");
}
for(int i=0;i<this.level;i++){
System.out.print("-");
}
}
catalogComponent.print();
}
}
}
public class Test {
public static void main(String[] args) {
System.out.println("=========透明组合模式==========");
CourseComponent javaBase = new Course("Java入门",8200);
CourseComponent ai = new Course("人工智能",5000);
CourseComponent packageCourse = new CoursePackage("Java架构师",2);
CourseComponent design = new Course("设计模式",1500);
packageCourse.addChild(design);
CourseComponent catalog = new CoursePackage("课程主目录",1);
catalog.addChild(javaBase);
catalog.addChild(ai);
catalog.addChild(packageCourse);
catalog.print();
}
}
安全组合模式的写法:好处是接口定义职责清晰,符合设计模式单一职责原则和接口隔离原则;缺点是客户需要区分树枝节点和叶子节点,客户端无法依赖抽象,违背了设计模式依赖倒置原则。
import lombok.Data;
import java.util.ArrayList;
import java.util.List;
abstract class CourseComponent{
public void print(){
throw new UnsupportedOperationException("不支持打印操作");
}
}
@Data
class Course extends CourseComponent{
private String name;
private double price;
public Course(String name, double price) {
this.name = name;
this.price = price;
}
@Override
public void print() {
System.out.println(name + "(¥" + price + "元)");
}
}
class CoursePackage extends CourseComponent{
private List<CourseComponent> items = new ArrayList<>();
private String name;
private Integer level;
public CoursePackage(String name, Integer level) {
this.name = name;
this.level = level;
}
public void addChild(CourseComponent catalogComponent) {
items.add(catalogComponent);
}
public String getName(CourseComponent catalogComponent) {
return this.name;
}
public void removeChild(CourseComponent catalogComponent) {
items.remove(catalogComponent);
}
@Override
public void print() {
System.out.println(this.name);
for (CourseComponent catalogComponent : items){
if(this.level != null){
for(int i=0;i<this.level;i++){
System.out.print(" ");
}
for(int i=0;i<this.level;i++){
System.out.print("-");
}
}
catalogComponent.print();
}
}
}
public class Test {
public static void main(String[] args) {
System.out.println("=========透明组合模式==========");
CourseComponent javaBase = new Course("Java入门",8200);
CourseComponent ai = new Course("人工智能",5000);
CoursePackage packageCourse = new CoursePackage("Java架构师",2);
CourseComponent design = new Course("设计模式",1500);
packageCourse.addChild(design);
CoursePackage catalog = new CoursePackage("课程主目录",1);
catalog.addChild(javaBase);
catalog.addChild(ai);
catalog.addChild(packageCourse);
catalog.print();
}
}