【原】Java学习笔记003 - 数据类型

 package cn.temptation;

 public class Sample01 {
     public static void main(String[] args) {
         System.out.println("第一个例子");
     }
 }

 package cn.temptation;

 public class Sample02 {
     public static void main(String[] args) {
         // Java的基本数据类型
         // 分为四大类，共八种数据类型
         /*                        占用字节数
          * 1、整数类型
          * byte：    字节类型            1            -128~127
          * short：    短整型            2
          * int：        整型                4
          * long：    长整型            8
          *
          * 2、浮点数类型
          * float：    单精度类型        4
          * double：    双精度类型        8
          *
          * 3、字符类型
          * char：    字符类型            2
          *
          * 4、布尔类型
          * boolean：    布尔类型            1
          */

         // 变量：在程序执行过程中发生变化的量

         // 思考：为什么要使用变量？全部都使用常量行不行？
 //        System.out.println(123);
 //        System.out.println(123);
 //        System.out.println(123);

         // 现在要进行修改，不要显示123了，要显示456，那么需要把前面使用常量123的地方全部改为常量456
 //        System.out.println(456);
 //        System.out.println(456);
 //        System.out.println(456);

         // 注意：使用变量是一种思想：通过封装变化来达到拥抱变化的结果，即在变化时，只需要修改变量赋值的地方，不需要修改变量使用的地方
         // int i = 123;
         // 变化时，只要修改变量赋值的地方
         // int i = 456;

         // 把变量使用的地方 和 变量赋值的地方 分离开
 //        System.out.println(i);
 //        System.out.println(i);
 //        System.out.println(i);

         // 定义变量的格式：
         // 数据类型        变量名        =       初始化的值;

         byte i = 3;
         System.out.println(i);

         short j = 4;
         System.out.println(j);

         int k = 123;
         System.out.println(k);

         // Java中书写整型数字，不加说明，默认认为是int类型
         // The literal 12345678901 of type int is out of range
         // long m = 12345678901;
         // 要使用long类型，需要在数字后添加大写的L 或是 小写的l（因为小写的l和数字1容易混淆，所以使用大写的L）
         long m = 12345678901L;
         System.out.println(m);

         // Java中书写浮点书数字，不加说明，默认认为是double类型
         // Type mismatch: cannot convert from double to float
         // float x = 123.456;
         // 要使用float类型，需要在数字后添加大写的F 或是 小写的f（为了保持风格的一致，所以使用大写的F）
         float x = 123.456F;
         System.out.println(x);

         double y = 987.654;
         System.out.println(y);

         // 字符类型使用单引号把字符包含其中
         char z = 'a';
         System.out.println(z);

         // 布尔类型有两个特殊值：true 和 false
         boolean flag1 = true;
         boolean flag2 = false;
         System.out.println(flag1);
         System.out.println(flag2);
     }
 }

 package cn.temptation;

 public class Sample03 {
 //    int i = 123;

     public static void main(String[] args) {
         // 使用变量的注意事项：
         /*
          * 1、作用范围（作用域）：通过大括号来划定作用范围，变量不在该大括号内且没有其他的范围描述时，是无法使用的
          * 2、在同一作用域下，变量不能重复命名
          * 3、变量的初始化值：
          *         变量没有初始化就直接使用会语法出错
          *         要不在声明变量的时候就进行变量的初始化；要不就在使用的时候进行初始化
          */
 //        int i = 123;
         // 在主函数之外定义int类型的变量i，在主函数中（大括号）中无法访问到
         // Cannot make a static reference to the non-static field i
 //        System.out.println(i);

 //        int i = 3;
 //        System.out.println(i);
         // Duplicate local variable i
 //        int i = 4;
 //        System.out.println(i);

         // 只对变量进行声明但是不赋值
 //        int i;
         // 对只声明但是不赋值的变量直接使用
         // The local variable i may not have been initialized
 //        System.out.println(i);

         // 先做声明
 //        int i;
         // 在使用前进行赋值
 //        i = 5;
         // 再使用变量，这样没有语法问题
 //        System.out.println(i);

         // 声明变量时并对变量进行初始化赋值（初始化）
 //        int i = 2;

         // 如下写法语法没有问题，但是不建议这样写（可读性差）
 //        int i = 2; int j = 3;
 //        System.out.println(i);
 //        System.out.println(j);

         // 如下写法也可以，但是不推荐这样写
 //        int i = 2, j = 3;
 //        System.out.println(i);
 //        System.out.println(j);

         // 在一行语句中对多个变量进行声明是可以的，并且多个变量之间使用英文的逗号分隔开
         int i, j;
         // 在一行语句中对于声明好的多个变量进行赋值，不能使用英文的逗号分隔开进行赋值，而只能使用英文的分号分隔开进行赋值
         // Syntax error on token ",", ; expected
 //        i = 2, j = 3;
         i = 2; j = 3;
         // 上句等价于
         i = 2;
         j = 3;
         System.out.println(i);
         System.out.println(j);
     }
 }

 package cn.temptation;

 public class Sample04 {
     public static void main(String[] args) {
         // 两个int类型的变量做加法
 //        int i = 2;
 //        int j = 3;
 //        int result = i + j;
 //        System.out.println(result);

         // byte类型的变量 和 int类型的变量做加法
 //        byte i = 2;
 //        int j = 3;
 //        int result = i + j;
 //        System.out.println(result);

         // int类型的变量 和 int类型的变量做加法，得到的结果赋值给一个byte类型的变量
 //        int i = 2;
 //        int j = 3;
         // Type mismatch: cannot convert from int to byte
         // 赋值号右侧两个int类型的变量相加，得到的结果还是一个int类型的结果，把这个int类型的结果赋值给byte类型的变量，提示类型不匹配
 //        byte result = i + j;
 //        System.out.println(result);

         // byte类型的变量 和 int类型的变量做加法，得到的结果赋值给一个byte类型的变量
 //        byte i = 2;
 //        int j = 3;
         // Type mismatch: cannot convert from int to byte
         // 赋值号右侧byte类型的变量  和  int类型的变量相加，得到的结果还是一个int类型的结果（类型提升），把这个int类型的结果赋值给byte类型的变量，提示类型不匹配
 //        byte result = i + j;
 //        System.out.println(result);

         // 解决类型不匹配错误的方法：
         /*
          * 1、将结果的数据类型改为范围大的数据类型
          * 2、使用强制类型转换，注意可能会发生精度丢失的问题
          *         联想一下：小碗盛米，大锅里的米比较少的时候，倒入小碗中是没有问题的；大锅里的米比较多的时候，倒入小碗里就有问题了
          */

         // 强制类型转换的格式：(要转换为的数据类型)(被转换的数据内容);
         int i = 2;
         int j = 3;
         byte result = (byte)(i + j);
         System.out.println(result);
     }
 }

 package cn.temptation;

 public class Sample05 {
     public static void main(String[] args) {
         // 字面量常量整数不加说明，默认是int类型
 //        byte i = 127;
 //        System.out.println(i);

 //        byte i = (byte)127;
 //        System.out.println(i);

         // Type mismatch: cannot convert from int to byte
 //        byte j = 130;
 //        System.out.println(j);

         byte j = (byte)130;
         System.out.println(j);        // -126
     }
 }
 /*
  * 原码、反码 和 补码
  * 规则：
  * 1、正数的原码、反码和补码都相同
  * 2、负数的反码和原码符号位相同，其他位取反；负数的补码  = 负数的反码 + 1;
  * 3、计算机在进行运算时，使用的是补码，最终显示出来的是原码
  *
  * int类型的正整数130的原码：0000 0000 0000 0000 0000 0000 1000 0010
  * int类型的正整数130的反码：0000 0000 0000 0000 0000 0000 1000 0010
  * int类型的正整数130的补码：0000 0000 0000 0000 0000 0000 1000 0010
  *
  * 强制类型转换做了截取
  *
  * byte类型的           补码：1000 0010        最高位是符号位
  * byte类型的           反码：1000 0001
  * byte类型的           原码：1111 1110        -126
  */

 package cn.temptation;

 public class Sample06 {
     public static void main(String[] args) {
         double i = 123.45;
         System.out.println(i);

         // 在单精度浮点数后添加F 和 对单精度浮点书进行强制类型转换为float类型，效果一致
 //        float j = 987.65F;
         float j = (float) 987.65;
         System.out.println(j);
     }
 }

 package cn.temptation;

 public class Sample07 {
     public static void main(String[] args) {
         // 定义两个byte类型的变量
 //        byte i = 2;
 //        byte j = 3;

         // Type mismatch: cannot convert from int to byte
         // 使用加号进行加法计算时，对于比int类型范围小的数据类型进行了类型提升
 //        byte result = i + j;
 //        byte result = (byte) (i + j);
 //        System.out.println(result);

         // 第11行使用byte类型的变量相加提示语法错误，第16行使用int类型的字面量常量相加没有语法错误
         byte result = 2 + 3;

         // Type mismatch: cannot convert from int to byte
 //        byte result = 2 + 126;

         System.out.println(result);

         // 注意：
         // 变量相加，先看变量的数据类型是否有问题
         // 常量相加，先看结果是否在被赋值的变量的数据类型范围内
     }
 }

 package cn.temptation;

 public class Sample08 {
     public static void main(String[] args) {
         // char字符类型 和 整型存在转换的关系
         System.out.println('a');            // a

         char i = 'b';
         System.out.println(i);                // b

         // 把字符'c' 和 int类型的数字1做加法，加出来的结果赋值给char类型的变量j
         // 因为j的数据类型为char字符类型，所以输出的结果还是字符
         char j = 'c' + 1;
         System.out.println(j);                // d

         // 字符类型和int类型做加法，得到的结果是int类型
         System.out.println('c' + 1);        // 100

         // 字符类型和int类型做加法，得到的结果是int类型
         System.out.println('B' + 'e' + 'i' + 'J' + 'i' + 'n' + 'g' + 2008);        // 2672

         // 字符类型和字符类型做加法，得到的结果是int类型
         System.out.println('B' + 'e' + 'i' + 'J' + 'i' + 'n' + 'g');            // 664

         // 布尔类型不参与加法运算
         // The operator + is undefined for the argument type(s) boolean, int
 //        System.out.println(true + 1);

 //        boolean flag = false;
         // The operator + is undefined for the argument type(s) boolean, int
 //        System.out.println(flag + 1);
     }
 }