java什么类是不可变类？java中,什么叫不可更改的类(immutable class)

大家好，如果您还对java什么类是不可变类不太了解，没有关系，今天就由本站为大家分享java什么类是不可变类的知识，包括java中,什么叫不可更改的类(immutable class)的问题都会给大家分析到，还望可以解决大家的问题，下面我们就开始吧！

java中,什么叫不可更改的类(immutable class)

从字面意思来理解就是不会发生变化的类，那么是什么不会发生变化呢，其实就是类的状态，也就是不变类的实例一旦被创建，其状态就不会发生变化，举个例子：如果人是一个class，那么我们中的每一个都是人这个类的具体的instance，如果人这个类只有一个状态就是生身父母，那么它就是一个不变类，因为每一个人在出生的那一刹那，生身父母就已经被设置了值，而且终生都不会发生变化。

不变类有什么好处呢？

1）不变类是线程安全的，由于不变类的状态在创建以后不再发生变化，所以它可以在线程之间共享，而不需要同步。

2）不变类的instance可以被reuse

创建类的实例需要耗费CPU的时间，当这个实例不再被引用时，将会被垃圾回收掉，这时候，又需要耗费CPU的时间。对于不变类而言，一个好处就是可以将常用的实例进行缓存，从而减少了对象的创建。举个例子，对于布尔型，最常用的便是true and false。JDK中的Boolean类就是一个不变类，并且对这两个实例进行了缓冲。

public final class Boolean implements java.io.Serializable{

/**

* The<code>Boolean</code> object corresponding to the primitive

* value<code>true</code>.

*/

public static final Boolean TRUE= new Boolean(true);

/**

* The<code>Boolean</code> object corresponding to the primitive

* value<code>false</code>.

*/

public static final Boolean FALSE= new Boolean(false);

//这个方法不会创建新的对象，而是重用已经创建好的instance

public static Boolean valueOf(boolean b){

return(b? TRUE: FALSE);

}

}

3）不变类的某些方法可以缓存计算的结果

hashCode这个方法来自于Object这个类，这个方法用来返回对象的hashCode,主要用于将对象放置到hashtable中时，来确定这个对象的存储位置。对于一个不变类的实例，它的hashCode也是不变的，所以就可以缓存这个计算的结果，来提高性能，避免不必要的运算，JDK中的String类就是一个例子。

public final class String{

/** Cache the hash code for the string*/

private int hash;// Default to 0

public int hashCode(){

int h= hash;

if(h== 0){

// compute the value

hash= h;// cache the value

}

return h;

}

}

在JDK中， String, the primitive wrapper classes, and BigInteger and BigDecimal都是不变类。

如果一个类是不变类，这个类是不是就不能有改变状态的方法呢？

答案当然是否定的，String是一个不变类，仍然有replace，replaceAll这样的方法，而String仍然是一个不变类，那是因为在这些改变状态的方法中，每次都是新创建一个String对象。

如果大家理解了不变类，那也就不难理解为什么在做String的concatenate时，应当用StringBuffer而不是用+的操作符。

如何正确使用String呢?

1）不要用new去创建String对象。

如果使用new去创建String，那么每次都会创建一个新对象。

public static void main(String[] args){

String A1="A";

String A2="A";// It won't create a new object

checkInstance(A1, A2);// Result: They are same instances

String B1= new String("A");// create a new object

String B2= new String("A");// creat a new object

checkInstance(B1, B2);// Result: They are different instances

}

private static void checkInstance(String a1, String a2){

if(a1== a2){

System.out.println("They are same instances");

} else{

System.out.println("They are different instances");

}

}

2）应当用StringBuffer来做连接操作

因为String是一个不变类，那么在做连接操作时，就会创建临时对象来保存中间的运算结果，而StringBuffer是一个mutable class,这样就不需要创建临时的对象来保存结果，从而提高了性能。

我抄来的自己也学到东西了，以前这个都没接触过的说。

java中一个类是不可变类的条件是什么求详细解答。

不可变类的唯一判断条件是：

“不可变类的实例在实例的整个生命周期中永远保持初始化的状态”

比如一个类里面有个属性是private List list，然后只提供了getList()方法，但是你还是可以通过getList().add(XXX)来修改list的内容。即是，它没有保持“初始化”状态，它是个可变类。

来自百度：

可变类和不可变类(Mutable and Immutable Objects)的初步定义：

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

不可变类：当你获得这个类的一个实例引用时，你不可以改变这个实例的内容。不可变类的实例一但创建，其内在成员变量的值就不能被修改。

如何创建一个自己的不可变类：

.所有成员都是private

.不提供对成员的改变方法，例如：setXXXX

.确保所有的方法不会被重载。手段有两种：使用final Class(强不可变类)，或者将所有类方法加上final(弱不可变类)。

.如果某一个类成员不是原始变量(primitive)或者不可变类，必须通过在成员初始化(in)或者get方法(out)时通过深度clone方法，来确保类的不可变。

Java如何创建不可变类

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

//Pointisamutableclass

classPoint{

privateintxPos,yPos;

publicPoint(intx,inty){

xPos=x;

yPos=y;

}

publicStringtoString(){

return"x="+xPos+",y="+yPos;

}

intgetX(){returnxPos;}

intgetY(){returnyPos;}

}

//ImmutableCircleisanimmutableclass_thestateofitsobjects

//cannotbemodifiedoncetheobjectiscreated

publicfinalclassImmutableCircle{

privatefinalPointcenter;

privatefinalintradius;

publicImmutableCircle(intx,inty,intr){

center=newPoint(x,y);

radius=r;

}

publicStringtoString(){

return"center:"+center+"andradius="+radius;

}

publicintgetRadius(){

returnradius;

}

publicPointgetCenter(){

//returnacopyoftheobjecttoavoid

//thevalueofcenterchangedfromcodeoutsidetheclass

returnnewPoint(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类。

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

如果你还想了解更多这方面的信息，记得收藏关注本站。