为什么很多程序员不用switch，而是大量的if……elseif？
不会吧还有人用ifelse和switchcase？三目运算符？
不会吧？不会吧？大佬都是全都不用的！以JA为例
条件判断语句的四种写法，茴字的四种写法大家不会不知道吧
<>1.正常人写法：
privatestaticStringMAN="man";
privatestaticStringWOMAN="woman";
@Data
staticclassPerson{
privateStringgender;
privateStringname;
}
pulicstaticvoidmain(String[]args){
Personp=newPerson();
p.setGender(MAN);
p.setName("张三");
if(Ojects.equals(p.getGender(),MAN)){
System.out.println(p.getName()+"应该去男厕所");
}
if(Ojects.equals(p.getGender(),WOMAN)){
System.out.println(p.getName()+"应该去女厕所");
}
}
//输出：张三应该去男厕所
<>2.Lamda策略模式写法：
某些大公司P6级别以上（年薪30w-50w）标准写法，写ifelse是要被骂的
privatestaticMap<String,Consumer<String>>FUNC_MAP=newConcrentHashMap<>();
privatestaticStringMAN="man";
privatestaticStringWOMAN="woman";
static{
FUNC_MAP.put(MAN,person->{System.out.println(person+"应该去男厕所");});
FUNC_MAP.put(WOMAN,person->{System.out.println(person+"应该去女厕所");});
}
@Data
staticclassPerson{
privateStringgender;
privateStringname;
}
pulicstaticvoidmain(String[]args){
Personp=newPerson();
p.setGender(MAN);
p.setName("张三");
Personp2=newPerson();
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）标准写法（笑）
privatestaticStringMAN="man";
privatestaticStringWOMAN="woman";
@Data
staticclassPerson{
privateStringgender;
privateStringname;
privatestaticMap<String,Consumer<String>>FUNC_MAP=newConcrentHashMap<>();
static{
FUNC_MAP.put(MAN,person->{System.out.println(person+"应该去男厕所");});
FUNC_MAP.put(WOMAN,person->{System.out.println(person+"应该去女厕所");});
}
pulicvoidgoToWC(){
FUNC_MAP.get(gender).accept(name);
}
}
staticclassPersonFactory{
pulicstaticPersoninitPerson(Stringname,Stringgender){
Personp=newPerson();
p.setName(name);
p.setGender(gender);
retnp;
}
}
pulicstaticvoidmain(String[]args){
Personp=PersonFactory.initPerson("张三",MAN);
Personp2=PersonFactory.initPerson("张三他老婆",WOMAN);
p.goToWC();
p2.goToWC();
}
//输出：
//张三应该去男厕所
//张三他老婆应该去女厕所
某些奇葩公司就是喜欢这种语法，看起来够，实际上效率并没有高多少，可读性差了很多，而且Deug较麻烦
<>4.Actor模型+领域驱动设计+策略模式+事件响应式架构
正的P8年薪百万架构师级写法，逼王才这么写代码，的极限，内卷的奥义
Men依赖：
依赖Akka框架Actor模型，懂得都懂，大数据分布式计算Spark框架RDD依赖的框架，很复杂，源码是Scala语言，逼王必学。也可以Scala做架构，Ja做上层，有兴趣可以了解一下，反正管他是什么，够就完了。哎，就是得有牌面。ifelse什么的太low，应届毕业生水平才写ifelse（魔怔领导原话）。
<dependency>
<groupId>com.typesafe.akka</groupId>
<artifactId>akka-actor_2.12</artifactId>
<version>2.5.2</version>
</dependency>
代码
privatestaticStringMAN="man";
privatestaticStringWOMAN="woman";
privatestaticStringWC_="想上厕所";
@Data
staticclassPersonextendsUntypedActor{
privateStringgender;
privateStringname;
pulicstaticPropsprops(finalStringname,finalStringgender){
retnProps.create(newCreator<Person>(){
privatestaticfinallongserialVersionUID=1L;
@Override
pulicPersoncreate()throwsException{
Personp=newPerson();
p.setGender(gender);
p.setName(name);
retnp;
}
});
}
@Override
pulicvoidonReceive(Ojectmessage)throwsThrowale{
Pair<String,ActorRef>m=(Pair<String,ActorRef>)message;
System.out.println(name+m.getLeft());
m.getRight().l(this,ActorRef.noSender());
}
}
@Data
staticclassToiletextendsUntypedActor{
privatestaticMap<String,Consumer<String>>FUNC_MAP=newConcrentHashMap<>();
static{
FUNC_MAP.put(MAN,person->{System.out.println(person+"应该去男厕所");});
FUNC_MAP.put(WOMAN,person->{System.out.println(person+"应该去女厕所");});
}
pulicvoidwc(Personp){
FUNC_MAP.get(p.getGender()).accept(p.getName());
}
pulicstaticPropsprops(){
retnProps.create(Toilet.class);
}
@Override
pulicvoidonReceive(Ojectmessage)throwsThrowale{
Personp=(Person)message;
wc(p);
}
}
pulicstaticvoidmain(String[]args){
ActorSystemactorSystem=ActorSystem.create();
ActorRefperson=actorSystem.actorOf(Person.props("张三",MAN),"ZhangSan");
ActorReftoilet=actorSystem.actorOf(Toilet.props(),"Toilet");
Pair<String,ActorRef>message=Pair.of(WC_,toilet);
person.l(message,ActorRef.noSender());
}
//输出
//张三想上厕所
//张三应该去男厕所
<>5.Actor模型+领域驱动设计+策略模式+事件响应式架构+动态类模板构建+运行时编译
为什么要写ifelse？为什么要创建类？为什么要写方法？正的大佬（）根本不需要写ifelse，也不需要创建class，甚至不需要命名方法。我上厕所就要写Toilet类，开车就要写Car类，还得继承Actor的抽象类，太low，正的Ja不需要类型，不需要类，不需要ifelse，不需要命名方法，什么都不需要，便是Ja的极致。我悟了。
Men依赖：
咱还得整新活，jassist动态类加载，框架级代码才会用，运行时调编译器搞起，类型什么的根本不需要，咱就是要颠覆Ja的根基，什么class，小孩才写class，大人都是玩编译器。
<dependency>
<groupId>com.typesafe.akka</groupId>
<artifactId>akka-actor_2.12</artifactId>
<version>2.5.2</version>
</dependency>
<dependency>
<groupId>org.jassist</groupId>
<artifactId>jassist</artifactId>
<version>3.25.0-GA</version>
</dependency>
代码：
importakka.actor.ActorRef;
importakka.actor.ActorSystem;
importakka.actor.Props;
importakka.actor.UntypedActor;
importakka.japi.Creator;
importjassist.*;
importorg.apachemons.lang3.tuple.Pair;
importja.util.HashMap;
importja.util.Map;
importja.util.function.iConsumer;
importja.util.function.Consumer;
pulicclassDynamicActor{
privatestaticStringMAN="man";
privatestaticStringWOMAN="woman";
privatestaticStringWC_="想上厕所";
privatestaticStringWC_OVER_="上完厕所了";
privatestaticActorSystemactorSystem=ActorSystem.create();
/**
*创建一个动态类，并实例化为对象，该方根据参数动态构建Class
*@paramname动态类名
*@paramfunctionactor模型消息处理方法两个参数一个是自身，一个是消息
*@paramattrAndValues动态类的属性和属性值
*@retnactor引用
*@throwsException
*/
pulicstaticActorRefcreateDynamicClassImpl(Stringname,iConsumerfunction,Pair<String,String>...attrAndValues)throwsException{
ClassPoolpool=ClassPool.getDefault();
//动态定义包名瞎几把写就行
StringclassName="com.xxx.xxx.xxx."+name;
//创建一个空类
CtClasscc=pool.makeClass(className);
//动态继承抽象类UntypedActor
cc.setSuperclass(pool.get(UntypedActor.class.getName()));
//动态根据参数创建类的属性
for(Pair<String,String>attrValue:attrAndValues){
CtFieldparam=newCtField(pool.get(String.class.getName()),attrValue.getLeft(),cc);
//访问级别是PULIC
param.setModifiers(Modifier.PULIC);
cc.addField(param,CtField.Initializer.constant(attrValue.getRight()));
}
//创建类一个属性叫function类型是iConsumer
CtFieldparam=newCtField(pool.get(iConsumer.class.getName()),"function",cc);
//访问级别是PRIVATE
param.setModifiers(Modifier.PRIVATE);
cc.addField(param);
//创建模板方法方法是执行iConsumer对应的lamda表达式
CtMethodm=CtNewMethod.make(
"pulicvoidonReceive(Ojectmessage){function.accept($0,message);}",
cc);
cc.addMethod(m);
//动态添加构造函数
CtConstructorcons=newCtConstructor(newCtClass[]{pool.get(iConsumer.class.getName())},cc);
//构造函数内容就是给function参数赋值
cons.setody("{$0.function=$1;}");
cc.addConstructor(cons);
//-----------动态Actor类构建完毕------------
//实例化Actor
Propsp=Props.create(newCreator<UntypedActor>(){
@Override
pulicUntypedActorcreate()throwsException{
//反射创建对象
retn(UntypedActor)cc.toClass().getConstructor(iConsumer.class).newInstance(function);
}
});
retnactorSystem.actorOf(p);
}
pulicstaticvoidmain(String[]args)throwsException{
//class什么的根本不需要，直接动态创建类，对于复杂场景可以搞分布式remoteActor
//创建一个Car类(领域对象），并实例化，定义他的消息处理方法(或者你乐意叫领域驱动事件也可以)
ActorRefcar=createDynamicClassImpl("Car",(self,message)->{
System.out.println(message);
System.out.println("开车走咯~");
});
//创建一个Toilet类，并实例化，定义他的消息处理方法(或者你乐意叫领域驱动事件也可以)
ActorReftoilet=createDynamicClassImpl("Toilet",(self,message)->{
try{
Map<String,Consumer<String>>FUNC_MAP=newHashMap<>();
FUNC_MAP.put(MAN,person->{System.out.println(person+"应该去男厕所");});
FUNC_MAP.put(WOMAN,person->{System.out.println(person+"应该去女厕所");});
//因为是无类型取值使用反射
Stringgender=message.getClass().getField("gender").get(message).toString();
Stringname=message.getClass().getField("name").get(message).toString();
FUNC_MAP.get(gender).accept(name);
car.l(name+WC_OVER_,ActorRef.noSender());
}catch(Exceptione){
System.out.println("厕所不太欢迎这位");
}
});
//创建一个Person类，具有两个属性name和gender，并实例化，定义他的消息处理方法(或者你乐意叫领域驱动事件也可以)
ActorRefperson=createDynamicClassImpl("Person",(self,message)->{
Pair<String,ActorRef>pair=(Pair<String,ActorRef>)message;
System.out.println(pair.getLeft());
pair.getRight().l(self,ActorRef.noSender());
},Pair.of("name","张三"),Pair.of("gender",MAN));
//告诉张三想上厕所了让他找厕所去
person.l(Pair.of(WC_,toilet),ActorRef.noSender());
}
}
//输出:
//想上厕所
//张三应该去男厕所
//张三上完厕所了
//开车走咯~
