java 7大心法,23种绝学,你学会了不?


其实对于学习java来说,就是一种修炼,哈哈,7种心法,23种武功,如果你要修炼成一代大侠,必先挥刀自宫。。。各位绿林好汉,请珍重

java常用的设计模式,是每位大侠都需要掌握的东西,所以这里讲述下关于常用的设计模式如何(挥刀入宫)入门。

首先介绍下设计模式分类(23种顶级武学任你选):

java的设计模式大体上分为三大类:

创建型模式(5种):工厂方法模式抽象工厂模式单例模式,建造者模式,原型模式。

结构型模式(7种):适配器模式,装饰器模式,代理模式外观模式,桥接模式,组合模式,享元模式。

行为型模式(11种):策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。

上面字体加粗的几个(入门绝学)设计模式,就是平时我们比较常用的设计模式,当然具体根据项目实际情况为准。

除了设计模式的分类,还需要了解的就是设计模式的设计准则,这是我们需要在使用设计模式过程中遵循的原则(7大心法,想要牛逼,没有配对的装逼心法如何能行,就像一个任你采摘的萌萌妹子,你虽有技巧,却是一个秒秒钟挣扎的身躯。。。。。有心无力啊,有点偏题了额,当然欢迎来探讨绝学,嘿嘿):

设计模式遵循的原则有7个:

1、开闭原则(Open Close Principle)
  对扩展开放,对修改关闭2、里氏代换原则(Liskov Substitution Principle)
  只有当衍生类可以替换掉基类,软件单位的功能不受到影响时,基类才能真正被复用,而衍生类也能够在基类的基础上增加新的行为。

3、依赖倒转原则(Dependence Inversion Principle)
  这个是开闭原则的基础,对接口编程,依赖于抽象而不依赖于具体。

4、接口隔离原则(Interface Segregation Principle)
  使用多个隔离的借口来降低耦合度。

5、迪米特法则(最少知道原则)(Demeter Principle)
  实体之间尽量少的发生相互作用,使得系统功能模块相对独立。

6、合成复用原则(Composite Reuse Principle)
  原则是尽量使用合成/聚合的方式,而不是使用继承。继承实际上破坏了类的封装性,超类的方法可能会被子类修改。

7、组合/聚合复用原则
   在一个新的对象里面使用一些已有的对象,使之成为新对象的一部分:新的对象通过向这些对象的委派达到复用已有功能的目的。

关于详细的心法口诀可以参考下这里,请务必。。勿要走火入魔:java设计模式之七大原则(七大心法口诀)

 

额…忽然感觉还是真刀实抢比较来的痛快,毕竟还是个爷们。

1、工厂模式(Factory Method)

常用的工厂模式是静态工厂,利用static方法,作为一种类似于常见的工具类Utils等辅助效果,一般情况下工厂类不需要实例化。

interface Girl{}

class 女汉子 implements Girl{}
class 御姐 implements Girl{}
class 萝莉 implements Girl{}

public class GirlFactory{
  private GirlFactory(){}
  public static Girl get女汉子(){ return new 女汉子(); }
  public static Girl get御姐(){ return new 御姐(); }
  public static Girl get萝莉(){ return new 萝莉(); }
}

class 爷们{
  //爷们只需要将相应的妹子参数传入即可得到一个对象哦
  //爷们不需要了解妹子工厂类内部的逻辑。----快说,你喜欢那种妹子
  public void get(String 妹子参数){
    Girl xx = null ;
    if ( name.equals("女汉子")) {
      xx = GirlFactory.get女汉子();
    }else if ( name.equals("御姐")){
      xx = GirlFactory.get御姐();
    }else {
      xx = GirlFactory.get萝莉();
    }
  }
}

 

2、抽象工厂模式(Abstract Factory)

一个基础接口定义了功能,每个实现接口的子类就是产品,然后定义一个工厂接口,实现了工厂接口的就是工厂,这时候,接口编程的优点就出现了,我们可以新增产品类(只需要实现产品接口),只需要同时新增一个工厂类,客户端就可以轻松调用新产品的代码。

抽象工厂的灵活性就体现在这里,无需改动原有的代码,毕竟对于客户端来说,静态工厂模式在不改动 GirlFactory类 的代码时无法新增产品,如果采用了抽象工厂模式,就可以轻松的新增拓展类。

interface Girl{}//基础接口

class 萝莉 implements Girl{}//----
class 御姐 implements Girl{}

interface GirlProduce{ Girl get();}//工厂接口

class FactoryFor萝莉 implements GirlProduce{
    @Override
    public Girl get() {
        return new 萝莉();
    }
}
class FactoryFor御姐 implements GirlProduce{
    @Override
    public Girl get() {
        return new 御姐();
    }
}
public class GirlStractFactory {
    public void ClientCode(){
        Girl xx= new FactoryFor萝莉().get();
        xx = new FactoryFor御姐().get();
    }
}

 

3、 单例模式(Singleton)

在内部创建一个实例,构造器全部设置为private,所有方法均在该实例上改动,在创建上要注意类的实例化只能执行一次,可以采用许多种方法来实现,如Synchronized关键字,或者利用内部类等机制来实现。

//饿汉式,线程安全 但效率比较低 
public class SingletonTest { 
 
  private SingletonTest() { 
  } 
 
  private static final SingletonTest instance = new SingletonTest(); 
 
  public static SingletonTest getInstancei() { 
     return instance; 
  } 
} 

//饱汉式,非线程安全 
public class SingletonTest { 
  private SingletonTest() { 
  } 
 
  private static SingletonTest instance; 
 
  public static SingletonTest getInstance() { 
     if (instance == null) 
        instance = new SingletonTest(); 
     return instance; 
  } 
} 

//线程安全,但是效率非常低 
public class SingletonTest { 
  private SingletonTest() { 
  } 
 
  private static SingletonTest instance; 
 
  public static synchronized SingletonTest getInstance() { 
     if (instance == null) 
         instance = new SingletonTest(); 
     return instance; 
 } 
} 

//线程安全  并且效率高 
public class SingletonTest { 
   private static SingletonTest instance; 
 
   private SingletonTest() { 
   } 
 
   public static SingletonTest getIstance() { 
      if (instance == null) { 
         synchronized (SingletonTest.class) { 
            if (instance == null) { 
               instance = new SingletonTest(); 
            } 
         } 
      } 
      return instance; 
   } 
} 

 

4、代理模式(Proxy)

客户端通过代理类访问,代理类实现具体的实现细节,客户只需要使用代理类即可实现操作。这种模式可以对旧功能进行代理,用一个代理类调用原有的方法,且对产生的结果进行控制。

比如生活中的通过代理访问网络,客户通过网络代理连接网络(具体业务),由代理服务器完成用户权限和访问限制等与上网相关的其他操作(相关业务)。

interface Network { // 定义Network接口 
  public void browse(); // 定义浏览的抽象方法 
} 
 
class Real implements Network { // 真实的上网操作 
  public void browse() { // 覆写抽象方法 
    System.out.println("上网浏览信息!"); 
  } 
} 
 
class Proxy implements Network { // 代理上网 
  private Network network; 
 
  public Proxy(Network network) {// 设置代理的真实操作 
    this.network = network; // 设置代理的子类 
  } 
 
  public void check() { // 身份验证操作 
    System.out.println("检查用户是否合法!"); 
  } 
 
  public void browse() { 
    this.check(); // 调用具体的代理业务操作 
    this.network.browse(); // 调用真实的上网操作 
  } 
} 
 
public class ProxyDemo { 
  public static void main(String args[]) { 
  Network net = null; // 定义接口对象 
  net = new Proxy(new Real()); // 实例化代理,同时传入代理的真实操作 
  net.browse(); // 调用代理的上网操作 
 } 
}

 

5、外观模式(Facade)

为子系统中的一组接口提供一个一致的界面,定义一个高层接口,这个接口使得这一子系统更加容易使用。如果不懂这句的意思,看下面的例子,我们在启动停止所有子系统的时候,为它们设计一个外观类,这样就可以实现统一的接口,这样即使有新增的子系统 “萌妹子System”,也可以在不修改客户端代码的情况下轻松完成。

public class Facade {
    private 萝莉System system1 = new 萝莉System();//萝莉System、御姐System、女汉子System 不作一一列举
    private 御姐System system2 = new 御姐System();
    private 女汉子System system3 = new 女汉子System();
    
    //一个抠脚大汉要看所有妹子跳舞,他只要说我要看妹子跳舞即可,如果新来一个萌妹子,工作人员只需要把这个萌妹子安排进来就可以了,不用单独让抠脚大汉一个一个去点。
    public void 跳舞(){
        system1.跳舞();
        system2.跳舞();
        system3.跳舞();
    }
    
    public void 唱歌(){
        system1.唱歌();
        system2.唱歌();
        system3.唱歌();
    }
}

 

6、观察者模式(Observer Pattern)

观察者模式定义了一对多的依赖关系,让多个观察者对象同时监听某一个主题对象。这个主题对象在状态上发生变化时,会通知所有观察者对象,使他们能够自动更新自己。

public abstract class Subject {
     //定义一个观察者数组
     private Vector<Observer> obsVector = new Vector<Observer>();
     //增加一个观察者
     public void addObserver(Observer o){
             this.obsVector.add(o);
     }
     //删除一个观察者
     public void delObserver(Observer o){
             this.obsVector.remove(o);
     }
     //通知所有观察者
     public void notifyObservers(){
             for(Observer o:this.obsVector){
                     o.update();
             }
     }
}

 

想要学到更多绝学,就自己加油吧,嘿嘿

 

打赏

未经允许不得转载:五二零九 » java 7大心法,23种绝学,你学会了不?

赞 (0)
分享到:更多 ()