网站logo如何做链接怎么提高百度关键词排名

享元模式

享元模式（Flyweight Pattern）又称为轻量模式，是对象池的一种实现。类似于线程池，线程池可以避免不停的创建和销毁多个对象，销毁性能。提供了减少对象数量从而改善应用所需的对象结构的方式。其宗旨是共享细粒度对象，将多个对同一对象的访问集中起来，不必为每个访问者创建一个单独的对象，以此来降低内存的消耗，属于结构型模式。

应用场景：

1. 常常应用于系统底层的开发，以便解决系统的性能问题。
2. 系统有大量相似对象，需要缓存池的场景。

利用缓存机制实现享元模式： 

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;}@Overridepublic 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); //trueSystem.out.println(b==d); //false}
}

组合模式 

组合模式（Composite Pattern）也称为整体-部分模式，它的宗旨是通过将单个对象和组合对象用相同的接口进行表示，使得客户对单个对象和组合对象的使用具有一致性，属于结构型模式。

组合关系和聚合关系的区别：

1. 组合关系：一只狗可以生多只小狗，但每只小狗只有一个妈妈（具有相同的生命周期）。
2. 聚合关系：一个老师有很多学生，但每个学生又有多个老师（具有不同的生命周期）。

透明组合模式的写法：透明组合模式把所有的公共方法都定义在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;}@Overridepublic 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;}@Overridepublic void addChild(CourseComponent catalogComponent) {items.add(catalogComponent);}@Overridepublic String getName(CourseComponent catalogComponent) {return this.name;}@Overridepublic void removeChild(CourseComponent catalogComponent) {items.remove(catalogComponent);}@Overridepublic 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;}@Overridepublic 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);}@Overridepublic 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();}
}