[解锁新姿势] 兄dei，你代码需要优化了

快来打我* 2022-12-15 02:58 102阅读 0赞

点击上方“java大数据修炼之道”,选择“设为星标”

# 优质文章和精品资源, 第一时间送达![format_png][] #

![format_png 1][]

来源：https://juejin.im/post/6844903983744548877

> 黑客(程序员)也是创作者，与画家、建筑师、作家一样。     ——《黑客与画家》

## 前言 ##

在我们平常开发过程中，由于项目时间紧张，代码可以用就好，往往会忽视代码的质量问题。甚至有些复制粘贴过来，不加以整理规范。往往导致项目后期难以维护，更别说后续接手项目的人。所以啊，我们要编写出优雅的代码，方便你我他，岂不美哉？

下面分享一些我在开发中常用的编码中`小建议`，如有不妥，欢迎大家一起交流学习。

## 卫语句 ##

卫语句，就是把复杂的条件表达式拆分成多个条件表达式。比如 多个 `if-elseif-else` 嵌套, 可以拆分成多个 `if`。如下面代码

### 代码： ###

-------------------- before  --------------------
    
    public void today() {
        if (isWeekend()) {
            if (isFee()) {
                System.out.println("study Android");
            } else {
                System.out.println("play a game");
            }
        } else {
            System.out.println("go to work");
        }
    }
    
    
     -------------------- after  (建议) --------------------
    
    public void today() {
    
        // 提前过滤掉`特殊情况`
        if (!isWeekend()) {
            System.out.println("go to work");
            return; // 提前return
        }
    
        //提前过滤掉`特殊情况`
        if (isFee()) {
            System.out.println("study Android");
            return; // 提前return
        }
    
        // 更关注于 `核心业务`代码实现。
        System.out.println("play a game");
    }

> 提前过滤掉`特殊`情况，更关注`核心`业务逻辑

## 小函数 ##

我们平常开发的时候，应该编写`小而美`函数，避免`函数过长`。一般函数最好在15行以内(`建议`) 我们看看下面代码：

-------------------- before  --------------------
    
    if (age > 0 && age < 18){
        System.out.println("小孩子");
    }
    
    if (number.length() == 11){
        System.out.println("符合手机号");
    }
    
    -------------------- after (建议) --------------------
    
    private static boolean isChild(int age) {
        return age > 0 && age < 18;
    }
    
    private static boolean isPhoneNumber(String number) {
        return number.length() == 11;
    }
    
    if (isChild(age)){
        System.out.println("小孩子");
    }
    
    if (isPhoneNumber(number)){
        System.out.println("符合手机号");
    }
    复制代码

> 把判断语句抽取成一个个`小函数`, 这样代码更加清晰明了。

## 迪米特法则 ##

### 概念： ###

迪米特法则（Law of Demeter）又叫作最少知识原则（Least Knowledge Principle 简写LKP），就是说一个对象应当对其他对象有尽`可能少`的`了解`。例如 当一条语句中 一个对象出现两个 `.` （`student.getName().equals("张三")`） 就是代码坏味道的表现，如下代码所示。

### 代码： ###

-------------------- before  --------------------
    
    public class Student {
    
        private String name;
    
        public Student(String name) {
            this.name = name;
        }
    
        public String getName() {
            return name;
        }
    }
    
    public static void main(String[] args) {
    
        Student student = new Student("张三");
    
        // 注意看这里，
        // 这里获取 student的name属性，在根据name属性进行判断
        if (StringUtils.isNotBlank(student.getName()) && student.getName().equals("张三")) {
            System.out.println("我的好朋友是 " + student.getName());
        }
    }
    
    
     -------------------- after (建议) --------------------
     
     public class Student {
    
        ... 省略name代码
    
        // 新增一个 判断是否是我的好朋友方法
        public boolean isGoodFriend(){
            return StringUtils.isNotBlank(this.name) && this.name.equals("张三");
        }
    }
    
    public static void main(String[] args) {
    
        Student student = new Student("张三");
    
        // 根据迪米特法则，把判断逻辑，抽取到 Student 内部，暴露出方法（isGoodFriend）
        if (student.isGoodFriend()){
            System.out.println("我的好朋友是 " + student.getName());
        }
    }

> IDEA/Android Studio 抽取方法快捷键： `option + command + M`

## Map 提取对象 ##

我们在平常开发中，会使用到`map`，但是在面向对象开发理念中，一个 `map`的使用，往往就会错过了 `Java Bean`。建议使用 `Java Bean` 更直观。如下代码：

public static void main(String[] args) {
    
        -------------------- before  --------------------
            Map<String, String> studentMap = new HashMap<>();
            studentMap.put("张三", "男");
            studentMap.put("小红", "女");
            studentMap.put("李四", "男");
    
            studentMap.forEach((name, sex) -> {
                System.out.println(name + " : " + sex);
            });
    
        -------------------- after (建议)  --------------------
        
            List<Student> students = new ArrayList<>();
            students.add(new Student("张三", "男"));
            students.add(new Student("小红", "女"));
            students.add(new Student("李四", "男"));
    
            for (Student student : students) {
                System.out.println(student.getName() + ":" + student.getSex());
            }
        }

笔者在编写这点时候，有所顾虑。肯定有小伙伴跳出来说，`map` 和 `bean` 不是一样吗？用`map` 我还可以省去思考如何命名`Class`呢。但是从代码规范来说，这样代码设计不是更符合 `Java 面向对象`的思想吗？

## Stream ##

Java 8 API添加了一个新的抽象称为流`Stream`，可以让你以一种声明的方式处理数据。使得代码调用起来更加优雅～ 直接来看代码：

public static void main(String[] args) {
            List<Student> students = new ArrayList<>();
            students.add(new Student("张三", "男"));
            students.add(new Student("李四", "男"));
            students.add(new Student("小红", "女"));
            students.add(new Student("小花", "女"));
            students.add(new Student("小红", "女"));
            
            -------------------- before  --------------------
            //统计男生个数
            //传统的 for each 循环遍历
            long boyCount = 0;
            for (Student student : students) {
                if (student.isBoy()) {
                    boyCount++;
                }
            }
    
            System.out.println("男生个数 = " + boyCount);
    
            -------------------- after (建议)  --------------------
    
            //统计男生个数
            //stream 流遍历
            long count = students.stream()
                    .filter(Student::isBoy) // 等同于.filter(student -> student.isBoy())
                    .count();
                    
            System.out.println("男生个数 = " + boyCount);
    }

相比与 传统的 `For` 循环，更推荐大家使用 `stream` 遍历。`stream` 流的链式调用，还有许多骚操作，如 `sorted`, `map`, `collect`等操作符，可以省去不必要`if-else`，`count`等判断逻辑。

## 多态 ##

Java 三大特性之一，`多态`，相信大家都不会陌生，多态的好处就是根据对象不同类型采取不同的的行为。我们常常在编写 `switch` 语句的时候，如果改用多态，可以把每个分支，抽取到一个子类内的覆写函数中，这就更加灵活。

我们有这样一个需求，编写一个简单计算器方法，我们先来看一小段代码：

-------------------- before  --------------------
        public static int getResult(int numberA, int numberB, String operate) {
            int result = 0;
            switch (operate) {
                case "+":
                    result = numberA + numberB;
                    break;
                case "-":
                    result = numberA - numberB;
                    break;
                case "*":
                    result = numberA * numberB;
                    break;
                case "/":
                    result = numberA / numberB;
                    break;
            }
            return result;
        }
        
        -------------------- after (建议)  --------------------
        
        abstract class Operate {
            abstract int compute(int numberA, int numberB);
        }
        
        class AddOperate extends Operate {
    
            @Override
            int compute(int numberA, int numberB) {
                // TODO 在这里处理相关逻辑
                return numberA + numberB;
            }
        }
        
        ... SubOperate, MulOperate, DivOperate 也和 AddOperate一样这里就不一一贴出
        
        public static int getResult(int numberA, int numberB, String operate) {
            int result = 0;
            switch (operate) {
                case "+":
                    result = new AddOperate().compute(numberA, numberB);
                    break;
                case "-":
                    result = new SubOperate().compute(numberA, numberB);
                    break;
                case "*":
                    result = new MulOperate().compute(numberA, numberB);
                    break;
                case "/":
                    result = new DivOperate().compute(numberA, numberB);
                    break;
            }
            return result;
        }

有小伙伴可能会说，你这不是更复杂了吗？

对比起单纯的`switch`，我们可以这样理解：

*  虽然在类上有所增加，但是通过多态，把对应操作的逻辑分离出来，使得代码耦合度降低。
 *  如果要修改对应`加法`的逻辑, 我们只需要修改对应 `AddOperate`类就可以了。避免直接修改`getResult` 方法
 *  代码可读性更好，语义更加明确。

但是这里会存在一些问题，如果我们新增一个`平方根`，`平方`等计算方式, 就需要修改 `switch` 里面的逻辑，新增一个条件分支。下面我们再来看看更进一步的优化。

## 反射 ##

通过上面例子，我们可以进一步优化，通过`反射`生成对应的 `Class`，然后在调用`compute`方法。如下代码：

public static <T extends Operate> int getResult(int numberA, int numberB, Class<T> clz) {
            int result = 0;
            try {
                return clz.newInstance().compute(numberA, numberB);
            } catch (InstantiationException | IllegalAccessException e) {
                e.printStackTrace();
                return result;
            }
    }
    
    
    public static void main(String[] args) {
        // 调用的时候直接传递 class 即可
        System.out.println(getResult(1, 2, SumOpearte.class));
    }

根据传入 `class` 参数，然后生成对应 `Opearte`处理类， 对比多态方式，我们这里采用反射，使得代码耦合度大大降低，如果在增加`平方根`，`平方`等计算方式。我们只需要 新增一个 `class` 继承 `Opearte` 即可，`getResult` 不用做任何修改。

> 需要注意的是，不是所有`switch`语句都需要这样替换, 在面对简单的 `switch`语句，就不必要了， 避免`过度设计`的嫌疑。如下代码：

public String getResult(int typeCode) {
            String type = "";
            switch (typeCode) {
                case 0:
                    type = "加法";
                    break;
                case 1:
                    type = "减法";
                    break;
                case 2:
                    type = "乘法";
                    break;
                case 3:
                    type = "除法";
                    break;
            }
            return type;
    }

END

![format_png 2][]

**推荐阅读：**

#### 1、[JVM加载Class文件的原理机制][JVM_Class]     2、[项目中常用的19条MySQL优化][19_MySQL]  3、[后端必备 Git 分支开发：规范指南][Git]  4、[老要求用java将word转为PDF，这么搞？][java_word_PDF]     5、[Redis分布式锁没用明白，搞出了大故障…][Redis]  6、[程序员面试 10 大潜规则，千万不要踩坑！][10]     7、[卧槽，为什么volatile关键字保证不了线程安全啊][volatile]     8、  [单怼60道][60]  [多线程][60]  [面试题，你能答上几个?(附答案)][60]  9、[这21个刁钻的HashMap 面试题，我把阿里面试官吊打了！][21_HashMap]     10、[一款SQL自动检查神器，再也不用担心SQL出错了，自动补全、回滚等功能大全][SQL_SQL] ####

**看完有收获?请转发分享给更多有需要的人**

关注 java大数据修炼之道

每天学习java技术，你想学的Java知识这里都有!**![format_png 3][]**

![format_png 4][]微信扫描二维码，关注我的公众号

写留言

*  
 *  ####  ####
    
    如果对你有帮助,请点个"在看 ![format_png 5][]",谢谢 ![format_png 6][]

好文章，我在看❤️

[format_png]: /images/20221123/21f8174394c8449cb72bb4d9d196ed66.png
[format_png 1]: /images/20221123/5e6691a732ed4a74841059c59535f38d.png
[format_png 2]: /images/20221123/d9b9bfca14b54599ac400cca41fc0187.png
[JVM_Class]: http://mp.weixin.qq.com/s?__biz=MzU1NjczNTM5NQ%3D%3D&chksm=fbc22a24ccb5a332f7f6f597d4c3c703b50b9a13aec76b4176e7d7115fe153b7fca4ed67ff81&idx=1&mid=2247492840&scene=21&sn=d648d08050dd2a9a1ea2a74f946222e5#wechat_redirect
[19_MySQL]: http://mp.weixin.qq.com/s?__biz=MzU1NjczNTM5NQ%3D%3D&chksm=fbc22c17ccb5a501df41ddeaecf0f7e85e292b45d6c7522e4d6a4d9c4a93a389338ee175eae8&idx=1&mid=2247492315&scene=21&sn=37c6888e30892c7fae56d0769c35a571#wechat_redirect
[Git]: http://mp.weixin.qq.com/s?__biz=MzU1NjczNTM5NQ%3D%3D&chksm=fbc22bcfccb5a2d98a805b1ed4816628f3d98975c4a77f91a48ef0ec96da89bf4aa5566430de&idx=1&mid=2247492867&scene=21&sn=fd9cd7f805dd36680220b909d5f50b8e#wechat_redirect
[java_word_PDF]: http://mp.weixin.qq.com/s?__biz=MzU1NjczNTM5NQ%3D%3D&chksm=fbc22dc7ccb5a4d1b94f2a9bbce26082c9f845fbbf7d588a5540d072bcef39b2281d0b705f91&idx=1&mid=2247492363&scene=21&sn=6975a1a5de92dc49d04654f21ffa7c21#wechat_redirect
[Redis]: http://mp.weixin.qq.com/s?__biz=MzU1NjczNTM5NQ%3D%3D&chksm=fbc1d038ccb6592e2d08ccd07a31a069ebbfc64d9abd2d1cfd88dba5efc1439f14cc78392bf3&idx=1&mid=2247491316&scene=21&sn=59fdccb5447abec7e33c881110c5be1f#wechat_redirect
[10]: http://mp.weixin.qq.com/s?__biz=MzU1NjczNTM5NQ%3D%3D&chksm=fbc22cc6ccb5a5d09ec368b85dfe087d1b68f6ccbf67d7275356f64f203d353dcba684b4012e&idx=1&mid=2247492106&scene=21&sn=e25c3eea649006f34fd6f5cb62ea78be#wechat_redirect
[volatile]: http://mp.weixin.qq.com/s?__biz=MzU1NjczNTM5NQ%3D%3D&chksm=fbc22a05ccb5a31383ee13bb6c58f8c12dada691c16624e028f23f24c32d1e4201b4ebd1a354&idx=1&mid=2247492809&scene=21&sn=47c50b227f8063129ed09edc91449100#wechat_redirect
[60]: http://mp.weixin.qq.com/s?__biz=MzU1NjczNTM5NQ%3D%3D&chksm=fbc1d557ccb65c41ec5d3b7dedd6c7a22949ddcb5de1406de482c3b702a1a4768c66b730b219&idx=1&mid=2247490459&scene=21&sn=66bc23ae41a8abcb9a6f00be754b2e47#wechat_redirect
[21_HashMap]: http://mp.weixin.qq.com/s?__biz=MzU1NjczNTM5NQ%3D%3D&chksm=fbc1d429ccb65d3fc4be6ab008e4318d3beeccb1394801c72e33cbb9fd162868dce2b9b0c0f2&idx=1&mid=2247490277&scene=21&sn=63d44db7ae6930f25478119f423227d4#wechat_redirect
[SQL_SQL]: http://mp.weixin.qq.com/s?__biz=MzU1NjczNTM5NQ%3D%3D&chksm=fbc22a13ccb5a305f809cc500952a30c90dc6fbfc8e622ff7ba78b85e64f1ceda60ac8e8ad1c&idx=1&mid=2247492831&scene=21&sn=8b98b8982b38e236f0a798d55f1a46af#wechat_redirect
[format_png 3]: /images/20221123/a7c42135a79c4e68a4bf4f2664549397.png
[format_png 4]: /images/20221123/87e5e874fa794fe7b4caed49046167dd.png
[format_png 5]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly9tbWJpei5xcGljLmNuL21tYml6X2pwZy9DMXVETURxam4xOXd0dVFwSzNqbUpXM2JGR1dJOFl6NkZSMTd0bDFNRjhWZnFZeFB4OTkwa3YySjc0THZxd2liMjZLYXlIZE9YZDZlYnpycVlpYmJUand3LzY0MA?x-oss-process=image/format,png
[format_png 6]: /images/20221123/40321432d9b24bbdb87466b03c79c6ab.png