如何写出更好的Java代码

Java是最流行的编程语言之一，但似乎并没有人喜欢使用它。好吧，实际上Java是一门还不错的编程语言，由于最近Java 8发布了，我决定来编辑一个如何能更好地使用Java的列表，这里面包括一些库，实践技巧以及工具。

　　这篇文章在GitHub上也有。你可以随时在上面贡献或者添加你自己的Java使用技巧或者最佳实践。

  • 编码风格

    • 结构体

      • builder模式
    • 依赖注入
    • 避免null值
    • 不可变
    • 避免过多的工具类
    • 格式
      • 文档
      • Stream
  • 部署
    • 框架
    • Maven
      • 依赖收敛
    • 持续集成
    • Maven仓储
    • 配置管理
  • 库
    • 遗失的特性

      • Apache Commons
      • Guava
      • Gson
      • Java Tuples
      • Joda-Time
      • Lombok
      • Play framework
      • SLF4J
      • jOOQ
    • 测试
      • jUnit 4
      • jMock
      • AssertJ
  • 工具
    • IntelliJ IDEA

      • Chronon
    • JRebel
    • 校验框架
    • Eclipse Memory Analyzer
  • 资源
    • 书籍
    • 播客

　　编码风格

　　传统的Java编码方式是非常啰嗦的企业级JavaBean的风格。新的风格更简洁准确，对眼睛也更好。

　　结构体

　　我们这些码农干的最简单的事情就是传递数据了。传统的方式就是定义一个JavaBean:

?


1

2

3

4

5

6

7

8

9

10

11

12

13

14

public
class DataHolder {

    private
String data;

 

    public
DataHolder() {

    }

 

    public
void setData(String data) {

        this.data = data;

    }

 

    public
String getData() {

        return
this.data;

    }

}

这不仅拖沓而且浪费。尽管你的IDE可以自动地生成这个，但这还是浪费。因此，不要这么写。

　　相反的，我更喜欢C的结构体的风格，写出来的类只是包装数据：

?


1

2

3

4

5

6

7

public
class DataHolder {

    public
final String data;

 

    public
DataHolder(String data) {

        this.data = data;

    }

}

　　这样写减少了一半的代码。不仅如此，除非你继承它，不然这个类是不可变的，由于它是不可变的，因此推断它的值就简单多了。

　　如果你存储的是Map或者List这些可以容易被修改的数据，你可以使用ImmutableMap或者ImmutableList，这个在不可变性这节中会有讨论。

　　Builder模式

　　如果你有一个相对复杂的对象，可以考虑下Builder模式。

你在对象里边创建一个子类，用来构造你的这个对象。它使用的是可修改的状态，但一旦你调用了build方法，它会生成一个不可变对象。

想象一下我们有一个非常复杂的对象DataHolder。它的构造器看起来应该是这样的：

?


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

public
class ComplicatedDataHolder {

    public
final String data;

    public
final int
num;

    // lots more fields and a constructor

 

    public
class Builder {

        private
String data;

        private
int num;

 

        public
Builder data(String data) {

            this.data = data;

            return
this;

        }

 

        public
Builder num(int
num) {

            this.num = num;

            return
this;

        }

 

        public
ComplicatedDataHolder build() {

            return
new ComplicatedDataHolder(data, num);
// etc

        } 

    }

}

　　现在你可以使用它了：

?


1

2

3

4

final
ComplicatedDataHolder cdh = new
ComplicatedDataHolder.Builder()

    .data("set this")

    .num(523)

    .build();

　　关于Builder的使用这里还有些更好的例子，我这里举的例子只是想让你大概感受一下。当然这会产生许多我们希望避免的样板代码，不过好处就是你有了一个不可变对象以及一个连贯接口。

　　依赖注入

　　这更像是一个软件工程的章节而不是Java的，写出可测的软件的一个最佳方式就是使用依赖注入（Dependency injection，DI）。由于Java强烈鼓励使用面向对象设计 ，因此想写出可测性强的软件，你需要使用DI。

　　在Java中，这个通常都是用Spring框架来完成的。它有一个基于XML配置的绑定方式，并且仍然相当流行。重要的一点是你不要因为它的基于XML的配置格式而过度使用它了。在XML中应该没有任何的逻辑和控制结构。它只应该是依赖注入。

　　还有一个不错的方式是使用Dagger库以及Google的Guice。它们并没有使用Spring的XML配置文件的格式，而是将注入的逻辑放到了注解和代码里。

　　避免null值

　　如果有可能的话尽量避免使用null值。你可以返回一个空的集合，但不要返回null集合。如果你准备使用null的话，考虑一下@Nullable注解。IntelliJ IDEA对于@Nullable注解有内建的支持。

　　如果你使用的是Java 8的话，可以考虑下新的Optional类型。如果一个值可能存在也可能不存在，把它封装到Optional类里面，就像这样：

?


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

public
class FooWidget {

    private
final String data;

    private
final Optional<Bar> bar;

 

    public
FooWidget(String data) {

        this(data, Optional.empty());

    }

 

    public
FooWidget(String data, Optional<Bar> bar) {

        this.data = data;

        this.bar = bar;

    }

 

    public
Optional<Bar> getBar() {

        return
bar;

    }

}

　　现在问题就清楚了，data是不会为null的，而bar可能为空。Optional类有一些像isPresent这样的方法，这让它感觉跟检查null没什么区别。不过有了它你可以写出这样的语句：

?


1

2

3

4

final
Optional<FooWidget> fooWidget = maybeGetFooWidget();

final
Baz baz = fooWidget.flatMap(FooWidget::getBar)

                         .flatMap(BarWidget::getBaz)

                         .orElse(defaultBaz);

　　这比使用if来检查null好多了。唯一的缺点就是标准类库中对Optional的支持并不是很好，因此你还是需要对null进行检查的。

　　不可变

　　变量，类，集合，这些都应该是不可变的，除非你有更好的理由它们的确需要进行修改。

　　变量可以通过final来设置成不可变的：

?


1

2

3

4

5

6

7

8

9

10

11

12

final
FooWidget fooWidget;

if
(condition()) {

    fooWidget = getWidget();

} else
{

    try
{

        fooWidget = cachedFooWidget.get();

    }
catch (CachingException e) {

        log.error("Couldn‘t get cached value", e);

        throw
e;

    }

}

// fooWidget is guaranteed to be set here

　　现在你可以确认fooWidget不会不小心被重新赋值了。final关键字可以和if/else块以及try/catch块配合使用。当然了，如果fooWidget对象不是不可变的，你也可以很容易地对它进行修改。

　　有可能的话，集合都应该尽量使用Guava的ImmutableMap, ImmutableList, or ImmutableSet类。这些类都有自己的构造器，你可以动态的创建它们，然后将它们设置成不可变的，。

　　要使一个类不可变，你可以将它的字段声明成不可变的（设置成final)。你也可以把类自身也设置成final的这样它就不能被扩展并且修改了，当然这是可选的。

　　避免大量的工具类

　　如果你发现自己添加了许多方法到一个Util类里，你要注意了。

?


1

2

3

4

5

6

7

8

9

public
class MiscUtil {

    public
static String frobnicateString(String base,
int times) {

        // ... etc

    }

 

    public
static void
throwIfCondition(boolean
condition, String msg) {

        // ... etc

    }

}

　　这些类乍一看挺吸引人的，因为它们里面的这些方法不属于任何一个地方。因此你以代码重用之名将它们全都扔到这里了。

　　这么解决问题结果更糟。把它们放回它们原本属于的地方吧，如果你确实有一些类似的常用方法，考虑下Java 8里接口的默认方法。并且由于它们是接口，你可以实现多个方法。

?


1

2

3

4

5

6

7

8

9

public
interface Thrower {

    public
void throwIfCondition(boolean
condition, String msg) {

        // ...

    }

 

    public
void throwAorB(Throwable a, Throwable b,
boolean throwA) {

        // ...

    }

}

　　这样需要使用它的类只需简单的实现下这个接口就可以了。

　　格式

　　格式远比许多程序员相像的要重要的多。一致的格式说明你关注自己的代码或者对别人有所帮助？是的。不过你先不要着急为了让代码整齐点而浪费一整天的时间在那给if块加空格了。

　　如果你确实需要一份代码格式规范，我强烈推荐Google的Java风格指南。这份指南最精彩的部分就是编程实践这节了。非常值得一读。

　　文档

　　面向用户的代码编写下文档还是很重要的。这意味着你需要提供一些使用的示例，同时你的变量方法和类名都应该有适当的描述信息。

　　结论就是不要给不需要文档的地方添加文档。如果对于某个参数你没什么可说的，或者它已经非常明显了，别写文档了。模板化的文档比没有文档更糟糕，因为它欺骗了你的用户，让他觉得这里有文档。

　　流

　　Java 8有一个漂亮的流和lambda表达式的语法。你的代码可以这么写：

?


1

2

3

final
List<String> filtered = list.stream()

    .filter(s -> s.startsWith("s"))

    .map(s -> s.toUpperCase());

　　而不是这样：

?


1

2

3

4

5

6

final
List<String> filtered = Lists.newArrayList();

for
(String str : list) {

    if
(str.startsWith("s") {

        filtered.add(str.toUpperCase());

    }

}

　　这样你能写出更连贯的代码，可读性也更强。

　　部署

　　正确地部署Java程序还是需要点技巧的。现在部署Java代码的主流方式有两种 ：使用框架或者使用自家摸索出来的解决方案，当然那样更灵活。

　　框架

　　由于部署Java程序并不容易，因此才有了各种框架来用于部署。最好的两个是Dropwizard以及Spring Boot。Play
Framework也可以算是一个部署框架。

　　这些框架都试图降低部署程序的门槛。如果你是一个Java的新手或者你需要快速把事情搞定的话，那么框架就派上用场了。单个jar的部署当然会比复杂的WAR或者EAR部署要更容易一些。

　　然而，这些框架的灵活性不够，并且相当顽固，因此如果这些框架的开发人员给出的方式不太适合你的项目的话，你只能自己进行配置了。

　　Maven

　　备选方案：Gradle。

　　Maven仍然是编译，打包，运行测试的标准化工具。还有其它一些选择，比如Gradle，不过它们的采用程度远不Maven。如果你之前没用过Maven，你可以看下这个Maven的使用示例。

　　我喜欢用一个根POM文件来包含所有的外部依赖。它看起来就像是这样。这个根POM文件只有一个外部依赖，不过如果你的产品很大的话，你可能会有很多依赖。你的根POM文件自己就应该是一个项目：它有版本控制，并且和其它的Java项目一样进行发布。

　　如果你觉得为每个外部依赖的修改都给POM文件打个标签（tag)有点太浪费了，那是你还没有经历过花了一个星期的时间来跟踪项目依赖错误的问题。

　　你的所有Maven工程都应该包含你的主POM文件以及所有的版本信息。这样的话，你能知道公司项目的每个外部依赖所选择的版本，以及所有正确的Maven插件。如果你需要引入一个外部依赖的话，大概是这样的：

?


1

2

3

4

5

6

<dependencies>

    <dependency>

        <groupId>org.third.party</groupId>

        <artifactId>some-artifact</artifactId>

    </dependency>

</dependencies>

　　如果你需要进行内部依赖的话，应该在项目的段中单独进行维护。不然的话，主POM文件的版本号就要疯涨了。

　　依赖收敛

　　Java的一个最好的地方就是有大量的第三方库，它们无所不能。几乎每个API或者工具都有相应的Java SDK，并且可以很容易地引入到Maven中来。

　　所有的这些Java库自身可能又会依赖一些特定的版本的其它类库。如果你引入了大量的库，可能会出现版本冲突 ，比如说像这样：

?


1

2

Foo library depends on Bar library v1.0

Widget library depends on Bar library v0.9

　　你的工程应该引入哪个版本？

　　有了Maven的依赖收敛的插件后，如果你的依赖版本不一致的话，编译的时候就会报错。那么你有两种解决冲突的方案：

  • 在dependencyManagement区中显式地选择某个版本的bar。
  • Foo或者Widget都不要依赖Bar。

　　到底选择哪种方案取决你的具体情况： 如果你想要跟踪某个工程的版本，不依赖它是最好的。另一方面，如果你想要明确一点，你可以自己选择一个版本，不过这样的话，如果更新了其它的依赖，也得同步地修改它。

　　持续集成

　　很明显你需要某种持续集成的服务器来不断地编译你的SNAPSHOT版本，或者对Git分支进行构建。

　　Jenkins和Travis-CI是你的不二选择。

　　代码覆盖率也很重要，Cobertura有一个不错的Maven插件，并且对CI支持的也不错。当然还有其它的代码覆盖的工具，不过我用的是Cobertura。

　　Maven库

　　你需要一个地方来存储你编译好的jar包，war包，以及EAR包，因此你需要一个代码仓库。

　　常见的选择是Artifactory或者Nexus。两个都能用，并且各有利弊。

　　你应该自己进行Artifactory/Nexus的安装并且将你的依赖做一份镜像。这样不会由于下载Maven 库的时候出错了导到编译中断。

　　配置管理

　　那现在你的代码可以编译了，仓库也搭建起来了，你需要把你的代码带出开发环境，走向最终的发布了。别马虎了，因为自动化执行从长远来看，好处是大大的。

　　Chef，Puppet，和Ansible都是常见的选择。我自己也写了一个可选方案，Squadron。这个嘛，当然了，我自然是希望你们能下载下它的，因为它比其它那些要好用多了。

　　不管你用的是哪个工具，别忘了自动化部署就好。

　　库

　　可能Java最好的特性就是它拥有的这些库了。下面列出了一些库，应该绝大多数人都会用得上。

　　Java的标准库，曾经还是很不错的，但在现在看来它也遗漏掉了很多关键的特性。

　　Apache Commons

　　Apache Commons项目有许多有用的功能。

  • Commons Codec有许多有用的Base64或者16进制字符串的编解码的方法。别浪费时间自己又写一遍了。
  • Commons Lang是一个字符串操作，创建，字符集，以及许多工具方法的类库。
  • Commons IO，你想要的文件相关的方法都在这里了。它有FileUtils.copyDirectory，FileUtils.writeStringToFile, IOUtils.readLines，等等。

　　Guava

　　Guava是一个非常棒的库，它就是Java标准库"所缺失的那部分"。它有很多我喜欢的地方，很难一一赘述，不过我还是想试一下。

  • Cache，这是一个最简单的获取内存缓存的方式了，你可以用它来缓存网络访问，磁盘访问，或者几乎所有东西。你只需实现一个CacheBuilder，告诉Guava如何创建缓存就好了。
  • 不可变集合。这里有许多类：ImmutableMap, ImmutableList，甚至还有ImmutableSortedMultiSet，如果这就是你想要的话。

　　我还喜欢用Guava的方式来新建可变集合：

?


1

2

3

4

5

// Instead of

final
Map<String, Widget> map = new
HashMap<String, Widget>();

 

// You can use

final
Map<String, Widget> map = Maps.newHashMap();

　　有许多像Lists, Maps, Sets的静态类，他们都更简洁易懂一些。

　　如果你还在坚持使用Java 6或者7的话，你可以用下Collections2，它有一些诸如filter和transform的方法。没有Jvaa 8的stream的支持，你也可以用它们来写出连贯的代码。

　　Guava也有一些很简单的东西，比如Joiner，你可以用它来拼接字符串，还有一个类可以用来处理中断。

　　Gson

　　Google的Gson是一个简单高效的JSON解析库。它是这样工作的：

?


1

2

3

4

final
Gson gson = new
Gson();

final
String json = gson.toJson(fooWidget);

 

final
FooWidget newFooWidget = gson.fromJson(json, FooWidget.class);

　　真的很简单，使用它会感觉非常愉快。Gson的用户指南中有更多的示例。

　　Java Tuples

　　我对Java一个不爽的地方就是它的标准库中居然没有元组。幸运的是， Java tuples工程解决了这一问题。

　　它也很容易使用，并且真的很赞：

?


1

2

3

4

Pair<String, Integer> func(String input) {

    // something...

    return
Pair.with(stringResult, intResult);

}

　　Joda-Time

　　Joda-Time是我用过的最好的时间库了。简直，直接，容易测试。你还想要什么？

　　这个库里我最喜欢的一个类就是Duration，因为我用它来告诉说我要等待多长时间，或者过多久我才进行重试。

　　Lombok

　　Lombok是一个非常有趣的库。它通过注释来减少了Java中的饱受诟病的样板代码（注：setter,getter之类的）。

　　想给你类中的变量增加setter， getter方法？太简单了：

?


1

2

3

public
class Foo {

    @Getter
@Setter private
int var;

}

　　现在你可以这么写了：

?


1

2

final
Foo foo = new Foo();

foo.setVar(5);

　　这里还有更多的示例。我还没在生产代码中用过Lombok，不过我有点等不及了。

Play框架

　　备选方案：Jersey或者Spark

　　在Java中实现REST风格的WEB服务有两大阵营：JAX-RS和其它。

　　JAX-RS是传统的方式。你使用像Jersey这样的东西来将注解和接口，实现组合到一起来实现WEB服务。这样做的好处就是，你可以通过一个接口就能很容易创建出一个调用的客户端来。

　　Play框架是在JVM上实现WEB服务的截然不同的一种方式：你有一个routes文件，然后你去实现routes中那些规则所引用到的类。它其实就是个完整的MVC框架，不过你可以只用它来实现REST服务。

　　它同时支持Java和Scala。它优先使用Scala这点可能有点令人沮丧，但是用Java进行开发的话也非常不错。

　　如果你习惯了Python里的Flask这类的微框架，那么你应该会对Spark感到很熟悉。有了Java 8它简直如虎添翼。

　　SLF4J

　　Java打印日志有许多不错的解决方案。我个人最喜欢的是SLF4J，因为它是可挺插拔的，并且可以同时混合不同的日志框架中输出的日志。有个奇怪的工程同时使用了java.util.logging, JCL, 和log4j？没问题，SLF4J就是为它而生的。

　　想入门的话，看下它的这个两页的手册就足够的了。

　　jOOQ

　　我不喜欢很重的ORM框架，因为我喜欢SQL。因此我写了许多的JDBC模板，但它们很难维护。jOOQ是个更不错的解决方案。

　　你可以在Java中以一种类型安全的方式来书写SQL语句：

?


1

2

3

4

5

6

7

8

// Typesafely execute the SQL statement directly with jOOQ

Result<Record3<String, String, String>> result = 

create.select(BOOK.TITLE, AUTHOR.FIRST_NAME, AUTHOR.LAST_NAME)

    .from(BOOK)

    .join(AUTHOR)

    .on(BOOK.AUTHOR_ID.equal(AUTHOR.ID))

    .where(BOOK.PUBLISHED_IN.equal(1948))

    .fetch();

　　将它以及DAO模式结合起来，你可以让数据库访问变得更简单。

　　测试

　　测试对软件来说至关重要。下面这些库能让测试变得更加容易。

　　jUnit 4

　　jUnit就不用介绍了。它是Java中单元测试的标准工具。

　　不过可能你还没有完全发挥jUnit的威力。jUnit还支持参数化测试，以及能让你少写很多样板代码的测试规则，还有能随机测试代码的Theory,以及Assumptions。

　　jMock

　　如果你已经完成了依赖注入，那么它回报你的时候来了：你可以mock出带副作用的代码（就像和REST服务器通信那样），并且仍然能对调用它的代码执行断言操作。

　　jMock是Java中标准的mock工具。它的使用方式是这样的：

?


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

public
class FooWidgetTest {

    private
Mockery context = new
Mockery();

 

    @Test

    public
void basicTest() {

        final
FooWidgetDependency dep = context.mock(FooWidgetDependency.class);

 

        context.checking(new
Expectations() {

            oneOf(dep).call(with(any(String.class)));

            atLeast(0).of(dep).optionalCall();

        });

 

        final
FooWidget foo = new
FooWidget(dep);

 

        Assert.assertTrue(foo.doThing());

        context.assertIsSatisfied();

    }

}

　　这段代码通过jMock设置了一个FooWidgetDependency ，然后添加了一些期望的操作。我们希望dep的call方法被调用一次而dep的optionalCall 方法会被调用0或更多次。

　　如果你反复的构造同样的FooWidgetDependency，你应该把它放到一个测试设备（Test Fixture）里，然后把assertIsSatisfied放到一个@After方法中。

　　AssertJ

　　你是不是用jUnit写过这些？

?


1

2

3

4

5

final
List<String> result = some.testMethod();

assertEquals(4, result.size());

assertTrue(result.contains("some result"));

assertTrue(result.contains("some other result"));

assertFalse(result.contains("shouldn‘t be here"));

　　这些样板代码有点太聒噪了。AssertJ解决了这个问题。同样的代码可以变成这样：

?


1

2

3

assertThat(some.testMethod()).hasSize(4)

                             .contains("some result",
"some other result")

                             .doesNotContain("shouldn‘t be here");

　　连贯接口让你的测试代码可读性更强了。代码如此，夫复何求？

　　工具

　　IntelliJ IDEA

　　备选方案： Eclipse and Netbeans

　　最好的Java IDE当然是 IntelliJ IDEA。它有许多很棒的特性，我们之所以还能忍受Java这些冗长的代码，它起了很大的作用。自动补全很棒，< a href="http://i.imgur.com/92ztcCd.png" target="_blank">代码检查也超赞，重构工具也非常实用。

　　免费的社区版对我来说已经足够了，不过在旗舰版中有许多不错的特性比如数据库工具，Srping框架的支持以及Chronon等。

　　Chronon

　　GDB 7中我最喜欢的特性就是调试的时候可以按时间进行遍历了。有了IntelliJ IDEA的Chronon插件后，这个也成为现实了。当然你得是旗舰版的。

　　你可以获取到变量的历史值，跳回前面执行的地方，获取方法的调用历史等等。第一次使用的话会感觉有点怪，但它能帮忙你调试一些很棘手的BUG。

　　JRebel

　　持续集成通常都是SaaS产品的一个目标。你想想如果你甚至都不需要等到编译完成就可以看到代码的更新？

　　这就是JRebel在做的事情。只要你把你的服务器挂到某个JRebel客户端上，代码一旦有改动你马上就能看到效果。当你想快速体验一个功能的话，这个的确能节省不少时间。

　　验证框架

　　Java的类型系统是相当弱的。它不能区分出普通字符串以及实际上是正则的字符串，也不能进行

?


1

2

3

4

5

6

7

8

$ jmap -dump:live,format=b,file=heapdump.hprof -F
8152

Attaching to process ID
8152, please wait...

Debugger attached successfully.

Server compiler detected.

JVM version is
23.25-b01

Dumping heap to heapdump.hprof ...

... snip ...

Heap dump file created

　　然后你就可以用Memory Analyzer来打开heapdump.hprof文件，看看到底发生了什么。

如何写出更好的Java代码,布布扣,bubuko.com

时间： 2024-10-24 00:29:29

如何写出更好的Java代码的相关文章

Java 11 正式发布，这 8 个逆天新特性教你写出更牛逼的代码

美国时间 09 月 25 日,Oralce 正式发布了 Java 11,这是据 Java 8 以后支持的首个长期版本. 为什么说是长期版本,看下面的官方发布的支持路线图表. Java 11 正式发布,这 8 个逆天新特性教你写出更牛逼的代码可以看出 Java 8 扩展支持到 2025 年,而 Java 11 扩展支持到 2026 年. 现在大部分都在用 Java 8,Java 9 和 10 目前很少有人在用,至少我没有发现有公司在生产环境应用的,那就是找死. 现在 Java 11 长期支持,也已

理解CacheLine与写出更好的JAVA

今天查了很多资料,主要是想搞清楚写JAVA和CacheLine有什么关系以及我们如何针对CacheLine写出更好的JAVA程序. CPU和内存 CPU是计算机的大脑,它负责运算,内存是数据,它为CPU提供数据.这里之所以忽略其他存储设备是为了简化模型.假设我们面对的是具有两个核心的CPU,那么我们的模型大概如下面的样子: CPU计算核心不会直接和内存打交道,它会直接从缓存拿数据,如果缓存没拿到,专业点说即缓存未命中的时候才会去内存去拿,同时会更新缓存.这个过程CPU不会仅仅读取需要的某个字节或

[label][翻译][JavaScript-Translation]七个步骤让你写出更好的JavaScript代码

7 steps to better JavaScript 原文:http://www.creativebloq.com/netmag/7-steps-better-javascript-51411781七个步骤让你写出更好的JavaScript代码 随着浏览器的性能提升,新的HTML5 APIS也在不断地被应用,JavaScript在web使用中不断增长.然而,一行糟糕的代码就有可能会影响到整个网站,产生糟糕的用户体验和造成潜在客户的流失. 开发者必须使用他所能使用的工具和技巧来提高代码的质量,

Java 11正式发布，这几个逆天新特性教你写出更牛逼的代码

就在前段时间,Oracle 官方宣布 Java 11 (18.9 LTS) 正式发布,可在生产环境中使用! 这无疑对我们来说是一大好的消息.作为一名java开发者来说,虽然又要去学习和了解java11,但内心还是欣慰的.我想至少你和我一样的心情:Java在手,天下我有! 今天我们来看一下Java 11到底是什么.他有什么特别的.到底要不要升级到Java 11. Java 11有什么特别的 在Oracle官网中,进入下载页面,第一个可供下载的JDK版本已经提换成了Java SE 11 (LTS),

让我们一起写出更有效的CSharp代码吧，少年们！

周末空闲,选读了一下一本很不错的C#语言使用的书,特此记载下便于对项目代码进行重构和优化时查看. Standing On Shoulders of Giants,附上思维导图,其中标记的颜色越深表示在实际中的实际意义越大. 名称 内容和示例 提供API时尽量提供泛型接口 Public interface IComparable<T>{ int CompareTo(T other) } 泛型约束尽可能的严格并有效 Public delegate T FactoryFunc<T>();

怎样写出更好的JavaScript代码

一.可维护性的代码 1.可读性:在函数和方法.大段代码.复杂算法和hack上加上帮助理解的注释.    2.变量的函数的命名:变量最好用名词,函数最好以动词开头.有较好的语义和逻辑性. 3.变量类型透明:以合适的命名方式来帮助记忆变量的类型 . a:初始化法. b:匈牙利标记法. c:在后面用注释说明. 4.松散耦合 松散耦合就是一部分的代码功能依赖于另外一部分.   a:html/javascript 解耦:html与js尽量分离,比如在html中添加事件处理,动态插入标签.解耦可以更快地知道

用Cython编译写出更快的Python代码

原文地址: http://www.behnel.de/cython200910/talk.html以下为原文 About myself Passionate Python developer since 2002 after Basic, Logo, Pascal, Prolog, Scheme, Java, C, ... CS studies in Germany, Ireland, France PhD in distributed systems in 2007 Language desi

【整洁之道】如何写出更整洁的代码(上)

如何写出更整洁的代码 代码整洁之道不是银弹,不会立竿见影的带来收益. 没有任何犀利的武功招式,只有一些我个人异常推崇的代码整洁之道的内功心法.它不会直接有效的提高你写代码的能力与速度,但是对于程序员的整个职业生涯必然会带来意想不到的好处. 如果你还是一个在校学生,或者是刚工作没多久的"菜鸟",那么很有必要接触一些这方面的知识的.很显然,它会帮助你更快的适应企业级开发的要求. 1. 为什么需要代码更整洁? 在考虑代码整洁的时候,我们需要明确的一个前提是,这里不讨论代码的对错. 关于什么是

掌握解决问题的艺术，学会迭代开发，成为协作开发的专家，然后为写出更好的代码而担忧(转)

很多开发人员普遍犯有一个错误,认为他们的工作就是写代码.这不是一个开发人员要做的事情. 一个开发人员的工作是解决问题. 解决问题的一部分过程通常涉及到写代码,但是这部分工作是非常非常小的.开发有用的东西才花更多时间. 明白如何迭代开发,随着对问题有更好的理解,你才能给难题增加一些小功能,因为从头开发完美的产品是不可能的.不用写代码就能验证功能,因为很明显,写代码是相当昂贵的. 用于测试.评测和抛弃想法的系统也是极其重要的,因为要是没有它,整个开发组将耗费越来越多的精力,还有用来帮助他们执行得更有