java设计模式享元模式
Java的23种开发模式
1、工厂模式：客户类和工厂类分开。
消费者任何时候需要某种产品，只需向工厂请求即可。
消费者无须修改就可以接纳新产品。
缺点是当产品修改时，工厂类也要做相应的修改。
如：如何创建及如何向客户端提供。
2、建造模式：将产品的内部表象和产品的生成过程分割开来，从而使一个建造过程生成具有不同的内部表象的产品对象。
建造模式使得产品内部表象可以独立的变化，客户不必知道产品内部组成的细节。
建造模式可以强制实行一种分步骤进行的建造过程。
3、工厂方法模式：核心工厂类不再负责所有产品的创建，而是将具体创建的工作交给子类去做，成为一个抽象工厂角色，仅负责给出具体工厂类必须实现的接口，而不接触哪一个产品类应当被实例化这种细节。
4、原始模型模式：通过给出一个原型对象来指明所要创建的对象的类型，然后用复制这个原型对象的方法创建出更多同类型的对象。
原始模型模式允许动态的增加或减少产品类，产品类不需要非得有任何事先确定的等级结构，原始模型模式适用于任何的等级结构。
缺点是每一个类都必须配备一个克隆方法。
5、单例模式：单例模式确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例单例模式。
单例模式只应在有真正的“单一实例”的需求时才可使用。
6、适配器(变压器)模式：把一个类的接口变换成客户端所期待的另一种接口，从而使原本因接口原因不匹配而无法一起工作的两个类能够一起工作。
适配类可以根据参数返还一个合适的实例给客户端。
7、桥梁模式：将抽象化与实现化脱耦，使得二者可以独立的变化，也就是说将他们之间的强关联变成弱关联，也就是指在一个软件系统的抽象化和实现化之间使用组合/聚合关系而不是继承关系，从而使两者可以独立的变化。
8、合成模式：合成模式将对象组织到树结构中，可以用来描述整体与部分的关系。
合成模式就是一个处理对象的树结构的模式。
合成模式把部分与整体的关系用树结构表示出来。
合成模式使得客户端把一个个单独的成分对象和由他们复合而成的合成对象同等看待。
《Java设计模式大全》
《Java设计模式大全》Java语言是当今非常流行的编程语言，在Web开发、大数据处理、机器学习等领域都有广泛的应用。
Java设计模式是Java开发中非常重要的一部分，它可以帮助开发者更好地组织和管理代码，提高代码的可重用性和可维护性。
本文将为大家介绍Java设计模式的各种类型，以及如何在实际开发中应用这些设计模式。
一、什么是设计模式设计模式是指在软件设计过程中经过反复验证，被广泛应用并被认同的一种解决特定问题的方案。
设计模式是对软件设计经验的总结和提炼，它可以指导开发者在特定情境下进行面向对象的软件设计和编程。
设计模式在软件开发中的作用是非常重要的，它可以提高软件的可扩展性、可维护性和可复用性，减少软件开发过程中的重复工作，同时还可以让开发者更好地进行沟通和协作。
二、Java设计模式的分类Java设计模式按照其目的和形式可以分为以下三种类型。
1、创建型模式创建型模式是一种用于创建对象的模式，它主要是处理对象的实例化、初始化和组合等问题。
这种模式在需要对对象的具体实现进行隔离时非常有用，它可以让代码更加灵活和可维护。
常见的创建型模式有：简单工厂模式、工厂方法模式、抽象工厂模式、单例模式、建造者模式和原型模式。
2、结构型模式结构型模式是一种用于描述对象之间组合方式的模式，它关注的是对象的组合和协作方式。
结构型模式可以允许开发者通过某些方式，将对象组织起来以满足特定需求。
常见的结构型模式有：适配器模式、桥接模式、组合模式、装饰器模式、外观模式、享元模式和代理模式。
3、行为型模式行为型模式是一种用于描述对象之间消息传递和流程控制的模式，它关注的是对象之间的交互方式和协作机制。
行为型模式可以帮助开发者构建一个有机的、高度可扩展的软件系统。
常见的行为型模式有：责任链模式、命令模式、解释器模式、迭代器模式、中介者模式、备忘录模式、观察者模式、状态模式、策略模式、模板方法模式和访问者模式。
三、Java设计模式的应用Java设计模式是一种非常实用的开发技巧，它可以帮助开发者更好地组织和管理代码，提高软件的可重用性和可维护性，同时也可以让团队进行更加高效的协作和沟通。
面向对象23种设计模式
面向对象23种设计模式面向对象23种设计模式在面向对象的编程中，设计模式是一种解决问题的通用方案。
设计模式可以帮助开发人员在开发过程中减少代码的冗余和复杂性，并提高代码的可维护性和可重用性。
本文将介绍23种面向对象的设计模式。
1. 工厂方法模式工厂方法模式是一种创建型设计模式，它定义了一个用于创建对象的接口，但是让子类决定实例化哪个类。
在工厂方法模式中，客户端不需要知道具体的创建逻辑，只需要知道工厂类中定义的接口即可。
2. 抽象工厂模式抽象工厂模式是一种创建型设计模式，它提供了一个接口，用于创建相关或依赖对象的家族，而不需要指定它们的具体类。
在抽象工厂模式中，客户端不需要知道具体的创建逻辑，只需要知道工厂类中定义的接口即可。
3. 单例模式单例模式是一种创建型设计模式，它保证一个类只有一个实例，并提供一个访问该实例的全局点。
4. 原型模式原型模式是一种创建型设计模式，它允许复制或克隆一个现有的对象，而不必知道其具体实现。
5. 建造者模式建造者模式是一种创建型设计模式，它允许逐步创建复杂的对象，而不必知道其内部实现细节。
6. 适配器模式适配器模式是一种结构型设计模式，它将一个或多个不兼容的类或接口转换为客户端所需的接口。
7. 桥接模式桥接模式是一种结构型设计模式，它将抽象部分与其实现部分分离开来，以便独立地进行修改。
8. 组合模式组合模式是一种结构型设计模式，它将一组对象作为单个对象处理，以便客户端可以以相同的方式处理单个对象和组合对象。
9. 装饰器模式装饰器模式是一种结构型设计模式，它允许向现有对象添加额外的功能，同时不改变其现有的结构。
10. 外观模式外观模式是一种结构型设计模式，它为一组复杂的子系统提供了一个统一的接口，以便于客户端使用。
11. 享元模式享元模式是一种结构型设计模式，它利用共享技术来最小化内存使用，以及提高应用程序的性能。
12. 代理模式代理模式是一种结构型设计模式，它提供了一个代理对象，使得客户端可以通过代理对象间接地访问实际对象。
设计模式 分类
设计模式分类设计模式是指可重复使用的解决方案，它是一套经过归纳总结的代码设计的最佳实践，目的是提高程序的可维护性、复用性、灵活性和可拓展性。
根据功能、作用和应用场景等不同分类准则，设计模式可以被分成若干个类别，以下是常用的几种分类。
1.创建型模式创建型模式用于封装对象的创建过程，隐藏具体实现的细节，提供一个通用的接口让用户生成对象，并且尽量将对象的创建过程与使用过程分离。
创建型模式包括工厂方法模式、抽象工厂模式、单例模式、原型模式和建造者模式等。
工厂方法模式：定义一个用于创建对象的接口，但由子类决定要实例化的具体类。
工厂方法把对象的创建职责交给了特定的类。
抽象工厂模式：提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们的具体类。
单例模式：确保类只有一个实例，并提供全局访问点。
原型模式：通过复制现有的实例来创建新的实例。
建造者模式：将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。
2.结构型模式结构型模式用于描述如何组合类和对象以形成大型结构，并解决类与类之间的关系问题。
结构型模式包括适配器模式、桥接模式、装饰器模式、组合模式、外观模式、享元模式和代理模式等。
适配器模式：将一个类的接口转换成客户希望的另一个接口，使得原本不兼容的类可以协同工作。
桥接模式：将抽象部分与它的实现部分分离，使它们可以独立变化。
装饰器模式：动态地给对象添加一些额外的职责，使得对象的功能具有更高的灵活性。
组合模式：将对象组合成树形结构以表示"部分-整体"的层次结构，使得用户对于单个对象和组合对象的使用具有一致性。
外观模式：为子系统中的一组接口提供一个一致的界面，以便于子系统的使用。
享元模式：通过共享对象来减少内存使用以及对象创建的时间。
代理模式：为其他对象提供一个代理以控制对这个对象的访问。
3.行为型模式行为型模式用于描述对象间的通讯、算法和职责分配等关系，以便更好地划分对象的职责，减少对象间的耦合，增强系统的灵活性和可扩展性。
Java23模式
}
public class TeacherWork implements Work {
public void doWork() {
System.out.println("老师审批作业!");
}
}
Creator
1.2.1 适配器模式 17
1.2.2 桥接模式 19
1.2.3 组合模式 23
1.2.4 装饰模式 26
1.2.5 外观模式 29
1.2.6 享元模式 32
1.2.7 代理模式 34
1.3 行为型模式 37
1.3.1 责任链模式 37
3.当*将创建对象的职责委托给多个帮助*类中的某一个，并且*希望将哪一个帮助子类是代理者这一信息局部化的时候。
参与者
1.Product
定义工厂方法所创建的对象的接口。
2.ConcreteProduct
实现Product接口。
public interface IWorkFactory {
Work getwork();
}
ConcreteCreator
public class StudentWorkFactory implements IWorkFactory { public 来自ork getWork() {
return new TeacherWork();
}
}
Test
public class Test {
public static void main(String[] args) {
}
res*lt
The bla*k cat is eating!
Flyweight(享元)模式
设计模式----Flyweight(享元)模式GOF：运用共享技术有效地支持大量细粒度的对象。
解释一下概念：也就是说在一个系统中如果有多个相同的对象，那么只共享一份就可以了，不必每个都去实例化一个对象。
比如说（这里引用GOF书中的例子）一个文本系统，每个字母定一个对象，那么大小写字母一共就是52个，那么就要定义52个对象。
如果有一个1M的文本，那么字母是何其的多，如果每个字母都定义一个对象那么内存早就爆了。
那么如果要是每个字母都共享一个对象，那么就大大节约了资源。
在Flyweight模式中，由于要产生各种各样的对象，所以在Flyweight(享元)模式中常出现Factory模式。
Flyweight的内部状态是用来共享的,Flyweight factory负责维护一个对象存储池（Flyweight Pool）来存放内部状态的对象。
Flyweight模式是一个提高程序效率和性能的模式,会大大加快程序的运行速度.应用场合很多，下面举个例子：先定义一个抽象的Flyweight类：package Flyweight;public abstract class Flyweight{public abstract void operation();}//end abstract class Flyweight在实现一个具体类：package Flyweight;public class ConcreteFlyweight extends Flyweight{private String string;public ConcreteFlyweight(String str){string = str;}//end ConcreteFlyweight(...)public void operation(){System.out.println("Concrete---Flyweight : " + string);}//end operation()}//end class ConcreteFlyweight实现一个工厂方法类：package Flyweight;import java.util.Hashtable;public class FlyweightFactory{private Hashtable flyweights = new Hashtable();//----------------------------1public FlyweightFactory() {}public Flyweight getFlyWeight(Object obj){Flyweight flyweight = (Flyweight) flyweights.get(obj);//----------------2if(flyweight == null) {//---------------------------------------------------3//产生新的ConcreteFlyweightflyweight = new ConcreteFlyweight((String)obj);flyweights.put(obj, flyweight);//--------------------------------------5}return flyweight;//---------------------------------------------------------6}//end GetFlyWeight(...)public int getFlyweightSize(){return flyweights.size();}}//end class FlyweightFactory这个工厂方法类非常关键，这里详细解释一下：在1处定义了一个Hashtable用来存储各个对象；在2处选出要实例化的对象，在6处将该对象返回，如果在Hashtable中没有要选择的对象，此时变量flyweight为null，产生一个新的flyweight存储在Hashtable中，并将该对象返回。
面向对象设计的23个设计模式详解
面向对象设计的23个设计模式详解面向对象设计是一种广泛应用于软件开发的思想，其核心在于将数据和操作封装在一起形成对象，并通过各种方式进行交互和组合，从而实现复杂的功能。
在这一过程中，设计模式起到了非常重要的作用，可以有效地提高代码的可读性、可维护性和可扩展性。
本文将对23种常见的设计模式进行详解。
一、创建型模式1.简单工厂模式简单工厂模式属于创建型模式，其目的是提供一个工厂类，使得创建对象的过程更加简单。
在这种模式中，使用者只需要提供所需对象的参数，而无需关心对象的具体实现细节。
简单工厂模式适合于对象创建过程较为简单的情况。
2.工厂方法模式工厂方法模式是简单工厂模式的进一步扩展，其核心在于将工厂类进行接口抽象化，使得不同的工厂类可以创建不同的对象实例。
工厂方法模式适合于对象创建过程较为复杂的情况。
它可以为工厂类添加新的产品类型，而不会影响原有的代码。
3.抽象工厂模式抽象工厂模式是工厂方法模式的进一步扩展，其目的是提供一个可以创建一系列相关或者独立的对象的接口。
在抽象工厂模式中，使用者只需要关心所需对象组合的类型，而无需关注对象的具体实现过程。
4.建造者模式建造者模式也是一种创建型模式，其目的在于将复杂对象分解为多个简单的部分，并将其组装起来形成复杂对象实例。
在建造者模式中，使用者只需要关注所需对象以及它们的组合方式，而无需关心对象的具体实现过程。
5.原型模式原型模式是一种基于克隆的创建型模式，其核心在于通过复制现有的对象实例来创建新的对象。
在原型模式中，对象实例的创建过程与对象所包含的状态密切相关。
原型模式适合于创建复杂对象实例，且这些对象实例之间是相对独立的情况。
二、结构型模式6.适配器模式适配器模式是一种结构型模式，其目的在于将一个类的接口转换为另一个类所能使用的接口。
在适配器模式中，使用者可以通过不同的适配器实现对象之间的互相调用。
7.桥接模式桥接模式是一种结构型模式，其目的在于将抽象部分与实现部分相互分离，从而使得两者可以独立变化。
软件设计模式三大类
软件设计模式三⼤类创建型⼯⼚模式与抽象⼯⼚模式（Factory Pattern）（Abstract Factory Pattern）单例模式（Singleton Pattern）建造者模式（Builder Pattern）原型模式（Prototype Pattern）1、⼯⼚⽅法模式⼯⼚⽅法模式的创建是因为简单⼯⼚模式有⼀个问题，在简单⼯⼚模式中类的创建依赖⼯⼚类，如果想要拓展程序，必须对⼯⼚类进⾏修改，这违背了开闭原则，所以就出现了⼯⼚⽅法模式，只需要创建⼀个⼯⼚接⼝和多个⼯⼚实现类。
⼦类可以⾃⼰决定实例化哪⼀个⼯⼚类，client类针对抽象接⼝进⾏编程，如果需要增加新的功能，继承⼯⼚接⼝，直接增加新的⼯⼚类就可以了，创建过程延迟到⼦类中进⾏，不需要修改之前的代码，满⾜了开闭原则，达到灵活地⽣产多种对象。
2、抽象⼯⼚模式抽象⼯⼚模式是提供⼀个创建⼀系列相关或相互依赖对象的接⼝，⽽⽆需指定它们具体的类。
区别于⼯⼚⽅法模式的地⽅，⼯⼚⽅法模式是创建⼀个⼯⼚，可以实现多种对象；⽽抽象⼯⼚模式是提供⼀个抽象⼯⼚接⼝，⾥⾯定义多种⼯⼚，每个⼯⼚可以⽣产多种对象。
前者的重点在于"怎么⽣产"，后者的重点在于"⽣产哪些"；前者是⼀个抽象产品类，可以派⽣出多个具体产品类，后者是多个抽象产品类，每个抽象产品类可以派⽣出多个具体产品类。
3、单例模式单例模式能保证⼀个类仅有⼀个实例，并提供⼀个访问它的全局访问点，同时在类内部创造单⼀对象，通过设置权限，使类外部⽆法再创造对象。
单例对象能保证在⼀个JVM中，该对象只有⼀个实例存在。
在创建的时候，省去了new操作符，降低了系统内存的使⽤频率，减轻了系统的压⼒。
同时单例模式保证在⼀个jvm中仅存在⼀个实例的好处就在于好⽐⼀个军队当中只会存在⼀个最⾼级别的军官来指挥整个军队，这样才能保证独⽴控制整个过程，否则如果出现多个，肯定会杂乱⽆序。
Java设计模式知识要点
AbstractClass 叫做抽象模板，它的方法分为两类： ● 基本方法 基本方法也叫做基本操作，是由子类实现的方法，并且在模板方法被调用。 ● 模板方法 可以有一个或几个，一般是一个具体方法，也就是一个框架，实现对基本方法的调 度，完成固定的逻辑。 注意： 为了防止恶意的操作，一般模板方法都加上 final 关键字，不允许被覆 写。 具体模板：ConcreteClass1 和 ConcreteClass2 属于具体模板，实现父类所定义的 一个或多个抽象方法，也就是父类定义的基本方法在子类中得以实现 使用场景： ● 多个子类有公有的方法，并且逻辑基本相同时。 ● 重要、复杂的算法，可以把核心算法设计为模板方法，周边的相关细节功能则由 各个子类实现。 ● 重构时，模板方法模式是一个经常使用的模式，把相同的代码抽取到父类中，然 后通过钩子函数（见“模板方法模式的扩展”）约束其行为。
2.工厂模式
定义：Define an interface for creating an object,but let subclasses decide which class to instantiate.Factory Method lets a class defer instantiation to subclasses. （定义一个用于创建对象的接口，让子类决定实例化哪一个类。工厂方法使一个类 的实例化延迟到其子类。）
java23种设计模式及其应用场景
创建型模式•单例模式（Singleton）：确保一个类只有一个实例。
–应用场景：数据库连接池、日志记录、缓存系统。
•工厂方法模式（Factory Method）：定义一个创建对象的接口，但让子类决定实例化哪个类。
–应用场景：提供创建对象的灵活性，允许在不改变代码的情况下更换创建逻辑。
•抽象工厂模式（Abstract Factory）：提供一个创建一系列相关或依赖对象的接口，而无需指定具体的类。
–应用场景：创建复杂的对象结构，需要保持多个对象之间的一致性。
•建造者模式（Builder）：将一个复杂对象的构建与它的表示分离，使其能够一步一步创建。
–应用场景：创建复杂的对象，需要自定义不同的配置或属性。
•原型模式（Prototype）：通过复制一个现有的对象来创建新的对象。
–应用场景：创建大量相似对象时，避免重复创建的开销。
结构型模式•适配器模式（Adapter）：将一个类的接口转换成另一个类所期望的接口。
–应用场景：将不兼容的类或系统集成在一起。
•桥接模式（Bridge）：将抽象部分与实现部分解耦，使它们可以独立变化。
–应用场景：当需要在抽象层和实现层之间引入灵活性时。
•组合模式（Composite）：将对象组织成树形结构，以便以类似的方式处理单个对象和组合对象。
–应用场景：表示部分与整体之间的层次关系。
•装饰器模式（Decorator）：在不改变对象自身的情况下，向对象添加新的功能。
–应用场景：向对象添加可选项功能，避免创建新的子类。
•外观模式（Facade）：提供一个统一的界面来访问一个子系统，隐藏其内部复杂性。
–应用场景：简化对复杂系统的访问，降低客户端与子系统之间的耦合。
•享元模式（Flyweight）：使用共享的对象来减少内存开销和对象数量。
–应用场景：需要创建大量相同或相似对象时。
•代理模式（Proxy）：为另一个对象提供一个代理或替身，以便控制对该对象的访问。
–应用场景：为对象添加额外的功能，如访问控制、缓存、日志记录。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
java设计模式———享元模式享元模式的结构享元模式采用一个共享来避免大量拥有相同内容对象的开销。
这种开销最常见、最直观的就是内存的损耗。
享元对象能做到共享的关键是区分内蕴状态(Internal State)和外蕴状态(External State)。
一个内蕴状态是存储在享元对象内部的，并且是不会随环境的改变而有所不同。
因此，一个享元可以具有内蕴状态并可以共享。
一个外蕴状态是随环境的改变而改变的、不可以共享的。
享元对象的外蕴状态必须由客户端保存，并在享元对象被创建之后，在需要使用的时候再传入到享元对象内部。
外蕴状态不可以影响享元对象的内蕴状态，它们是相互独立的。
享元模式的优点：减少对象数量，节省内存空间。
享元模式的缺点：维护共享对象，需要额外的开销（用一个线程来维护垃圾回收）。
享元模式的本质：分离与共享何时使用享元模式：如果一个应用程序使用了大量的细粒度对象，可以使用享元模式来减少对象数量。
如果使用大量的对象，造成很大的存储开销，可以使用享元模式来减少对象数量，并节约内存。
如果对象的大多数状态都可以转变为外部状态，可以使用享元对象来实现外部状态与内部状态的分离。
享元模式可以分成单纯享元模式和复合享元模式两种形式。
单纯享元模式在单纯的享元模式中，所有的享元对象都是可以共享的。
单纯享元模式所涉及到的角色如下：抽象享元(Flyweight)角色：给出一个抽象接口，以规定出所有具体享元角色需要实现的方法。
具体享元(ConcreteFlyweight)角色：实现抽象享元角色所规定出的接口。
如果有内蕴状态的话，必须负责为内蕴状态提供存储空间。
享元工厂(FlyweightFactory)角色：本角色负责创建和管理享元角色。
本角色必须保证享元对象可以被系统适当地共享。
当一个客户端对象调用一个享元对象的时候，享元工厂角色会检查系统中是否已经有一个符合要求的享元对象。
如果已经有了，享元工厂角色就应当提供这个已有的享元对象；如果系统中没有一个适当的享元对象的话，享元工厂角色就应当创建一个合适的享元对象。
好了，废话不多说，直接上代码，首先抽象一个场景：公司的管理层和普通员工对员工的信息有不同的权限。
管理层可以修改员工的个人信息，普员工只能查看不能修改，擅自修改系统会给出提示。
员工的个人信息是可以共享的，但是起职能范围和操作权限可以被管理层修改。
抽象享元角色：[java]public interface IFlyWeight { /** * 判断传入的安全实体和权限，是否和享元对象内部状态匹配* 参数securityEntity 和permit 是外蕴对象* @param securityEntity * @param permit * @return */ public boolean match(String securityEntity, Stringpermit); }具体享元角色：[java]public class AuthorizationFlyweight implements IFlyWeight { /** * 内蕴对象，安全实体*/ private String mSecurityEntity; /** * 内蕴对象，权限*/ private String mPermit; public AuthorizationFlyweight(String state) { String str[] = state.split(","); this.mSecurityEntity = str[0];this.mPermit = str[1]; } @Overridepublic boolean match(String securityEntity, String permit){ if (mSecurityEntity.equals(securityEntity)&& mPermit.equals(permit)) { return true; } return false; } } 享元工厂：[java]public class FlyWeightFactory { private static FlyWeightFactory mFactory = new FlyWeightFactory(); private FlyWeightFactory() { } public static FlyWeightFactory getInstance() { return mFactory; } /** * 缓存多个人IFlyWeight 对象*/ private Map<String, IFlyWeight> flyMap = new HashMap<String, IFlyWeight>(); /** * 获取享元单元* @param key * @return */ public IFlyWeight getFlyWeight(String key) { IFlyWeight fly = flyMap.get(key);if(fly==null){ fly = new AuthorizationFlyweight(key); flyMap.put(key, fly); } return fly; } } 员工信息的管理工具：[java]public class SecurityManager { private staticSecurityManager manager = new SecurityManager();private SecurityManager() { } public static SecurityManager getInstance() { return manager; } /** * 存放登录人员的权限*/ private Map<String,Collection<IFlyWeight>> map = newHashMap<String, Collection<IFlyWeight>>(); public void logon(String user){ Collection<IFlyWeight> coll = queryByUser(user); map.put(user, coll); }/** * 从数据库中获取某人所有的权限** @param user * @return */ private Collection<IFlyWeight> queryByUser(String user){ Collection<IFlyWeight> coll = new ArrayList<IFlyWeight>(); for (String s : TestDB.coll) { String str[] = s.split(",");if (str[0].equals(user)) { IFlyWeight fly = FlyWeightFactory.getInstance().getFlyWeight(str[1] + "," + str[2]);coll.add(fly); } } return coll; } /** * 判断某个用户对某个安全实体是否有某种权限* * @param user *用户* @param securityEntity * 安全实体* @param permit * 权限* @return */ public boolean hasPermit(String user, String securityEntity, String permit){ Collection<IFlyWeight> coll =map.get(user); if (coll == null || coll.size() == 0) { System.out.println(user + "没有登录或者没有该权限..."); return false; }for (IFlyWeight fly : coll) { if(fly.match(securityEntity, permit)) { return true; } } return false; } } 模拟一个数据库保存员工信息：[java]public class TestDB { public staticCollection<String> coll = new ArrayList<String>(); static { coll.add("张三,人员列表,查看");coll.add("李四,人员列表,查看"); coll.add("李四,薪资列表,查看"); coll.add("李四,薪资列表,修改"); for (short i = 0; i < 3; i++) { coll.add("张三" + i + ",人员列表,查看"); } } }具体的实现，本例子是基于android实现的，java只单独写一个Test类在main里面实现就行了：[java] view plaincopySecurityManager manager = SecurityManager.getInstance(); manager.logon("张三"); manager.logon("李四"); boolean b1 = manager.hasPermit("张三", "薪资列表", "查看"); boolean b2 = manager.hasPermit("李四", "薪资列表", "查看"); boolean b3 = manager.hasPermit("张三", "人员列表", "查看"); System.out.println("b1 = "+b1); System.out.println("b2 = "+b2); System.out.println("b3 = "+b3); 运行效果：从数据库中可以看出来，张三是人事的普通员工，只能查看公司在职人员，对员工的薪资无权限查看，b1返回false，b3返回true李四是人事普通员工兼财务主管，可以修改查询员工薪资并且可以查看在职员工信息，b2返回true如果[java]boolean b4 = manager.hasPermit("王武", "人员列表", "查看"); 因为“王武”这个人没有登录，所以提示信息是“没有登录或者没有该权限...”。