不可变对象是指一个对象的状态在对象被创建之后就不再变化。不可变对象对于缓存是非常好的选择，因为你不需要担心它的值会被更改。

创建一个不可变类：

将类声明为final，所以它不能被继承；

将所有的成员声明为私有的，这样就不允许直接访问这些成员；

对变量不要提供setter方法；

将所有可变的成员声明为final，这样只能对它们赋值一次；

通过构造器初始化所有成员，进行深拷贝（deep copy）；

在getter方法中，不要直接返回对象本身，而是克隆对象，并返回对象的拷贝；

示例：

public final class Immutable {  

    private final int id  

    private final String name  

    private final HashMap map  

   

    public int getId() {  

        return id  

    }  

   

    public String getName() {  

        return name  

    }  

   

    /** 

     * 可变对象的访问方法 

     */  

    public HashMap getMap() {  

        return (HashMap) testMap.clone()  

    }  

   

    /** 

     * 实现深拷贝的构造器*/  

    public Immutable(int i, String n, HashMap hm){this.id=i  

        this.name=n  

        HashMap tempMap=new HashMap()  

        String key  

        Iterator it = hm.keySet().iterator()  

        while(it.hasNext()){  

            key=it.next()  

            tempMap.put(key, hm.get(key))  

        }  

        this.map = tempMap  

    }  

  

}

不变模式有两种形式：弱不变模式和强不变模式。

弱不变模式，指类实例的状态是不可改变，但是这个类的子类的实例具有可能会变化的状态，要实现弱不变模式，一个类必须满足下面条件：

对象没有任何会修改对象状态的方法 ，这样一来当对象的构造函数将对象的状态初始化之后，对象的状态便不再改变；

属性都是私有的，以防客户端对象直接修改内部状态；

这个对象所引用的其他对象如果是可变的话，必须设法限制外界对这些可变对象的访问，以防止外界修改这些对象，尽量在不可变对象内部初始化这些被引用的对象，而不要在客户端初始化再传入到不可变对象内部来，如果某个可变对象必须在客户端初始化，然后再传入到不变对象里的话，就应当考虑在不可变对象初始化的时候，将这个可变对象进行拷贝。

弱不变模式的缺点是，一个弱不变对象的子对象可能是可变的，这个可变的子对象可能可以修改父对象的状态，从而可能允许外界修改父对象的状态。

强不变模式：一个类的实例不会改变，同时它的子类的实例也具有不可变化的状态。一个类必须首先满足弱不变模式所要求的所有条件，并且还有满足下面条件之一：

类所有的方法都应当是final，这样这个类的子类不能够重写此类的方法；

此类本身就是final的，那么这个类就不可能会有子类，从而也就不可能有被子类修改的问题；

不变和只读的区别：当一个变量是只读时，变量的值不能直接改变，但是可以在其他变量发生改变的时候改变；比如生日是不变属性，而年龄是只读的，年龄会随着时间发生变化，生日则不会变化。（用final声明的变量是只读的）

不可变对象的好处：

不可变对象更容易构造，测试与使用；

真正不可变对象都是线程安全的；

不可变对象的使用没有副作用（没有保护性拷贝）；

对象变化的问题得到了避免；

不可变对象的失败都是原子性的；

不可变对象更容易缓存，且可以避免null引用；

不可变对象可以避免时间上的耦合；

String，StringBuffer，StringBuilder，都是final类，不允许被继承，在本质上都是字符数组，不同的是，String的长度是不可变的而后两者长度可变，在进行连接操作时，String每次返回一个新的String实例，而StringBuffer和StringBuilder的append方法直接返回this，所以当进行大量的字符串连接操作时，不推荐使用String，因为它会产生大量的中间String对象。

StringBuffer和StringBuilder的一个区别是，StringBuffer在append方法前增加了一个synchronized修饰符，以起到同步的作用，为此也降低了执行效率；若要在toString方法中使用循环，使用StringBuilder。

函数式编程（Functional Programming）是一种编程风格，它是相对于指令式编程风格而言的，常见的面向对象编程就是指令式编程风格。

指令式编程是面向计算机硬件的抽象，有变量（对应着存储单元），赋值语句（获取、存储指令），表达式（内存引用和算术运算）和控制语句（跳转语句）。

而函数式编程是面向数学的抽象，将计算描述为一种表达式求值。这里的函数实际就是数学中的函数，即自变量到因变量的映射。也就是说，一个函数的值仅决定于函数参数的值，不依赖其他状态。

函数式编程是一种抽象程度很高的编程范式，纯粹的函数式编程语言编写的函数没有变量，因此，任意一个函数，只要输入是确定的，输出就是确定的，这种纯函数我们称之为没有副作用。而允许使用变量的程序设计语言，由于函数内部的变量状态不确定，同样的输入，可能得到不同的输出，因此，这种函数是有副作用的。

在函数式语言当中，函数作为一等公民，可以在任何地方定义，在函数内或函数外，可以作为函数的参数或返回值，可以对函数进行组合，也可以将函数赋值给变量。严格意义上的函数式编程意味着不适用可变的变量，赋值，循环和其他命令式控制结构进行编程。

函数式编程风格带来的好处是：

函数式编程使用不可变对象作为变量，不会修改变量的值，而是返回一个新的值，如此这样，更容易理清头绪，使得单元测试和调试更加容易；

可以很自由地传递不可变对象，但对于可变对象来说，传递给其他代码之前，需要先建造一个以防万一的副本；

一旦不可变对象完成构造以后，就不会有线程因为并发访问而破坏对象内部状态，因为根本没有线程可以改变不可变对象的状态；

不可变对象让哈希表键值更安全，所以哈希表键要求必须是不可变对象，否则使用可变对象，如果对象状态发生变化，那么在哈希表中就找不到这个对象了；

具体到编程语言，Scala（静态语言）和Python（动态语言）都能比较的支持函数式编程风格，但是它们都不是纯函数式的，也就是说它们同时支持指令式风格和函数式风格。而Java基本是指令式风格，但自从Java8引入lambda表达式以后也开始部分支持函数式风格。函数式编程最典型的是诸如map, flatMap, reduce, filter等函数，它们的特点是支持某个函数作为上面这些函数的参数

class：java中class确切的表示为一个类object：java中object确切的表示为一个对象，也称为类的实例其实，如果一个类被设计成不可变的类，那么这个类的实例化对象也是不可变的。

不可变类：当你获得这个类的一个实例引用时，你不可以改变这个实例的内容。

那么，什么是不可变对象?一旦一个类的实例化对象被创建并初始化，那么它就不可以被改变。

我们可以调用访问器方法(getter)，复制对象，或者传递对象，但是不允许任何方法改变这个对象的状态。

包装类(e.g.Integer或Float)和String类是不可变类的代表。

访问器方法(accessormethod)：对成员变量做出访问的方法，e.g.getter()方法。

修改器方法(mutatormethod)：对成员变量做出修改的方法，e.g.setter()方法。

定义一个不可变类如果我们要自己创建一个不可变类，需要遵守下面的规则：将成员变量(field：在一些书中也翻译为域)声明成final并在构造器中初始化。

对于基本类型的成员变量，用final修饰，一旦它被初始化，就不能被改变了。

而对于引用类型的成员变量，不能够改变它的引用。

成员变量如果被声明称final，那么构建对象时，必须要初始化这样的域引用类型是可变的，我们需要采取一些措施来保证它的不可变性。

为什么?如果我们只是声明了一个final的可变引用类型，那么这个引用可以去引用外部的类，或者被其他外部类引用。

在这种情况下，我们要做到：1.这些方法不会改变这些可变对象中的内容2.不要将这些引用分享到外部供其他类使用，例如，如果对成员变量的引用是可以被其他类改变的，那么这些外部类就可以改变这个类中的内容。

3.如果必须要返回一个引用，那么就返回一个对象的深度拷贝，这样尽管返回的对象内容改变了，但也保存着原始的内容。

只提供访问器方法(i.e.getter方法)不提供修改器方法(i.e.setter方法)如果一定要改变这个对象的内容，那就创建一个新的不可变对象内容做相应的修改，返回修改后的对象的引用声明类是final的。

如果一个类可以被继承，那么它子类就可以重载它的方法，并且修改成员变量JavaAPI中不可变类的例子让我们来回顾一下String类，用它来理解上述的几个方面在String类实现中的体现：所有在Stirng类中成员变量都被声明成private，这些成员变量都在构造器中在构建对象时被初始化。

trimconcatsubstring都可以改变String的对象，为了保证String的不可变性，这些方法都返回的是一个改变相应内容后新的对象。

string类被声明称final，所以任何类都不能继承，重载它的方法。

自己实现一个不可变类接下来我们自己实现一个不可变类ImmutableCircle。

//ImmutableCircle.java//PointisamutableclassclassPoint{privateintxPos,yPospublicPoint(intx,inty){xPos=xyPos=y}publicStringtoString(){return"x="+xPos+",y="+yPos}intgetX(){returnxPos}intgetY(){returnyPos}}//ImmutableCircleisanimmutableclass_thestateofitsobjects//cannotbemodifiedoncetheobjectiscreatedpublicfinalclassImmutableCircle{privatefinalPointcenterprivatefinalintradiuspublicImmutableCircle(intx,inty,intr){center=newPoint(x,y)radius=r}publicStringtoString(){return"center:"+center+"andradius="+radius}publicintgetRadius(){returnradius}publicPointgetCenter(){//returnacopyoftheobjecttoavoid//thevalueofcenterchangedfromcodeoutsidetheclassreturnnewPoint(center.getX(),center.getY())}publicstaticvoidmain(String[]s){System.out.println(newImmutableCircle(10,10,20))}//othermembersareelided...}上面的程序运行之后，打印：center:x=10,y=10andradius=20上面的程序体现了不可变类的以下几点：·这个类被声明成final，不可以被继承，也不可以重载它的方法·这个类的成员变量都是final并且是私有的·因为成员变量center是一个引用类型，是可变的，所以在他的getter方法中，返回的是对point对象的拷贝设计一个不可变的类最关键的一点：要注意引用类型的成员变量，如果成员变量的类型是可变的引用类型，就必须要采取必要的措施来保护这个成员变量不会被修改不可变类不足的地方不可变对象同样也有不足的地方。

为了保证不可变性，不可变类中的方法会创建出一定量的对象的拷贝。

例如，在上面的代码中，每次调用getcenter方法都会新建并返回一个point对象的拷贝。

而假如我们只需要调用一次，返回一个point对象，就没必要费尽心神的去设计一个不可变类，仅仅只需要一个可变的immutablecircle类就可以了。

String类在很多应用场景中都会用到，如果我们调用String类中trim，concat，或者是在循环中调用substring方法，都会创建一个新的临时String对象。

同时，java也提供了Stringbuffer和Stringbuilder的可变类。

他们同String一样，但是却可以改变这个对象的内容。

所以，我们可以根据不同的场景使用String类或者Stringbuffer/Stringbuilder类。

总结,文章的最后还是那句话，要根据自己的实际需要，去设计代码，而不要过度设计。

---