2020-09-12

常量：
1.用关键字final定义
final <data_type> var_name=var_value;
关键字final 表示这个关键字只能赋值一次
<data_type> 表示java语言的任意数据类型之一
var_name 表示常量名，要符合标识符命名规则，一般常量全部大写，用下划线分隔多个单词
var_value 表示常量值

数据类型：
1.数据类型的作用是什么？
程序当中有很多数据，每一个数据都是有相关类型的，不同数据类型的数据占用空间大小不同。
数据类型的作用是指导JVM在运行程序的时候给该数据分配多大的内存空间。

 2.java中的数据类型包括两种：

   * 基本数据类型

   * 引用数据类型【后面讲】
       - 类(class)
       - 接口(interface)
       - 数组(如int[])
       - 枚举(enum)
       - 注解(annotation)
       ....

 3.关于基本数据类型：
   
   * 基本数据类型包括四大类八小种：
       第一类：整数型
           byte,short,int,long
       第二类：浮点型
           float,double
       第三类：布尔型
           boolean
       第四类：字符型
           char

     4.字符串"abc"不属于基本数据类型，属于"引用数据类型"，字符属于基本数据类型：
   * 字符串使用双引号 "abc"
   * 字符使用单引号 'a'

 5.八种基本数据类型各自占用空间大小是多少？

   基本数据类型                  占用空间大小【单位： 字节】
   -----------------------------------------------------------
   byte                           1
   short                          2
   int                            4
   long                           8
   float                          4
   double                         8
   boolean                        1
   char                           2

 6.计算机在任何情况下都只能识别二进制。例如：101010101010101..............
 【现代计算机底层采用交流电的方式，接通和断开就是两种状态，计算机只识别1或0，其他不认识】

 7.什么是二进制？
   * 数据的一种表示形式。十进制表示满十进一原则。二进制表示满二进一原则。

   例如：十进制
      0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
   例如：二进制
      0 1 10 11 100 101 110 111 1000 1001 .....
      0 1  2  3   4   5   6   7    8    9
       
 8.字节（byte):
   1 Byte = 8 bit  【1个字节 = 8 个比特位】1个比特位表示一个二进制位：1/0
   1 KB = 1024 Byte
   1 MB = 1024 KB
   1 GB = 1024 MB
   1 TB = 1024 GB

   1 TB = 1024 * 1024 * 1024 * 1024 *8 bit

 9.整数型当中的byte类型，占用1个字节，所以byte类型的数据占用8个比特位。那么byte类型
 的取值范围是什么？
   * 关于java中的数字类型，数字都是有正负之分的，所以在数字的二进制当中有一个二进制位被称为"符号位".
   并且这个"符号位"在所有二进制的最左边，0表示正数，1表示负数。

   * byte类型最大值：01111111 
   【 
      00000000 00000000 00000000 10000000（二进制）128
             减去1结果是：
      00000000 00000000 00000001111111（二进制）127
    】

   * byte类型最大值：2的7次方 - 1，结果是：127

   * byte类型最小值：-128【位运算：具体的怎么用二进制表示，这个和原码，反码，补码有关】

   * byte类型取值范围：[-128 ~ 127]

   * byte类型可以表示256个不同的数字【256个不同的二进制】

 10.二进制和十进制之间的转换规则：
    * 二进制转换成十进制（0表示此位上没有，1则表示有）
    * 十进制转换成二进制（除2求余数，逆序输出）

 11.计算机只认识二进制，那么计算机是怎么表示现实世界当中的文字的呢？

   * 八种基本数据类型当中，byte,short,int,long,float,double,boolean这7种
   数据类型计算机在表示的时候比较容易，因为底层都是数字，十进制的数字和
   二进制之间存在一种固定的转换规则。

   * 但是八种基本数据类型当中char类型表示的是现实世界中的文字，文字和计算机
   二进制之间"默认"情况下是不存在任何转换关系的。

   * 为了让计算机可以表示现实世界当中的文字，我们需要进行人为的干涉，需要人
   负责提前制定好"文字"和"二进制"之间的对照关系。这种对照转换关系被称为：字符编码。

   * 计算机最初只支持英文，最先出现的字符编码是：ASCII码【采用一个字节编码】
          'a' --> 97   【01100001】
          'A' --> 65
      '0' --> 48
           0 int 和字符编码没有关系

      'a' --(按照ASCII解码）--> 01100001
      01100001 ---按照ASCII编码--> 'a'

      编码和解码的时候采用同一套字典/对照表，不会出现乱码。
      当解码和编码的时候采用的不是同一套对照表，会出现乱码问题。

   * 随着计算机的发展，后来出现了一种编码方式，是国际化标准组织ISO制定的，
   这种编码方式支持西欧语言，向上兼容ASCII码，仍然不支持中文。这种编码方式
   是：ISO-8859-1,又被称为latin-1

   * 随着计算机向亚洲发展，计算机开始支持中文，日文，韩文等国家文字，其中支持
   简体中文的编码方式：
       GB2312 < GBK < GB18030

   * 支持繁体中文： 大五码<big5>

   * 后来出现了一种编码方式统一了全球所有的文字，容量较大，这种编码方式叫做：unicode编码
   unicode编码方式有多种具体的实现：
      - UTF-8
      - UTF-16
      - UTF-32
      ...... 

   * java语言采用的是哪一种编码方式呢？
     - java语言源代码采用的是unicode编码方式，所以"标识符"可以用中文。

   * 现在在实际开发中，一般使用UTF-8编码方式较多。【统一编码方式】

 12.八种基本数据类型的取值范围：

   类型                         取值范围
   -----------------------------------------
   byte                         [-128 ~ 127]
   short                        [-32768 ~ 32767]
   int                          [-2147483648 ~ 2147483647]
   long
   float
   double
   boolean                      [true,false]
   char                         [0 ~ 65535]

   注意：short和char所表示的种类总数是一样的，只不过char可以表示更大的正数，因为char没有负数。

 13.成员变量没有手动赋值系统会默认赋值【局部变量不会】

    关于八种基本数据类型的默认值：

      数据类型              默认值
      ----------------------------------
      byte,short,int,long     0
      float,double            0.0
      boolean                 false 【在c语言当中，true是1，false是0】
      char                    \u0000

     八种基本数据类型的默认值是一切向0看齐

 14.以下java程序主要讲解的是数据类型之：char类型
      转义字符  \
          固定规律： 转义字符出现在特殊字符之前，会将特殊字符转换成普通字符。

      \n        换行符
      \t        制表符
      \'        普通的单引号
      \\        普通的反斜杠
      \"        普通的双引号

     * 依照目前所学知识，以下程序无法编译通过，因为显然是一个字符串，不能使用单引号括起来
       但是经过编译，发现编译通过了，这说明以下并不是一个字符串，而是"一个"字符
       这是一个"换行符"，属于char类型的数据
       反斜杠（下坡）在java语言当中具有转义功能。正斜杠（上坡）
       char c2 = '\n';

     * System.out.println()与System.out.print()区别：
         println输出之后换行，print表示输出，但是不换行

     * 制表符Tab：'\t'
           强调：制表符与空格不同，他们的ASCII码不一样，体现在键盘上两个不同的"按键"。

     * 反斜杠将后面的具备特殊含义单引号转义成不具备特殊含义的普通单引号字符，
       左边的单引号缺少了结束的单引号字符，编译报错。

       解释：第一个反斜杠具有转义功能，将后面的反斜杠转义为普通的反斜杠字符。第一个单引号和最后单引号配对儿。
       结论：在java当中两个反斜杠代表一个普遍的反斜杠字符
       char k = '\\';

     * java中不允许这样编写程序，编译报错
       char a = '';
       以下编译报错：第一个单引号和第二个单引号配对儿，最后的单引号找不到另一半儿！
       char a = ''';

       对的：char f = '"';
                 System.out.println("“Hello!”")
                 System.out.println("\"Hello!\"")

           错的：System.out.println(""Hello!"")* JDK中自带的bin目录中native2ascii.exe命令，可以将文字转换成unicode编码形式
       怎么使用这个命令：
                        在Dos命令窗口中命令行中输入native2ascii，回车，然后输入文字之后回车即可得到unicode编码
			char n = '\u4e2d';//'中'对应的unicode编码是 4e2d（十六进制）
			                    反斜杠u联合起来后面的一串数字是某个文字的unicode编码

     * 十进制：0 1 2 3 4 5 6 7 8 9 10 11 12 13....
       二进制：0 1 10 11 100 101...
       十六进制： 0 1 2 3 4 5 6 7 8 9 a b c d e f 10 11 12 13 14 15 16 17 18 1a 1b 1c 1d 1e 1f 20...
       八进制：0 1 2 3 4 5 6 7 10 11 12 13 14 15 16 17 20...

    一个中文占用2个字节，char类型正好是2个字节，所以java中的char类型变量可以存储一个中文字符。
    ab是字符串不能使用单引号括起来，编译错误。
    "a"是字符串类型，k变量是char类型，类型不兼容，编译错误，char k = "a"

 15.关于java语言当中的整数型：

     数据类型              占用空间大小         默认值       数据范围
     --------------------------------------------------------------------
     byte                      1                   0           [-128 ~ 127]
     short                     2                   0           [-32768 ~ 32767]
     int                       4                   0           [-2147483648 ~ 2147483647]
     long                      8                   0L

     * java语言当中的“整数型字面值”被默认当作int类型来处理。要让这个“整数型字面值”被当作
     long类型来处理的话，需要在“整数型字面值”后面添加l/L,建议用大写的L。

     * java语言当中的整数型字面值有三种表示法式：
       第一种方式：十进制【是一种缺省(没有0或0x开头)默认的方式】
       第二种方式：八进制【在编写八进制整数型字面值的时候需要以0开始】
       第三种方式：十六进制【在编写十六进制整数型字面值的时候需要以0x开始】

     * 123这个整数型字面值是int类型
       i变量在声明的时候也是int类型
       int类型的123赋值给int类型的变量i，不存在类型转换
       int i = 123;

     * 自动类型转换：456整数型字面值被当作int类型，占用4个字节
                      x变量在声明的时候是long类型，占用8个字节
                      int类型的字面值456赋值给long类型的变量x，存在类型转换
                      int类型转换成long类型
                      int类型是小容量
                      long类型是大容量
                      小容量可以自动转换成大容量，称为自动类型转换机制。

       编译错误：过大的整数：2147483648
           2147483648被当作int类型4个字节处理，但是这个字面值超出int类型范围
       long z = 2147483648;
       解决错误：
           2147483648字面值一上来就当作long类型来处理，在字面值后面添加L
           2147483648是8个字节的long类型
       z是long类型变量，以下程序不存在类型转换
       long z = 2147483648L; * 强制类型转换：大容量转换成小容量，需要进行强制类型转换
                      强制类型转换需要加“强制类型转换符”
		      加上强制类型转换符之后编译通过了，但是运行阶段可能损失精度。
		      所以强制类型转换谨慎使用，因为损失精度之后可能损失更严重

                          强转原理：
		               原始数据：00000000 00000000 00000000 00000000 00000000 00000000 00000000 01100100（以100为例）
			       强转之后的数据：00000000 00000000 00000000 01100100
			       将左边的二进制砍掉【所有的数据强转的时候都是这样完成的】
		      long x = 100L;
		      int y = (int)x;

                                   原始数据：00000000 00000000 00000000 00000000 10000000 00000000 00000000 00000000
		               强转之后的数据：10000000 00000000 00000000 00000000
                                   10000000 00000000 00000000 00000000目前存储在计算机内部，计算机存储数据都是采用补码的形式存储
			       将以上的补码转换到原码就是最终的结果
			       long k = 2147483648L;
			       int e = (int)k;
			       System.out.println(e);//损失精度严重，结果是负数【-2147483648】

			       分析以下程序是否可以编译通过？
			       依据目前所学内容，以下程序是无法编译通过的
			       理由：50是int类型的字面值，b是byte类型的变量，显然是大容量int转换成小容量byte
			       大容量转换成小容量是需要添加强制类型转换符的，以下程序没有添加强转符，所以编译报错。
			       但是，在实际编译的时候，以下代码编译通过了，这说明：在java语言当中，当一个整数型字面值
			       没有超出byte类型取值范围的话，该字面值可以直接赋值给byte类型的变量。
			       byte b = 50;（可以）

			       byte c = 127;（可以）

			       byte b1 = 128;（编译报错）

			       纠正错误，需要使用强制类型转换符，但是一定会损失精度
                                   原始数据：00000000 00000000 00000000 10000000 
			       强转之后的数据：10000000【这是存储在计算机内部的，这是一个补码，它的原码是什么？】
			       byte b1 = (byte)128;//-128
			       System.out.println(b1);

			       计算机二进制有三种表示方式：
			          原码
				  反码
				  补码
				计算机在任何情况下底层表示和存储数据的时候采用了补码形式。
				正数的补码：和原码相同
				负数的补码：负数的绝对值对应的二进制码所有二进制位取反（包括符号位），再加1

				补码：10000000
				原码计算过程：
				    * 10000000 - 1 --> 01111111
				    * 10000000 --> 128
				    * -128

				 原始数据：00000000 00000000 00000000 11000110
                                     强转之后的数据：11000110
                                     11000110现在在计算机当中存储，它是一个补码，将补码转换成原码就是该数字：
				 11000110 - 1 --> 11000101
				 00111010 [ 2 + 8 + 16 + 32] -->58
				 -58(为什么是负的，因为强转之后符号位是1)

	     当一个整数字面值没有超出byte,short,char的取值范围，这个字面值可以直接赋值给byte,short,char类型的变量。
	     这种机制SUN允许了，目的是为了方便程序员的编程。