好奇 Java 味是什么味

大概就这种：

public interface Subject {
public void attach(Observer observer);
public void detach(Observer observer);
public void notifyObservers();
}

public interface Observer {
public void update(Subject subject);
}

public class HelloWorldSubject implements Subject {

private ArrayList<Observer> observers;
private String str;

public HelloWorldSubject() {
super();

observers = new ArrayList<Observer>();
}

public void attach(Observer observer) {
observers.add(observer);
}

public void detach(Observer observer) {
observers.remove(observer);
}

public void notifyObservers() {
Iterator<Observer> iter = observers.iterator();

while (iter.hasNext()) {
Observer observer = iter.next();
observer.update(this);
}
}

public String getStr() {
return str;
}

public void setStr(String str) {
this.str = str;
notifyObservers();
}
}

public class HelloWorldObserver implements Observer {

public void update(Subject subject) {
HelloWorldSubject sub = (HelloWorldSubject)subject;
System.out.println(sub.getStr());
}
}

public interface Command {
void execute();
}

public class HelloWorldCommand implements Command {

private HelloWorldSubject subject;

public HelloWorldCommand(Subject subject) {
super();

this.subject = (HelloWorldSubject)subject;
}

public void execute() {
subject.setStr("hello world");
}
}

public interface AbstractFactory {
public Subject createSubject();
public Observer createObserver();
public Command createCommand(Subject subject);
}

public class HelloWorldFactory implements AbstractFactory {

public Subject createSubject() {
return new HelloWorldSubject();
}

public Observer createObserver() {
return new HelloWorldObserver();
}

public Command createCommand(Subject subject) {
return new HelloWorldCommand(subject);
}
}

public class FactoryMakerSingleton {

private static FactoryMakerSingleton instance = null;
private AbstractFactory factory;

private FactoryMakerSingleton() {
factory = new HelloWorldFactory();
}

public static synchronized FactoryMakerSingleton getInstance() {
if (instance == null) {
instance = new FactoryMakerSingleton();
}

return instance;
}

public AbstractFactory getFactory() {
return factory;
}
}

public class AbuseDesignPatterns {

public static void main(String[] args) {
AbstractFactory factory = FactoryMakerSingleton.getInstance().getFactory();

Subject subject = factory.createSubject();
subject.attach(factory.createObserver());

Command command = factory.createCommand(subject);

command.execute();
}
}

Jvav 味儿比二次元味儿都冲
如果你还需要别人来告诉你啥是 Jvav 味儿而不能靠自己一眼分辨，
那说明你自己早就腌制入味了

就好像抽烟的人旁人一闻可知，他自己却总是自我感觉良好

@NessajCN emmm 。主要我接触其他语言比较少，除了 Java 相关只接触过 Python 和稍微学习过 Go

你糊涂呀，这么好的话题不在上班时间发。

读取某个文件，正常味道的语言
open().read()
fd = open(...); read(fd, ...);
File(...).readAll()
ioutils.read(...)

Java 味儿，来，先学一下 reader, buffered reader, inputstream, buffered input stream ，然后再研究用哪个，中间包的用完了该不该 close 。

设计时就确定只有一个 implementation ，也要强行定义 interface ，还要定义一堆一模一样的 vo/dto...，不要问，问就是业界规范，大家都这么干。

@wxw752 还在上班中，只是快下班了扫了一眼论坛

@sagaxu Java 这些 Reader Stream 我自己也难绷

Java 味就是嗦，代码写起来像老太太的裹脚布，又臭又长……

@sagaxu java 也有 hutool ，别黑了，java 味就是标准的 controller bean service ，真落在业务逻辑，都是调库，谁手搓原生代码啊

@dranfree 跟 objc 比 java 都是弟弟

java

person.fuck(personb, true, true)

obj-c

[person haveSexualIntercorseWith]:personB healthCheckBeforeYouDid: YES useSomethingToProtectYourSafety: YES

比又长又臭 java 真不配

不懂，说分多个文件 java 味十足的， 要是看了「重构」 这个本书， 那不得气得跳脚...

java 味 --> 指一个简单 crud 先来个 dto/vo/cotroller/service/serviceimpl/dao/daoimpl/mapper/mapper.xml 大礼包

@murmur 这不叫味儿 这是 objc 本身语法和命名规范就这样

https://github.com/apache/dubbo
https://github.com/google/guice

这种味道， 看到难受。

居然没有人说 lamuda 表达式，

就是代码繁琐

哪门语言需要 ide 来自动生成代码。

搬一下我 1 坤年之前一个回复 https://v2ex.com/t/872064#r_11975008

最 java 味应该是一个项目里写 99% 都用不到的 额外的 空的 一堆什么也不干的 setter/getter

我受不了的 java 味：
1. 无意义的抽象和继承，简单问题复杂化，自以为是预留扩展性，然而绝大多数情况下非但用不到，反而是增加了复杂度和项目维护成本（当然有人把这种操作当作防御式编程增加自身不可替代性，实际结果往往不过是叠屎山）
2. 滥用多线程。有些人似乎觉得 java 不写多线程很 low ，结果滥用多线程，没必要的时候也要强上，然而很多 javaer 实际的心智水平根本玩不转多线程，要么自以为提高效率的多线程实际比一般写法还慢，要么生产出现线程安全甚至死锁，纯纯又菜又爱玩自讨苦吃
3. 滥用架构。web 服务必上 redis ，设计必须拆成微服务，看似追求最近技术方案，然而却抱着 mysql5.7 、centos6 不放，整天还研究 java1.8 的 jvm 调参，就不想想守着这堆破烂搞架构的路子能走多远。
4. 把一些 java 本身缺陷导致的东西当作唯一正确性去要求别的语言和框架，比如语法贫瘠导致的各种设计模式，比如灵活性不足而不得不使用的反射技术，比如落后的线程模型催生的一堆教条，很多新的语言和框架从本身就已经解决或者规避了，有些 javaer 用的时候却还习惯性往上靠，靠的不对劲了还觉得是那些语言和框架不行，反正就是 java 祖宗之法不可变……

关于我在 #18 发的评论的佐证评论 https://v2ex.com/t/872064?p=2#r_11976203

这样的：

@fulln

你把每个 class 都写一个文件，有人要骂你。
如果你把一个文件写了多个 class 也有人要骂你。

我就问问怎么才不挨骂？

特性啊，嗦啊，套娃啊什么的都好改，毕竟也不是没改。最恶心的其实是守旧，他发任他发，我用 java8.

@< href="/member/mahaoqu">mahaoqu 你是 javer 届的叛徒, 罚你以后 Xmx16g

上次我看到这词的时候还是吐槽说：go 语言 sdk java 味：
t/1036033

就是一看几十个文件, 实际上核心代码就几十行

对了，想了解啥叫其他语言里透出 jvav 味儿的可以去看看 NestJS
体会一下啥叫扑鼻的 Jvav 恶臭

没喝过咖啡吗？当然是咖啡味了 (doge

用 ai 都更浪费 token

@zwzwzwzwzxt 长命名不是 OC 味吗

@zwzwzwzwzxt #21 这个类名比我命还长

@pikko 别说不吉利的话。

httpDispatcherDecoratorHandlerAdapterStrategyConfigObserverFactory

https://x.com/cholf5/status/1900033963290448223

味道在于人,就算 java 现在也不需要什么 FileUtils,TimeUtil,都是什么年代的了..nio 的 Files,time 的 Instant 等不够用?

典型的又臭又长。 虽然是 ide 可以生成，getter setter 一大堆。
其他语言 30 行代码就够，他的 100 行

@murmur Java 有各种 XXTool 是 JVM 生态好，不是 JRE 标准库好，主流语言有几个连 JSON 库都要第三方提供的？

java 确实有味，ide 自动生成的代码能占 80%

就是过度封装 一串代码内只有少数几行真正起关键作用 当然现在都不只 java 这样...
这样封装他们觉得很灵活 会以生物学角度看待 oop
但就我来看就是奇美拉 透过继承等特性合成对象 这一串看起来是灵活了 看来是个战力高的生物 但很难与其它类相容 不是不行 但得绞尽脑汁 必需得经过生物演化痛苦的过程
java 还是可以写不那么 oop 类与命名空间我觉得雷同
但很少人写的简洁

讲道理这是菜味不是 java 味

无穷多的 getter setter

不会用注解

和 Go 相反的味儿

java 味就是老人味

File 相关有啥可以写到 util 里的？
不就一行就完事了 open(xxx).read()
最多 with open(..) as fd: ...
或者 pathlib: Path(..).read_text()
就真没必要一堆 util util 的，大概率是垃圾无效代码了。

当然，对于 java 来说，都不算垃圾。

过度封装过度设计
就这八个字都定论多少年了，有什么好讨论的，铜板拿去拿去

@sagaxu 人的问题，jdk 版本一直都不换新

//Since: 9
new FileInputStream(new File("")).readAllBytes()

get
set
vo
bo
....

《 20 亿种设计模式》

Java 味就是 Jvav 味，Jvav 味就是 AV 味，AV 味就是海的味道，而海中又有 Java 岛，Java 岛产 Java 咖啡，因此 Java 味就是 Java 咖啡的味。

老太婆的裹脚布又臭又长

不写这个，据发小所言，应该是班味。

我记得大学先学了 c 和 c++,后来有一门 java 课,刚学的时候发现很多名字都那么长,
就像楼上贴到的 public class HelloWorldCommand implements Command ,
然后我就很抗拒,感觉看不顺眼,后来就没怎么学.
不知道方法名字很长是不是 java 味

曾经，甲方装了个脚本到我们运维的主机上(8G 内存)，具体的功能就是操作 chrome 浏览器，获取一些监控数据，然后调用短信接口发短信。
就是一个脚本性质的程序，然后用 springboot 写的，内存占用 800MB ，Java8 。
曾经在跟车友(前端)爬山的时候，他吐槽前端一个框架一个写法，个个不一样，一个功能一片轮子。
我:“那你应该写 Java ，springboot 大一统，都不知道 Java 程序员离开 springboot 还会不会写代码写工程。”
个人感觉就是 Java 对资源的无止境的贪婪获取，各种封装各种抽象，不论要解决的问题是大是小，先把这一套来一遍。

把 SQL 写到方法名里

要不是 Java 能帮我糊口，我一定跟你们一起唾弃

换个语言都能又臭又长，还不能说的味道

其实没什么东西叫 java 味，楼上说的 getter setter 、滥用设计模式，其他语言也有，只不过加上了语法糖，看起来没那么一坨。只是因为低水平的 java 开发者过多形成的鄙视链罢了

@yooomu #58 java 代码看起来又臭又长，原因还是 java 历史包袱重，对于语法糖和特性的添加过于克制，还有最关键的万年 java8 。为了代码扩展性，不得不一层套一层，用一大堆设计模式。要是 java 能支持扩展方法那我觉得就不会有这种一层套一层的情况出现了。

@mahaoqu 太抽象了 太有味了

@sagaxu javax.json ，你好，有的，但是不是开源 java ，是甲骨文 java

@yooomu "楼上说的 getter setter ，只不过加上了语法糖，看起来没那么一坨"，这句是不对的，

举个例子，下面的代码，有 java 味的人看了浑身不自在：

class A {
public int a = 0;
}

一定要写成这样，才舒服：

class A {
private int a = 0;
public int getA() {
return a;
}
public void setA(int a) {
this.a = a;
}
}

@xuld 你这个例子让我想起来我看过的一本算法书，那本书用的语言是 python ，但是还是写了和你代码中一样的 getter setter ，完全不知道 python 里还有 @property 。

@xuld getter setter 绝对是有好处的，如果有语法层面的支持，像 c#和 kotlin 一样优雅，就没人反感了。高版本的 java 已经引入了 record ，解决了这个问题，然而归根到底还是万年 java8 导致的

@yooomu 有好处不代表就要到处用。

药有没有好处？你天天吃吗？

javaer 总是用“这样才专业，这样能避免 XXXX 问题，这就是 java 生态”这样的方式回答问题

确实，这样能避免 XXXX 问题，但问题是过去、现在、未来都不会出现 XXXX 问题。
或者，如果 XXXX 问题真的出现了，再改代码也来得及

@xuld 如果有好处，而且使用成本极低，那为什么不用。还是我强调的，如果 java8 和 kotlin 的属性一样优雅，那就没人黑 getter 和 setter 这种冗余设计。更何况谁不知道 getter setter 恶心，所以才有 lombok 这种工具

@debuggerx 我排查过生产 OOM ，比较过分的是一个大任务过来就创建一个线程池去拆任务，结果出问题时一堆线程池。

@huigeer 我觉得 lambda 挺优秀的，不过很多老程序员不喜欢

@retrocode
你让我想起之前被支配的恐惧了。
通过 ai,终于找到那个框架了: https://apiato.io/docs/architecture-concepts/porto
返回一个简单的列表: route -> controller -> task -> action -> service -> repository -> model -> transformer ...

老奶奶的袜子味，又臭又长，没有灵性