为什么一定要学习设计模式

最新推荐文章于 2024-06-26 11:07:08 发布
最新推荐文章于 2024-06-26 11:07:08 发布
阅读量587 收藏 3
点赞数 3
文章标签： Java 架构 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/gupaoedu_tom/article/details/121045063
版权
本文通过生活案例展示了设计模式在代码优化中的应用，从冗余的代码到简洁优雅的实现，强调了设计模式对于写出高质量代码的重要性。文章通过重构JDBC操作示例，展示了如何使用设计模式减少重复代码，提高代码可维护性，并引入了模板方法和IRowMapper接口以实现更灵活的ORM处理。此外，文章指出Spring等经典框架广泛应用设计模式，鼓励开发者深入学习以提升技术水平。
摘要由CSDN通过智能技术生成

先来看一个生活案例，当我们开心时，也许会寻求享乐。在学习设计模式之前，你可能会这样感叹：

file

学完设计模式之后，你可能会这样感叹：

file

大家对比一下前后的区别，有何感受？

file

回到代码中，我们来思考一下，设计模式能解决哪些问题？

1 写出优雅的代码

先来看一段我很多年前写的代码。


public void setExammingForm(ExammingForm curForm,String parameters)throws BaseException {
    
     ...

      JSONObject jsonObj = new JSONObject(parameters);
      //试卷主键
      if(jsonObj.getString("examinationPaper_id")!= null && (!jsonObj.getString ("examinationPaper_id").equals("")))
         curForm.setExaminationPaper_id(jsonObj.getLong("examinationPaper_id"));
      //剩余时间
      if(jsonObj.getString("leavTime") != null && (!jsonObj.getString("leavTime").equals("")))
         curForm.setLeavTime(jsonObj.getInt("leavTime"));
      //单位主键
      if(jsonObj.getString("organization_id")!= null && (!jsonObj.getString ("organization_id").equals("")))
         curForm.setOrganization_id(jsonObj.getLong("organization_id"));
      //考试主键
      if(jsonObj.getString("id")!= null && (!jsonObj.getString("id").equals("")))
         curForm.setId(jsonObj.getLong("id"));
      //考场主键
      if(jsonObj.getString("examroom_id")!= null && (!jsonObj.getString ("examroom_id").equals("")))
         curForm.setExamroom_id(jsonObj.getLong("examroom_id"));
      //用户主键
      if(jsonObj.getString("user_id")!= null && (!jsonObj.getString("user_id").equals("")))
         curForm.setUser_id(jsonObj.getLong("user_id"));
      //专业代码
      if(jsonObj.getString("specialtyCode")!= null && (!jsonObj.getString ("specialtyCode").equals("")))
         curForm.setSpecialtyCode(jsonObj.getLong("specialtyCode"));
      //报考岗位
      if(jsonObj.getString("postionCode")!= null && (!jsonObj.getString ("postionCode").equals("")))
         curForm.setPostionCode(jsonObj.getLong("postionCode"));
      //报考等级
      if(jsonObj.getString("gradeCode")!= null && (!jsonObj.getString ("gradeCode").equals("")))
         curForm.setGradeCode(jsonObj.getLong("gradeCode"));
      //考试开始时间
      curForm.setExamStartTime(jsonObj.getString("examStartTime"));
      //考试结束时间
      curForm.setExamEndTime(jsonObj.getString("examEndTime"));
      
	 ...
}

优化之后的代码如下。


public class ExammingFormVo extends ExammingForm{

   private String examinationPaperId;	//试卷主键
   private String leavTime;				//剩余时间
   private String organizationId;		//单位主键
   private String id;					//考试主键
   private String examRoomId;			//考场主键
   private String userId;				//用户主键
   private String specialtyCode;		//专业代码
   private String postionCode;			//报考岗位
   private String gradeCode;			//报考等级
   private String examStartTime;		//考试开始时间
   private String examEndTime;			//考试结束时间

   ...
}

public void setExammingForm(ExammingForm form,String parameters)throws BaseException {
   try {
      JSONObject json = new JSONObject(parameters);
      ExammingFormVo  vo = JSONObject.parseObject(json,ExammingFormVo.class);

      form = vo;

   }catch (Exception e){
      e.printStackTrace();
   }

}

2 更好地重构项目

平时我们写的代码虽然满足了需求，但往往不利于项目的开发与维护，以下面的JDBC代码为例。

public void save(Student stu){
    String sql = "INSERT INTO t_student(name,age) VALUES(?,?)";
    Connection conn = null;
    Statement st = null;
    try{
        //1. 加载注册驱动
        Class.forName("com.mysql.jdbc.Driver");
        //2. 获取数据库连接
        conn=DriverManager.getConnection("jdbc:mysql:///jdbc_demo","root","root");
        //3. 创建语句对象
        PreparedStatement ps=conn.prepareStatement(sql);
        ps.setObject(1,stu.getName());
        ps.setObject(2,stu.getAge());
        //4. 执行SQL语句
        ps.executeUpdate();
        //5. 释放资源
    }catch(Exception e){
        e.printStackTrace();
    }finally{
        try{
            if(st != null)
                st.close();
        }catch(SQLException e){
            e.printStackTrace();
        }finally{
            try{
                if(conn != null)
                    conn.close();
            }catch(SQLException e){
                e.printStackTrace();
            }
        }
    }
}

//删除学生信息
public void delete(Long id){
    String sql = "DELETE  FROM t_student WHERE id=?";
    Connection conn = null;
    Statement st = null;
    try{
        //1. 加载注册驱动
        Class.forName("com.mysql.jdbc.Driver");
        //2. 获取数据库连接
        conn=DriverManager.getConnection("jdbc:mysql:///jdbc_demo","root","root");
        //3. 创建语句对象
        PreparedStatement ps = conn.prepareStatement(sql);
        ps.setObject(1,id);
        //4. 执行SQL语句
        ps.executeUpdate();
        //5. 释放资源
    }catch(Exception e){
        e.printStackTrace();
    }finally{
        try{
            if(st != null)
                st.close();
        }catch(SQLException e){
            e.printStackTrace();
        }finally{
            try{
                if(conn != null)
                    conn.close();
            }catch(SQLException e){
                e.printStackTrace();
            }
        }
    }
}

//修改学生信息
public void update(Student stu){
    String sql = "UPDATE t_student SET name=?,age=? WHERE id=?";
    Connection conn = null;
    Statement st = null;
    try{
        //1. 加载注册驱动
        Class.forName("com.mysql.jdbc.Driver");
        //2. 获取数据库连接
        conn=DriverManager.getConnection("jdbc:mysql:///jdbc_demo","root","root");
        //3. 创建语句对象
        PreparedStatement ps = conn.prepareStatement(sql);
        ps.setObject(1,stu.getName());
        ps.setObject(2,stu.getAge());
        ps.setObject(3,stu.getId());
        //4. 执行SQL语句
        ps.executeUpdate();
        //5. 释放资源
    }catch(Exception e){
        e.printStackTrace();
    }finally{
        try{
            if(st != null)
                st.close();
        }catch(SQLException e){
            e.printStackTrace();
        }finally{
            try{
                if(conn != null)
                    conn.close();
            }catch(SQLException e){
                e.printStackTrace();
            }
        }
    }
}

上述代码的功能没问题，但是代码重复得太多，因此可以进行抽取，把重复代码放到一个工具类JdbcUtil里。

//工具类
public class JdbcUtil {
    private JdbcUtil() { }
    static {
        //1. 加载注册驱动
        try {
            Class.forName("com.mysql.jdbc.Driver");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public static Connection getConnection() {
        try {
            //2. 获取数据库连接
            return DriverManager.getConnection("jdbc:mysql:///jdbc_demo", "root", "root");
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    //释放资源
    public static void close(ResultSet rs, Statement st, Connection conn) {
        try {
            if (rs != null)
                rs.close();
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            try {
                if (st != null)
                    st.close();
            } catch (SQLException e) {
                e.printStackTrace();
            } finally {
                try {
                    if (conn != null)
                        conn.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

只需要在实现类中直接调用工具类JdbcUtil中的方法即可。


//增加学生信息
public void save(Student stu) {
    String sql = "INSERT INTO t_student(name,age) VALUES(?,?)";
    Connection conn = null;
    PreparedStatement ps=null;
    try {
        conn = JDBCUtil.getConnection();
        //3. 创建语句对象
        ps = conn.prepareStatement(sql);
        ps.setObject(1, stu.getName());
        ps.setObject(2, stu.getAge());
        //4. 执行SQL语句
        ps.executeUpdate();
        //5. 释放资源
    } catch (Exception e) {
        e.printStackTrace();
    } finally {
        JDBCUtil.close(null, ps, conn);
    }

}

//删除学生信息
public void delete(Long id) {
    String sql = "DELETE  FROM t_student WHERE id=?";
    Connection conn = null;
    PreparedStatement ps = null;
    try {
        conn=JDBCUtil.getConnection();
        //3. 创建语句对象
        ps = conn.prepareStatement(sql);
        ps.setObject(1, id);
        //4. 执行SQL语句
        ps.executeUpdate();
        //5. 释放资源
    } catch (Exception e) {
        e.printStackTrace();
    } finally {
        JDBCUtil.close(null, ps, conn);
    }

}

//修改学生信息
public void update(Student stu) {
    String sql = "UPDATE t_student SET name=?,age=? WHERE id=?";
    Connection conn = null;
    PreparedStatement ps = null;
    try {
        conn=JDBCUtil.getConnection();
        //3. 创建语句对象
        ps = conn.prepareStatement(sql);
        ps.setObject(1, stu.getName());
        ps.setObject(2, stu.getAge());
        ps.setObject(3, stu.getId());
        //4. 执行SQL语句
        ps.executeUpdate();
        //5. 释放资源
    } catch (Exception e) {
        e.printStackTrace();
    } finally {
        JDBCUtil.close(null, ps, conn);
    }

}

public Student get(Long id) {
    String sql = "SELECT * FROM t_student WHERE id=?";
    Connection conn = null;
    Statement st = null;
    ResultSet rs = null;
    PreparedStatement ps=null;
    try {
        conn = JDBCUtil.getConnection();
        //3. 创建语句对象
        ps = conn.prepareStatement(sql);
        ps.setObject(1, id);
        //4. 执行SQL语句
        rs = ps.executeQuery();
        if (rs.next()) {
            String name = rs.getString("name");
            int age = rs.getInt("age");
            Student stu = new Student(id, name, age);
            return stu;
        }
        //5. 释放资源
    } catch (Exception e) {
        e.printStackTrace();
    } finally {
        JDBCUtil.close(rs, ps, conn);
    }
    return null;
}

public List<Student> list() {
    List<Student> list = new ArrayList<>();
    String sql = "SELECT * FROM t_student ";
    Connection conn = null;
    Statement st = null;
    ResultSet rs = null;
    PreparedStatement ps=null;
    try {
        conn=JDBCUtil.getConnection();
        //3. 创建语句对象
        ps = conn.prepareStatement(sql);
        //4. 执行SQL语句
        rs = ps.executeQuery();
        while (rs.next()) {
            long id = rs.getLong("id");
            String name = rs.getString("name");
            int age = rs.getInt("age");
            Student stu = new Student(id, name, age);
            list.add(stu);
        }
        //5. 释放资源
    } catch (Exception e) {
        e.printStackTrace();
    } finally {
        JDBCUtil.close(rs, ps, conn);
    }
    return list;
}

虽然完成了重复代码的抽取，但数据库中的账号密码等直接显示在代码中，不利于后期账户密码改动的维护。可以建立一个db.propertise文件，用来存储这些信息。


driverClassName=com.mysql.jdbc.Driver
url=jdbc:mysql:///jdbcdemo
username=root
password=root

只需要在工具类JdbcUtil中获取里面的信息即可。


static {
    //1. 加载注册驱动
    try {
        ClassLoader loader = Thread.currentThread().getContextClassLoader();
        InputStream inputStream = loader.getResourceAsStream("db.properties");
        p = new Properties();
        p.load(inputStream);
        Class.forName(p.getProperty("driverClassName"));
    } catch (Exception e) {
        e.printStackTrace();
    }
}

public static Connection getConnection() {
    try {
        //2. 获取数据库连接
        return DriverManager.getConnection(p.getProperty("url"), p.getProperty("username"),
        p.getProperty("password"));
    } catch (Exception e) {
        e.printStackTrace();
    }
    return null;
}

代码抽取到这里，貌似已经完成，但在实现类中，依然存在部分重复代码，在DML操作中，除了SQL和设置值的不同，其他都相同，把相同的部分抽取出来，把不同的部分通过参数传递进来，无法直接放在工具类中。此时，可以创建一个模板类JdbcTemplate，创建一个DML和DQL的模板来对代码进行重构。


//查询统一模板
public static List<Student> query(String sql,Object...params){
    List<Student> list=new ArrayList<>();
    Connection conn = null;
    PreparedStatement ps=null;
    ResultSet rs = null;
    try {
        conn=JDBCUtil.getConnection();
        ps=conn.prepareStatement(sql);
        //设置值
        for (int i = 0; i < params.length; i++) {
            ps.setObject(i+1, params[i]);
        }
        rs = ps.executeQuery();
        while (rs.next()) {
            long id = rs.getLong("id");
            String name = rs.getString("name");
            int age = rs.getInt("age");
            Student stu = new Student(id, name, age);
            list.add(stu);
        }
        //5. 释放资源
    } catch (Exception e) {
        e.printStackTrace();
    } finally {
        JDBCUtil.close(rs, ps, conn);
    }
    return list;
}

实现类直接调用方法即可。
//增加学生信息
public void save(Student stu) {
    String sql = "INSERT INTO t_student(name,age) VALUES(?,?)";
    Object[] params=new Object[]{stu.getName(),stu.getAge()};
    JdbcTemplate.update(sql, params);
}

//删除学生信息
public void delete(Long id) {
    String sql = "DELETE FROM t_student WHERE id = ?";
    JdbcTemplate.update(sql, id);
}

//修改学生信息
public void update(Student stu) {
    String sql = "UPDATE t_student SET name = ?,age = ? WHERE id = ?";
    Object[] params=new Object[]{stu.getName(),stu.getAge(),stu.getId()};
    JdbcTemplate.update(sql, params);
}

public Student get(Long id) {
    String sql = "SELECT * FROM t_student WHERE id=?";
    List<Student> list = JDBCTemplate.query(sql, id);
    return list.size()>0? list.get(0):null;
}

public List<Student> list() {
    String sql = "SELECT * FROM t_student ";
    return JDBCTemplate.query(sql);
}

这样重复的代码基本就解决了，但有一个很严重的问题，就是这个程序DQL操作中只能处理Student类和t_student表的相关数据，无法处理其他类，比如Teacher类和t_teacher表。不同的表（不同的对象）应该有不同的列，不同列处理结果集的代码就应该不一样，处理结果集的操作只有DAO自己最清楚。也就是说，处理结果的方法根本就不应该放在模板方法中，应该由每个DAO自己来处理。因此，可以创建一个IRowMapper接口来处理结果集。


public interface IRowMapper {
    //处理结果集
    List rowMapper(ResultSet rs) throws Exception;
}

DQL模板类中调用IRowMapper接口中的handle方法，提醒实现类自己去实现mapping方法。


public static List<Student> query(String sql,IRowMapper rsh, Object...params){
    List<Student> list = new ArrayList<>();
    Connection conn = null;
    PreparedStatement ps=null;
    ResultSet rs = null;
    try {
        conn = JdbcUtil.getConnection();
        ps = conn.prepareStatement(sql);
        //设置值
        for (int i = 0; i < params.length; i++) {
            ps.setObject(i+1, params[i]);
        }
        rs = ps.executeQuery();
        return rsh.mapping(rs);
        //5. 释放资源
    } catch (Exception e) {
        e.printStackTrace();
    } finally {
        JdbcUtil.close(rs, ps, conn);
    }
    return list ;
}

实现类自己去实现IRowMapper接口的mapping方法，想要处理什么类型的数据在里面定义即可。


public Student get(Long id) {
    String sql = "SELECT * FROM t_student WHERE id = ?";
    List<Student> list = JdbcTemplate.query(sql,new StudentRowMapper(), id);
    return list.size()>0? list.get(0):null;
}
public List<Student> list() {
    String sql = "SELECT * FROM t_student ";
    return JdbcTemplate.query(sql,new StudentRowMapper());
}
class StudentRowMapper implements IRowMapper{
    public List mapping(ResultSet rs) throws Exception {
        List<Student> list=new ArrayList<>();
        while(rs.next()){
            long id = rs.getLong("id");
            String name = rs.getString("name");
            int age = rs.getInt("age");
            Student stu=new Student(id, name, age);
            list.add(stu);
        }
        return list;
    }
}

到这里为止，实现ORM的关键代码已经大功告成，但是DQL查询不单单要查询学生信息（List类型），还要查询学生数量，这时就要通过泛型来完成。


public interface IRowMapper<T> {
    //处理结果集
    T mapping(ResultSet rs) throws Exception;
}

public static <T> T query(String sql,IRowMapper<T> rsh, Object...params){
    Connection conn = null;
    PreparedStatement ps=null;
    ResultSet rs = null;
    try {
        conn = JdbcUtil.getConnection();
        ps = conn.prepareStatement(sql);
        //设置值
        for (int i = 0; i < params.length; i++) {
            ps.setObject(i+1, params[i]);
        }
        rs = ps.executeQuery();
        return rsh.mapping(rs);
        //5. 释放资源
    } catch (Exception e) {
        e.printStackTrace();
    } finally {
        JdbcUtil.close(rs, ps, conn);
    }
    return null;
}

StudentRowMapper类的代码如下。


class StudentRowMapper implements IRowMapper<List<Student>>{
    public List<Student> mapping(ResultSet rs) throws Exception {
        List<Student> list=new ArrayList<>();
        while(rs.next()){
            long id = rs.getLong("id");
            String name = rs.getString("name");
            int age = rs.getInt("age");
            Student stu=new Student(id, name, age);
            list.add(stu);
        }
        return list;
    }
}

这样，不仅可以查询List，还可以查询学生数量。


public Long getCount(){
    String sql = "SELECT COUNT(*) total FROM t_student";
    Long totalCount = (Long) JdbcTemplate.query(sql,
            new IRowMapper<Long>() {
                public Long mapping(ResultSet rs) throws Exception {
                    Long totalCount = null;
                    if(rs.next()){
                        totalCount = rs.getLong("total");
                    }
                    return totalCount;
                }
            });
    return totalCount;
}

这样，重构设计就已经完成，好的代码能让我们以后维护更方便，因此学会对代码的重构是非常重要的。

3 经典框架都在用设计模式解决问题

比如，Spring就是一个把设计模式用得淋漓尽致的经典框架。本书会结合JDK、Spring、MyBatis、Netty、Tomcat、Dubbo等经典框架的源码对设计模式展开分析，帮助大家更好、更深入地理解设计模式在框架源码中的落地。

关注微信公众号『 Tom弹架构 』回复“设计模式”可获取完整源码。

【推荐】Tom弹架构：30个设计模式真实案例（附源码），挑战年薪60W不是梦

在这里插入图片描述

本文为“Tom弹架构”原创，转载请注明出处。技术在于分享，我分享我快乐！
如果本文对您有帮助，欢迎关注和点赞；如果您有任何建议也可留言评论或私信，您的支持是我坚持创作的动力。关注微信公众号『 Tom弹架构 』可获取更多技术干货！

Tom弹架构
关注
设计模式的杰作：深入设计模式
06-13
- **为什么以及如何学习设计模式**：了解设计模式有助于提高代码质量，增强代码的可读性和可维护性。通过学习设计模式，开发者可以更好地理解软件架构，并能够快速地适应新的项目需求。 #### 软件设计原则 《深入...
千万不要学设计模式
无相
02-13 3896
一、设计模式有用吗？ 我觉得除了方便与他人交流，包括写的代码别人方便阅读或者阅读别人的代码外，其它基本没什么特别用处了。 因为如果你比较菜，而且理解能力一般，经验也浅，你强制学习和使用设计模式，容易误入歧途，生搬硬套，只适合研究和学习一下，能够明白最好，不明白就算了，还不如老实从面向对象分析设计以及UML等基础的东西学起。 但如果你从面向对象以及UML研究起，能够老实研究完一本这样的书，最好...
设计模式总结篇（为什么要学习设计模式，学习设计模式的好处）
qq_43842093的博客
01-10 982
在学习完设计模式后，LZ想告诉大家： ​ 对于一名工作不久的程序员来说，学习设计模式是非常有必要的，设计模式可以让你知道在某些场景下如何来设计出适合场景的架子，对，因为经验不丰富，大部分程序员写的代码的可维护性是非常差的，基本上只是实现了功能，没有做其他的考虑，比如以后要加新功能，目前写的程序改怎么改，或者类之间的关系非常复杂，不熟悉代码的人，根本不能开发等问题。 ​ 而设计模式，LZ认为是前辈程序员在大量开发中累积的经验，然后归纳为了这些设计模式，理所当然的，这23个设计模式绝不是代表了所有的
三：为什么学习设计模式很重要？
IT18810289203的博客
04-20 383
学习设计模式的重要性在于，它们提供了编程领域的经验和最佳实践，帮助你提高代码质量、可读性和可维护性。当你掌握了设计模式，你将能够在编程世界中游刃有余，驰骋疆场，成为一名真正的编程高手。如果你不会设计模式，不能将设计模式如鱼得水地应用到开发中，你大概只能当当武林中的小喽啰。
开篇：为什么要学设计模式
zherop的博客
07-31 546
为什么要学设计模式？为了自己写好代码；为了看懂别人的代码。
设计模式要不要学，该怎么学
最新发布
m0_56653160的博客
06-26 925
大家有没有思考过如下几个问题？同样都是写代码，为什么有些同学的思路清晰、代码整洁；而我的代码却充满了重复和混乱，每次要修改时都无从下手、Bug 一堆？如何写代码，才能使得项目易于扩展和维护？我每天都在写重复的代码，如何提升水平？为什么我读不懂大佬写的源码？是不是缺少了什么知识？如果存在上述问题，那么我们一定要学习软件开发中的重要技能 —— 设计模式。设计模式是软件开发人员在软件开发过程中面临的一般问题的通用解决方案。这些解决方案是众多软件开发人员经过相当长的一段时间的试验和错误总结出来的。
设计模式资料-自用学习的
10-19
设计模式资料-自用学习的 设计模式是软件设计中的一种重要概念，它描述了在软件设计过程中的一些不断重复发生的问题，以及该问题的解决方案。设计模式的产生背景可以追溯到1988年，勃兰特·梅耶（Bertrand Meyer）...
Java23种基本的设计模式整料整理学习源码示例zip
05-08
Java23种基本的设计模式整料整理学习源码示例zip Java23种基本的设计模式整料整理学习源码示例zip Java23种基本的设计模式整料整理学习源码示例zip Java23种基本的设计模式整料整理学习源码示例zip 设计模式的六大...
GoF 23种设计模式学习笔记
02-28
"GoF 23种设计模式学习笔记" 是一个深入探讨这23个经典设计模式的资源，这些模式最初由Erich Gamma、Richard Helm、Ralph Johnson和John Vlissides四位作者在1994年的著作《设计模式：可复用面向对象软件的基础》中...
设计模式_原型模式(一)
weixin_44547668的博客
03-18 204
需求: 有一只羊叫:sheep,姓名为:tom 年龄为:1,颜色为:white 请编写程序和tom属性完全相同的十只羊 public void main(String[] args) { Sheep sheep= new Sheep("tom",1,"白色"); Sheep sheep2= new Sheep(sheep.getName(),sheep.getAge(),sheep.getColor()); ....... } 优缺点 1)优点时比较好理解,简单那易操作 2)在创建新的对
1、 设计模式学习的必要性
DuanRay
05-31 2983
自从程序诞生之初，就面临着来自耦合性，内聚性以及可维护性，可扩展性，重用性，灵活性等多方面的挑战。 而面向对象是为了解决系统的可维护性，可扩展性，可重用性等以上问题而出现的。 设计模式（Design Pattern）是一套被反复使用、多数人知晓的、经过分类的、代码设计经验的总结 为了代码可重用性、让代码更容易被他人理解、保证代码可靠性。 设计模式包含了面向对象的精髓，有种说法是“懂了设...
设计模式的由来与学习的必要性，真的知道吗？
weixin_42080277的博客
04-03 557
设计模式不知道各位对这些有哪些理解？最近则在看相关的设计模式的书，有些模式我也有些云里雾绕的，借此机会，深入拜读一下设计模式的经典书籍，有一些更加深层次的理解，在此以文章的形式分享出来，希望可以帮助一些朋友，更加深入的理解设计模式的内在美，可以非常自然的使用到设计模式的魅力，希望能够为大家带来启发和帮助。
设计模式白话说 | 什么是设计模式？设计模式有什么好处？如何高效学习设计模式？
Long-Tai
05-25 1958
简介：为什么要开展设计模式这个专栏？设计模式对于开发而言无疑是一把‘神兵利器’的存在【用不好也是伤敌一千自损八百】。在JAVA底层包的源码，各大流行框架的代码设计中充满了设计模式的踪迹。无疑，掌握了设计模式，无论对于代码开发设计或阅读框架源码都是很有好处的。【难道你不想隔壁MM同事投来看大牛的目光么????】使用了设计模式的代码都拥有**高内聚、低耦合**的特性。什么是高内聚？什么是低耦合？对扩展开放，对修改关闭。专栏中每一篇设计模式的讲解都是在项目中实际应用的如果本专栏对你有用，欢迎点赞、关注、转载，由于
设计模式有多重要？高级工程师：就像小孩学走路一样重要！
Java架构师联盟
03-28 257
无论是你初识编程还是有多年开发经验的编程老兵，相信你肯定为下面这些事儿发愁过！ 1）面试现场敲代码，虽然当前功能实现了，但无奈被吐槽代码质量差 2）一遇到复杂需求就头疼，写出的代码不仅混乱，扩展性也很差，要是遇上需求变更更是牵一发而动全身，甚至只能推倒重来 3）接手一个新项目，思路混乱，根本不知从何下手，虽然写完了，但是也都是各种东拼西凑 每个程序员的困境都不尽相同，但是都可以...
设计模式有用吗
叶孤城
03-18 801
说到设计模式，给人的感觉很高深莫测，而且许多有关设计模式的书，动不动加之艺术、禅等等唬人的词语，未开始学心已先怯。还有许多初学者，听前辈介绍，买了本GoF的《设计模式-可复用面向对象软件的基础》，啃了几章后，更是云里雾里不知所云，于是内心深处更是避之如蛇蝎。更有甚至，自己不会，不想学，于是乎找出各种佐证来证实设计模式对实际编程并没有什么用处，以此自欺欺人。关于设计模式，因为国内目前IT界鱼...
汤姆大叔设计模式学习体会：设计模式的思想
weixin_34000916的博客
02-08 382
汤姆大叔的教程地址：http://www.cnblogs.com/TomXu/archive/2011/12/15/2288411.html，谢谢大叔。 1、单例模式 核心是该对象只存在一个实例，要么直接写成实例的形式， 要么就需要写成构造函数形式，但是需要在构造函数里面通过模拟闭包的方式重新定义该构造函数，保存当前this对象，新定义的构造函数返回该this对象，达到只存在改对象只存在一个...
为什么要学习设计模式
技术杂谈
03-01 1354
写出可维护、可复用、可扩展及灵活的代码是我们的目的，也是学习设计模式的理由，但是这个理由对我们来说太抽象，下面从「读」和「写」两方面来说明到底为什么要学习设计模式。读作为开发人员，不可避...
1个月连载30个设计模式真实案例（附源码），挑战年薪60W不是梦
Tom弹架构
10-29 1553
本文节选自《设计模式就该这样学》 本文自2012年10月29日起持续连载，请大家持续关注.... 序言 Design Patterns: Elements of Reusable Object-Oriented Software（以下简称《设计模式》），一书由Erich Gamma、Richard Helm、Ralph Johnson和John Vlissides合著（Addison-Wesley，1995）。这四位作者常被称为“四人组（Gang of Four）”，而这本书也就被称为“四人组（或 .
Java设计模式源码学习与实践
资源摘要信息:"Java23种基本的设计模式整料整理学习源码示例zip" 设计模式是软件开发中用于解决常见问题的一种方案模板，它能够让代码更加灵活、易维护、可复用。在Java开发中，设计模式被广泛应用，并且是学习进阶...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Tom弹架构

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值