Java学习笔记-《Java程序员面试宝典》-第四章基础知识-4.4基本类型与运算(4.4.2-4.4.4)

4.4.2什么是不可变类

不可变类(immutable class)是指当创建了这个类的实例后，就不允许修改它的值了，也就是说，一个对象一旦被创建出来，在整个声明周期中，它的成员变量就不能被修改了。他有点类似于常量，只允许别的程序读，不允许别的程序进行修改。
**在java类库中，所有基本类型的包装类都是不可变类。**例如Integer、Float等。此外，String也是不可变类。但是，我们也可以通过如下代码对String类型的对象做出修改：

public class Test{
    public static void main(String[] args)
    {
        String s = "Hello";
        s+=" World";
        System.out.println(s);
    }
}


程序运行结果为：
Hello World

表面上看，好像是修改了String类型对象s的值。其实不是，String s = “Hello”语句声明了一个可以指向String类型对象的引用，这个引用的名字为s。它指向了一个字符串常量“Hello”。s += ” World”并没有改变s所指向的对象(由于“Hello”是String类型的对象，而String又是不可变量)，这句代码运行后，s指向了另外一个String类型的对象，该对象的内容为”Hello World”。原来的那个字符串常量“Hello”还存在于内存中，并没有被改变。
在介绍完不可变类的基本概念后，下面主要介绍如何创建一个不可变类。通常来讲，需要遵循下面四条原则：
1>类中所有成员变量被private所修饰
2>类中没有写或者修改成员变量的方法，例如setxxx，只提供构造函数，一次生成，永不改变
3>确保类中的所有方法不会被子类覆盖，可以通过把类定义为final或者把类中的方法定义为final来达到这个目的
4>如果一个类成员不是不可变量，那么在成员初始化或者使用get方法来获取该成员变量时，需要通过clone方法来确保类的不可变性，即返回与该成员变量完全一样的另一个变量，那么对原来的那个类成员的修改是不会对新建的类生效的
如果有必要，可使用覆盖Object类的equals()方法个hashCode()方法。在equals()方法中，根据对象的属性值来比较两个对象是否相等，并且保证用equals()方法判断为相等的两个对象的hashCode()方法的返回值也相等，这可以保证这些对象能被正确的放到HashMap或HashSet集合中。
除此之外，还有一些小的注意事项：由于类的不可变性，在创建对象时就需要初始化所有成员变量，因此最好提供一个带参数的构造函数来初始化这些成员变量。
首先给出一个错误的实现方法：

import java.util.Date;

class ImmutableClass{
    private Date d;

    public ImmutableClass(Date d)
    {
        this.d = d;
    }

    public void printState()
    {
        System.out.println(d);
    }

}

public class TestImmutable {

    @SuppressWarnings("deprecation")
    public static void main(String[] args){

        Date d = new Date();
        ImmutableClass im = new ImmutableClass(d);
        im.printState();

        d.setMonth(4);
        im.printState();
    }

}

运行结果：
Sun Jun 18 11:14:16 CST 2017
Thu May 18 11:14:16 CST 2017

由于这里的Date对象的状态是可以被改变的，而ImmutableClass保存了Date类型对象的引用，当被引用的对象的状态改变时会导致Immutable对象状态的改变。
正确的实现方法如下所示：

import java.util.Date;

class ImmutableClass{
    private Date d;

    public ImmutableClass(Date d)
    {
        this.d = (Date) d.clone();//解除与传入参数的绑定
    }

    public void printState()
    {
        System.out.println(d);
    }

}

public class TestImmutable {

    @SuppressWarnings("deprecation")
    public static void main(String[] args){

        Date d = new Date();
        ImmutableClass im = new ImmutableClass(d);
        im.printState();

        d.setMonth(4);
        im.printState();
    }

}

运行结果：
Sun Jun 18 11:25:14 CST 2017
Sun Jun 18 11:25:14 CST 2017

java语言中之所以设计有很多不可变类，主要是不可变类具有使用简单、线程安全、节省内存等优点，但是不可变类也有缺点，例如，不可变类的对象会因为值得不同而产生新的对象，从而导致无法预料的问题。

4.4.3值传递与引用传递有哪些区别

Java语言提供了两种参数传递的方式：值传递和引用传递。
1>值传递
在方法调用中，实参会把它的值传递给形参，形参只是用实参的值初始化一个临时的存储单元，因此形参与实参虽然有着相同的值，但是却有着不同的存储单元，因此对形参的改变不会影响实参的值。
2>引用传递
在方法调用中，传递的是对象(也可以看作是对象的地址)，这时形参与实参的对象指向同一块存储单元，因此对形参的修改就会影响实参的值。
在Java语言中，原始数据类型在传递参数时都是按值传递，而其他所有类型在传递参数时是按引用传递。
下面一个例子介绍值传递和按引用传递的区别：

public class Test {

    public static void testPassParameter(StringBuffer ss1,int n)
    {
        ss1.append(" World"); //引用
        n = 8;                //值
    }

    public static void main(String[] args)
    {
        int i=1;
        StringBuffer s1 = new StringBuffer("Hello");
        testPassParameter(s1, i);
        System.out.println(s1);
        System.out.println(i);
    }
}

运行结果：
Hello World
1

按引用传递其实与传递指针类似，是把对象的地址作为参数的。
再看下面一个例子：

public class Test {


    public static void changeStringBuffer(StringBuffer ss1,StringBuffer ss2)
    {
        ss1.append(" World");
        ss2 = ss1;
    }

    public static void main(String[] args)
    {
        Integer a = 1;
        Integer b = a;
        b++;
        System.out.println(a);
        System.out.println(b);

        StringBuffer s1 = new StringBuffer("Hello");
        StringBuffer s2 = new StringBuffer("Hello");
        changeStringBuffer(s1,s2);
        System.out.println(s1);
        System.out.println(s2);
    }
}

运行结果：
1
2
Hello World
Hello

在这里首先对两个Integer进行分析。这里的Integer赋值时的传值其实是按引用传递的，不是按值传递。但是为什么b的值修改了，而a的值还是没变呢。这是因为Integer是不可变类，没有提供修改它值的方法。那么在执行完b++这句代码时，程序会新建一个值为2的Integer赋值给b，所以这里b的引用就改变了，a的引用还是没变，还是指向1，因为此时a、b已经没有任何关系了。
下面是两个StringBuffer类的分析。在changeStringBuffer中，首先对传入的ss1做出改变，因为ss1是与main()中的s1指向了同一地址，所以对ss1引用指向的值做出改变，也就是对s1指向的地址的内容做出改变。然后是ss2做赋值操作，因为ss2在传入的时候与s2存放的地址是相同的，这时候再进行赋值为ss1，那么这时候ss2指向的就是ss1指向的内容，与s2没有任何关系了，那么就是从头到尾对s2存放的内容没有做出修改，那么s2的内容也就不会做出改变了。

4.4.4不同数据类型的转换有哪些规则

java中，存在两个变量的数据类型不同时，就需要进行隐式的数据类型转换，转换的规则为：从低精度到高精度转换，即满足：byte

自动转换规则
**这里的操作数1指的是等号左边的值，操作数2是等号右边的值**
操作数1的类型         操作数2的类型                转换后的类型
long             byte,short,char,int                long
int              byte,short,char                    int
float            byte,short,char,int,long           float
double           byte,short,char,int,lng,float      double

当类型自动转换时需要注意一下几点：
1)char类型的数据转换为高级类型(如int,long等)，会转换为其对应的ASCII码
2)byte,short，char类型的数据在参与运算时会自动转换为int类型，但当使用“+=”运算时，就不会产生类型转换
3）基本数据类型与boolean类型是不能互相转换的
总之，当多种类型的数据混合运算时，系统会优先将所有数据转换为容量最大的那种数据类型，再进行计算。
2>强制类型转换
当需要从高级数据类型转换为低级数据类型时，就需要用到强制类型转换了。

强制类型转换的规则
原操作数的类型                转换后操作数的类型
byte                            char
short                           byte,char
char                            byte,char
int                             byte,char,short
long                            byte,char,short,int
float                           byte,char,short,int,long
double                          byte,char,short,int,long,float

在强制类型转换的时候，可能会损失精度。
如下代码所示：

short a=255;
byte b = (byte)a;

运行结果:
a = 255
b = -1

因为a是short类型，占两个字节，那么a在内存中的内容就是00000000 11111111， 由于byte只占一个字节，所以 short强制转换为byte的时候，就需要低位开始截取一个字节，也就是：11111111，所以b=-1。