為什么很多程式員不用switch，而是大量的if……else if？-有解無憂

不會吧還有人用if else和switch case？三目運算子？

不會吧？不會吧？大佬都是全都不用的！以JAVA為例

條件判斷陳述句的四種寫法，茴字的四種寫法大家不會不知道吧

1.正常人寫法：

    private static String MAN = "man";
    private static String WOMAN = "woman";
    @Data
    static class Person{
        private String gender;
        private String name;
    }  
    public static void main(String[] args) {
        Person p = new Person();
        p.setGender(MAN);
        p.setName("張三");

        if(Objects.equals(p.getGender(),MAN)){
            System.out.println(p.getName() + "應該去男廁所");
        }

        if(Objects.equals(p.getGender(),WOMAN)){
            System.out.println(p.getName() + "應該去女廁所");
        }

    }
//輸出 ：張三應該去男廁所

2.Lambda策略模式寫法：

某些大公司P6級別以上（年薪30w-50w）標準寫法，寫if else是要被罵的

    private static Map<String, Consumer<String>> FUNC_MAP = new ConcurrentHashMap<>();
    private static String MAN = "man";
    private static String WOMAN = "woman";
    static {
        FUNC_MAP.put(MAN,person ->{System.out.println(person + "應該去男廁所");});
        FUNC_MAP.put(WOMAN,person ->{System.out.println(person + "應該去女廁所");});
    }
    @Data
    static class Person{
        private String gender;
        private String name;
    }
    public static void main(String[] args) {
        Person p = new Person();
        p.setGender(MAN);
        p.setName("張三");
        Person p2 = new Person();
        p2.setGender(WOMAN);
        p2.setName("張三他老婆");

        FUNC_MAP.get(p.getGender()).accept(p.name);
        FUNC_MAP.get(p2.getGender()).accept(p2.name);

    }


//輸出：
//張三應該去男廁所
//張三他老婆應該去女廁所

3.DDD領域驅動設計思想+策略模式寫法：

某些大公司P7級別以上（年薪40w-70w）標準寫法（笑）

    private static String MAN = "man";
    private static String WOMAN = "woman";
    @Data
    static class Person{
        private String gender;
        private String name;

        private static Map<String, Consumer<String>> FUNC_MAP = new ConcurrentHashMap<>();
        static {
            FUNC_MAP.put(MAN,person ->{System.out.println(person + "應該去男廁所");});
            FUNC_MAP.put(WOMAN,person ->{System.out.println(person + "應該去女廁所");});
        }
        public void goToWC(){
            FUNC_MAP.get(gender).accept(name);
        }
    }

    static class PersonFactory{
        public static Person initPerson(String name ,String gender){
            Person p = new Person();
            p.setName(name);
            p.setGender(gender);
            return p;
        }
    }
    public static void main(String[] args) {
        Person p = PersonFactory.initPerson("張三",MAN);
        Person p2 = PersonFactory.initPerson("張三他老婆",WOMAN);
        p.goToWC();
        p2.goToWC();
    }


//輸出：
//張三應該去男廁所
//張三他老婆應該去女廁所

某些奇葩公司就是喜歡這種語法，看起來夠裝逼，實際上效率并沒有高多少，可讀性差了很多，而且Debug比較麻煩

4.Actor模型+領域驅動設計+策略模式+事件回應式架構

真正的P8年薪百萬架構師級寫法，逼王才這么寫代碼，裝逼的極限，內卷的奧義

Maven依賴：

依賴Akka框架 Actor模型，懂得都懂，大資料分布式計算Spark框架RDD依賴的框架，很復雜，原始碼是Scala語言，逼王必學，也可以Scala做架構，Java做上層，有興趣可以了解一下，反正管他是什么，夠牛逼就完了，哎，就是得有牌面，if else什么的太low，應屆畢業生水平才寫if else（魔怔領導原話），

       <dependency>
            <groupId>com.typesafe.akka</groupId>
            <artifactId>akka-actor_2.12</artifactId>
            <version>2.5.2</version>
        </dependency>

代碼

    private static String MAN = "man";
    private static String WOMAN = "woman";
    private static String WC_EVENT= "想上廁所";
    @Data
    static class Person extends UntypedActor {
        private String gender;
        private String name;

        public static Props props(final String name,final String gender) {
            return Props.create(new Creator<Person>() {
                private static final long serialVersionUID = 1L;
                @Override
                public Person create() throws Exception {
                    Person p = new Person();
                    p.setGender(gender);
                    p.setName(name);
                    return p;
                }
            });
        }
        @Override
        public void onReceive(Object message) throws Throwable {
            Pair<String,ActorRef> m = (Pair<String,ActorRef>)message;
            System.out.println(name + m.getLeft());
            m.getRight().tell(this, ActorRef.noSender());

        }
    }

    @Data
    static class Toilet extends UntypedActor {
        private static Map<String, Consumer<String>> FUNC_MAP = new ConcurrentHashMap<>();
        static {
            FUNC_MAP.put(MAN,person ->{System.out.println(person + "應該去男廁所");});
            FUNC_MAP.put(WOMAN,person ->{System.out.println(person + "應該去女廁所");});
        }

        public void wc(Person p ){
            FUNC_MAP.get(p.getGender()).accept(p.getName());
        }

        public static Props props() {
            return Props.create(Toilet.class);
        }

        @Override
        public void onReceive(Object message) throws Throwable {
            Person p = (Person) message;
            wc(p);
        }
    }

    public static void main(String[] args) {
        ActorSystem actorSystem = ActorSystem.create();
        ActorRef person = actorSystem.actorOf(Person.props("張三",MAN), "ZhangSan");
        ActorRef toilet = actorSystem.actorOf(Toilet.props(), "Toilet");
        Pair<String,ActorRef> message = Pair.of(WC_EVENT,toilet);
        person.tell(message,ActorRef.noSender());
    }
//輸出
//張三想上廁所
//張三應該去男廁所

5.Actor模型+領域驅動設計+策略模式+事件回應式架構+動態類模板構建+運行時編譯

為什么要寫if else？為什么要創建類？為什么要寫方法？真正的大佬（神經病）根本不需要寫if else，也不需要創建class，甚至不需要命名方法，我上廁所就要寫Toilet 類，開車就要寫Car類，還得繼承Actor的抽象類，太low，真正的Java不需要型別，不需要類，不需要if else，不需要命名方法，什么都不需要，便是Java的極致，我悟了，

Maven依賴：

咱還得整新活，javassist動態類加載，框架級代碼才會用，運行時調編譯器搞起，型別什么的根本不需要，咱就是要顛覆Java的根基，什么class，小孩才寫class ，大人都是玩編譯器，

       <dependency>
            <groupId>com.typesafe.akka</groupId>
            <artifactId>akka-actor_2.12</artifactId>
            <version>2.5.2</version>
        </dependency>

        <dependency>
            <groupId>org.javassist</groupId>
            <artifactId>javassist</artifactId>
            <version>3.25.0-GA</version>
        </dependency>

代碼：

import akka.actor.ActorRef;
import akka.actor.ActorSystem;
import akka.actor.Props;
import akka.actor.UntypedActor;
import akka.japi.Creator;
import javassist.*;
import org.apache.commons.lang3.tuple.Pair;

import java.util.HashMap;
import java.util.Map;
import java.util.function.BiConsumer;
import java.util.function.Consumer;

public class DynamicActorTest {

    private static String MAN = "man";
    private static String WOMAN = "woman";
    private static String WC_EVENT= "想上廁所";
    private static String WC_OVER_EVENT = "上完廁所了";
    
    private static ActorSystem actorSystem = ActorSystem.create();

    /**
     * 創建一個動態類，并實體化為物件，該方法會根據引數動態構建Class
     * @param name 動態類名
     * @param function actor模型訊息處理方法 兩個引數 一個是自身，一個是訊息
     * @param attrAndValues 動態類的 屬性 和 屬性值
     * @return actor參考
     * @throws Exception
     */
    public static ActorRef createDynamicClassImpl(String name, BiConsumer function, Pair<String, String>... attrAndValues) throws Exception {
        ClassPool pool = ClassPool.getDefault();
        // 動態定義包名 瞎幾把寫就行
        String className = "com.xxx.xxx.xxx." + name;
        // 創建一個空類
        CtClass cc = pool.makeClass(className);
        // 動態繼承抽象類UntypedActor
        cc.setSuperclass(pool.get(UntypedActor.class.getName()));
        // 動態根據引數創建類的屬性
        for (Pair<String, String> attrValue : attrAndValues) {
            CtField param = new CtField(pool.get(String.class.getName()), attrValue.getLeft(), cc);
            // 訪問級別是 PUBLIC
            param.setModifiers(Modifier.PUBLIC);
            cc.addField(param, CtField.Initializer.constant(attrValue.getRight()));
        }

        //創建類一個屬性叫function 型別是BiConsumer
        CtField param = new CtField(pool.get(BiConsumer.class.getName()), "function", cc);
        //訪問級別是 PRIVATE
        param.setModifiers(Modifier.PRIVATE);
        cc.addField(param);
        //創建模板方法 方法是執行BiConsumer對應的lambda運算式
        CtMethod m = CtNewMethod.make(
                "public void onReceive(Object message) { function.accept($0 ,message);}",
                cc);
        cc.addMethod(m);
        // 動態添加建構式
        CtConstructor cons = new CtConstructor(new CtClass[]{pool.get(BiConsumer.class.getName())}, cc);
        // 建構式內容就是給function引數賦值
        cons.setBody("{ $0.function = $1 ;}");
        cc.addConstructor(cons);
        //-----------動態Actor類構建完畢------------
        // 實體化Actor
        Props p = Props.create(new Creator<UntypedActor>() {
            @Override
            public UntypedActor create() throws Exception {
                //反射創建物件
                return (UntypedActor)cc.toClass().getConstructor(BiConsumer.class).newInstance(function);
            }
        });
        return actorSystem.actorOf(p);
    }


    public static void main(String[] args) throws Exception {
        // class什么的根本不需要，直接動態創建類，對于復雜場景可以搞分布式remoteActor
        // 創建一個Car類(領域物件），并實體化，定義他的訊息處理方法(或者你樂意叫領域驅動事件也可以)
        ActorRef car = createDynamicClassImpl("Car",(self, message)->{
            System.out.println(message);
            System.out.println("開車走咯~");
        });

        // 創建一個Toilet類，并實體化，定義他的訊息處理方法(或者你樂意叫領域驅動事件也可以)
        ActorRef toilet = createDynamicClassImpl("Toilet", (self, message) ->{
            try {
                Map<String, Consumer<String>> FUNC_MAP = new HashMap<>();
                FUNC_MAP.put(MAN,person ->{System.out.println(person + "應該去男廁所");});
                FUNC_MAP.put(WOMAN,person ->{System.out.println(person + "應該去女廁所");});
                // 因為是無型別取值使用反射
                String gender = message.getClass().getField("gender").get(message).toString();
                String name = message.getClass().getField("name").get(message).toString();
                FUNC_MAP.get(gender).accept(name);
                car.tell(name+WC_OVER_EVENT,ActorRef.noSender());
            } catch (Exception e) {
                System.out.println("廁所不太歡迎這位");
            }

        });

        // 創建一個Person類，具有兩個屬性name和gender，并實體化，定義他的訊息處理方法(或者你樂意叫領域驅動事件也可以)
        ActorRef person = createDynamicClassImpl("Person", (self, message) -> {
            Pair<String,ActorRef> pair = (Pair<String,ActorRef>) message;
            System.out.println(pair.getLeft());
            pair.getRight().tell(self,ActorRef.noSender());
        }, Pair.of("name", "張三"), Pair.of("gender", MAN));
        // 告訴張三想上廁所了 讓他找廁所去
        person.tell(Pair.of(WC_EVENT,toilet), ActorRef.noSender());
    }
}
//輸出:
//想上廁所
//張三應該去男廁所
//張三上完廁所了
//開車走咯~

這樣寫代碼，基本會被開除，你已經無敵了公司已經容不下你了，

總結，代碼還是正常寫就得了，能實作業務不出bug好維護的就是好代碼，切勿為了裝逼使用各種奇技淫巧，if else沒啥不好的，

轉載請註明出處，本文鏈接：https://www.uj5u.com/qita/300192.html

標籤：其他

上一篇：成功轉行，從一個機械攻城獅變為程式猿的坎坷之路

下一篇：一份MyBaits框架PDF檔案，阿里架構師直言，Java程式員快收藏吧