¿Por qué muchos programadores no usan switch, sino muchos if... else if?

Enterprise 2023-07-29 22:06:34 views: null

De ninguna manera, ¿algunas personas usan if else y cambian de caso? ¿Operador ternario?

¿De ninguna manera? ¿De ninguna manera? ¡Los tipos grandes son todos inútiles! Toma JAVA como ejemplo

Las cuatro formas de escribir oraciones de juicio condicional y las cuatro formas de escribir caracteres fen no son desconocidas para todos, ¿verdad?

1. Cómo escribir para gente normal:

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() + "应该去女厕所");
    }

}

// Salida: Zhang San debe ir al baño de hombres
2. Escritura del patrón de estrategia Lambda:

Algunas grandes empresas por encima del nivel P6 (salario anual 30w-50w) escritura estándar, escritura si se debe regañar

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);

}

//Salida:
//Zhang San debe ir al baño de hombres
//La esposa de Zhang San debe ir al baño de mujeres
3. DDD pensamiento de diseño basado en el dominio + escritura en modo de estrategia:

Algunas grandes empresas por encima del nivel P7 (salario anual 40w-70w) escritura estándar (risas)

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();
}

//Salida:
//Zhang San debería ir al baño de hombres
//La esposa de Zhang San debería ir al
baño de mujeres Muchos, y Debug es más problemático
4. Modelo de actor + diseño basado en dominios + modo de estrategia + arquitectura de respuesta a eventos

El salario anual real P8 de un millón de escritura a nivel de arquitecto, obligando al rey a escribir código de esta manera, el límite de la pretensión, el misterio de la introversión.

Maven depende de:

Confiando en el modelo Actor del marco Akka, todos lo entienden. El marco del que depende el marco RDD de la computación distribuida de grandes datos Spark es muy complicado. El código fuente es el lenguaje Scala, y el rey debe aprenderlo. También puedes usar Scala como arquitectura y Java como capa superior. Si te interesa, puedes aprender más al respecto. De todos modos, no importa lo que sea, se acabó si es genial. Oye, debe haber tarjetas. Si else es demasiado bajo, solo los recién graduados pueden escribir if else (las palabras originales del líder enloquecido).

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

el código

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());
}

//Salida
//Zhang San quiere ir al baño //Zhang San
debería ir al baño de hombres

¿Por qué escribir si más? ¿Por qué crear clases? ¿Por qué escribir métodos? El verdadero jefe (loco) no necesita escribir si más, ni necesita crear una clase, o incluso nombrar un método. Cuando voy al baño, necesito escribir la clase Aseo, cuando conduzco un automóvil, necesito escribir la clase Automóvil, y tengo que heredar la clase abstracta de Actor, que es demasiado baja. Real Java no necesita tipos, clases, si no, o métodos con nombre No, es lo último en Java. Me di cuenta.

Maven depende de:

Tenemos que hacer un nuevo trabajo, la carga dinámica de clases javassist, se usará código de nivel de marco y el compilador se ajustará en tiempo de ejecución. Los tipos no son necesarios en absoluto. Solo queremos subvertir la base de Java, qué clase, los niños solo escriben clases, los adultos juegan con compiladores.

   <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>

código:

importar como.actor.ActorRef;
importar como.actor.ActorSystem;
importar como.actor.Accesorios;
importar como.actor.UntypedActor;
importar como.japi.Creador;
importar javassist.*;
importar org.apache.commons.lang3.tuple.Pair;

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

clase pública 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());
}

}
//Salida:
//Quiero ir al baño
//Zhang San debería ir al baño de hombres
//Zhang San ha terminado de ir
al baño//Maneje~
Escribir código como este básicamente hará que lo despidan, usted Ya eres invencible, y la empresa ya no puede tolerarte.

En resumen, el código se puede escribir normalmente, y el código que puede realizar el negocio sin errores y mantenerlo es un buen código. No use todo tipo de trucos y trucos para fingir. De lo contrario, no es malo.

declaración de originalidad

Autor zh: Gu Ming Dijue

Supongo que te gusta

Origin blog.csdn.net/Tiam_cr/article/details/131924246
Recomendado
Clasificación
Diario
Más
2024-05-12(22)
2024-05-11(31)
2024-05-10(32)
2024-05-09(31)
2024-05-08(18)
2024-05-07(35)
2024-05-06(4)
2024-05-05(0)
2024-05-04(17)
2024-05-03(8)

Code World

© 2018 codetd.com