【Java程序员必知必会的90个细节】1，java算法百度网盘

它只有单个参数，返回该类型的一个相对应的实例。

Date date = Date.from(instant);

2、of，聚合方法

带有多个参数，返回该类型的一个实例，把它们合并起来。

Set faceCards = EnumSet.of(JACK,QUEEN,KING);

3、valueOf

比from和of更繁琐的一种替代方法。

BigInteger prime = BigInteger.valueOf(Integer.MAX_VALUE);

4、instance或者getInstance，返回的实例是通过方法的参数来描述的。

StackWalker luke = StackWalker.getInstance(options);

5、create或者newInstance，和instance和getInstance一样，但create和newInstance能够确保每次调用都返回一个新的实例。

Object newArray = Array.newInstance(classObject,arrayLen);

6、getType，像getInstance一样，但是在工厂方法处于不同类中的时候使用。Type表示工厂方法所返回的对象类型。

FileStore fs = Files.getFileStore(path);

7、newType，像newInstance一样。

8、type，getType和newType的简版

四、总结

---

简而言之，静态工厂方法和共有构造器都各有好处，我们需要理解它们各自的长处。

静态工厂方法更加合适，因此切忌第一反应就是提供公有的构造器，而不考虑静态工厂。

第2条：遇到多个构造器参数时要考虑使用构建器

======================

静态工厂和构造器有个共同的局限性：它们都不能很好地扩展到大量的可选参数。

1、重叠构造器

---

重叠构造器可行，但是当许多参数的时候，客户端代码会很难编写并且难以阅读。

2、JavaBeans模式

---

先调用无参构造器来创建对象，然后调用setter方法来设置每个必要的参数。

JavaBeans模式是我常用的方式，但是JavaBeans也有着很严重的缺点。因为构造过程被分到了几个调用中，在构造过程中JavaBean可能处于不一致的状态。类无法通过检验构造器参数的有效性来保证一致性。

3、建造者模式（并非设计模式中的建造者模式）

---

幸运的是，还有第三种替代方法。它既能像重叠构造器模式的安全性，又能保证像JavaBeans模式那样的可读性。这就是建造者模式。

package com.guor.effective.chapter2.worker;

public class Worker {

private int id;

private String name;

private int age;

private int sex;

private String school;

private String address;

public static class Builder{

private int id;

private String name;

private int age = 18;

private int sex = 1;

private String school = “辽宁石油化工大学”;

private String address = “辽宁省大连市高新园区”;

public Builder(int id, String name) {

this.id = id;

this.name = name;

}

public Builder age(int val){

age = val;

return this;

}

public Builder sex(int val){

sex = val;

return this;

}

public Builder school(String val){

school = val;

return this;

}

public Builder address(String val){

address = val;

return this;

}

public Worker build() {

return new Worker(this);

}

}

public Worker(Builder builder){

int id = builder.id;

String name = builder.name;

int age = builder.age;

int sex = builder.sex;

String school = builder.school;

String address = builder.address;

}

@Override

public String toString() {

return “Worker{” +

“id=” + id +

“, name=’” + name + ‘’’ +

“, age=” + age +

“, sex=” + sex +

“, school=’” + school + ‘’’ +

“, address=’” + address + ‘’’ +

‘}’;

}

}

package com.guor.effective.chapter2.worker;

public class Test {

public static void main(String[] args) {

Worker worker = new Worker

.Builder(1,“郭晓彤”).age(1).sex(1).school(“中铁诺德幼儿园”)

.address(“中铁诺德滨海花园”).build();

System.out.println(worker.toString());

}

}

第3条：用私有构造器或者枚举类型强化Singleton属性

=============================

第4条：通过私有构造器强化不可实例化的能力

======================

package com.guor.effective.chapter2.test;

public class Test2 {

private Test2(){

System.out.println(“我是一个私有构造器”);

}

public static void constructor() {

System.out.println(“我是一个工具类”);

}

}

第5条：优先考虑依赖注入来引用资源

=================

第6条：避免创建不必要的对象

==============

1、自动装箱

---

创建多余对象的方法，有一种叫自动装箱，它允许程序员将基本类型和封装类型混用，按需要自动装箱和拆箱。自动装箱使得基本类型和装箱基本类型之间的差别变得模糊起来，但是并没有完全消除，它们在语义上还有着微妙的差别，在性能上也有着明显的差别。

举例说明，计算所有int正整数值的总和。

（1）基本类型性能测试

package com.guor.effective.chapter2.test;

public class getIntSum {

public static void main(String[] args) {

long a= System.currentTimeMillis();//获取当前系统时间(毫秒)

long sum = 0;

for (int i = 0; i < Integer.MAX_VALUE; i++) {

sum += i;

}

System.out.println(“int正整数之和：”+sum);

System.out.println(“程序执行时间为：”+(System.currentTimeMillis()-a)+“毫秒”);

}

}

（2）封装类型性能测试

Long比long时间差的还是挺悬殊的。要优先使用基本类型，而不是封装类型，要当心无意识的自动装箱。

2、创建有意义的小对象

---

不要错误的认为此条所介绍内容暗示着“创建对象的代价非常昂贵，我们应该尽可能的创建对象”。相反，由于小对象的构造器只做少量的显示工作，所以小对象的创建和回收工作是非常廉价的，特别是在现代的JVM实现上更是如此。通过创建附加的对象提升程序的清晰性、简洁性、功能性，这通常是件好事。反之，通过维护自己的对象池来避免创建对象，并不是一种好的做法，除非池中的对象是非常重量级的，正确使用对象池的典型示例就是数据库连接池。建立数据库连接的代价是非常昂贵的，因此重用这些对象非常有意义。一般而言，维护自己的对象池，一般会将代码变得很乱，同时增加内存占用，而且还会损害性能。现代的JVM实现具有高度优化的垃圾回收器，其性能很容易就会超过轻量级对象池的性能。

第7条：消除过期的对象引用

=============

1、自己管理内存

---

只要类时自己管理内存，程序员就应该警惕内存泄漏问题。一旦元素被释放，该元素中包含的任何对象引用都应该被清空。

2、内存泄漏的另一种常见来源是缓存。

---

一旦把对象放到缓存中，就有可能被遗忘，长时间留在缓存中。对于这个问题，可以使用WeakHashMap代表缓存，当缓存中的项过期之后，它们就会自动被删除。记住只有当所要的缓存项的生命周期是由该键的外部引用而不是由值决定时，WeakHashMap才有用处。

3、内存泄漏的第三种来源是监听器和其它回调

---

如果你实现一个API，客户端在这个API中注册回调，却没有显示地取消注册，那么除非你采取某些动作，否则它们就会不断地堆积起来。确保回调立即被当做垃圾回收的最佳方法是只保存它们的弱引用，例如，只讲它们保存成WeakHashMap中的键。

由于内存泄漏不会表现成

《一线大厂Java面试题解析+后端开发学习笔记+最新架构讲解视频+实战项目源码讲义》

【docs.qq.com/doc/DSmxTbFJ1cmN1R2dB】 完整内容开源分享

明显的失败，所以它们可以在一个系统中存在很多年。往往通过仔细检查代码，或者借助于Heap剖析工具（Heap Profiler）才能发现内存泄漏问题。因此，如果能够在内存泄漏发生之前就知道如何预测此类问题，并阻止它们发生，那是最好不过的了。

第8条：避免使用终结方法和消除方法

=================