今天，我们学习Java的一些基础知识，循序渐进，让我们慢慢的发现Java的魅力！

目录

一、Java须知的命名规则和规范

        1.1 标识符

        1.2 命名规范 

二、关键字和保留字 

三、八大基本数据类型 

        3.1、byte 

        3.2、short

        3.3、int

        3.4、long 

         3.5、float/double

         3.6、boolean

         3.7、char

一、Java须知的命名规则和规范

        1.1 标识符

        标识符，通俗意义上讲，就是我们程序员自己定义的名称，例如类名，方法名，变量名等等。也可以这样理解，只要需要我们自己起名字的，就是标识符。

        当然，名字也不能随便取，Java定义了合法标识符的规则：

        1）由26个英文字母大小写，0-9，_或者$组成

        2）数字不可以开头

        3）不可以使用关键字和保留字，但是可以包含关键字和保留字

        4）Java中严格区分大小写，长度没有限制

        5）标识符不能包含空格

        1.2 命名规范 

        我们除了要遵守标识符的规则，还要知道Java中命名的规范，规范的意义就是你不按照这个方式来命名，程序也不会报错，可是会显得很不正规，标准。命名规范就是我们程序员都会默认遵守的一些Java命名“规则”，是一种共识。

        1）包名

        在多个单词组合时，所有字母全部都小写。

        例如：testhelloworld

        2）类名、接口名

         在多个单词组合时，所有字母的首字母大写。

        例如：TestHelloWorld        （又名：大驼峰命名法）

        3）变量名、方法名

         在多个单词组合时，第一个单词全小写，从第二个单词开始，后续单词全部首字母大写。

        例如：testHelloWorld        （又名：小驼峰命名法）

        4）常量名

        在多个单词组合时，所以字母都大写，每个单词之间使用 _（下划线）来进行连接。

        例如：TEST_HELLO_WORLD 

注意：起名字时，我们为了提高阅读性，尽量起的名字做到“见名知意”。 

二、关键字和保留字 

        通过上面的学习，我们知道标识符是不能直接使用关键字和保留字来进行命名的，可是关键字和保留字都有哪些呢？让我们继续往下看。

关键字：就是在Java中具有特殊意义的字符，有表示数据类型、权限修饰等等
保留字：可以理解为目前还没有被使用，但是随着版本的更新，有可能会被使用的预备关键字 

 以上就是目前Java中的所有关键字和保留字了，总共53个。其中goto、const为保留字，其余都是关键字。在之后的学习中，就让我们来一个一个的攻克这些关键字吧！

三、八大基本数据类型 

        从上图可以看出，基本的数据类型分成了三大类：数值型、字符型、布尔型。数值型又细分成了两类：整数型和浮点型。 

        在这里我们引入一个概念：bit（binary digit）。bit是表示数据的最小单位。只有两种表现形式：0,1，可也理解为每一个二进制数字就是1bit。

        一个字节(byte)为8个比特，一个英文字母通常占用一个字节，一个汉字通常占用两个字节。普通计算机系统能读取和定位到最小信息单位是字节(byte)。

    1 Byte（B）= 8 bit
    1 Kilo Byte（KB）= 1024 B
    1 Mega Byte（MB）= 1024 KB
    1 Giga Byte（GB）= 1024 MB
    1 Trillion Byte（TB）=1024 GB   

         关于基本数据类型，这里先放个表格，以供参考，下面为大家一一解释。

        3.1、byte 

        byte 数据类型是8位、有符号的，以二进制补码表示的整数。byte 类型用在大型数组中节约空间，主要代替整数，因为 byte 变量占用的空间只有 int 类型的四分之一。我们可以先看一段代码：

public class ByteTest {
    static byte b;  //声明byte类型的变量b
    public static void main(String[] args) {
        System.out.println("byte的大小：" + Byte.SIZE);
        System.out.println("byte的的默认值：" + b);
        System.out.println("byte的取值范围：[" + Byte.MIN_VALUE + "," + Byte.MAX_VALUE + "]");
    }
}

        运行结果如下：

 根据运行结果，我们可以得到三个结论：

        1）1 byte 在Java中的大小为 8 bit;

        2)  byte 在Java中的默认值为 0；

        3）byte在Java中 最大值为127，最小值为-128；

//定义byte数据类型
        byte x = 100;
        byte y = -50;

那我们再深入思考一下，为什么byte的取值范围会是[-128,127]，而不是[-128,128]呢？

首先，我们先了解一个运算规则：

        正数的最高位都是0，正数的值就是二进制表示的值。
        负数的最高位都是1，负数的值是取反后加1然后加个负号得到的值
我们简单的举个栗子理解一下：
        比如：0000 0001，这个二进制数字，最高位是0为正数，表示的是十进制中的1.

        再比如1000 0001，最高位是1为负数，取反后得到0111 1110，再加上1得到0111 1111，换算成10进制值前面再加上负号，就得到了-127. 

         回到byte，我们已经知道了byte是8位的二进制数，可以推断出byte的最大正整数就是0111 1111，也就是127.那么byte的最小负整数呢？

        根据计算规则，我们可以推断出最小的负整数是1000 0000，进行取反就是0111 1111，再加1可以得出1000 0000，然后换算成十进制后加上负号，可以得出是-128

 我们现在已经知道了byte的最大正整数是127，那么如果我们将127再加1，结果会怎么样呢？

public class ByteTest {
    public static void main(String[] args) {
        byte b = 127;
        b += 1;
        System.out.println("b = " + b);
    }
}

让我们看一下运行结果：

 我们发现，当byte b = 127 + 1;时，结果居然是-128，这是为什么？

  这里我们需要先了解一些概念。对于一个数，计算机要使用一定的编码方式进行存储，而这个存储具体数字的编码方式有三种：原码、反码、补码。

原码：原码就是二进制数的符号位加上真值的绝对值，二进制数的第一位表示符号，其余位表示值。

        如：[+1]原 = 0000 0001； [-1]原 = 1000 0001；

反码：反码分为两种：正数的反码还是它本身，而负数的反码是在其基础上，符号位不变，其余位置全部取反。

        如： [+1]原 = 0000 0001 ；[+1]反 = 0000 0001；

                [-1]原 = 1000 0001 ；[-1]反 = 1111 1110；

补码：补码分为两种：正数的补码还是它本身。负数的补码是在其反码的基础上，再加1。

         如：[+1]原 = 0000 0001 ；[+1]反 = 0000 0001 ；[+1]补 = 0000 0001；
                [-1]原 = 1000 0001 ；[-1]反 = 1111 1110 ；[-1]补 = 1111 1111；

注意：想要求一个补码的原码，就是对这个补码再次补码。

为什么要使用反码和补码呢？

        因为让计算机去辨别符号位，其电路设计将会变得非常复杂，为了简化运算，人们想到了一种让符号位也参与运算的运算方式，我们都知道，减去一个数等于加上这个数的负数， 所以机器可以只有加法而没有减法, 这样计算机运算的设计就更简单了。

例如：

        1 + （-1） = [0000 0001] 原+ [1000 0001]原 = [1000 0010]原 = -2

        这样结果是错误的，所以引入了反码的概念，加入反码后我们再看：

        1 + （-1） = [0000 0001] 原+ [1000 0001]原 =  [0000 0001] 反+ [1111 1110]反 = [1111 11111] 反 = [1000 0000]原 = -0.

        这里我们可以看到，运算结果是对了，可是多了+0，-0两个数字，是没有意义的。于是，又引入了补码的概念。

        1 + （-1） = [0000 0001] 原+ [1000 0001]原 =  [0000 0001] 反+ [1111 1110]反 = [0000 0001]补 +[1111 1111]补 = [0000 0000]补 = 0；

        这样，之前的问题就都不存在了。

        int类型的128原码为0000 0000 0000 0000 0000 0000 1000 0000，在 byte += 1；的时候，发生了强制类型转换，因为byte只有8为二进制数，所以这里就截取了128原码的后8位，即1000 0000，转换成10进制后就得到了-128.

        为了加深映像，我们可以再看一段代码：

public class ByteTest {
    public static void main(String[] args) {
        byte b = -128;
        b += -1;
        System.out.println("b = " + b);
    }
}

运行结果如下：

 经过上面的学习，相信这里我们已经不难理解了。

int类型的-129原码为1000 0000 0000 0000 0000 0000 1000 0001;

补码为1111 1111 1111 1111 1111 1111 0111 1111;

强制转换为byte类型，只取后8位为：0111 1111；转换为10进制就为127了。

大家可以去做更多的尝试，这里就不再演示了。

        3.2、short

short 数据类型是 16 位、有符号的以二进制补码表示的整数.short 数据类型也可以像 byte 那样节省空间。一个short变量是int型变量所占空间的二分之一。

还是先看一下代码：

public class ShortTest {
    static short s;
    public static void main(String[] args) {
    System.out.println("short的大小：" + Short.SIZE);
    System.out.println("short的的默认值：" + s);
    System.out.println("short的取值范围：[" + Short.MIN_VALUE + "," + Short.MAX_VALUE + "]");
    }
}

运行结果如下：

根据运行结果，我们可以得到三个结论：

        1）1 short 在Java中的大小为 16 bit;

        2)  short 在Java中的默认值为 0；

        3）short 在Java中 最大值为32767，最小值为-32768；

//定义short数据类型
        short s = 1000;
        short r = -20000;

        3.3、int

int 数据类型是32位、有符号的以二进制补码表示的整数。一般地整型变量默认为 int 类型。看以下代码：

public class IntTest {
    static int i;
    public static void main(String[] args) {
        System.out.println("int的大小：" + Integer.SIZE);
        System.out.println("int的的默认值：" + i);
        System.out.println("int的取值范围：[" + Integer.MIN_VALUE + "," + Integer.MAX_VALUE + "]");
    }
}

运行结果如下：

根据运行结果，我们可以得到三个结论：

        1）1 int 在Java中的大小为 32 bit，占用4个字节;

        2)  int 在Java中的默认值为 0；

        3）int 在Java中 最大值为2147483647，最小值为-2147483648；

//定义int数据类型
        int a = 100000;
        int b = -200000;

 首先我们先来明确一下Java虚拟机在对int型数据进行处理时默认的两条规则：

        1. 当程序出现“整型常量”的时候，默认都是以int型存储的

        2.如果算术表达式中出现的所有的数字都是int型的，默认运算结果也是int类型

注意：
    需要注意一点：在程序编辑过程中，编译器只对直接出现的int常量进行超范围检查，
    但是对于在编译中算数运算、表达式产生的int型值则不会进行范围检查；

 为了方便我们理解，简单举个栗子：
        当我们将long类型数据赋值为9999999999时，并没有超出long类型数据的取值范围，但是编译器还是会报错。

         这是因为当程序中出现“整型常量”的时候，默认都是以int类型存储的。而”9999999999“ 就是直接出现的”整型常量“，所以编译器会把他当作int型看待。即使它被赋值给了long类型。
        我们知道，编译器会对”直接出现“的int常量进行数据超范围的检查，所以这里编译器将直接出现的整形常量“9999999999”看待int类型，并且进行数据超范围的检查，而经过检查这个数字已经超过了int类型所表示的范围，所以就会报错。
        这种情况的解决方法也很简单，只需在赋值的“整数常量”后面加上“L”即可 

        这是编译器能帮助我们识别的情况，我们还需要注意一些编译器无法帮我们识别的时候：

/**
 * 计算一天时间有多少微秒
 * (1小时=60分钟)
 * (1分钟=60秒)
 * (1秒=1,000毫秒)
 * (1毫秒=1,000微秒)
 */
public class MicrosecondTest {
    public static void main(String[] args) {
        //计算出一天的微秒数，考虑到结果超出了int类型的取值范围，使用long类型接收
        long microsecond = 24 * 60 * 60 * 1000 * 1000;  //正确结果：86,4000,000,000
        System.out.println("microsecond = " + microsecond);
    }
}

运行结果如下：

        在上面的算式中，所有计算的整数常量都是int类型，所以每一步的运算结果都会被保存在一个int型的临时变量中，由因为计算出来的整数结果不是“直接出现的整数常量”，所以并不会对其进行范围检查。
        随着计算的进行，结果超过了int的取值范围，但是在没有进行范围检查的情况下，编译器还是将结果保留在了int类型的临时变量中，造成了一种“溢出”现像，和之前byte类型中说的情况一样，int类型取值时会将超出取值范围的高位部分舍弃，保留取值范围内的数字，最后得到了一个错误的结果。 

        想要解决这种情况，只需在计算结果超出int取值范围之前，将其转换成long类型即可。

/**
 * 计算一天时间有多少微秒
 * (1小时=60分钟)
 * (1分钟=60秒)
 * (1秒=1,000毫秒)
 * (1毫秒=1,000微秒)
 */
public class MicrosecondTest {
    public static void main(String[] args) {
        //计算出一天的微秒数，考虑到结果超出了int类型的取值范围，使用long类型接收
        long microsecond = 24L * 60 * 60 * 1000 * 1000;  //正确结果：86,4000,000,000
        System.out.println("microsecond = " + microsecond);
    }
}

运行结果如下：

        除此之外，还有一种情况：

public class IntTest {
    public static void main(String[] args) {
        //定义一个int类型中的最大值
        int a = 2147483647;
        try {
            //进行循环，根据代码，好像这个代码只能循环10次
            for (int i = a - 9; i <= a; i++) {
                //将i的值打印出来
                System.out.println(i);
                Thread.sleep(1000);//每循环一次等1秒钟
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

运行结果如下：

        从这个结果中，我们可以看出，看上去只能执行10次循环，可当 i 的值等于int类型的最大数时，再进行 i++运算，其结果就会变成 i = -2147483648。最终，形成一次死循环。        

        3.4、long 

long 数据类型是 64 位、有符号的以二进制补码表示的整数。这种类型主要使用在需要比较大整数的系统上。看以下代码：

public class LongTest {
    static long l;
    public static void main(String[] args) {
        System.out.println("long的大小：" + Long.SIZE);
        System.out.println("long的：默认值" + l);
        System.out.println("long的取值范围：[" + Long.MIN_VALUE + "," + Long.MAX_VALUE + "]");
    }
}

运行结果如下：

根据运行结果，我们可以得到三个结论：

        1）long 在Java中的大小为 64 bit，占用8个字节;

        2)  long 在Java中的默认值为 0；

        3）long 在Java中 最大值为9223372036854775807，最小值为-9223372036854775808；

//定义long数据类型
        long a = 100000L;
        long b = -200000L;

 这里我们需要注意：
    当我们对long类型数据赋值时，被赋值的数值不超过int类型的取值范围时，是可以不用在数值后面添加L的，如：

long num = 100;	//num long类型，100 int类型
long num2 = 100L;	//num2 long类型，100L long类型

        这两种定义方式都是可以的，因为在Java中，long > int > short > byte, 而小的数据类型转换成大的数据类型，是会自动转换的，不过为了更好地区分int类型和long类型，我们最好在给long类型的赋值的时候，后面都加上一个L。

注意： 

   "L"理论上不分大小写，但是若写成"l"容易与数字"1"混淆，不容易分辩。所以最好大写。

         3.5、float/double

float和double，都是浮点型数据类型。
float 数据类型是单精度、32位、符合IEEE 754标准的浮点数；float 在储存大型浮点数组的时候可节省内存空间；
double 数据类型是双精度、64 位、符合 IEEE 754 标准的浮点数；浮点数的默认类型为 double 类型；

/**
 * float和double的测试类
 */
public class FloatAndDoubleTest {
    static float f;
    static double d;
    public static void main(String[] args) {
        //float
        System.out.println("float的大小：" + Float.SIZE);
        System.out.println("float的默认值：" + f);
        System.out.println("float的取值范围：[" + Float.MIN_VALUE + "," + Float.MAX_VALUE + "]");

        System.out.println("=====================================================");
        //double
        System.out.println("double的大小：" + Double.SIZE);
        System.out.println("double的默认值：" + d);
        System.out.println("double的取值范围：[" + Double.MIN_VALUE + "," + Double.MAX_VALUE + "]");
    }
}

运行结果如下：

        单精度的小数位在计算机中只有23位（二进制），换算到十进制只能百分百保证6位十进制数字的精确度。不能百分百保证7位的精度运算。同理，双精度，小数位是52位（二进制），换算为十进制则只能百分百能保证15位。

注意：声明并初始化float是，格式为：float f = 1.0f; 而使用double时，可以有两种写法：（1）double d1 = 10.2d; （2）double d2 = 10.2; 因为浮点数在默认情况下，都是double类型。

         3.6、boolean

        boolean数据类型表示一位的信息，只有两个取值：true 和 false，这种类型只作为一种标志来记录 true/false 情况,true表示条件成立，false表示添加不成立。

        默认的值为false，其在储存时大小只有1位，由于计算机在处理数据时最小单位为1个字节，所以有些人也会说它是8位。

        boolean类型适用于逻辑运算，表示某个条件是否成立。一般用于程序的流程控制。

public class BooleanTest {
    public static void main(String[] args) {
        int age = 18;
        boolean result = age > 20;
        System.out.println("当age > 20时，result = " + result);

        result = age < 20;
        System.out.println("当age < 20时，result = " + result);
    }
}

运行结果如下：

         3.7、char

        char是字符类型，占2个字节，用单引号' '标识，只能放单个字符。可以直接赋值一个字符：字母、汉子、数字，也可以赋值一个数字范围：0~65565。
        根据设计，一个字符集中，每个字符都对应一个数值。比如ASCII 码表中，‘a’对应这数值是97。

/**
 * char的定义
 */
public class CharTest {
    public static void main(String[] args) {
        char a = 'a';   //任意单个字符，加单引号
        System.out.println("a = " + a);

        char a2 = '中';  //任意单个中文字，加单引号。
        System.out.println("a2 = " + a2);

        char a3 = 111;  //整数。0~65535.输出字符编码表中对应的字符
        System.out.println("a3 = " + a3);

        char a4 = 'a' + 1;  //自动转换为int类型，输出对应编码表中的字符
        System.out.println("a4 = " + a4);

        char a5 = 'a' + 'b';    //自动转换为int类型，输出结果
        System.out.println("a5 = " + a5);

        char a6 = '中' + 1;  //自动转换为int类型,输出对应的字符
        System.out.println("a6 = " + a6);
    }
}

运行结果如下：

 根据运行结果，我们可以总结一下：

        1）char类型用单引号' '标识，只能放单个字符。
        2）char类型为数值时，表示的是这个数值在字符集中对应的字符。
        3）两个char字符的加减操作，运算的是其字符集对应的数值进行加减。结果为计算后的数值所对应的字符集

注意：

        char型变量是用来存储Unicode编码的字符的，unicode编码字符集中包含了汉字，所以，char型变量中可以存储汉字。不过，如果某个特殊的汉字没有被包含在unicode编码字符集中，那么，这个char型变量中就不能存储这个特殊汉字。

转义字符 ：\

        转义字符出现在特殊字符之前会将特殊字符转换成普通字符。

        常见的转义字符有：

 我们通过一段代码来演示一下：

/**
 * 转义字符测试
 */
public class ESCTest {
    public static void main(String[] args) {
        char c1 = '\n';     //  '\n'换行符
        System.out.println("Hello," + c1 +"World!");
        System.out.println("==================");

        c1 = '\t';  //  '\t'缩进符
        System.out.println("Hello," + c1 +"World!");
        System.out.println("==================");

        c1 = '\'';  //  '\''单引号
        System.out.println(c1 + "Hello,World!" + c1);
        System.out.println("==================");

        c1 = '\"';  //  '\"'双引号
        System.out.println(c1 + "Hello,World!" + c1);
        System.out.println("==================");

        c1 = '\\';  //  '\\'反斜杠
        System.out.println(c1 + "Hello,World!" + c1);
        System.out.println("==================");
        
    }
}

运行结果如下：

        以上就是今天学习的全部内容了，有些可能需要学习到后面才能理解，大家可以先了解了解，加深下印象。