数值类型的注意问题（代码形式）

public class HelloWord{
 
 public static void main(String[] args){
 System.out.println("HelloWord");
 byte a =36;
 /*
 系统不会把一个超过int型整数范围的数当做long类型处理，即使没有超过int型也不会自动当做long型，而是int型数字；
 */
 //long bigValue = 9999999999999999999; //报错，超出int型范围。
 /*
 要在整数后面添加L后缀
 */
 long bigValue2= 99999999999999L;
 long bigValue3=12;//不会报错，12当做int型，自动类型转换到long型
 
 
 /*
 只有浮点类型的数值才可以使用科学表示法。
 只有浮点数除以0才可以得到正负无穷大，因为java语言会自动把和浮点数运算的0（整数）当成0.0（浮点数）处理，
 如果一个整数值除以0，则会抛出一个异常。
 
 浮点类型默认是double类型，要把一个浮点数赋给float类型，需加f或F后缀。
 */
 double d=0.0;
 double b=12;
 double c=b/d;
 System.out.println(c);
 
 /*
 boolean的值自动转换为字符串
 */
 String str =true+"";
 String str2 =2+"";
 System.out.println(str);
 System.out.println(str2);
 
 /*
 通过基本类型对应的包装类可以把字符串转换成基本类型
 8种基本数据类型对应的包装类：
   boolean     Boolean
   byte           Byte
   short         Short
   int              Integer
   long           Long
   char          Character
   float           Float
   double      Double
   
 */
 String str3 = "12";
 int istr3 =Integer.parseInt(str3);
 System.out.println(istr3);
 
 /*
 表达式类型的自动提升
 byte short char 将被提升到int型
 整个算术过程中，自动提升到表达式中最高等级的类型。
 */
 short s1 = 6;
 //s1= s1-3;//s1自动提升到int型，运算完后将一个int型赋给short型变量将发生错误。
 s1-=2;     //底层的运行机制不一样。推荐使用这种，程序更健壮。
 System.out.println(s1);
 
 
 /*
    (/)除法运算时，两个运算数都是整数类型和有一个或两个浮点数的运算规则不一样。
    (%)求余运算，浮点求余时，除于0会得到NaN（非数）
 */
 double d2=112;
 int    i2=0;
 //d2=d2%0;   //得到NaN
 d2= 0%d2;    //得到0.0
 System.out.println(d2);
 
 /*
 左移相当于乘以2的N次方
 右移相当于除以2的N次方
 */
 int i3= 2;
 i3<<=3;   //得到16--->2*2的3次方=16
 System.out.println(i3);
 
  
 /*
 ==     比较的两个操作数都是数值型，即使它们的数据类型不相同，只要它们的值相等，都返回true；
          比较的两个操作数都是引用类型，只有引用相同类的实例时才可以比较，而且，只有指向同一个对象才会返回true；
 !=      类似== 
 
 */
 System.out.println((5.0==5));//true
 System.out.println((new String()==new String()));//false
 Integer i=new Integer(5);
 System.out.println(i>6);//false  包装类的i虽然是引用类型，但可以与数值型的值进行比较，直接取出包装类实例
       //所包装的数值来进行比较的
 System.out.println((new Integer(2)==new Integer(2)));//false
 
 
 /*
 Integer:系统把-128~127的Integer实例放入一个cache的数组缓存起来。
 String：也会对通过直接量直接赋值的String实例进行缓存。
 */
 Integer ina=2;
 Integer inb=2;//其实ina inb都是引用cache数组中的同一个cache[X]引用。
 System.out.println(ina==inb);//true
 
 Integer inc=128;
 Integer ind=128;//超出了系统缓存-128~127的范围，需要新建一个实例。两个实例引用不同
 System.out.println(inc==ind);//false
 
 String sa="a";
 String sb="a";//系统会进行缓存，相同引用。
 System.out.println(sa==sb);//true
 
 String sc=new String("a");
 String sd=new String("a");//新建实例，引用不同
 System.out.println(sc==sd);//false
 
 
 /*
 实际的数组元素被存储在堆（heap）内存中；数组引用变量是一个引用类型的变量，被存储在栈（stack）内存中。
 定义并初始化一个数组后，在内存里分配了两个空间，一个（stack）用于存放数组的引用变量，另一个（heap）
 用于存放数组本身。
 
 方法及方法内的变量存放在stack中，对象存放在heap中。
 */
 
 int[] iarr;   //定义一个int[]类型的数组变量
 iarr=new int[5];//动态初始化数组，数组长度为5
 for(int i=0;i<iarr.length;i++){//循环赋值
  iarr[i]=i+10;
  }
  
  
 
 }

}