JAVA从入门到入土（二）!

最新推荐文章于 2024-05-15 11:13:56 发布

千年小妖L

最新推荐文章于 2024-05-15 11:13:56 发布

阅读量300

点赞数

分类专栏： JAVA 文章标签： java java 零基础 Java Java入门

本文链接：https://blog.csdn.net/weixin_42947670/article/details/107130058

版权

JAVA 专栏收录该内容

5 篇文章 1 订阅

订阅专栏

JAVA从入门到入土(二)

文章目录

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. 标识符的命名规则

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

由字母、数字、下划线和$符号组成。
不能以数字作为开头。
不能与系统关键字或者保留字重名。

关键字、保留字:

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

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

千年小妖L

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
JAVA从入门到入土（二）!

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.
复制链接

扫一扫