JAVA从入门到入土（二）!

JAVA从入门到入土(二)

第二章、进制

2.1进制的简介

进制也就是进位计数制，是人为定义的带进位的计数方法（有不带进位的计数方法，比如原始的结绳计数法，唱票时常用的“正”字计数法，以及类似的tally mark计数）。 对于任何一种进制—X进制，就表示每一位置上的数运算时都是逢X进一位。 十进制是逢十进一，十六进制是逢十六进一，二进制就是逢二进一，以此类推，X进制就是逢X进位。

2.2.进制的分类

在程序中，常用的进制可以分为以下几种：

二进制： 以数字0-1来表示每一个自然数，逢2进1。

​ 二进制: 0, 1, 10, 11, 100, 101, 110, 111, 1000, …

八进制： 以数字0-7来表示每一个自然数，逢8进1。

​ 八进制: 0, 1, 2, 3, 4, 5, 6, 7, 10, 11, 12, …

十进制： 以数字0-9来表示每一个自然数，逢10进1。

​ 十进制： 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, …

十六进制： 以数字0-9，a-f来表示每一个自然数，逢16进1。

​ 十六进制: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, a, b, c, d, e, f, 10, 11, …

2.3. 进制的表示

同一个自然数，用不同的进制表示的话，结果可能是不一样的。例如，数字10，如果是二进制，表示数字2； 如果是八进制，表示数字8；如果是十进制，表示数字10；如果是十六进制，表示数字16。 因此，不同的进制，需要有不同的标识，来区分不同的进制。

二进制： 以0b作为开头，表示一个二进制的数字，例如： 0b10、0b1001…

八进制： 以 0 作为开头，表示一个八进制的数字，例如：010、027…

十进制： 没有以任何其他的内容作为开头，表示一个十进制的数字，例如： 123、29…

十六进制： 以0x作为开头，表示一个十六进制的数字，例如：0x1001、0x8FC3…

2.4. 进制的转换

2.4.1. 十进制转其他进制

辗转相除法： 用数字除进制，再用商除进制，一直到商为零结束，最后将每一步得到的余数倒着连接以来，就是这个数字的指定的进制表示形式。

​ 18 = 0b10010 = 022 = 0x12

2.4.2. 其他进制转十进制

每一位的数字乘进制的位数的 -1次方，再将所有的结果累加到一起。

2.4.3. 二进制与八进制, 十六进制的相互转换

每一个八进制位可以等价替换成三个二进制位。 每一个十六进制位可以等价替换成四个二进制位。

2.5.原反补

2.5.1. 数据的转换

在计算机中， 所有的数据存储都是以二进制的形式存储的。 文字、图片、视频… ， 在计算机中都是二进制。 那么， 在计算机的存储系统中， 每一个文件都有大小。 那么文件的大小是如何计算的？

每一个二进制位称为一个 比特位(bit)

8个比特位称为一个字节(byte)

从字节开始， 每1024个单位向上增1。

8bit = 1byte

1024byte = 1kb

1024kb = 1mb

1024mb = 1GB

1024Gb = 1Tb

1024Tb = 1Pb

1024Pb = 1Eb

1024Eb = 1Zb

​ …

2.5.2. 负数的表示

在使用二进制表示数字的时候，通常会写满1个字节，如果1个字节表示不了，使用2个字节。如果2个字节表示不了，使用 4个字节。以此类推，8个字节、16个字节、32个字节…

在使用二进制表示数字的时候，最高位（最左侧的位）不是用来表示数字的大小的，而是用来表示数字的正负的。0代表正数，1代表负数。因此，最高位又被称为符号位。

2.5.3. 补码的引入

2.5.3.1. 符号位参与运算的问题

在数据的运算中， 由于有符号位的存在。 符号位直接参与运算， 会导致计算的结果出问题。例如， 在计算 8 + (-8) 的时候， 如果直接使用二进制表示形式进行运算的时候:

0000 1000 + 1000 1000 = 1001 0000

得到结果 -16

原因就是因为符号位参与了运算， 导致计算的结果出了问题。

2.5.3.2. 原反补

为了规避在计算过程中， 符号位的参与运算， 导致计算结果出错。 人们引入了补码， 规避了这个问题。 在计算机中，所有的数据存储和运算， 都是以补码 的形式进行的。

• 原码： 一个数字的二进制表示形式， 前面的计算二进制表示形式， 得到的就是原码。

• 反码: 正数的反码与原码相同； 负数的反码是原码符号位不变， 其他位按位取反。

• 补码: 正数的补码与原码相同； 负数的补码是反码 + 1 。

  8， 因为是正数， 原反补都是 0000 1000

  -8[原] = 1000 1000

  -8[反] = 1111 0111

  -8[补] = 1111 1000

2.5.3.3. 补码运算

在计算机中， 所有的数据存储和运算， 都是以 补码 的形式进行的。 因此， 在进行数据运算的时候， 将数据计算出补码， 再进行运算。

8 + (-8) = 0

0000 1000 + 1111 1000 = 1 0000 0000

在上述的计算结果中， 出现了多出一位的情况， 这种情况， 称为 溢出 。 如果出现了溢出的情况， 溢出位直接舍去不要， 即最后的计算结果是 0000 0000， 结果是 0

8 + (-16) = -8

0000 1000 + 1111 0000 = 1111 1000

注意: 补码与补码的计算结果，还是补码。 所以， 我们需要将这个结果再转成原码。补码求原码的过程： 再对这个补码求补即可。得出结果: 1000 1000， 结果是 -8

第三章、Java语法基础

3.1. 数据类型

3.1.1. 数据类型概念

在编程中， 其实就是操作着各种数据进行各种的运算。 所有的数据在计算机中进行存储的时候都是有自己的类型的。数据类型， 即数据存储的类型。

在Java中， 数据类型分为两类: 基本数据类型 和 引用数据类型

先说基本数据类型

3.1.2. 基本数据类型分类

啊

数据类型	标识符	占用大小(字节)
字节型	byte	1
短整型	short	2
整型	int	3
长整型	long	8
单精度浮点型	float	4
双精度浮点型	double	8
字符型	char	2
布尔型	boolean	1

3.2. 标识符

3.2.1. 标识符的概念

程序的运行， 其实就是若干数据的运算。 每一个数据都有类型， 就是上述的数据类型。 除此之外， 每一个数据都需要有一个唯一标识来表示。 这个用来表示内存中的某一个数据的表示形式， 就是一个标识符。

类似数学中的代数。

x = 10;y = 20;

在进行 x + y 的时候， 我们知道其实计算的是 10 + 20。 因此此时x就代表了数字10， y就代表了数字20。这里的x、y就是标识符。

3.2.2. 标识符的命名规则

标识符， 是由若干个字符组成的有序序列。 在标识符的命名中， 应该遵循以下命名的规则：

1. 由字母、数字、下划线和$符号组成。

2. 不能以数字作为开头。

3. 不能与系统关键字或者保留字重名。

关键字、保留字:

其实也是一个字符序列， 同样遵循上述两点要求。 不过这些字符序列， 已经被系统占用了。 有些被占用后， 被赋予了特殊的含义， 这样的被称为关键字。 有些字符序列被占用， 但是暂未赋予特殊含义， 在后续的版本更新中， 可能会使用， 这样的被称为保留字。

3.2.3. 标识符的命名规范

在实际开发中， 遵循了标识符的命名规则的情况下， 有些标识符是可以随意命名的。 比如如下的标识符:

a1, a2, a3, a4, a5, a6, a7

但是， 这样的标识符， 在实际使用过程中， 可读性极差。 在使用的时候， 基本很难理解这个标识符想要表示什么数据。因此标识符的命名， 在遵循命名规则的同时， 还需要遵循一些命名的规范。

标识符的命名规范， 首先需要遵循望文知意， 即一个标识符的命名， 应该一眼能够看出来想表示什么含义。 例如:

name：表示姓名

age: 表示年龄

gender: 表示性别

但是， 在遵循了望文知意的基础上， 有些标识符的命名会比较长。例如：

ageofperson: 人的年龄

countofstudent: 学生的数量

这样的标识符， 可读性也不高， 因为无法很快的分隔开每一个单词。 所以，在此基础上， 还需要在遵循驼峰命名法

• 大驼峰命名法： 每一个单词的首字母都大写。

• 小驼峰命名法： 首单词除外， 从第二个单词开始， 每个单词的首字母都大写。

大驼峰命名法: AgeOfPerson、CountOfStudent

小驼峰命名法: ageOfPerson、countOfStudent

3.3. 变量、常量

3.3.1. 概念

在程序中， 使用标识符表示程序中的某个数据。

• 如果某个数据在程序运行的过程中， 值是可以改变的， 这样的数据被称为是变量。

• 如果某个数据在程序运行的过程中， 值是不可以改变的， 这样的数据被称为是常量。

例如:

一个人的年龄、身高、体重， 都是可以发生改变的， 因此这样的数据， 常用变量表示。

一个人的出生日期、身份证号码， 是不可以发生改变的， 因此这样的数据， 常用常量表示。

3.3.2. 定义

变量的定义， 遵循最基础的语法: 数据类型 标识符

public class JavaSyntax {
    public static void main(String[] args) {
        //1.定义一个变量
        int age;
        //2.定义多个类型相同的变量
        int height, weight;
        //定义一个变量,并赋予初值
        int score = 100;
        //4.定义多个变量，同事给某些变量赋初始值
        int chineseScore = 99,mathScore = 98,englishScore;
    }
}

3.3.3. 各种类型的变量的定义

public class JavaSyntax {
    public static void main(String[] args) {
        byte n1 = 10;
        short n2 = 10;
        int n3 = 10;
        long n4 = 10;
        //浮点型数字默认的类型是double，如果要给float变量赋值，需要在最后加一个f
        float n5 = 3.14f;
        double n6 = 3.14;
        char n7 = 'a';
        boolean n8 = true;
    }
}

3.3.4. 注意事项

局部变量或者局部常量， 在使用的时候一定要有值。 如果某一个局部变量或者局部常量没有值， 这个变量或者常量将无法使用。

局部变量: 定义在某一个局部代码段中的变量， 例如定一个方法中的变量。

public class JavaSyntax {
    public static void main(String[] args) {
        //1.定义一个变量，不赋初始值
        int age;
        //2.使用这个变量的值
        System.out.println(age);//这里有问题，因为age没有值
    }
}

3.4. 转义字符

3.4.1. 概念

在一个字符中， 单引号表示一个字符的开始和结尾。 在单引号中， 可以写任意的字符， 但是不能是单引号。 因为单引号是有特殊含义的， 用来匹配字符的开始和结尾。 如果此时， 如果要表示单引号， 就需要使用到转义字符了。

转义字符， 是一个特殊的字符 \ ， 有两层含义:

• 将某一个具有特殊含义的字符变成普通字符， 没有特殊的含义。
• 将某些普通字符变成具有特殊含义的字符。

3.4.2. 使用

public class JavaSyntax {
    public static void main(String[] args) {
        //1.将特殊字符转义，变成普通字符
        char c1 = '\'';
        char c2 = '\\';

        //2.将某些普通字符，变成特殊字符
        char c3 = '\n'; //换行符
        char c4 = '\r'; //回车符
        char c5 = '\t'; //制表符
    }
}

3.5. 数据类型转换

3.5.1. 类型转换的概念

一个变量声明完成后, 在内存中已经开辟好了空间, 此时是不允许调整空间大小的, 也就是说这个变量的数据类型是不允许改变的。这里说的数据类型转换, 指的是声明一个新的指定类型的变量, 将原来变量中的值拷贝到新的变量中。

3.5.2. 类型转换的分类

数据类型转换可以分为两种:

• 自动类型转换

  • 又叫做隐式转换, 一般是由取值范围小的数据类型, 向取值范围大的数据类型转换

  • 转换过程不需要任何额外操作

  • 转换后, 没有任何精度丢失情况

• 强制类型转换

  • 又叫做显式转换, 一般是由取值范围大的数据类型, 向取值范围小的数据类型

  • 转换转换过程需要强制操作, 不能自动完成

  • 转换后, 可能会出现精度丢失的情况

3.5.3. 示例代码

public class ClassCastUsage {
    public static void main(String[] args) {
        // 自动类型转换
        byte a = 10;
        int b = a; // 定义一个取值范围大于byte类型的变量, 直接将a的值, 给这个int变量赋值
        // 此时的变量b就拥有原来a的值, 并且b的数据类型, 就是我们需要转型的int类型

        // 强制类型转换
        int c = 200;
        byte d = (byte)c;//由int类型转型为byte类型,会存在精度丢失
        System.out.println(d);
    }
}

3.5.4. 特殊说明

• byte, short, char 类型的数据在进行运算的时候, 会自动的转型为int类型
• 浮点型转整型, 会舍去小数点后面所有的内容, 只保留整数部分

3.6. 常用运算符

3.6.1. 算术运算符

3.6.1.1. 运算符分类

运算符	描述
+	加法运算
-	减法运算
*	乘法运算
/	除法运算
%	模运算（求余数）
++	自增运算符
–	自减运算符

3.6.1.2. 特殊说明

• ±*% 和数学计算中没有区别

• 两个整型的数据进行除法, 结果还是整型, 会将计算的浮点结果强转成整型

• 自增运算符++, 用在变量前, 表示是前取变量值, 后对这个变量进行+1操作

• 自增运算符++, 用在变量后, 表示是先对这个变量进行+1操作, 然后再取变量值自减同自增

3.6.1.3. 示例代码

public class Calculator {
    public static void main(String[] args) {
        // 1. 定义两个变量, 用于做算术运算
        int x = 30, y = 7;
        // 2. 进行常用运算
        System.out.println(x + y);  // 37
        System.out.println(x - y);  // 23
        System.out.println(x * y);  // 210
        System.out.println(x / y);  // 4
        System.out.println(x % y);  // 2

        // 3. 自增, 自减运算符
        //    ++: 自增运算符, 将一个变量, 在现有的值的基础上, 加一
        //    --: 自减运算符, 将一个变量, 在现有的值的基础上, 减一
        x++;
        System.out.println(x);
        y--;
        System.out.println(y);

        // 4. 自增自减运算符, 在操作变量的时候, 可以放在变量前, 也可以放在变量后
        //    在变量前: 表示先对这个变量进行自增自减操作, 再使用这个变量的值
        //    在变量后: 表示先取这个变量值使用, 再对这个变量进行自增自减操作
        x = 10;
        System.out.println(++x);    // x = 11
        System.out.println(x--);
        System.out.println(x);      // x = 10

        // 5. 案例:
        x = 20;
        System.out.println(x++);    // 20, x = 21
        System.out.println(++x);    // 22, x = 22
        System.out.println(--x);    // 21, x = 21
        System.out.println(x--);    // 21, x = 20
        System.out.println(x);      // 20
    }
}

3.6.2. 赋值运算符

3.6.2.1. 运算符分类

运算符	描述
=	赋值运算， 右边的值给左边的变量赋值
+=	组合运算符， 在现有值的基础上， 加某一个值
-=	组合运算符， 在现有值的基础上， 减某一个值
*=	组合运算符， 在现有值的基础上， 乘某一个值
/=	组合运算符， 在现有值的基础上， 除某一个值
%=	组合运算符， 将一个数字与另外一个数字求模的结果给变量赋值

3.6.2.2. 特殊说明

赋值运算，也是有运算结果的。 赋值运算的结果就是赋值完成后的变量的值。

3.6.2.3. 示例代码

public class BValue {
    public static void main(String[] args) {
        // 1. 定义一个变量, 并且进行初始化的赋值操作
        byte x = 30;
        // 2. 赋值运算, 可以和常用的其他运算符组成组合运算符
        x += 10;    // 同 x = x + 10;
        x -= 10;    // 同 x = x - 10;
        x *= 10;    // 同 x = x * 10;
        x /= 10;    // 同 x = x / 10;
        x %= 10;    // 同 x = x % 10;

        // 3. 赋值运算的运算结果: 是赋值完成之后, 这个变量的值
        System.out.println(x = 50);
    }
}

3.6.3. 关系运算符

3.6.3.1. 运算符分类

运算符	描述
>	大于
<	小于
>=	大于等于
<=	小于等于
==	等于
!=	不等于

3.6.4. 逻辑运算符

3.6.4.1. 运算符分类

运算符	描述
&	逻辑与， 两真即为真， 任意一个为假， 结果即为假。
|	逻辑或， 两假即为假， 任意一个为真， 结果即为真。
!	逻辑非， 非真即假， 非假既真。
^	逻辑异或， 相同为假， 不同为真。
&&	短路与，如果前面的结果可以决定整体的运算结果, 后面的表达式不参与运算
||	短路或，如果前面的结果可以决定整体的运算结果, 后面的表达式不参与运算

3.6.4.2. 示例代码

public class Logic {
    public static void main(String[] args) {
        // 相亲:
        // 1. 进行逻辑运算
        System.out.println(true & false);  // 白 并且 富 并且 美
        System.out.println(true | false);  // 白 或者 富 或者 美
        System.out.println(!true);         // 只要不是男的就行
        System.out.println(true ^ false);  // 只要和自己是不同的

        // 2. 短路运算
        //    &&: 短路与, 运算结果和与操作相同, 区别在于, 如果前面的布尔值可以决定整体结果, 则后面的表达式不参与运算.
        //    ||: 短路或, 运算结果和或操作相同, 区别在于, 如果前面的布尔值可以决定整体结果, 则后面的表达式不参与运算.

        int x = 10, y = 20;
        System.out.println(x > 50 && y++ < 10);
        System.out.println(y);
    }
}

3.6.5. 位运算符

3.6.5.1. 运算符分类

位运算符， 只能作用于两个整型的变量。 将两个整型变量计算出补码， 然后对每一位的数字， 进行类似于逻辑运算的操作。 1相当于true， 0相当于false。

运算符	描述
&	位与运算， 对补码的每一位进行与运算。
|	位或运算， 对补码的每一位进行或运算。
^	位异或运算， 对补码的每一位进行异或运算。
~	按位取反运算， 对补码的每一位进行取反操作， 包括符号位。
<<	位左移运算， 将补码的每一位依次向左移动指定的位数。
>>	位右移运算， 将补码的每一位一次向右移动指定的位数。 左侧补符号位。
>>>	无符号位右移运算， 将补码的每一位一次向右移动指定的位数。 左侧补0。

3.6.5.2. 示例代码

public class Binary {
    /*
        5的补码: 0000 0101
        -17的补码: 1110 1111
     */
    public static void main(String[] args) {
        // 1. 位与运算
        //    0000 0101
        //    1110 1111
        //    0000 0101     位与运算结果
        System.out.println(5 & -17);        // 5

        // 2. 位或运算
        //    0000 0101
        //    1110 1111
        //    1110 1111     位或运算结果(补码)
        //    1001 0001     原码
        System.out.println(5 | -17);        // -17

        // 3. 位异或运算
        //    0000 0101
        //    1110 1111
        //    1110 1010     位异或运算结果(补码)
        //    1001 0110     原码
        System.out.println(5 ^ -17);        // -22

        // 4. 按位取反
        //    将每一位都取反, 包括符号位
        //    0000 0101
        //    1111 1010     按位取反结果(补码)
        //    1000 0110     原码
        System.out.println(~5);

        // 5. 一个数字和另外一个数字异或两次, 得到自己
        System.out.println(-763 ^ 916 ^ 916);  // -763
    }
}

public class Binary2 {
    public static void main(String[] args) {
        // 1. 左移运算: 将补码中的每一位都向左移动指定位, 右端补0
        //             每向左移动一位, 都相当于乘2
        //    0000 0101
        //    0001 0100
        System.out.println(5 << 2);
        System.out.println(8 << 3);

        // 2. 右移运算: 将补码中的每一位都向右移动指定位, 左端补符号位
        //    0001 0001
        //    0000 0100     4
        System.out.println(17 >> 2);
        //    1110 1111
        //    1111 1011
        //    1000 0101
        System.out.println(-17 >> 2);       // -5

        // 3. 无符号位右移运算: 将补码中的每一位都向右移动指定位, 左端补0
        System.out.println(17 >>> 2);
        System.out.println(-17 >>> 2);
    }
}

3.6.4. 三目运算符

3.6.4.1. 三目运算符描述

?:

三目运算符， 是一个带有点逻辑的运算符， 基础语法如下：

布尔结果表达式/布尔变量 ? 值1 ： 值2

如果问号前面的布尔值为true， 整体的结果为值1。 否则整体的结果为值2。

3.6.4.2. 示例代码

public class ternaryOperator {
    public static void main(String[] args) {
        System.out.println(true ? 10 : 20);    //
        System.out.println(false ? 10 : 20);    //

        // 1. 定义两个变量
        int x = 100, y = 20;
        // 2. 找出这两个变量中最大值
        int max = x > y ? x : y;
        // 3. 输出最大值
        System.out.println(max);
    }
}

3.6.3. 运算符的优先级

3.6.4.1. 运算符的分类

按照运算符可以操作的数据的数量， 可以将运算符分为: 一元运算符、二元运算符、三元运算符

• 一元运算符: 只能操作一个数据，例如: + - ++ – ! ~

• 二元运算符: 可以操作两个数据，例如: + - * /

• 三元运算符: 可以操作三个数据， 只有一个， 即三目运算符

3.6.4.2. 优先级

• 整体来看， 一元运算符 > 二元运算符 > 三元运算符

• 赋值运算符的优先级最低

• 算术运算中: 乘、除、模 > 加、减

• 逻辑运算符中: 与 > 或、异或

• 小括号的优先级最高

优先级	运算符	结合性
1	()、[]、{}	从左向右
2	！、+(正)、-(负)、~、++、–	从右向左
3	*、/、%	从左向右
4	+、-	从左向右
5	>>、<<、>>>	从左向右
6	<、<=、>、>=、instance of	从左向右
7	==、!=	从左向右
8	&	从左向右
9	^	从左向右
10	|	从左向右
11	&&	从左向右
12	||	从左向右
13	?:	从右向左
14	=、+=、-=、*=、/=、&=、|=、^=	从右向左

----- | ------------------------------ | -------- |
| 1 | ()、[]、{} | 从左向右 |
| 2 | ！、+(正)、-(负)、~、++、-- | 从右向左 |
| 3 | 、/、% | 从左向右 |
| 4 | +、- | 从左向右 |
| 5 | >>、<<、>>> | 从左向右 |
| 6 | <、<=、>、>=、instance of | 从左向右 |
| 7 | ==、!= | 从左向右 |
| 8 | & | 从左向右 |
| 9 | ^ | 从左向右 |
| 10 | | | 从左向右 |
| 11 | && | 从左向右 |
| 12 | || | 从左向右 |
| 13 | ?: | 从右向左 |
| 14 | =、+=、-=、=、/=、&=、|=、^= | 从右向左 |