blocks|key|3267568|text|请阅读布洛赫的Effective+Java。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|3267569|这正是您所要求的，一套编写非常棒的、惯用的java代码的规则。|3267570|entityMap|0|LINK|mutability|MUTABLE|url|http://java.sun.com/docs/books/effective/^0|7|E|0|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@$A|O|B|P|1|Q]]|C|$]]|$1|D|3|E|5|6|7|R|8|@]|9|@]|C|$]]|$1|F|3|-4|5|6|7|S|8|@]|9|@]|C|$]]]|G|$H|$5|I|J|K|C|$L|M]]]]

Read <a href="http://java.sun.com/docs/books/effective/" rel="nofollow noreferrer">Effective Java</a> by Bloch.

It's exactly what you're asking for, a set of rules for writing really great, idiomatic java code.

blocks|key|3267763|text|好的，头脑风暴：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3267764|在类和对象中思考，而不是在functions.|3267765|Avoid+|unordered-list-item|3267766|子句中思考(尤其是。catch(Throwable+t)+{})+|offset|length|style|BOLD|3267767|处理错误，不要忽略它。|3267768|仅处理您要在E213<>处理的位置要处理的异常类型|3267769|3267770|3267771|3267772|​|3267773|3267774|使用Javadoc。Eclipse让您思考自己是什么doing.|3267775|Generates文档，而developing.|3267776|Enables+IDE喜欢在使用类和methods.|3267777|时显示提示|3267778|3267779|3267780|尝试使用泛型和注释来适应它。|3267781|3267782|还有更多，但那些是我第一次想到的地方。|3267783|顺便说一句，如果你从初学者发展到专家，你就会知道什么时候对这些规则做出例外;)|3267784|entityMap^0|0|0|0|A|L|1|1|6|5|E|B|1|0|0|0|0|1|0|0|0|W|0|0|O|0|0|Q|0|0|5|0|0|1|0|0|0|E|0|0|0|J|0|0|13|0^^$0|@$1|2|3|4|5|6|7|1F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|1G|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|1H|8|@]|9|@]|A|$]]|$1|G|3|H|5|F|7|1I|8|@$I|1J|J|1K|K|L]]|9|@]|A|$]]|$1|M|3|N|5|F|7|1L|8|@]|9|@]|A|$]]|$1|O|3|P|5|F|7|1M|8|@$I|1N|J|1O|K|L]|$I|1P|J|1Q|K|L]]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|1R|8|@]|9|@]|A|$]]|$1|R|3|-4|5|6|7|1S|8|@]|9|@]|A|$]]|$1|S|3|-4|5|6|7|1T|8|@]|9|@]|A|$]]|$1|T|3|U|5|6|7|1U|8|@$I|1V|J|1W|K|L]]|9|@]|A|$]]|$1|V|3|-4|5|6|7|1X|8|@]|9|@]|A|$]]|$1|W|3|X|5|F|7|1Y|8|@$I|1Z|J|20|K|L]]|9|@]|A|$]]|$1|Y|3|Z|5|F|7|21|8|@$I|22|J|23|K|L]]|9|@]|A|$]]|$1|10|3|11|5|F|7|24|8|@$I|25|J|26|K|L]]|9|@]|A|$]]|$1|12|3|13|5|6|7|27|8|@$I|28|J|29|K|L]]|9|@]|A|$]]|$1|14|3|U|5|6|7|2A|8|@$I|2B|J|2C|K|L]]|9|@]|A|$]]|$1|15|3|-4|5|6|7|2D|8|@]|9|@]|A|$]]|$1|16|3|17|5|F|7|2E|8|@$I|2F|J|2G|K|L]]|9|@]|A|$]]|$1|18|3|-4|5|6|7|2H|8|@]|9|@]|A|$]]|$1|19|3|1A|5|6|7|2I|8|@$I|2J|J|2K|K|L]]|9|@]|A|$]]|$1|1B|3|1C|5|6|7|2L|8|@$I|2M|J|2N|K|L]]|9|@]|A|$]]|$1|1D|3|-4|5|6|7|2O|8|@]|9|@]|A|$]]]|1E|$]]

OK, brainstorming:

<ul>
<li>Think in classes and objects, not in functions.</li>
<li>Avoid empty catch clauses (esp. catch(Throwable t) {})

<ul>
<li>Handle an error, do not ignore it.</li>
<li>Handle only the type of exception You want to handle at the place You can handle it.</li>
</ul></li>
<li>Use Javadoc.

<ul>
<li>Makes You think about what You are doing.</li>
<li>Generates documentation while developing.</li>
<li>Enables IDEs like Eclipse to show hints while using Your classes and methods.</li>
</ul></li>
<li>Try using generics and annotations to get used to it.</li>
</ul>

There are many more, but those where the first that came into my mind.

By the way, if You advance from beginner to expert, You will know when to make exceptions to those rules ;)

blocks|key|4735430|text|我的方法之一就是坚持使用Sun+coding+conventions。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|4735431|entityMap|0|LINK|mutability|MUTABLE|url|http://java.sun.com/docs/codeconv/html/CodeConvTOC.doc.html^0|C|M|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@$A|M|B|N|1|O]]|C|$]]|$1|D|3|-4|5|6|7|P|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]]]

One of mine is to stick with the <a href="http://java.sun.com/docs/codeconv/html/CodeConvTOC.doc.html" rel="nofollow noreferrer">Sun coding conventions</a>.

blocks|key|3267944|text|如果你重复你自己，比如通过复制和粘贴，你就做错了。Java是一种面向对象的语言，你可以这样使用它。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3267945|如果你没有使用设计模式，你就是在重新发明轮子。原来的GOF设计模式很好地解决了这么多问题，这真是令人惊讶。只有在回顾了这些之后，你才应该做一些不同的事情。|3267946|方法名要长，参数名要有描述性，但方法要短。这有点主观，但拆分得越多，修复和重用代码就越容易。如果你不能在一个句子中解释你的方法在做什么，你要么有一个通常很复杂的问题，要么更有可能你的方法做得太多了。|3267947|避免让每个对象做太多的事情。看看你的对象上的名字。如果对象中有与对象名称无关的方法，请将它们移动到可能属于它们的地方。|3267948|方法重载很好，它可以让你从到处都是类型转换中解脱出来。|3267949|尽量避免“聪明”，因为这种方式会让你更难理解你写的代码。尽可能多地使用语言的内置功能(例如迭代器)。做可能可行的最简单的事情。你以后会感谢自己的。|3267950|即使你是一个单独工作的开发人员，源代码控制也是必要的。它救了我无数次，我已经数不清了。|3267951|在初始调试之后，任何东西都不应该是硬编码的。对于跨应用程序使用的项，如环境和相关消息，请在数据库中存储尽可能多的项。如果您认为这些项永远不会更改，请使用属性文件和全局java文件来处理您确信永远不会更改的内容，因为它们将会更改。|3267952|使用IDE自动格式化您的代码，即使它让您的代码看起来很丑陋，但从长远来看，您还是会更好。|3267953|如果有一个广为人知的、可靠的框架，就使用它。JSF或Struts将比你自己开发的任何东西都要好，即使你认为你自己的MVC框架真的很酷。持久化也是一样，使用一些主流的东西。在可能的情况下，尽量少用或使用一个框架。你可能会给你的朋友留下深刻的印象，你有一个使用Hibernate的Spring、Shale、JSF、Struts项目，以及你自己开发的其他一些框架，但实际上只是为了复杂性而变得复杂。|3267954|entityMap^0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|V|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|W|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|X|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|Y|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|Z|8|@]|9|@]|A|$]]|$1|J|3|K|5|6|7|10|8|@]|9|@]|A|$]]|$1|L|3|M|5|6|7|11|8|@]|9|@]|A|$]]|$1|N|3|O|5|6|7|12|8|@]|9|@]|A|$]]|$1|P|3|Q|5|6|7|13|8|@]|9|@]|A|$]]|$1|R|3|S|5|6|7|14|8|@]|9|@]|A|$]]|$1|T|3|-4|5|6|7|15|8|@]|9|@]|A|$]]]|U|$]]

If you repeat yourself, such as by copy and paste, you're doing it wrong. Java is an OO language, use it that way. 

If you aren't using design patterns, you are reinventing the wheel. It's amazing how many problems are best solved by the original GOF design patterns. Only after reviewing these should you do something different.

Keep your method names long, your parameter names descriptive, but your methods short. This is a bit subjective, but the more you split things apart, the easier it is to fix and reuse the code. If you can't explain what your method is doing in a sentence, you either have an usually complex problem, or more likely your methods are trying to do too much.

Avoid having each object do too much. Look at the names on your objects. If there are methods in the object that don't relate to the name of the object, move them somewhere where they might belong.

Method overloading is nice, and it can save you from typecasting all over the place. 

Try to avoid being "clever" in such a way that makes it more difficult to understand the code you wrote. Use as many built in features of the language (e.g. Iterators) as possible. Do the simplest thing that could possibly work. You will thank yourself later.

Source control is necessary, even if you are one developer working alone. It has saved my neck more times than I can count.

After initial debugging, nothing should be hard coded. For items used across the application, such as environment and related messages, store as many items as possible in the database. If you think these items will never change, use properties files, and a globals java file for things that you are convinced will never change, because they will.

Automatically format your code using your IDE, even if it makes it ugly you are still better off in the long run.

If there is a well known, and reliable framework for something, use it. JSF or Struts will be better than anything you could develop on your own, even if you think your own MVC framework is really cool. The same thing with persistence, use something mainstream. Try to use as few, or one framework, when possible. You might impress your friends to have a Spring, Shale, JSF, Struts project using Hibernate along with some other framework you developed yourself, but it is really just complexity for the sake of complexity.

blocks|key|3267733|text|你应该记录你的代码！|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3267734|3267735|您必须记录您编写的所有代码。当你3个月后回来读它的时候，你留下了一些关于代码功能的提示是至关重要的。|unordered-list-item|3267736|你不应该在代码中记录代码正在做什么，因为它就在那里。|3267737|你应该记录代码在那里的原因。从长远来看，你会从“为什么”的评论中获得比“什么”的评论更多的好处。|3267738|如果很难记录下来，很可能是你没有充分考虑这个问题。|3267739|3267740|entityMap^0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|P|8|@]|9|@]|A|$]]|$1|C|3|D|5|E|7|Q|8|@]|9|@]|A|$]]|$1|F|3|G|5|E|7|R|8|@]|9|@]|A|$]]|$1|H|3|I|5|E|7|S|8|@]|9|@]|A|$]]|$1|J|3|K|5|E|7|T|8|@]|9|@]|A|$]]|$1|L|3|-4|5|6|7|U|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|V|8|@]|9|@]|A|$]]]|N|$]]

Thou shalt document ye code!

<ul>
<li>You must document all code that you write. When you come back and read it 3 months later it is crucial you have left some hints on what the code does.</li>
<li>You should not document what the code is doing, as it is right there, in the code.</li>
<li>You should, however, document why the code is there. You will have much more benefit of the 'why' comments then the 'what' comments in the long run.</li>
<li>If it is hard to document, chances are you have not thought enough about the problem.</li>
</ul>

blocks|key|3267819|text|相等比较|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|3267820|在进行相等比较时，请考虑是否要比较值相等(两个对象是否具有相同的值)或引用相等(它们是完全相同的对象实例)。对于引用相等，请使用==运算符；对于值相等，通常需要使用.equals()方法。|CODE|3267821|(请注意，非核心类可能有也可能没有有意义的.equals()实现；大多数核心类都有很好的.equals()实现。)|3267822|例如，一个常见的错误是使用(string1+==+string2)来尝试确定字符串变量string1和string2是否表示相同的字符串值。|3267823|entityMap^0|0|4|0|1S|2|2A|9|0|0|D|K|17|7|1F|7|0^^$0|@$1|2|3|4|5|6|7|O|8|@$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|R|8|@$9|S|A|T|B|H]|$9|U|A|V|B|H]]|D|@]|E|$]]|$1|I|3|J|5|6|7|W|8|@]|D|@]|E|$]]|$1|K|3|L|5|6|7|X|8|@$9|Y|A|Z|B|H]|$9|10|A|11|B|H]|$9|12|A|13|B|H]]|D|@]|E|$]]|$1|M|3|-4|5|6|7|14|8|@]|D|@]|E|$]]]|N|$]]

Equality comparisons

When doing an equality comparison, think about whether you want to compare for value equality (do the two objects have the same value) or reference equality (are they the exact same object instance). For reference equality, use the <code>==</code> operator; for value equality, you will generally want to use the <code>.equals()</code> method. 

(Note that non-core Java classes may or may not have a meaningful .equals() implementation; most core classes do have a good .equals() implementation.)

For example, a common mistake would be to do <code>(string1 == string2)</code> to try and determine whether the string variables <code>string1</code> and <code>string2</code> represent the same string value.

blocks|key|1078211|text|切勿在AWT事件分派线程中执行耗时的任务，否则将出现无响应的GUI。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1078212|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Never execute time-consuming tasks in the AWT event dispatch thread or you will have a non-responsive GUI.

blocks|key|951520|text|你应该经常做的事情。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|951521|阅读Java语言规范。如果你至少有其他一种OOP语言的背景，它会带来巨大的回报。|951522|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|$]]

Things you should always do.

Read the Java language specification. It pays off hugely if you have some background at least in one other OOP language.

blocks|key|3267623|text|查看Java+API。尤其是util包。有许多库可以用来完成常见的任务，重用它们比滚动自己的库要好得多。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3267624|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Review the Java API. Especially the util package. There are many libraries in there to do common tasks, and reusing them is a lot better than rolling your own.

blocks|key|3267874|text|如果无法保证异常不会发生，请使用checked+(声明的)异常，但要确保异常记录在合同(+JavaDoc)中。如果调用者违反了约定，例如，当约定指定参数不能为空时，在传递空参数时，使用unchecked+(运行时)异常惩罚调用者。|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|3267875|entityMap^0|G|7|2K|9|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]|$9|K|A|L|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|M|8|@]|D|@]|E|$]]]|G|$]]

Use a checked (declared) exception if there is no way to guarantee the exception will not happen, but ensure the exception is documented in the contract (the JavaDoc).
Punish the caller with an unchecked (runtime) exception if the caller violated the contract, e.g. passed in a null argument when the contract specified that the argument may not be null.

blocks|key|3267980|text|总是尽可能多地编写单元测试。有两个主要的单元测试框架--+junit和TestNG。它们中的每一个都有其他测试扩展的ecoSystem。拥有单元测试会给你信心。在有人添加新代码或修改代码后，您可以通过到处运行单元测试来发现系统是否损坏。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3267981|此外，java社区已经接受了持续集成系统。其中许多都是开源的--计划定期构建您的软件。如果可以，部署它并对其运行集成测试，但至少要定期构建和运行单元测试。|3267982|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|$]]

always write unit tests as much as possible. There are 2 main unit test frameworks -- junit and TestNG. Each of them has an ecoSystem of other testing extensions.
 having unit tests gives you confidence. After someone has added new code or modified code, you can find if the system is broken or NOT by running the unit tests all over.

Also, the java community has embraced the Continuous Integration systems. Many of them are open source -- plan on building your software on a regular basis. If you can, deploy it and run Integration tests on them BUT at the least, build and run unit tests regularly.

blocks|key|1071904|text|如果您发现自己使用的是inheritance而不是composition，那么您可能做错了。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1071905|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/Inheritance_(computer_science)|1|http://en.wikipedia.org/wiki/Object_composition^0|B|B|0|P|B|1|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@$A|O|B|P|1|Q]|$A|R|B|S|1|T]]|C|$]]|$1|D|3|-4|5|6|7|U|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]|L|$5|G|H|I|C|$J|M]]]]

If you find yourself using <a href="http://en.wikipedia.org/wiki/Inheritance_(computer_science)" rel="nofollow noreferrer">inheritance</a> instead of <a href="http://en.wikipedia.org/wiki/Object_composition" rel="nofollow noreferrer">composition</a>, you're probably doing it wrong.

blocks|key|4735611|text|使用并理解Java集合框架。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4735612|使用类ArrayList而不是Vector。使用HashMap而不是Hashtable。|offset|length|style|CODE|4735613|对于同步访问，请使用Collections实用程序类。|4735614|如果你真的必须使用一些遗留的应用程序接口进行编码，那么只使用Hashtable和Vector。|4735615|entityMap^0|0|3|9|F|6|O|7|Y|9|0|A|B|0|U|9|14|6|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|O|8|@$D|P|E|Q|F|G]|$D|R|E|S|F|G]|$D|T|E|U|F|G]|$D|V|E|W|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|X|8|@$D|Y|E|Z|F|G]]|9|@]|A|$]]|$1|J|3|K|5|6|7|10|8|@$D|11|E|12|F|G]|$D|13|E|14|F|G]]|9|@]|A|$]]|$1|L|3|-4|5|6|7|15|8|@]|9|@]|A|$]]]|M|$]]

Use and understand the Java Collection Framework.

Use the class <code>ArrayList</code> instead of <code>Vector</code>. Use <code>HashMap</code> instead of <code>Hashtable</code>.

For synchronized access, use the <code>Collections</code> utility class.

Only use <code>Hashtable</code> and <code>Vector</code> if you really must code against some legacy API.

blocks|key|1072010|text|在你接受的东西上要宽宏大量，在你返回的东西上要具体。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1072011|例如，使用具有以下签名的通用方法：|1072012|1072013|+public+void+doXY(LinkedList+widgets)|blockquote|offset|length|style|CODE|1072014|1072015|1072016|有了这个签名，客户端就不能将您的通用方法与其他Lists甚至Set类型一起使用。输入参数类型通常可以加宽，以使方法更灵活地使用，例如：|1072017|1072018|+public+void+doXY(Collection+widgets)|1072019|1072020|entityMap^0|0|0|0|1|10|0|0|0|N|5|U|3|0|0|1|10|0|0^^$0|@$1|2|3|4|5|6|7|V|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|W|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|X|8|@]|9|@]|A|$]]|$1|E|3|F|5|G|7|Y|8|@$H|Z|I|10|J|K]]|9|@]|A|$]]|$1|L|3|-4|5|6|7|11|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|12|8|@]|9|@]|A|$]]|$1|N|3|O|5|6|7|13|8|@$H|14|I|15|J|K]|$H|16|I|17|J|K]]|9|@]|A|$]]|$1|P|3|-4|5|6|7|18|8|@]|9|@]|A|$]]|$1|Q|3|R|5|G|7|19|8|@$H|1A|I|1B|J|K]]|9|@]|A|$]]|$1|S|3|-4|5|6|7|1C|8|@]|9|@]|A|$]]|$1|T|3|-4|5|6|7|1D|8|@]|9|@]|A|$]]]|U|$]]

Be liberal in what you accept and specific in what you return.

For example, take a general-purpose method with the following signature:

<blockquote>
 <code>public void doXY(LinkedList widgets)</code>
</blockquote>

With this signature, clients cannot use your general-purpose method with other <code>Lists</code> or even a <code>Set</code> type. An input parameter type can often be broadened to make the method more flexible to use, e. g.:

<blockquote>
 <code>public void doXY(Collection widgets)</code>
</blockquote>

blocks|key|4735809|text|在我看来，最重要的事情是：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4735810|4735811|Formatting:我无法理解格式错误的代码。|ordered-list-item|4735812|良好的命名:良好的命名约定是实现良好的java的第一步。始终编写文档，说明代码是什么以及为什么这样做|4735813|不要重复代码|4735814|使用"effective+|4735815|“中提到的技术。这本书提供了非常有用的指南。|4735816|4735817|entityMap^0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|R|8|@]|9|@]|A|$]]|$1|C|3|D|5|E|7|S|8|@]|9|@]|A|$]]|$1|F|3|G|5|E|7|T|8|@]|9|@]|A|$]]|$1|H|3|I|5|E|7|U|8|@]|9|@]|A|$]]|$1|J|3|K|5|E|7|V|8|@]|9|@]|A|$]]|$1|L|3|M|5|E|7|W|8|@]|9|@]|A|$]]|$1|N|3|-4|5|6|7|X|8|@]|9|@]|A|$]]|$1|O|3|-4|5|6|7|Y|8|@]|9|@]|A|$]]]|P|$]]

In my mind the most important things are:

<ol>
<li>Formatting: I can't understand code with bad format.</li>
<li>Good naming: good naming convention is the first step to good code.</li>
<li>Documentation: always write documentation about what the code is and why it is done this way</li>
<li>Don't repeat code</li>
<li>Make use of the technique mentioned in "effective java". This book provides very useful guideline.</li>
</ol>

blocks|key|4735849|text|一组很棒的建议！|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4735850|让我看看，我没见过的东西..|4735851|使用大量的小类。每个班级都要做好一件事。我从来没有见过太多的类，实际上总是太少。|4735852|阅读Refactoring一书--+Bad+Code+Smells部分列出了很多需要注意的东西。|4735853|你做面向对象错误的最大的指针是大量的setter和getter，想要使用一个switch语句和一个大的继承树，但是还有很多其他的(你的问题不是面向对象，但是足够接近)。|4735854|不要习惯性地初始化局部变量(字符串s=null;)，否则编译器无法捕捉到这个问题：|4735855|String+s;
if(x+==+5)
++++s="5";

if(y+==+5)+
++++s.append("5");+//+Compiler+will+tell+you+s+might+not+have+been+assigned
+++++++++++++++++++//+UNLESS+your+first+line+was+"String+s=null"|code-block|syntax|javascript|4735856|学习Javadoc。只要养成使用它们的习惯，它们并不是那么复杂。|4735857|使用Eclipse或NetBeans。打开错误检查。注意错误。有些你可能认为不重要，但很多会有所帮助。|4735858|如果您使用的是Swing，请了解事件线程--理解它，否则您的GUI将看起来像垃圾。|4735859|SDK中有一些令人惊叹的库。高级线程控制、引用类、NIO和反射都被许多程序员遗漏了--这只是皮毛而已。|4735860|也就是说，不要滥用反射--它会让你的代码很难维护--只需要知道它的存在和它能做什么。|4735861|不要“空”变量来释放内存--这实际上永远不会有用，而且会让您看起来好像不了解垃圾收集。在finalize方法中做这件事更愚蠢。|4735862|嗯，当我们在那里的时候--不要使用finalize方法。永远不会。如果需要清理外部资源，请查找引用类(WeakReference)。|4735863|entityMap^0|0|0|0|0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|16|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|17|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|18|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|19|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|1A|8|@]|9|@]|A|$]]|$1|J|3|K|5|6|7|1B|8|@]|9|@]|A|$]]|$1|L|3|M|5|N|7|1C|8|@]|9|@]|A|$O|P]]|$1|Q|3|R|5|6|7|1D|8|@]|9|@]|A|$]]|$1|S|3|T|5|6|7|1E|8|@]|9|@]|A|$]]|$1|U|3|V|5|6|7|1F|8|@]|9|@]|A|$]]|$1|W|3|X|5|6|7|1G|8|@]|9|@]|A|$]]|$1|Y|3|Z|5|6|7|1H|8|@]|9|@]|A|$]]|$1|10|3|11|5|6|7|1I|8|@]|9|@]|A|$]]|$1|12|3|13|5|6|7|1J|8|@]|9|@]|A|$]]|$1|14|3|-4|5|6|7|1K|8|@]|9|@]|A|$]]]|15|$]]

A great set of advice!

Let's see, what haven't I seen mentioned..

use lots of small classes. Each class should do one thing well. I've never seen too many classes, virtually always too few.

read the Refactoring book--the section on Bad Code Smells lists a lot of stuff to look out for.

The biggest pointers that you are doing OO wrong is lots of setters and getters, the desire to use a switch statement and a large inheritance tree, but there are many others (Your question wasn't OO, but close enough).

Don't initialize local variables as a matter of habit (String s=null;), otherwise the compiler can't catch this problem:

<pre><code>String s;
if(x == 5)
 s="5";

if(y == 5) 
 s.append("5"); // Compiler will tell you s might not have been assigned
 // UNLESS your first line was "String s=null"
</code></pre>

Learn Javadocs. Just get in the habit of using them, they're not that complicated.

Use Eclipse or NetBeans. Turn up error checking. Pay attention to the errors. Some you may decide aren't important, but many will help.

If you are working in Swing, learn about the event thread--grok it or your GUIs will look like crap.

There are some AMAZING libraries in the SDK. Advanced threading control, Reference classes, NIO and reflection are all missed by many programmers--and that's just scratching the surface.

That said, don't abuse reflection--it can make your code hard to maintain--just know it's there and what it can do.

Don't "Null" out variables to free memory--it's virtually never useful and makes you look like you don't understand Garbage Collection. Even sillier to do it in a finalize method.

Hmm, while we're there--don't use finalize methods. Ever. If you need to clean up an external resource, look up reference classes (WeakReference).

blocks|key|3268077|text|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3268078|让你的代码保持整洁(缩进)，带有注释和清晰的变量名。这将帮助您以后阅读/编辑您的代码。|unordered-list-item|3268079|在你代码中创建applicable.|3268080|Ensure高效的对象，不要重复代码(no+copy%2Bpaste+mkay?.|3268081|3268082|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|-4|4|5|6|K|7|@]|8|@]|9|$]]|$1|A|3|B|4|C|6|L|7|@]|8|@]|9|$]]|$1|D|3|E|4|C|6|M|7|@]|8|@]|9|$]]|$1|F|3|G|4|C|6|N|7|@]|8|@]|9|$]]|$1|H|3|-4|4|5|6|O|7|@]|8|@]|9|$]]|$1|I|3|-4|4|5|6|P|7|@]|8|@]|9|$]]]|J|$]]

<ul>
<li>Keep your code neat (indentation), with comments and clear variable names. This will help you read/edit your code at a later date. It'll also help others to read your code.</li>
<li>Create objects where applicable.</li>
<li>Ensure efficiency in your code, don't repeat code (no copy+paste mkay?.</li>
</ul>

blocks|key|3267688|text|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3267689|尽可能少使用递归。递归是有用法的，但大多数情况下，一个简单的循环可以做同样的工作，而不会产生递归带来的开销。|ordered-list-item|3267690|在可能的情况下使用泛型。很多时候，一个类可以用于你在开发时从未想过的应用程序。泛型简化了无需重构的重用过程。|3267691|3267692|entityMap^0|0|0|0|0^^$0|@$1|2|3|-4|4|5|6|I|7|@]|8|@]|9|$]]|$1|A|3|B|4|C|6|J|7|@]|8|@]|9|$]]|$1|D|3|E|4|C|6|K|7|@]|8|@]|9|$]]|$1|F|3|-4|4|5|6|L|7|@]|8|@]|9|$]]|$1|G|3|-4|4|5|6|M|7|@]|8|@]|9|$]]]|H|$]]

<ol>
<li>Use recursion as little as possible. There are uses for recursion, but most of the time a simple loop will do the same job without the overhead created with recursion. </li>
<li>use Generics where possible. Many times a class can be used for an application that you never thought of when it was developed. Generics eases the process of reuse without refactoring.</li>
</ol>

blocks|key|952136|text|我看到了一个很好的建议，我尝试并应用了:避免将类字段初始化为默认值。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|952137|我仍然经常看到：|952138|public+class+Foo
{
++boolean+b+=+false;
++int+n+=+0;
++float+x+=+0.0;
++SomeClass+sc+=+null;
}|code-block|syntax|javascript|952139|诸若此类。|952140|由于JVM已经在变量分配时设置了值，丑陋的(并且分散了读者对非默认值的注意力)和恼人的调试时(我们必须在类创建时执行)，所以它的效率很低(尽管在较小的级别)。|952141|一些人说，有些情况下需要这样的init，但并不是不能提出一个真实的案例。如果有人在这里有更多信息。|952142|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|R|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|S|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|T|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|U|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|V|8|@]|9|@]|A|$]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

I saw a rather good advice that I try and apply: avoid to initialize class fields to default values.

I still often see:

<pre><code>public class Foo
{
 boolean b = false;
 int n = 0;
 float x = 0.0;
 SomeClass sc = null;
}
</code></pre>

and so on.

It is inefficient (although at a minor level) since the JVM have already set the values at variable allocation time, ugly (and distracting the reader from non-default values) and annoying at debugging time (we have to step there at class creation time).

Some people said there are cases where such init is needed, but wasn't unable to present a real case. If somebody has more info here...

blocks|key|3268182|text|Steven+McConnel的Code+Complete有许多有用的技巧，不仅适用于McConnel编程，而且适用于一般的编程。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|3268183|entityMap|0|LINK|mutability|MUTABLE|url|http://cc2e.com/^0|G|D|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@$A|M|B|N|1|O]]|C|$]]|$1|D|3|-4|5|6|7|P|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]]]

<a href="http://cc2e.com/" rel="nofollow noreferrer">Code Complete</a> by Steven McConnel has many useful tips, not just for programming in Java, but for programming generally.

blocks|key|952242|text|对于methods.和，|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|952243|始终使用自解释命名|ordered-list-item|952244|952245|仅在需要时使用|952246|Comment。|952247|952248|entityMap^0|2|7|0|0|0|0|0|7|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@$9|R|A|S|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|T|8|@]|D|@]|E|$]]|$1|I|3|-4|5|6|7|U|8|@]|D|@]|E|$]]|$1|J|3|K|5|6|7|V|8|@]|D|@]|E|$]]|$1|L|3|M|5|H|7|W|8|@$9|X|A|Y|B|C]]|D|@]|E|$]]|$1|N|3|-4|5|6|7|Z|8|@]|D|@]|E|$]]|$1|O|3|-4|5|6|7|10|8|@]|D|@]|E|$]]]|P|$]]

<ol>
<li><h3>Always use self-explanatory naming for <code>properties</code> and <code>methods</code>.</h3>
</li>
<li><h3><code>Comment</code> only when it is needed.</h3>
</li>
</ol>

blocks|key|952292|text|关于这个问题的另一本好书是Robert+C.+Martins+Clean+Code。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|952293|它包含了java的通用编码规则和指南，但其中大多数也可以应用于其他语言。|952294|我认为读过这本书的开发人员会产生更多可读性和可维护性更强的代码。|952295|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/Robert_Cecil_Martin|1|http://books.google.de/books?id=dwSfGQAACAAJ&dq=isbn:0132350882&source=bl&ots=YW1ku8GLVZ&sig=4vhcjNCxOlbMwlt_RM9Gu8YDurE&hl=de&sa=X&ei=HAtGUJjxE4fxsgbl6oHgAQ&redir_esc=y^0|D|H|0|V|A|1|0|0|0^^$0|@$1|2|3|4|5|6|7|R|8|@]|9|@$A|S|B|T|1|U]|$A|V|B|W|1|X]]|C|$]]|$1|D|3|E|5|6|7|Y|8|@]|9|@]|C|$]]|$1|F|3|G|5|6|7|Z|8|@]|9|@]|C|$]]|$1|H|3|-4|5|6|7|10|8|@]|9|@]|C|$]]]|I|$J|$5|K|L|M|C|$N|O]]|P|$5|K|L|M|C|$N|Q]]]]

Another good book on the issue is <a href="http://en.wikipedia.org/wiki/Robert_Cecil_Martin" rel="nofollow">Robert C. Martins</a> <a href="http://books.google.de/books?id=dwSfGQAACAAJ&amp;dq=isbn:0132350882&amp;source=bl&amp;ots=YW1ku8GLVZ&amp;sig=4vhcjNCxOlbMwlt_RM9Gu8YDurE&amp;hl=de&amp;sa=X&amp;ei=HAtGUJjxE4fxsgbl6oHgAQ&amp;redir_esc=y" rel="nofollow">Clean Code</a>.

It contains general coding rules and guidelines for java but most of them could be applied to other languages too.

I think a developer who read this book produces much more readable and maintainable code.

I'm learning Java and I'm wondering what everyone's Java rules are. The rules that you know intrinsically and if you see someone breaking them you try to correct them. Things to keep you out of trouble or help improve things. Things you should never do. Things you should always do. The rules that a beginner would not know.

What are your Java 'rules'?

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

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

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

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

文章

问答

视频

教程

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云智能顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云AI代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

功能1上新10个字符

功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符。

功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符。

功能5描述100个字符功能5描述100个字符功能5描述100个字符功能5描述100个字符功能5描述100个字符功能5描述100个字符

功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符

功能4上新

文章&问答评论现已支持表情

全新交互，全新视觉，新增快捷键、悬浮工具栏、高亮块等功能并同时优化现有功能，全面提升创作效率和体验

社区富文本编辑器全新改版！诚邀体验～ 

精选全网热门MCP server，让你的AI更好用 🚀

💥开发者 MCP广场重磅上线！

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

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

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

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

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

社区新版编辑器体验调研

我正在学习Java，我想知道每个人的Java规则是什么。你本质上知道的规则，如果你看到有人违反了这些规则，你就会尝试纠正它们。让你远离麻烦或帮助你改进的东西。一些你永远不应该做的事。你应该经常做的事情。初学者不会知道的规则。

问你的Java“规则”是什么？
EN

回答 22

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问你的Java“规则”是什么？EN

回答 22

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问你的Java“规则”是什么？
EN