第一式 外观模式
定义:为子系统的一组接口提供一个一致的界面，外观模式定义了一个高层接口，这一接口使得这一子系统更加容易使用。
优点：松散耦合 简单易用 更好地划分访问的层次
缺点：不应过度使用
本质：封装交互 简单调用
public interface testA {
public void test();
}
public interface testB {
public void test();
}
public interface testC {
public void test();
}
public class concreteTestA implements testA {
@Override
public void test() {
// TODO Auto-generated method stub
System.out.println("test A");
}
}
public class concreteTestB implements testB {
@Override
public void test() {
// TODO Auto-generated method stub
System.out.println("test B");
}
}
public class concreteTestC implements testC {
@Override
public void test() {
// TODO Auto-generated method stub
System.out.println("test C");
}
}
public class facade {
public void test() {
testA ta = new concreteTestA();
ta.test();
testB tb = new concreteTestB();
tb.test();
testC tc = new concreteTestC();
tc.test();
}
}
public class user {
public static void main(String[] args) {
// TODO Auto-generated method stub
facade fc = new facade();
fc.test();
}
}
第二式 适配器模式
定义：将一个类的接口转换成客户希望的另外一个接口。适配器模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。
优点：更好地复用性 更好地可扩展性
缺点：使用过多，会使系统更加凌乱，不容易整体进行把握
本质：转换匹配 复用功能
public interface target {
public void request();
}
public class adaptee {
public void request() {
System.out.println("adaptee test");
}
}
public class adapter implements target {
adaptee apt = null;
public adapter(adaptee apt) {
this.apt = apt;
}
@Override
public void request() {
// TODO Auto-generated method stub
apt.request();
}
}
public class user {
public static void main(String[] args) {
adaptee adp = new adaptee();
target tar = new adapter(adp);
tar.request();
}
}
第三式 单例模式
定义：保证一个类仅有一个实例，并提供一个访问他的全局访问点。
懒汉式是时间换空间，饿汉式是空间换时间。在线程安全方面，不加同步的懒汉式是线程不安全的，而饿汉式则是线程安全的。单例模式的实质在于控制实例数目，而在集群中使用单例模式则需要注意安全问题。
推广：缓存的实现--空间换时间。
懒汉式：
public class singleton {
private static singleton instance = null;
private singleton() {
}
public static singleton getInstance() {
if (instance == null) {
instance = new singleton();
}
return instance;
}
}
饿汉式：
public class singleton {
private static singleton instance = new singleton();
private singleton() {
}
public static singleton getInstance() {
return instance;
}
}
缓存的基本实现
public class javaCache {
private static Map<String, Object> instance = null;
public Object getInstance(String key) {
Object object = instance.get(key);
if (object == null) {
object = key + ", value";
instance.put(key, object);
}
return object;
}
}
枚举类型也是实现单例模式的一种选择。另外，还可以通过一种类级内部类的方式来实现单例模式。
public class singleton {
private static class instanceHolder {
private static singleton instance = new singleton();
}
private singleton() {
}
public static singleton getInstance() {
return instanceHolder.instance;
}
}
这里需要解释补充一下：类级内部类
-类级内部类就是由static修饰的成员式内部类，没有static修饰的称为对象式内部类。
-类级内部类可以直接创建，而对象级内部类需要绑定在外部类的成员变量上。
-类级内部类可以实现静态方法，静态方法可以用外部类的静态方法和静态成员变量。
-类级内部类相当与外部类的成员，因此在第一次使用的时候加载。
安全问题：
JVM在下列情况自动实现了同步
-静态初始化器初始化数据时
-访问final字段时
-在创建线程之前创建对象时
-线程可以看到它将要处理的对象时
因此，利用类级内部类来实现延迟加载，通过JVM自身来保证线程安全则是实现的基本思路。
时间： 2024-08-07 16:48:44