单例模式

定义:是指一个类只有一个实例,并且该类能自行创建这个实例的一种模式。

关键点:某个类只能有一个实例,必须自行创建这个实例,必须自行向整个系统提供这个实例。

解决的问题;提供全局需要使用的,唯一的数据访问,类似于软件的全局配置。

分为饿汉式和懒汉式

饿汉式:在类加载时创建。

优点:线程安全。

缺点:过早浪费资源。

  1. 需要一个静态私有的成员变量。
  2. 私有的构造方法。
  3. 全局的静态的外部可以访问的getInstance

懒汉式:在使用时做出判断,如果需要再创建。

优点:使用时才创建,资源节约。

缺点:为线程安全要付出额外代价。

饿汉式

1
2
3
4
5
6
7
8
9
10
package study.SingleTop;
public class SingleTonA {
private static SingleTonA SingleTonA = new SingleTonA();
private SingleTonA(){
}

public static SingleTonA getInstance(){
return SingleTonA;
}
}

懒汉式

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
package study.SingleTop;
public class SingleTonB {
private static SingleTonB SingleTonB = null;
private SingleTonB(){

};

public static SingleTonB getInstance(){
if(SingleTonB == null){
SingleTonB = new SingleTonB();
}
return SingleTonB;

};
}

在测试多线程时,发现饿汉式是线程安全的,而懒汉式会创建两个不同的实例,可以通过以下方法来解决

一,可以通过在“全局的静态的外部可以访问的getInstance”加一个synchronized关键字。(效率低)

二,双重检测锁机制

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
package study.SingleTop;

public class SingleTonDoubleCheck {
private volatile static SingleTonDoubleCheck SingleTon = null;
private SingleTonDoubleCheck(){};

public static SingleTonDoubleCheck getInstance(){
if (SingleTon == null){
synchronized (SingleTonDoubleCheck.class){
if(SingleTon == null){
SingleTon = new SingleTonDoubleCheck();
}
}
}

return SingleTon;
}
}

这里的volatile关键字的作用是禁止指令重排,如果没有加上的话可能返回的是还未初始化的对象,会造成程序的错误。

加上volatile的话,对象可以正常的进行初始化。

三,内部类Holder式

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
package study.SingleTop;

public class SingleTonHolder {
private static class SingleTonInnerHolder{
private static SingleTonHolder instance = new SingleTonHolder();
}

private SingleTonHolder(){

}

public static SingleTonHolder getInstance(){
return SingleTonInnerHolder.instance;
}

}

工厂模式

定义:工厂模式是一种创建型模式,它实现对象创建和使用的分离,客户端不需要知道具体创建过程,只需要知道所要产品的具体工厂。

工厂方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
package study.FactoryMethod;

public class Main {
public static void main(String[] args) {
System.out.println("this is FactoryMethod main");
IShop shop = new MShop();
shop.getChips().eat();
}
}

package study.FactoryMethod;

public interface IFood{
void eat();
}

package study.FactoryMethod;

public class KChips implements IFood {
@Override
public void eat() {
System.out.println("吃到了KFC的薯条");
}
}

package study.FactoryMethod;

public class MChips implements IFood{

@Override
public void eat() {
System.out.println("吃到了麦当劳的薯条");
}
}

package study.FactoryMethod;

public class DChips implements IFood{
@Override
public void eat() {
System.out.println("吃到了德克士的薯条");
}
}

package study.FactoryMethod;

public interface IShop {
IFood getChips();
}

package study.FactoryMethod;

public class MShop implements IShop{
@Override
public IFood getChips() {
System.out.println("麦当劳出品的薯条");
return new MChips();
}
}


package study.FactoryMethod;

public class DShop implements IShop{
@Override
public IFood getChips() {
System.out.println("德克士出品的薯条");
return new DChips();
}
}

package study.FactoryMethod;

public class KShop implements IShop{
@Override
public IFood getChips() {
System.out.println("KFC出品的薯条");
return new KChips();
}
}

代理模式

定义:为其他对象提供一种代理以控制这个对象的访问。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
package study.Proxy;

public class Client {
public static void main(String[] args) {
System.out.println("Proxy main");
IMacSeller iMacSeller = new HkMacSeller();
iMacSeller.buy();
}
}


package study.Proxy;

public interface IMacSeller {
void buy();
}


package study.Proxy;

public class HkMacSeller implements IMacSeller{
USAMacSeller usaMacSeller = new USAMacSeller();
@Override
public void buy() {
usaMacSeller.buy();
System.out.println("Mac from Hk");
}
}

package study.Proxy;

public class USAMacSeller implements IMacSeller {
@Override
public void buy() {
System.out.println("Mac from USA");
}
}

动态代理

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
package study.DynamicProxy;

import java.lang.reflect.Proxy;

public class Client {
public static void main(String[] args) {
System.out.println("this is DynamicProxy");

//第一种方式
Food food = (Food) Proxy.newProxyInstance(Client.class.getClassLoader(),
new Class[] {Food.class},
new ProxyHander(new KFCStore()));
food.eat();
//第二种方式
IMSeller imSeller = (IMSeller) Proxy.newProxyInstance(Client.class.getClassLoader(),
IMStore.class.getInterfaces(),
new ProxyHander(new IMStore()));
imSeller.buy();
}
}

package study.DynamicProxy;

public interface IMSeller {
void buy();
}

package study.DynamicProxy;

public interface Food {
void eat();
}


package study.DynamicProxy;

public class IMStore implements IMSeller{
@Override
public void buy() {
System.out.println("我买了一部手机!");
}
}


package study.DynamicProxy;

public class KFCStore implements Food{
@Override
public void eat() {
System.out.println("在Kfc吃了一顿饭");
}
}


package study.DynamicProxy;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

public class ProxyHander implements InvocationHandler {

Object realObject;
public ProxyHander(Object realObject) {
this.realObject = realObject;
}

@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

System.out.println("代理开始");
Object ret = method.invoke(realObject, args);
System.out.println("我们代理了" + realObject.getClass().getSimpleName());
return ret;
}
}

适配器模式

定义:将一个类的接口转换成用户希望的另一个接口,使得原本由于接口不兼容而不能在一起工作的类可以一起工作。

适配器模式

  • 类的适配器模式:使用对象继承的方式,是静态的定义方式。
  • 对象的适配器模式:使用对象组合的方式,是动态组合的方式。

类的适配器模式

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
package study.ClassAdapter;

public class Client {
public static void main(String[] args) {
System.out.println("this is classAdapter main");

NoteBook noteBook = new NoteBook();
noteBook.TurnOn(new ClassAdapter());
}
}


package study.ClassAdapter;

public interface Power5V {
void getPower5v();
}


package study.ClassAdapter;

public class Power220 {
public void power(){
System.out.println("提供了220V的电压");
}
}

package study.ClassAdapter;

public class NoteBook {
public void TurnOn(Power5V power5V){
power5V.getPower5v();
System.out.println("接受5v电压,开始运行");
}
}

package study.ClassAdapter;

public class ClassAdapter extends Power220 implements Power5V{

@Override
public void getPower5v() {
super.power();
transfrom();
System.out.println("输出了5V电压");
}

public void transfrom(){
System.out.println("变压处理");
}
}

对象的适配器模式

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
package study.ObjectAdapter;

public class Client {
public static void main(String[] args) {
System.out.println("this is ObjectAdapter main");

NoteBook noteBook = new NoteBook();
noteBook.turnon(new ObjectAdapter(new Power220()));
}
}

package study.ObjectAdapter;

public interface Power12 {
void getPower12();
}


package study.ObjectAdapter;

public class Power220 {
public void getPower220(){
System.out.println("提供220V电压");
}
}

package study.ObjectAdapter;

public class ObjectAdapter implements Power12{
private Power220 power220;

public ObjectAdapter(Power220 power220) {
this.power220 = power220;
}

@Override
public void getPower12() {
power220.getPower220();
transfrom();
System.out.println("输出了12v电压");
}

private void transfrom() {
System.out.println("做了变压处理");
}
}

package study.ObjectAdapter;

public class NoteBook {
public void turnon(Power12 power12){
power12.getPower12();
System.out.println("得到了12v电压,开机");
}

}

观察者模式

定义:对象之间的一种一对多的依赖关系,当一个对象的状态发生改变时,所有依赖他的对象都得到通知并被自动更新。常用来处理事件处理系统。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
package study.Observer;

public class main{
public static void main(String[] args) {
System.out.println("this is Observer main");

WeatherStation weatherStation = new WeatherStation();
Xiaohong xiaohong = new Xiaohong(weatherStation);
Jack jack = new Jack(weatherStation);

weatherStation.addObserver(xiaohong);
weatherStation.addObserver(jack);

// weatherStation.setTemperature(-10);
weatherStation.setHumidity(100);
}
}

package study.Observer;

public interface WeatherSubject {
void addObserver(Observer o);
void removeObserver(Observer o);
void notifyObserver();
}

package study.Observer;

import java.util.ArrayList;
import java.util.List;

public class WeatherStation implements WeatherSubject{

List<Observer> observers = new ArrayList<Observer>();

public int getTemperature() {
return temperature;
}

public void setTemperature(int temperature) {
this.temperature = temperature;
notifyObserver();
}

private int temperature;

public int getHumidity() {
return humidity;
}

public void setHumidity(int humidity) {
this.humidity = humidity;
notifyObserver();
}

private int humidity;
@Override
public void addObserver(Observer o) {
observers.add(o);
}

@Override
public void removeObserver(Observer o) {
observers.remove(o);
}

@Override
public void notifyObserver() {
for (Observer o : observers){
o.updata();
}
}
}

package study.Observer;

public class Xiaohong implements Observer{
WeatherStation weatherStation;

public Xiaohong(WeatherStation weatherStation){
this.weatherStation = weatherStation;
}


@Override
public void updata() {
if(weatherStation.getTemperature() < 0){
System.out.println("太冷了,多穿点衣服吧");
}
}
}

package study.Observer;

public class Jack implements Observer{
WeatherStation weatherStation;
public Jack(WeatherStation weatherStation){
this.weatherStation = weatherStation;
}

@Override
public void updata() {
if(weatherStation.getHumidity() > 50){
System.out.println("打开空调,开始除湿度");
}
}
}

package study.Observer;

public interface Observer {
void updata();
}

观察者模式

  • 推模式:被观察者对象向观察者推送主题的详细信息,不管观察者是否需要,推送的信息通常是主题对象的全部或者部分数据。
  • 拉模式:被观察者在通知观察者者时,只传递少量信息。如果观察者需要更具体的信息,需要观察者主动到被观察者对象中获取。

策略模式

定义:策略模式定义了一系列的算法,并将每一个算法封装起来,并且使它们还可以相互替换。策略模式让算法独立于使用他的用户而独立变化。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
package study.Strategy;

public class main{
public static void main(String[] args) {
System.out.println("this is strategy main");

TravelWay travelWay = new Car();
Person person = new Person(travelWay);
person.goTravel();
}
}

package study.Strategy;

public interface TravelWay {
void travel();
}


package study.Strategy;

public class BikeWay implements TravelWay{
@Override
public void travel() {
System.out.println("出行使用了自行车");
}
}

package study.Strategy;

public class Car implements TravelWay{
@Override
public void travel() {
System.out.println("出行使用了汽车");
}
}

package study.Strategy;

public class Train implements TravelWay{
@Override
public void travel() {
System.out.println("出行使用了火车");
}
}

package study.Strategy;

public class Person {
TravelWay travelWay;
public Person(TravelWay travelWay){
this.travelWay = travelWay;
}

public void goTravel(){
System.out.println("出去旅游啦");
travelWay.travel();
}
}