JAVA从入门到入土(二)

文章目录

JAVA从入门到入土(二)第二章、进制2.1进制的简介2.2.进制的分类2.3. 进制的表示2.4. 进制的转换2.4.1. 十进制转其他进制2.4.2. 其他进制转十进制2.4.3. 二进制与八进制, 十六进制的相互转换 2.5.原反补2.5.1. 数据的转换2.5.2. 负数的表示2.5.3. 补码的引入2.5.3.1. 符号位参与运算的问题2.5.3.2. 原反补2.5.3.3. 补码运算 第三章、Java语法基础3.1. 数据类型3.1.1. 数据类型概念3.1.2. 基本数据类型分类 3.2. 标识符3.2.1. 标识符的概念3.2.2. 标识符的命名规则3.2.3. 标识符的命名规范 3.3. 变量、常量3.3.1. 概念 3.3.2. 定义3.3.3. 各种类型的变量的定义3.3.4. 注意事项 3.4. 转义字符3.4.1. 概念3.4.2. 使用 3.5. 数据类型转换3.5.1. 类型转换的概念3.5.2. 类型转换的分类3.5.3. 示例代码3.5.4. 特殊说明 3.6. 常用运算符3.6.1. 算术运算符3.6.1.1. 运算符分类3.6.1.2. 特殊说明3.6.1.3. 示例代码 3.6.2. 赋值运算符3.6.2.1. 运算符分类3.6.2.2. 特殊说明3.6.2.3. 示例代码 3.6.3. 关系运算符3.6.3.1. 运算符分类 3.6.4. 逻辑运算符3.6.4.1. 运算符分类3.6.4.2. 示例代码 3.6.5. 位运算符3.6.5.1. 运算符分类3.6.5.2. 示例代码 3.6.4. 三目运算符3.6.4.1. 三目运算符描述3.6.4.2. 示例代码 3.6.3. 运算符的优先级3.6.4.1. 运算符的分类3.6.4.2. 优先级

第二章、进制

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. 基本数据类型分类

啊

数据类型标识符占用大小(字节)字节型byte1短整型short2整型int3长整型long8单精度浮点型float4双精度浮点型double8字符型char2布尔型boolean1

3.2. 标识符

3.2.1. 标识符的概念

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

类似数学中的代数。

x = 10;y = 20;

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

3.2.2. 标识符的命名规则

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

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

不能以数字作为开头。

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

关键字、保留字:

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

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 | =、+=、-=、=、/=、&=、|=、^= | 从右向左 |