首页新闻招聘找找看知识库
  • 回复:23 浏览:69 2019-11-25 17:21 来自 cn2019

    1、原则
      1)、单一职责 只一个引起变化
      2)、开闭 修改关闭、扩展开放=>接口、抽象类
      3)、里氏代换 子类对象替父类对象
        开闭补充,抽象化实现
      4)、依赖倒置=>依赖抽象接口
      5)、接口隔离=>依赖Min接口
      6)、合成/聚合复用=>已有对象成为新对象一部分
        聚合:整体<=部分 iphone<=os
        合成:整体=部分 ALL=part
        少继承
      7)、迪米特=>低耦低赖 A类-->友元/中介-->B类

    2、创建

      处理对象创建
      合适方式创建对象

      具体类封装、隐藏实例创建和结合方式

      对象创建型:处理对象创建;对象创建的一部分推迟到另一个对象
      类创建型:处理类创建;对象创建推迟到子类中

    2-1、简单工厂 SimplyFactory
      SimplyFactory=>typeA:productA type多复杂
    2-2、工厂方法 MethodFactory
      TypeAFactory=>Factory
      TypeAProduct=>Product....TypeZFactory复杂
    2-3、抽象工厂abstract
      TypeAFactory=>Factory
      TypeAProduct=>ProductA0....ProductAn A0..An复杂
    2-4、单列
    2-5、原型clone

    3、结构
      处理类/对象组合
      模块之间耦合


    4、行为
      类/对象=>交互、分配职责

      算法、对象间职责分配
      对象/类、之间通信方式
      控制流转移到对象间关系


      行为型类模式=>继承机制在类间分派行为
      行为型对象模式=>对象复合非继承

     

  • cn2019
    2019-11-26 10:14 cn2019
    2-5、原型clone
    对象A=new 类A, 对象B=对象A.clone 变化小
    A.GetClass=B.GetClass;A<>B
    浅Cloneable:值
    深Serializable:引用
    第1楼 回到顶楼
  • cn2019
    2019-11-26 10:16 cn2019
    浅clone

    public class Monkey implements Cloneable {

    public Object clone(){
    Monkey temp = null;
    try {
    temp = (Monkey) super.clone();
    } catch (CloneNotSupportedException e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
    } finally {
    return temp;
    }
    }
    第2楼 回到顶楼
  • cn2019
    2019-11-26 10:17 cn2019
    深clone
    public class Monkey implements Cloneable,Serializable {
    /**
    * 克隆方法
    */
    public Object clone(){
    Monkey temp = null;
    try {
    temp = (Monkey) super.clone();
    } catch (CloneNotSupportedException e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
    } finally {
    return temp;
    }
    }
    public Object deepClone() throws IOException, ClassNotFoundException{
    //将对象写到流里
    ByteArrayOutputStream bos = new ByteArrayOutputStream();
    ObjectOutputStream oos = new ObjectOutputStream(bos);
    oos.writeObject(this);
    //从流里读回来
    ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
    ObjectInputStream ois = new ObjectInputStream(bis);
    return ois.readObject();
    }
    第3楼 回到顶楼
  • cn2019
    2019-11-26 10:51 cn2019
    2-4、单列Singleton 扩展难 ==枚举
    饿汉synchronized第1次使用:空间大
    懒汉类加载:慢
    双锁volatile/synchronized:效率差
    内部类:多线程默认同步锁,同时延迟加载、线程安全
    第4楼 回到顶楼
  • cn2019
    2019-11-26 10:52 cn2019
    // 双锁volatile/synchronized:效率差

    public class Single4 {

    private static volatile Single4 instance;

    private Single4() {}

    public static Single4 getInstance() {

    if (instance == null) {

    synchronized (Single4.class) {

    if (instance == null) {

    instance = new Single4();

    }

    }

    }

    return instance;

    }

    }
    第5楼 回到顶楼
  • cn2019
    2019-11-26 10:53 cn2019
    内部类:多线程默认同步锁,同时延迟加载、线程安全
    public class ClassInnerClassDanli {
    public static class DanliHolder{
    private static ClassInnerClassDanli dl = new ClassInnerClassDanli();
    }
    private ClassInnerClassDanli(){}
    public static ClassInnerClassDanli getInstance(){
    return DanliHolder.dl;
    }
    }
    第6楼 回到顶楼
  • cn2019
    2019-11-27 11:15 cn2019
    3-1、适配器(对象)
    适配器=>适配者(不兼容接口对象)
    Client=>Target=>Adapter=>Adaptee
    3-2、桥接
    抽象部分与实现部分分离
    继承关系=>弱关联(组合或聚合) 降耦 少类数量

    桥接口=》扩展全部;抽象类=>桥接口,扩展全部继承
    第7楼 回到顶楼
  • cn2019
    2019-11-27 11:18 cn2019
    桥接..............................
    1、interface Color
    White implements Color

    2、abstract class Shape
    {
    Color color
    }
    3、Circle extends Shape

    4、
    public static void main(String[] args) {
    //白色
    Color white = new White();
    //正方形
    Shape square = new Square();
    //白色的正方形
    square.setColor(white);
    square.draw();

    //长方形
    Shape rectange = new Rectangle();
    rectange.setColor(white);
    rectange.draw();
    }
    第8楼 回到顶楼
  • cn2019
    2019-11-27 11:21 cn2019
    适配器
    1、interface Robot
    2、BioRobot implements Robot
    3、class Dog

    4、DogAdapter implements Robot{
    Dog dog;
    public DogAdapter(Dog dog){ //取得要适配的对象的引用
    this.dog = dog;
    }


    /**
    * 实现接口中的方法,只需要在相应的方法间进行转换即可完成。
    */
    public void cry() {
    System.out.println("机器人模拟狗叫...");
    dog.wang();
    }

    public void move() {
    System.out.println("机器人模拟狗跑...");
    dog.run();
    }

    }

    5、
    public static void main(String[] args) {
    BioRobot robot = new BioRobot(); //首先我们需要一个机器人
    Dog dog = new Dog(); //和一只狗

    //将这只狗包装到机器人中,使其有点儿像机器人
    Robot dogRobot = new DogAdapter(dog);

    //然后是机器人叫和跑
    System.out.println("BioRob cry.....");
    dogRobot.cry();
    dogRobot.move();
    }
    第9楼 回到顶楼
  • cn2019
    2019-11-27 14:50 cn2019
    3-3、组合
    整体/部分
    容器(叶子)、容器(容器)对象类层次=>递归树形
    第10楼 回到顶楼
  • cn2019
    2019-11-27 14:51 cn2019
    1、public abstract class File {
    2、public class Folder extends File{
    3、public class TextFile extends File{
    4、public class ImagerFile extends File{
    5、public class VideoFile extends File{


    public static void main(String[] args) {
    /**
    * 我们先建立一个这样的文件系统
    * 总文件
    *
    * a.txt b.jpg c文件夹
    * c_1.text c_1.rmvb c_1.jpg
    *
    */
    //总文件夹
    Folder zwjj = new Folder("总文件夹");
    //向总文件夹中放入三个文件:1.txt、2.jpg、1文件夹
    TextFile aText= new TextFile("a.txt");
    ImagerFile bImager = new ImagerFile("b.jpg");
    Folder cFolder = new Folder("C文件夹");

    zwjj.add(aText);
    zwjj.add(bImager);
    zwjj.add(cFolder);

    //向C文件夹中添加文件:c_1.txt、c_1.rmvb、c_1.jpg
    TextFile cText = new TextFile("c_1.txt");
    ImagerFile cImage = new ImagerFile("c_1.jpg");
    VideoFile cVideo = new VideoFile("c_1.rmvb");

    cFolder.add(cText);
    cFolder.add(cImage);
    cFolder.add(cVideo);

    //遍历C文件夹
    cFolder.display();
    //将c_1.txt删除
    cFolder.remove(cText);
    System.out.println("-----------------------");
    cFolder.display();
    }
    第11楼 回到顶楼
  • cn2019
    2019-11-29 11:28 cn2019
    3-4、装饰者
    对象动态加/减职责
    类A0、A1=>implements=>接口A{方法a}
    abstract Decorator{方法b,Set 接口A} implements=>接口A{方法a}
    注:+方法b
    类DecoratorA0、A1=>extends=>Decorator
    第12楼 回到顶楼
  • cn2019
    2019-11-29 11:29 cn2019
    装饰者
    1、public interface Person {

    void eat();
    }
    2、public class Man implements Person {

    public void eat() {
    System.out.println("男人在吃");
    }
    }

    3、public abstract class Decorator implements Person {

    protected Person person;

    public void setPerson(Person person) {
    this.person = person;
    }

    public void eat() {
    person.eat();
    }
    }

    //具体装饰者A
    4、public class ManDecoratorA extends Decorator {

    public void eat() {
    super.eat();
    reEat();
    System.out.println("ManDecoratorA类");
    }

    public void reEat() {
    System.out.println("再吃一顿饭");
    }
    }

    //具体装饰B
    public class ManDecoratorB extends Decorator {

    public void eat() {
    super.eat();
    System.out.println("===============");
    System.out.println("ManDecoratorB类");
    }
    }
    5、
    public class Test {

    public static void main(String[] args) {
    Man man = new Man();
    ManDecoratorA md1 = new ManDecoratorA();
    ManDecoratorB md2 = new ManDecoratorB();

    md1.setPerson(man);
    md2.setPerson(man);
    md2.eat();
    }
    }
    第13楼 回到顶楼
  • cn2019
    2019-11-29 14:34 cn2019
    3-5、装饰者
    统一接口=>访问子系统群接口

    类WatchTvSwtichFacade{
    类A0,A1.....AN
    方法a0{A0.a0......AN.a0}
    方法a1{A0.a1......AN.a1}
    }
    第14楼 回到顶楼
  • cn2019
    2019-11-29 17:42 cn2019
    3-6、享元
    相同或者相似对象大粒重用共享、变化小

    抽象享元类A{参:外状态}
    具体享元类B、C extends A
    享元工厂F{B、C}{单例模式、简单工厂}
    第15楼 回到顶楼
  • cn2019
    2019-12-02 17:59 cn2019
    3-7代理
    对象替身
    抽象对象:目标、代理对象共同接口
    目标对象代理对象使用一样
    目标对象:代理对象所代表的目标对象

    代理对象:代理对象内含目标对象,操作目标对象;
    代理、目标对象相同接口,替代目标对象

    客户端调用:传给目标前后执行操作

    抽象对象 AbstractObject{方法A}
    目标对象 RealObject extends AbstractObject{方法A}
    代理对象 ProxyObject extends AbstractObject{RealObjec、方法A}
    第16楼 回到顶楼
  • cn2019
    2019-12-03 11:28 cn2019
    4-1职责链
    请求者->处理者0{}.....->处理者n
    (处理者0.....n 动态增加/删除)

    请求者:类A
    abstract 处理B{ 处理{类A},后继者}
    处理B0 extends Leader B{}
    处理B1 extends Leader B{}
    ........................
    处理Bn extends Leader B{}
    第17楼 回到顶楼
  • cn2019
    2019-12-03 17:55 cn2019
    4-2命令
    请求对象
    发出、执行命令

    Receiver: 接收者
    Command:abstract 命令A{Receiver,abstract方法A0{}}
    ConcreteCommand extends Command{Receiver,Override 方法A0{})
    Invoker: 调用者{Command,方法A0{}}
    第18楼 回到顶楼
  • cn2019
    2019-12-04 17:56 cn2019
    4-3解释器
    环境类Context
    abstract Expression{Context}
    PlusExpression extends Expression{}
    MinusExpression extends Expression{}
    第19楼 回到顶楼
  • cn2019
    2019-12-10 11:33 cn2019
    4-4迭代器
    顺序聚合对象元素,不暴露内部

    4-5中介对象
    中介对象{交互对象A0.....交互对象An},不太多

    abstract 中介A{相互A}
    中介代理 extends 中介A{同事a...同事B}

    abstract 相互A
    同事a extends 相互A{中介A}
    同事b extends 相互A{中介A}
    ................................
    第20楼 回到顶楼
  • cn2019
    2019-12-11 14:47 cn2019
    4-6备忘录
    恢复状态,回到某个历史的状态
    Originator: 原发器 创建备忘录
    Memento: 备忘录
    Caretaker: 负责人 保存备忘录

    Caretaker.Mement1=Originator.Memento1
    Originator.Memento2
    Originator.Memento1=(Caretaker.Memento1)

    4-7 观察者
    发布-订阅(广播)
    观察者n:1主题

    interface 观察者I
    观察者1 implements 观察者I

    interface 主题I
    主题1 implements 主题I{观察者1......观察者n}
    第21楼 回到顶楼
  • cn2019
    2019-12-12 11:41 cn2019
    4-8状态
    内部状态<=>行为
    interface IState
    State0 implements IState
    ........................
    Staten implements IState
    Context{State0,......Staten}
    4-9策略
    算法族<>多条件
    interface ISort
    Sort0 implements ISort
    ........................
    Sortn implements ISort
    ArraySort{Sort0,......Sortn}

    4-10模板方法
    算法
    代码复用子类实现
    AbstractClass 模板方法{方法0...方法n,TemplateMethod{方法0...方法n}}
    ConcreteClassA extends 模板方法{}
    .................................
    ConcreteClassZ extends 模板方法{}
    第22楼 回到顶楼
  • cn2019
    2019-12-12 17:34 cn2019
    4-11访问者
    数据结构稳定
    操作变化
    interface I被访问{I访问{}}
    被访问a implements I被访问
    ..........................
    被访问n implements I被访问

    interface I访问
    访问1 implements I访问{被访问a......被访问n}
    访问2 implements I访问{被访问a......被访问n}
    ..........................
    访问n implements I访问{被访问a......被访问n}
    第23楼 回到顶楼
登录后才能评论,请先登录注册