1.单例模式
饿汉式:
public class Single{
private Single() {}
private static Singles = new Single();
public static Single getInstance() {
return s;
}
}
懒汉式:
public class Single {
private Single() {
}
private static Single t = null;
public static SinglegetInstance() {
if (t == null) {
synchronized (Single.class) {
if (t == null) {
t = new Single();
}
}
}
return t;
}
}
2.工厂模式
-
简单⼯⼚模式:
创建抽象产品类
public abstract class Computer { /** *产品的抽象⽅法,由具体的产品类去实现 */ public abstract void start(); }
创建具体产品类
public class LenovoComputer extends Computer{ @Override public void start() { System.out.println("联想电脑启动"); }
public class HpComputer extends Computer{ @Override public void start() { System.out.println("惠普电脑启动"); } }
创建⼯⼚类
public class ComputerFactory { public static Computer createComputer(String type){ Computer mComputer=null; switch (type) { case "lenovo": mComputer=new LenovoComputer(); break; case "hp": mComputer=new HpComputer(); break; } return mComputer; } }
调⽤
public class CreatComputer { public static void main(String[]args){ ComputerFactory.createComputer("hp").start(); } }
-
工厂模式一:
public class AnimalTest { public static void main(String[] args) { Animal a = AnimalFactory.createAnimal(Dog.class); a.eat(); a = AnimalFactory.createAnimal(Cow.class); a.eat(); a = AnimalFactory.createAnimal(Chiken.class); a.eat(); } }
public abstract class Animal { public abstract void eat(); } public class AnimalFactory { private AnimalFactory() { } public static Animal createAnimal(String type) { if ("dog".equals(type)) { return new Dog(); } else if ("cat".equals(type)) { return new Cat(); } else if("cow".equals(type)){ return new Cow(); }else{ return null; } } public static <T> T createAnimal(Class<T> type){ try { T instance = type.newInstance();//Cat.class.newInstance(); return instance; } catch (Exception e) { e.printStackTrace(); } return null; } } public class Dog extends Animal { @Override public void eat() { System.out.println("狗吃骨头"); } } ...略
-
工厂模式二:
/* * 多态的思想。 */ public class AnimalTest { public static void main(String[] args) { // 使用狗工厂 AnimalFactory af = new DogFactory(); Animal a = af.createAnimal(); a.eat(); af = new CatFactory(); a = af.createAnimal(); a.eat(); af = new PigFactory(); a = af.createAnimal(); a.eat(); } }
public abstract class Animal { public abstract void eat(); } public abstract class AnimalFactory { public abstract Animal createAnimal(); } public class DogFactory extends AnimalFactory { @Override public Animal createAnimal() { return new Dog(); } } public class CatFactory extends AnimalFactory { @Override public Animal createAnimal() { return new Cat(); } } public class Dog extends Animal { @Override public void eat() { System.out.println("狗吃骨头"); } } ...略
3.装饰模式
public class PhoneTest {
public static void main(String[] args) {
Phone p = new Phone();
p.call();
System.out.println("--------------");
p = new ColorPhone();
p.call();
System.out.println("--------------");
p = new GuangGaoPhone();
p.call();
System.out.println("--------------");
p = new ColorGuangGaoPhone();
p.call();
}
}
public class Phone {
public void call() {
System.out.println("用手机打电话");
}
}
public class ColorPhone extends Phone {
public void call() {
System.out.println("播放彩铃");
// System.out.println("用手机打电话");
super.call();
}
}
public class GuangGaoPhone extends Phone {
@Override
public void call() {
super.call();
System.out.println("播放广告");
}
}
public class ColorGuangGaoPhone extends ColorPhone {
@Override
public void call() {
super.call();
System.out.println("播放广告");
}
}
4.模板模式
public class PrintTest {
public static void main(String[] args) {
PrintTemplet pt = new PrintDemo1();
pt.print();
pt = new PrintDemo2();
pt.print();
}
}
/*
* 定义了一个打印的模板类
*/
public abstract class PrintTemplet {
public void print() {
printHead();
printBody();
printBottom();
}
public abstract void printHead();
public abstract void printBody();
public abstract void printBottom();
}
public class PrintDemo1 extends PrintTemplet {
@Override
public void printHead() {
System.out.println("采用第一种方案打印头");
}
@Override
public void printBody() {
System.out.println("采用第一种方案打印中间");
}
@Override
public void printBottom() {
System.out.println("采用第一种方案打印尾");
}
}
public class PrintDemo2 extends PrintTemplet {
@Override
public void printHead() {
System.out.println("采用第二种方案打印头");
}
@Override
public void printBody() {
System.out.println("采用第二种方案打印中间");
}
@Override
public void printBottom() {
System.out.println("采用第二种方案打印尾");
}
}
5.Builder构建者模式
直⽩来说,就是使⽤多个简单的对象⼀步⼀步构建成⼀个复杂的对象
public static void main(String[]args){
ComputerBuilder computerBuilder=new ComputerBuilder();
computerBuilder.installDisplayer("显万器");
computerBuilder.installMainUnit("主机");
computerBuilder.installKeybord("键盘");
computerBuilder.installMouse("⿏标");
Computer computer=computerBuilder.Builder();
System.out.println(computer);
}
定义computer
public class Computer {
private String displayer;
private String mainUnit;
private String mouse;
private String keyboard;
public String getDisplayer() {
return displayer;
}
public void setDisplayer(String displayer) {
this.displayer = displayer;
}
public String getMainUnit() {
return mainUnit;
}
public void setMainUnit(String mainUnit) {
this.mainUnit = mainUnit;
}
public String getMouse() {
return mouse;
}
public void setMouse(String mouse) {
this.mouse = mouse;
}
public String getKeyboard() {
return keyboard;
}
public void setKeyboard(String keyboard) {
this.keyboard = keyboard;
}
@Override
public String toString() {
return "Computer{" + "displayer='" + displayer + '\'' + ", mainUnit='"
+ mainUnit + '\'' + ", mouse='" + mouse + '\'' + ", keyboard='" + keyboard +
'\'' + '}';
}
}
ComputerBuilder
public static class ComputerBuilder {
private ComputerBuilder target = new ComputerBuilder();
public Builder installDisplayer(String displayer) {
target.setDisplayer(displayer);
return this;
}
public Builder installMainUnit(String mainUnit) {
target.setMainUnit(mainUnit);
return this;
}
public Builder installMouse(String mouse) {
target.setMouse(mouse);
return this;
}
public Builder installKeybord(String keyboard) {
target.setKeyboard(keyboard);
return this;
}
public ComputerBuilder build() {
return target;
}
}
6.代理模式
/**
* 抽象类⼈
*/
public interface Person {
void doSomething();
}
/**
* 创建⼀个名为Bob的⼈的实现类
*/
public class Bob implements Person {
public void doSomething() {
System.out.println("Bob doing something!");
}
}
/**
* JDK动态代理
* 需实现 InvocationHandler 接⼝ */
public class JDKDynamicProxy implements InvocationHandler {
//被代理的对象
Person target;
// JDKDynamicProxy 构造函数
public JDKDynamicProxy(Person person) {
this.target = person;
}
//获取代理对象
public Person getTarget() {
return (Person)Proxy.newProxylnstance(target.getClass().getClassLoader(),target.getClass().getInterfaces(), this);
}
//动态代理invoke⽅法
public Person invoke(Object proxy, Method method, Object[] args) throws Throwable {
//被代理⽅法前执⾏
System.out.println("JDKDynamicProxy do something before!");
//执⾏被代理的⽅法
Person result = (Person) method.invoke(target, args);
//被代理⽅法后执⾏
System.out.println("JDKDynamicProxy do something after!");
return result;
}
/**
* JDK动态代理测试
*/
public class JDKDynamicTest {
public static void main(String[] args) {
System.out.println("不使⽤代理类,调⽤doSomething⽅法。");
//不使⽤代理类
Person person = new Bob();
// 调⽤ doSomething ⽅法
person.doSomething();
System.out.println("分割线-----------");
System.out.println("使⽤代理类,调⽤doSomething⽅法。");
//获取代理类
Person proxyPerson = new JDKDynamicProxy(new Bob()).getTarget();
// 调⽤ doSomething ⽅法 proxyPerson.doSomething();
}
}