Java中数据类型转换&基本类型变量和对象型变量

1.Java的数据类型分为三大类

　　布尔型，字符型和数值型

　　　　其中数值型又分为整型和浮点型

2.Java的变量类型

　　布尔型 boolean

　　字符型 char

　　整型    byte，short，int，long

　　浮点型 float，double

3.数据类型转换

　　Java中数据类型转换分为三种，简单数据类型转换，字符串与其他类型转换，其他实用数据类型转换

　　（1）简单数据类型转换

　　　　在Java中，整型，实型，字符型被视为简单数据类型。

　　　　这些类型级别从低到高：（byte，short，char）-> int -> long -> float -> double

　　　　从低级变量到高级变量那是自动类型转换，从高级变量到低级变量那是强制类型转换，包装类过渡类型转换

　　（2）低级变量可以直接转换为高级变量

　　如：byte b;

　　　　int i=b;

　　　　float f=b;

　　　　如果低级类型为char型，向高级类型（整型）转换时，会转换成对应的ASCII码值

　　如：char c='c';

　　　　int i=c;

　　　　输出i的结果是：99

　　　　对于byte,short,char三种类型而言，它们是相同级别的，不能相互转换，可以使用强制类型转换

　　如：short i=99;

　　　　char c=(char)i;

　　　　输出c的结果是：c

　　（3）强制类型转换

　　　　int i=99;

　　　　byte b=(byte)i;

　　（4）包装类过渡类型转换

　　　　Java的包装类就是可以直接将简单类型的变量表示为一个类，Java共有6个包装类，分别是Boolean，Character，Integer，Long，Float，Double

　　　　包装类到底有什么作用？

　　　　在进行简单数据类型转换时，可以利用包装类进行中间过渡。一般情况下，首先声明一个变量，然后生成一个对应的包装类，就可以利用包装类的各种方法进行类型转换。

　　如：当希望把float型转换为double型

　　　　float f1=100.00f;

　　　　Float F1=new Float(f1);

　　　　Double d1=F1.doubleValue();

　　（5）字符串与其他数据类型的转换

　　　　几乎所有的java.lang.Object类派生的所有类都提供了toString()方法，就是可以将该类转换成字符串。

　　如：int f1=3.14f;

　　　　Float F1=new Float(f1);

　　　　String sf1=F1.toString();

栗子：给出以下代码,请给出结果.

class Two{
    Byte x;
}
class PassO{
    public static void main(String[] args){
        PassO p=new PassO();
        p.start();
    }
    void start(){
        Two t=new Two();
        System.out.print(t.x+””);
        Two t2=fix(t);
        System.out.print(t.x+” ” +t2.x);
    }
    Two fix(Two tt){
        tt.x=42;
        return tt;
    }
}

　　结果是：null,42,42

　　注意：x是包装类Byte，引用类型！不是基本类型byte。实例该类对象时，如果成员变量没有显示初始化那么Java默认初始化为null.

　　该题中引用类型t作为形参进行传递，形参的改变会改变实参的值，所以再次打印t.x时已经变为42了。

　　在java中，基本类型的初始化都为0，boolean初始化为false，类的初始化都为null。

　　本题中Two的属性x是Byte类型，是byte的包装类，是类，所以初始化后该属性的值为null，而非0。

　　本题中fix()方法的参数是引用传递而非值传递，对tt进行修改后，原参数对象的值也进行改动。

4.+能使类型提升

　　如:指出以下程序的错误之处：

　　　　short s=1;

　　　　s=s+1;

　　原因是，s+1为int，不能赋值给short。

栗子1：

　　boolean b=true?flase:true == true?false:true;

　　结果是：false

　　原因：（1）三目运算符是右结合性的，（2）==的优先级比 ? : 都高，所有要先算，

　　　　　　true?flase:((true == true)?false:true)

　　　　　　之后就是true?flase: (true ?false:true ) -->flase?false:false --> false

栗子2：

　　　int a=5;

　　　System.out.println("value is"+((a<5)?10.9:9));

　　结果是：9.0

　　原因：Java会根据运算符的精度类型进行自动类型转换。由于前面一个是10.9，那么后面的9就会自动变成9.0

栗子3：（重要）

　　布尔逻辑与（&）和逻辑与（&&），布尔逻辑或（|）和逻辑或（||）的区别

　　特点：凡是&&前面是false，那么&&后面的表达式就不用再做了。||前面的是true,||后面的就不用再做了。

　　　　　但是无论运算符&、| 前面的是true，还是false，运算符后面的表达式都的继续进行运算。

　　如：int m=n=5;

　　　　if((m!=5)&&(n++=5)){}

　　　　System.out.println(n);//结果是5，因为&&前面的是false，&&后面的就不用做了

　　　　int m=n=5;

　　　　if((m!=5)&(n++=5)){}

　　　　System.out.println(n);//结果是6

　　　　int m=n=5;

　　　　if((m==5)||(n++=5)){}

　　　　System.out.println(n);//结果是5，因为||前面是true，后面的就不用做了

　　　　int m=n=5;

　　　　if((m==5)|(n++=5)){}

　　　　System.out.println(n);//结果是6

5.传值与传引用

　不管Java参数的类型是什么，一律传递参数的副本。如果是传值，那么传递的是值的副本；如果Java是传引用，那么传递的是引用的副本。

　　（1）对于基本类型变量而言，传值就是把自己复制一份传递，即使自己的副本变了，自己也不变。

　　（2）对于对象类型而言，它传递的引用副本指向自己的地址，而不是自己实际值的副本。

　　　　为什么要这么做呢？

　　　　因为对象类型是放在堆里的，一方面，速度相对于基本类型比较慢，另一方面，对象类型本身比较大，如果采用重新复制对象值的办法，浪费内存且速度慢。

　　（3）String类型也是对象型变量，所以它必然传引用副本。

　　Java中的引用到底是什么？

　　Person person=new Person("张三");

　　这个person就是一个引用，是引用变量，保存了它所指向的对象的在堆中的地址。它是存在栈中的，指向新创建的Person对象。

栗子1：

public class Test{
        public static void test (StringBuffer str){
                   str.append(",world!");
   }
                public static void main(String[] args){
                    StringBuffer string =new StringBuffer("Hello");
                    test(string);
                    System.out.println(string);
   }
}

　　运行结果是：Hello,World!

　　这里的string是一个引用，Java对于引用形式传递对象类型的变量时，实际上是将引用作为一个副本传进方法函数的。那么这个函数里面的引用副本所指向的是什么?是对象的地址。

　　通过引用副本（复制的钥匙）找到地址（仓库）并修改地址中的值，也就修改了对象。（但是这样的引用副本有时效性，函数结束，钥匙销毁。）可以理解为，张三拿一把复制的钥匙，进了仓库，在仓库改变了很多东西，那李四拿着另外一把钥匙打开这个仓库，这个仓库还是那个仓库，里面的东西肯定改变了。

栗子2：

public class Test{
        public static void test (String str){
                   str="world";
   }
                public static void main(String[] args){
                    String string ="Hello";
                    test(string);
                    System.out.println(string);
   }
}

　　运行结果是：Hello

　　str="world";隐含着让Java生成一个新的String对象。当执行str="world";时，其过程为：首先系统会自动生成一个新String对象，并把这个新对象的值设为"world"，然后把这个引用赋给str（可以理解为str这把钥匙原来指向"Hello"这个仓库，但是现在要求str这把钥匙重新指向"world"这个仓库。），所以既然对象是新的，那就与原来的"Hello"没有任何关系。当函数结束，str作用消失，原来得内存地址上的内容并未改变。仍然是"Hello"。

栗子3：下列 java 程序输出结果为______。

int i=0;
Integer j = new Integer(0);
System.out.println(i==j);
System.out.println(j.equals(i));

true,true
解释：
==如果是primitive主类型，那么比较值；如果是对象，那么比较引用地址

　equals需要根据具体对象的实现来判断，在Integer里面是判断值是否相等

　i==j ，这个是基本类型与 Integer 的比较， j 会自动拆箱成 int 类型，然后比较的是值。因此返回真。

j.equals(i) ，调用 equals 方法后，这个 i 会自动装箱成 Integer 类型，然后再比较值，所以也返回真。