blocks|key|817907|text|@pek|type|unstyled|depth|inlineStyleRanges|entityRanges|data|817908|链式调用是Java7的建议之一，它说如果一个方法返回类型是无效的，它应该隐式地返回这个。如果您对这个主题感兴趣，那么在Alex+Miller的Java+7页上有一堆链接和一个简单的例子。|offset|length|style|BOLD|817909|entityMap|0|LINK|mutability|MUTABLE|url|http://tech.puredanger.com/java7#chained^0|0|15|2|1N|J|0|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Q|8|@$D|R|E|S|F|G]]|9|@$D|T|E|U|1|V]]|A|$]]|$1|H|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|I|$J|$5|K|L|M|A|$N|O]]]]

@pek 
Chained invocation is one of proposals for Java 7. It says that if a method return type is void, it should implicitly return this. If you're interested in this topic, there is a bunch of links and a simple example on <a href="http://tech.puredanger.com/java7#chained" rel="noreferrer">Alex Miller's Java 7 page</a>.

blocks|key|109939|text|这被称为Fluent接口，以供参考。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|109940|就我个人而言，我认为这是一个很好的主意，但真正的品味问题。我认为jQuery是这样工作的。|109941|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/Fluent_interface|1|http://en.wikipedia.org/wiki/Jquery^0|4|8|0|0|W|6|1|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@$A|Q|B|R|1|S]]|C|$]]|$1|D|3|E|5|6|7|T|8|@]|9|@$A|U|B|V|1|W]]|C|$]]|$1|F|3|-4|5|6|7|X|8|@]|9|@]|C|$]]]|G|$H|$5|I|J|K|C|$L|M]]|N|$5|I|J|K|C|$L|O]]]]

This is called a <a href="http://en.wikipedia.org/wiki/Fluent_interface" rel="noreferrer">Fluent Interface</a>, for reference.

Personally, I think it's a pretty neat idea, but a matter of taste really. I think <a href="http://en.wikipedia.org/wiki/Jquery" rel="noreferrer">jQuery</a> works this way.

blocks|key|817764|text|我不会亲自去做，因为对我来说，它混淆了某一种方法所做的事情，而这种方法--链子--对我来说，比长时间的方法更有用。但这不会让我陷入愤怒和精神错乱的战栗中，这总是一件好事。*‘)|type|unstyled|depth|inlineStyleRanges|entityRanges|data|817765|我不会关心表演的，只要问问Knuth就行了。|817766|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

I wouldn't do it myself, because to me it muddies what a particular method does, and the method-chaining is of limited use to me over doing it longhand. It isn't going to send me into a quivering ball of rage and psychosis, though, which is always a good thing. :')

I wouldn't be concerned about performance; just ask Knuth.

blocks|key|817838|text|我发现这是一个糟糕的风格，当使用在策划人。不可变类通常更适合链接，例如：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|817839|aWithB+=+myObject.withA(someA).withB(someB);|code-block|syntax|javascript|817840|其中myObject属于这个类：|offset|length|style|CODE|817841|class+MyClass+{
++++withA(TypeA+a)+{
+++++++++this.a.equals(a)+?+this+:+new+MyClass(this,+a);
++++}

++++private+MyClass(MyClass+copy,+TypeA+a)+{
++++++++this(copy);
++++++++this.a+=+a;
++++}
}|817842|构建器模式也很有用，因为它允许最终对象不可变，同时防止在使用此技术时必须创建的中间实例。|817843|entityMap^0|0|0|2|8|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|U|8|@$I|V|J|W|K|L]]|9|@]|A|$]]|$1|M|3|N|5|D|7|X|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|6|7|Y|8|@]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|R|$]]

I find this to be in poor style when used in setters. Immutable classes are usually a better fit for chaining, such as:

<pre><code>aWithB = myObject.withA(someA).withB(someB);
</code></pre>

where <code>myObject</code> is of this class:

<pre><code>class MyClass {
 withA(TypeA a) {
 this.a.equals(a) ? this : new MyClass(this, a);
 }

 private MyClass(MyClass copy, TypeA a) {
 this(copy);
 this.a = a;
 }
}
</code></pre>

The builder pattern is also useful, since it allows the final object to be immutable while preventing the intermediate instances you would normally have to create when using this technique.

blocks|key|817960|text|对于构建者来说，这是有意义的，在这里，您要做的就是设置大量的东西，创建真正的对象，并将构建器扔掉。对于构建器，最好去掉方法名称的"set“部分。类似地，不可变类型实际上不需要"get“。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|817961|Something+thing+=+new+SomethingBuilder()
++++.aProperty(wotsit)
++++.anotherProperty(somethingElse)
++++.create();|code-block|syntax|javascript|817962|一个有用的技巧(如果您不介意每个类的~2K运行时开销)是使用双大括号成语：|817963|JFrame+frame+=+new+JFrame("My+frame")+{{
++++setDefaultCloseOperation(DISPOSE_ON_CLOSE);
++++setLocation(frameTopLeft);
++++add(createContents());
++++pack();
++++setVisible(true);
}};|817964|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

It makes sense for builders, where all you are going to do is set a load of stuff, create the real object and throw the builder away. For builders, you might as well get rid of the "set" part of the method name. Similarly, immutable types don't really need the "get".

<pre><code>Something thing = new SomethingBuilder()
 .aProperty(wotsit)
 .anotherProperty(somethingElse)
 .create();
</code></pre>

A useful trick (if you don't mind a ~2K runtime overhead per class) is to use the double brace idiom:

<pre><code>JFrame frame = new JFrame("My frame") {{
 setDefaultCloseOperation(DISPOSE_ON_CLOSE);
 setLocation(frameTopLeft);
 add(createContents());
 pack();
 setVisible(true);
}};
</code></pre>

blocks|key|110051|text|我曾经是Java+(以及更糟的C#)的粉丝，这种做法是在整个对象中创建getter和setter+(get属性)。这曾经是我所认为的面向对象的，但实际上，这导致我们只是暴露对象的内部和实现，而不是真正利用封装。有些时候，您无法摆脱这一点(在脑海中是OR/M)，但一般来说，应该设置对象，然后执行其功能。我梦寐以求的对象往往有一两个构造函数，并且可能有六个可以工作的函数。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|110052|这样做的原因是，一旦我开始开发API，就真的需要保持简单。您实际上只想增加完成工作所需的复杂性，而getter和setter本身虽然简单，但在大量添加时却会在堆中添加复杂性。当我加载设置器时，会发生什么情况？有什么不同吗？真的吗？|110053|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

I use to be a fan of the Java (and worse C#) practice of making getters and setters (get set properties) throughout an object. This use to be what I considered object oriented, but really this leads us just to exposing the guts and implementation of the object and not really taking advantage of encapsulation. There are times you can't get away from this (OR/M comes to mind), but in general the object should be set up and then perform its function. My dream objects tend to have one or two constructors, and maybe a half dozen functions that do work.

The reason for this is that once I started developing API's there is a real need to keep things simple. You really only want to add as much complexity as is required to get the job done, and getters and setters, while simple in themselves, add complexity in heaps when added in mass. What happens when I load setters i na different order? Anythign different? Are you sure?

blocks|key|1109535|text|@Dan再次指出，对于更复杂的情况(考虑到不可变性)，Builder模式是一个很好的解决方案。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1109536|而且，我大部分同意你的观点。我相信你的意思是大部分遵循"告诉你别问“范式，我非常同意。但这主要是面向getter的。|offset|length|1109537|最后，所有这些都是针对具有大量属性的类的。我看不出任何理由，如果你只有少于，比方说，7。|1109538|entityMap|0|LINK|mutability|MUTABLE|url|http://www.pragprog.com/articles/tell-dont-ask^0|0|S|5|0|0|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Q|8|@]|9|@$D|R|E|S|1|T]]|A|$]]|$1|F|3|G|5|6|7|U|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|V|8|@]|9|@]|A|$]]]|I|$J|$5|K|L|M|A|$N|O]]]]

@Dan again, for more complex situations (immutability comes in mind) the Builder Pattern is a great solution.

Also, I agree with you mostly in getters. I believe what you are saying is to mostly follow the "<a href="http://www.pragprog.com/articles/tell-dont-ask" rel="nofollow noreferrer">Tell don't ask</a>" paradigm and I greatly agree. But that is oriented mostly at getters.

Lastly, all of the above are for classes that have a great deal of attributes. I don't see a reason for any if you only have less than, say, 7.

blocks|key|1109600|text|在使用Apache库时，我做了很多这样的工作；最后，我编写了链接在一起的助手方法，以便应用格式、数据类型、内部单元格数据、公式和单元格位置。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1109601|对于有很多微小的飞重元素的东西，需要有一些精巧的小调整应用，它工作得很好。|1109602|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

I ended up doing this a lot when working with the Apache POI excel library; I ended up writing helper methods that chained so I could apply formatting, data types, internal cell data, formulas, and cell positioning.

For stuff with lots of little tiny flyweight elements that need to have finicky little tweaks applied it works pretty well.

blocks|key|817982|text|如何使用|type|unstyled|depth|inlineStyleRanges|entityRanges|data|817983|/**
+*
+*+@author+sanjay
+*/
public+class+NewClass+{
private+int+left+;
private+int+top;
public+void+set(int+x,int+y)
++++{
++++left=x;
++++top=y;
}
public+NewClass+UP(int+x)
++++{
++++top%2B=x;
++++return+this;
}
public+NewClass+DOWN(int+x)
++++{
++++top-=x;
++++return+this;
}
public+NewClass+RIGHT(int+x)
++++{
++++left%2B=x;
++++return+this;
}
public+NewClass+LEFT(int+x)
++++{
++++left-=x;
++++return+this;
}
public+void+Display()
++++{
++++System.out.println("TOP:"%2Btop);
++++System.out.println("\nLEFT\n:"%2Bleft);
}
}
public+static+void+main(String[]+args)+{
++++//+TODO+code+application+logic+here
++++NewClass+test+=+new+NewClass();
++++test.set(0,0);
++++test.Display();
++++test.UP(20).UP(45).DOWN(12).RIGHT(32).LEFT(20);
+++++test.Display();|code-block|syntax|javascript|817984|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

How To Use

<pre><code>/**
 *
 * @author sanjay
 */
public class NewClass {
private int left ;
private int top;
public void set(int x,int y)
 {
 left=x;
 top=y;
}
public NewClass UP(int x)
 {
 top+=x;
 return this;
}
public NewClass DOWN(int x)
 {
 top-=x;
 return this;
}
public NewClass RIGHT(int x)
 {
 left+=x;
 return this;
}
public NewClass LEFT(int x)
 {
 left-=x;
 return this;
}
public void Display()
 {
 System.out.println("TOP:"+top);
 System.out.println("\nLEFT\n:"+left);
}
}
public static void main(String[] args) {
 // TODO code application logic here
 NewClass test = new NewClass();
 test.set(0,0);
 test.Display();
 test.UP(20).UP(45).DOWN(12).RIGHT(32).LEFT(20);
 test.Display();
</code></pre>

blocks|key|109966|text|我同意伯纳德那种像这样链结的方法，混淆了策划人的目的。相反，我建议，如果您总是创建这样的setter链，那么您可以为您的类创建一个自定义构造函数，而不是|type|unstyled|depth|inlineStyleRanges|entityRanges|data|109967|++++MyClass
++++.setInt(1)
++++.setString("test")
++++.setBoolean(true)
++;|code-block|syntax|javascript|109968|你做了|109969|new+MyClass(1,"test",true);|109970|这使得它更具可读性，如果您选择的话，可以使用它使类不可变。|109971|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|S|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

I agree with @Bernard that method chaining like this muddles the purpose of the setters. Instead I would suggest that if you are always creating chains of setters like this that you create a custom Constructor for your class so instead of

<pre><code> MyClass
 .setInt(1)
 .setString("test")
 .setBoolean(true)
 ;
</code></pre>

You do

<pre><code>new MyClass(1,"test",true);
</code></pre>

This makes it more readable and you can use this to make your class immutable if you chose to.

For classes that have a long list of setters that are used frequently, I found this way very useful (although I have recently read about the <a href="http://en.wikipedia.org/wiki/Builder_pattern" rel="noreferrer">Builder pattern</a> in Effective Java that is kinda the same).
Basically, all setter methods return the object itself so then you can use code like this:
<pre><code>myClass
 .setInt(1)
 .setString(&quot;test&quot;)
 .setBoolean(true);
</code></pre>
Setters simply return this in the end:
<pre><code>public MyClass setInt(int anInt) {
 // [snip]
 return this;
}
</code></pre>
What is your opinion? What are the pros and cons? Does this have any impact on performance?
Also referred to as the <a href="http://www.cs.technion.ac.il/users/yechiel/c++-faq/named-parameter-idiom.html" rel="noreferrer">named parameter idiom</a> in c++.

Design: Java and returning self-reference in setter methods

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

教程

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云智能顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

EdgeOne AI 安全实战专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

聚焦“写作效率、视觉美观与运行性能”三方面进行全面升级，为您提供更高效、稳定的创作环境

社区富文本&Markdown编辑器全新改版上线，欢迎大家体验!

诚挚邀请您参与本次调研，分享您的真实使用感受与建议。您的反馈至关重要，感谢您的支持与参与！

社区新版编辑器体验调研

对于拥有大量频繁使用的setter列表的类，我发现这种方法非常有用(尽管我最近在有效的Java中读到了一些类似的 )。基本上，所有setter方法都返回对象本身，这样您就可以使用如下代码：myClass    .setInt(1)    .setString("test")    .setBoolean(true);Setter只需返回以下内容：public MyClass setInt(int 

问设计: Java和在setter方法中返回自引用
EN

回答 10

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问设计: Java和在setter方法中返回自引用EN

回答 10

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问设计: Java和在setter方法中返回自引用
EN