一.单例模式
public class SingletonDemo {
public static void main(String[] args) {
//
}
}
class User1{//饿汉式
User1(){
}
private static User1 zs = new User1();
private static User1 getZs(){
return zs;
}
}
class User2{//懒汉式
private User2(){
}
private static User2 ls = null;
private synchronized static User2 getLs(){//为了线程安全，加上synchronized修饰
if(ls == null){
ls = new User2();
}
return ls;
}
}
class User3 {// 双重加锁机制
private User3() {
}
private static User3 ww = null;
private static User3 getWw() {
if (ww == null) {
synchronized (User3.class) {//只有ww为null的时候,创建过程中加上同步锁
if (ww == null) {
ww = new User3();
}
}
}
return ww;
}
}
二.简单工厂模式
public class SimpleFactoryDemo {
public static void main(String[] args) {
Factory.create("productA");
Factory.create("ProductB");
}
}
interface Product {
//声明类所需继承的共同接口，也可以是抽象类
}
class ProductA implements Product {
public ProductA() {
System.out.println("ProductA");
}
}
class ProductB implements Product {
public ProductB() {
System.out.println("ProductB");
}
}
class Factory {
//可以在工厂类中添加任何你所需要的逻辑
public static Product create(String str)
{
//生成ProductA
if(str.equalsIgnoreCase("ProductA"))
{
return new ProductA();
}
else
//生成ProductB
if(str.equalsIgnoreCase("ProductB"))
{
return new ProductB();
}
return null;
}
}
三.工厂方法模式
public class FactoryMethodDemo {
public static void main(String[] args) {
Factory factory = new FactoryA();
factory.createProduct();
factory = new FactoryB();
factory.createProduct();
}
}
interface Product{}
interface Factory {
//声明产生产品类的方法
public Product createProduct();
}
class ProductA implements Product {
public ProductA() {
System.out.println("ProductA");
}
}
class ProductB implements Product {
public ProductB() {
System.out.println("ProductB");
}
}
class FactoryA implements Factory {
//实现工厂类的方法生成产品类A
public Product createProduct()
{
return new ProductA();
}
}
class FactoryB implements Factory {
//实现工厂类的方法生成产品类B
public Product createProduct()
{
return new ProductB();
}
}
四.抽象工厂模式
public class AbstractFactory {
public static void main(String[] args) {
Factory factory = new FactoryA();
factory.createGift();
factory.createProduct();
}
}
interface Product{}
interface Gift {}//也可以是抽象类
class ProductA implements Product {
public ProductA() {
System.out.println("ProductA");
}
}
class ProductB implements Product {
public ProductB() {
System.out.println("ProductB");
}
}
class GiftA implements Gift {
public GiftA(){
System.out.println("GiftA");
}
}
class GiftB implements Gift {
public GiftB(){
System.out.println("GiftB");
}
}
interface Factory {
public Product createProduct();
public Gift createGift();
}
class FactoryA implements Factory {
@Override
public Product createProduct(){
return new ProductA();
}
@Override
public Gift createGift(){
return new GiftA();
}
}
class FactoryB implements Factory {
@Override
public Product createProduct(){
return new ProductB();
}
@Override
public Gift createGift(){
return new GiftB();
}
}
五.适配器模式
public class AdapterDemo {
public static void main(String[] args) {
SmallPort smallPort = new SmallPort() {//手机自带小的接口
public void useSmallPort() {
System.out.println("使用的是手机小的接口");
}
};
//需要一个大的接口才可以连上电脑,小口转换为大口
BigPort bigPort=new SmallToBig(smallPort);
bigPort.useBigPort();
}
}
interface BigPort {
public void useBigPort();//使用的大口
}
interface SmallPort {
public void useSmallPort();//使用小口
}
class SmallToBig implements BigPort{
private SmallPort smallPort;//小口
public SmallToBig(SmallPort smallPort){//获得小口
this.smallPort=smallPort;
}
@Override
public void useBigPort() {
this.smallPort.useSmallPort(); //使用小口
}
}
六.策略模式
public class StrategyDemo {
public static void main(String[] args) {
Car smallCar = new SmallCar("路虎","黑色");
Car bussCar = new BussCar("公交车","白色");
Person p1 = new Person("小明", 20);
p1.driver(smallCar);
p1.driver(bussCar);
}
}
interface CarFunction {
void run(); //每辆车有不同的行驶方法
}
class Car implements CarFunction {
protected String name; //车名字
protected String color; //车颜色
public Car(String name, String color) {
this.name = name;
this.color = color;
}
@Override
public void run() {
System.out.println(color +" " + name +"在行驶。。。");
}
}
class SmallCar extends Car {
public SmallCar(String name, String color) {
super(name, color);
}
@Override
public void run() {
System.out.println(color +" " + name +"在高速的行驶。。。");
}
}
class BussCar extends Car{
public BussCar(String name, String color) {
super(name, color);
}
@Override
public void run() {
System.out.println(color +" " + name +"在缓慢的行驶。。。");
}
}
class Person {
private String name;
private Integer age;
public void driver(Car car){
System.out.print(name +" "+ age+" 岁 "+" 开着");
car.run();
}
public Person(String name,Integer age) {
this.name=name;
this.age=age;
}
}
七.代理模式(静态代理)
public class StaticProxyDemo {
public static void main(String[] args) {
ProxySubject subject = new ProxySubject(new RealSubject());
subject.visit();
}
}
interface Subject {
void visit();
}
class RealSubject implements Subject {
private String name = "byhieg";
@Override
public void visit() {
System.out.println(name);
}
}
class ProxySubject implements Subject{
private Subject subject;
public ProxySubject(Subject subject) {
this.subject = subject;
}
@Override
public void visit() {
subject.visit();
}
}
八.代理模式(动态代理)
public class DynamicProxyDemo {
public static void main(String[] args) {
//创建一个实例对象，这个对象是被代理的对象
Person zhangsan = new Student("张三");
//创建一个与代理对象相关联的InvocationHandler
InvocationHandler stuHandler = new StuInvocationHandler<Person>(zhangsan);
//创建一个代理对象stuProxy来代理zhangsan，代理对象的每个执行方法都会替换执行Invocation中的invoke方法
Person stuProxy = (Person) Proxy.newProxyInstance(Person.class.getClassLoader(), new Class<?>[]{Person.class}, stuHandler);
//代理执行上交班费的方法
stuProxy.giveMoney();
}
}
interface Person {
//上交班费
void giveMoney();
}
class Student implements Person {
private String name;
public Student(String name) {
this.name = name;
}
@Override
public void giveMoney() {
try {
//假设数钱花了一秒时间
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(name + "上交班费50元");
}
}
class MonitorUtil {
private static ThreadLocal<Long> tl = new ThreadLocal<>();
public static void start() {
tl.set(System.currentTimeMillis());
}
//结束时打印耗时
public static void finish(String methodName) {
long finishTime = System.currentTimeMillis();
System.out.println(methodName + "方法耗时" + (finishTime - tl.get()) + "ms");
}
}
class StuInvocationHandler<T> implements InvocationHandler {
//invocationHandler持有的被代理对象
T target;
public StuInvocationHandler(T target) {
this.target = target;
}
/**
* proxy:代表动态代理对象
* method：代表正在执行的方法
* args：代表调用目标方法时传入的实参
*/
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("代理执行" +method.getName() + "方法");
//代理过程中插入监测方法,计算该方法耗时
MonitorUtil.start();
Object result = method.invoke(target, args);
MonitorUtil.finish(method.getName());
return result;
}
}
