前言
设计模式分类
创建型(创建一个对象):单例模式、工厂模式、抽象工厂模式
结构型(将几个对象组织成一个结构):桥接模式、外观模式、代理模式
行为型(多个对象间的通信):观察者模式、策略模式
一、单例模式?
1.饿汉式
public class SingletonDemo1 {
/**饿汉式
* 类加载时对象创建
* 线程安全,无法解决反射创建对象
* */
private static SingletonDemo1 instance= new SingletonDemo1();
//私有化构造方法
private SingletonDemo1(){
}
public static SingletonDemo1 getInstance(){
return instance;
}
public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
Constructor<SingletonDemo1> constructor = SingletonDemo1.class.getDeclaredConstructor();
constructor.setAccessible(true); //取消访问检查
SingletonDemo1 demo1 = constructor.newInstance();
SingletonDemo1 demo2 = SingletonDemo1.getInstance();
System.out.println(demo1==demo2);
}
}
2.懒汉式
public class SingletonDemo2 {
/**懒汉事
* 类加载时对象创建
* 线程不安全
* */
private static SingletonDemo2 instance= null;
//私有化构造方法
private SingletonDemo2(){
}
public static SingletonDemo2 getInstance(){
if (instance==null){
instance = new SingletonDemo2();
}
return instance;
}
}
3.加锁双重校验
public class SingletonDemo3 {
/**懒汉事 双重同步锁
* 类加载时对象创建
* 线程安全
* 存在 指令重排的线程安全问题 new SingletonDemo3() 不是原子操作,1分配地址 2初始化对象 3 对象指向地址
* 所以当线程A获得锁创建对象先执行3,cpu切换到线程A,第一个if判断就通过了,那么线程A就获取了一个未初始化的对象
* volatitle 不许重排
* */
private volatile static SingletonDemo3 instance= null;
//私有化构造方法
private SingletonDemo3(){
}
public static SingletonDemo3 getInstance(){
if (instance==null){
synchronized (SingletonDemo3.class){
if (instance ==null){
instance = new SingletonDemo3();
}
}
}
return instance;
}
}
4.枚举
public enum SingletonDemo4 {
instance;
}
二、策略模式?
链接: 策略模式.
继承能复用,但是修改父类局部,会影响所以子类
抽出接口,可以实现某一些子类具有飞的功能,但是每个子类都需要实现,无法复用
1.抽出要加的fly方法
public interface Flyable {
void fly();
}
2.提供不同的实现策略
public class Fly1 implements Flyable {
@Override
public void fly() {
System.out.println("横着飞");
}
}
public class Fly2 implements Flyable {
@Override
public void fly() {
System.out.println("仰着飞");
}
}
3.fly关联超类
public abstract class Duck {
//关联飞的属性
Flyable flyable;
//表示不同的鸭子
public abstract void display();
public void performFly(){
flyable.fly();
}
//设置fly
public void setFlyable(Flyable flyable) {
this.flyable = flyable;
}
}
4.不同鸭子
public class Duck1 extends Duck {
@Override
public void display() {
System.out.println("我是黑鸭");
}
}
public class Duck2 extends Duck {
@Override
public void display() {
System.out.println("我是白鸭");
}
}
5.客户端测试,黑鸭横着飞,白鸭不能飞
public class client {
public static void main(String[] args) {
Duck1 duck1 = new Duck1();
//设置飞
duck1.setFlyable(new Fly1());
//什么鸭子
duck1.display();
//能不能飞
duck1.performFly();
System.out.println("========================");
Duck2 duck2 = new Duck2(); //没有设置飞
duck2.display();
duck2.performFly();
}
}
三、工厂模式?
链接: 工厂模式
1.简单工厂(一个工厂里根据参数返回不同对象)
1.抽象手机
public interface Phone {
void make();
}
2.不同具体手机
public class Iphone implements Phone {
public Iphone() {
this.make();
}
@Override
public void make() {
System.out.println("苹果手机");
}
}
public class MiPhone implements Phone{
public MiPhone() {
this.make();
}
@Override
public void make() {
System.out.println("小米手机");
}
}
3.加工手机的工厂
public class PhoneFactory {
public Phone getInstance(String type){
if ("小米".equals(type)){
return new MiPhone();
}else if ("苹果".equals(type)){
return new Iphone();
}else {
return null;
}
}
}
3.客户
public class Client {
public static void main(String[] args) {
PhoneFactory phoneFactory = new PhoneFactory();
phoneFactory.getInstance("苹果");
}
}
//执行结果
苹果手机
2.方法工厂(工厂细化)
1.抽象手机
public interface Phone {
void make();
}
2.不同具体手机
public class Iphone implements Phone {
public Iphone() {
this.make();
}
@Override
public void make() {
System.out.println("苹果手机");
}
}
public class MiPhone implements Phone{
public MiPhone() {
this.make();
}
@Override
public void make() {
System.out.println("小米手机");
}
}
3.制作手机的抽象工厂
public interface AbstractFactory {
Phone makePhone();
}
4.不同产品的不同工厂
public class MiFactory implements AbstractFactory {
@Override
public Phone makePhone() {
return new MiPhone();
}
}
public class IFactory implements AbstractFactory {
@Override
public Phone makePhone() {
return new Iphone();
}
}
5.客户
public class Client {
public static void main(String[] args) {
AbstractFactory miFactory = new MiFactory();
miFactory.makePhone();
AbstractFactory iFactory = new IFactory();
iFactory.makePhone();
}
}
//结果 实现不同工厂生产不同产品
小米手机
苹果手机
3.抽象工厂(一个工厂需要生产不同类型的产品,就需要不同的流水线)
1.抽象PC
public interface PC {
void make();
}
2.具体PC
public class IPC implements PC {
@Override
public void make() {
System.out.println("苹果PC");
}
}
public class MiPc implements PC {
public MiPc() {
this.make();
}
@Override
public void make() {
System.out.println("小米PC");
}
}
3.抽象加工厂定义流水线
public interface AbstractFactory {
//手机流水线
Phone makePhone();
//pc流水线
PC makePC();
}
4.具体加工厂
public class MiFactory implements AbstractFactory {
@Override
public Phone makePhone() {
return new MiPhone();
}
@Override
public PC makePC() {
return new MiPc();
}
}
public class IFactory implements AbstractFactory {
@Override
public Phone makePhone() {
return new Iphone();
}
@Override
public PC makePC() {
return new IPC();
}
}
5.客户
public class Client {
public static void main(String[] args) {
//手机流水线
AbstractFactory miFactory = new MiFactory();
miFactory.makePhone();
//PC流水线
MiFactory miFactory = new MiFactory();
miFactory.makePC();
}
}
四、代理模式?
链接: 代理模式.
1.静态代理
代理类程序员自己写
1.公共接口
public interface Parent {
void go();
}
2.目标类
public class Real implements Parent {
@Override
public void go() {
System.out.println("真实对象执行代码");
}
}
3.代理类
public class Proxy implements Parent {
private Real real;
@Override
public void go() {
if (real == null)
real = new Real();
System.out.println("前置增强");
real.go();
System.out.println("后置增强");
}
}
4.客户端
public class Client {
public static void main(String[] args) {
Proxy proxy = new Proxy();
proxy.go();
}
}
2.动态代理
jdk动态代理,编写动态处理器,jdk动态生产代理类
1.动态代理处理器
public class MyInvocationHandler implements InvocationHandler {
//真实对象
private Object object;
// 有参构造获取代理对象时要
public MyInvocationHandler(Object object) {
this.object = object;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("前置增强");
// 真实对象执行
Object result = method.invoke(object, args);
System.out.println("后置增强");
return result;
}
}
2.客户端
public class Client {
public static void main(String[] args) {
Real real = new Real();
//第一参数是目标对象类加载器,app
//第一个参数是公共接口数组
//第三个是代理处理器,有参构造的用处
Parent realProxy=(Parent) Proxy.newProxyInstance(Real.class.getClassLoader(),new Class[]{Parent.class},new MyInvocationHandler(real));
realProxy.go();
}
}
2.Cglib动态代理
没有接口的代理,继承,动态生成子类代理类
1.真实对象
public class CReal {
public void go(){
System.out.println("真实对象执行了...");
}
}
2.动态增强器
public class CglibProxyEnhance implements MethodInterceptor {
private Object object;
public CglibProxyEnhance(Object object) {
this.object = object;
}
@Override
public Object intercept(Object o, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
System.out.println("前置增强");
Object result = method.invoke(object, args);
System.out.println("后置增强");
return result;
}
}
3.客户端
public class Client {
public static void main(String[] args) {
CReal cReal = new CReal();
Enhancer enhancer = new Enhancer();
//设置父类
enhancer.setSuperclass(cReal.getClass());
//设置增强器
enhancer.setCallback(new CglibProxyEnhance(cReal));
CReal cReal1 = (CReal) enhancer.create(); //生成代理子类
cReal1.go();
}
}
五、适配器模式?
链接: 适配器模式.
1.类适配器
把适配类的api转成目标api,继承关系连接源api
1.目标api
public interface Target {
//想要封装成这样的方法
void request();
}
2.源api
public class Adaptee {
//这个方法不兼容,需要转换成request
public void sourceRequest(){
System.out.println("源方法执行...");
}
}
3.适配器
public class Adapter extends Adaptee implements Target {
//souceRequest适配成request
@Override
public void request() {
this.sourceRequest();
}
}
4.客户端
public class Client {
public static void main(String[] args) {
Adapter adapter = new Adapter();
//目标api能执行源api的东西,转换成功
adapter.request();
}
}
2.对象适配器
关联关系连接源api
1.关联关系连接源api
public class Adapter1 implements Target {
//关联关系
private Adaptee adaptee;
public Adapter1(Adaptee adaptee) {
this.adaptee = adaptee;
}
@Override
public void request() {
this.adaptee.sourceRequest();
}
}
2.客户端
public class Client {
public static void main(String[] args) {
Adapter1 adapter1 = new Adapter1(new Adaptee());
adapter1.request();
}
}
六、设计原则?
1.单一原则: 一个类只负责一个职能
问题:如果一个T类有两个职责p1,p2,那么当只需要修改p1职责时,p2职责也可能被影响.
2.里氏替换原则: 继承时尽量不要重写父类已经实现好的方法
3.依赖倒置原则:高层不要依赖底层,最好依赖底层抽象,
问题: a类依赖b类,现在修改成依赖c类,那就要修改a类代码,存在风险,
解决: a类依赖b c的抽象
4.接口隔离原则:接口臃肿,实现类需要空实现,拆分接口
5.迪米特法则:最少知道原则(直接关系,成员,入参,输出)
6.开闭原则:对扩展开放,对修改闭合
总结
提示:这里对文章进行总结:
例如:以上就是今天要讲的内容,本文仅仅简单介绍了pandas的使用,而pandas提供了大量能使我们快速便捷地处理数据的函数和方法。