第二章 Java基础知识

于 2019-08-29 12:01:04 发布
阅读量216 收藏
点赞数
分类专栏： Java 文章标签： Java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/weixin_42023744/article/details/100134991
版权
本文详细介绍了Java的基础知识，包括数据类型如基本数据类型（整型、浮点型、字符型、布尔型）及其转换，进制概念，以及数据类型转换（自动和强制）。此外，还讲解了运算符，如算数、赋值、比较、逻辑和位运算符，特别强调了三元运算符和运算符优先级。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

typora-copy-images-to: …\01-code

第二章 Java基础知识

2.5 Java的数据类型

​ Java的数据类型分为两大类：

  1. 基本数据类型：8种；

  2. 引用数据类型：类、接口、数组。

2.5.1 基本数据类型

  1. **整型：**byte(1字节=8bit)\short(2字节)\int(4字节)\long(8字节)

    ​ ① byte范围：-128~127

    ​ ② 声明long型变量，必须以“l”或“L”结尾

    ​ ③ 通常定义整型变量时，使用int型

    ​ ④ 整型的常量，默认类型是int型

  2. **浮点型：**float(4字节)\double(8字节)

    ​ ① 浮点型，表示带小数的数值

    ​ ② float表示数值的范围比long还大

    ​ ③ 定义float类型变量时，变量要以“f”或“F”结尾

    ​ ④ 通常定义浮点型变量时，使用double型

    ​ ⑤ 浮点型的常量，默认类型是double型

  3. **字符型：**char（2字节）

    ​ ① 定义char型变量，通常使用一对’’，内部只能写一个字符

    ​ ② 表示方式：1.声明一个字符 2.转义字符 3.直接使用Unicode值来表示字符型常量

    转义字符：
    在这里插入图片描述

  4. **布尔型：**boolean

    ​ ① 只能取两个值之一：true或者false

    ​ ②常常在条件判断、循环结构中使用

2.5.2 原码、反码、补码的概念

​ 计算机底层存储还要涉及到符号，所以设计了原码、反码、补码的概念，计算机在实际中是补码来存储的。

  • 规定1：

    正数的原码、反码、补码三码合一

    负数的原码、反码、补码不一样

    反码：是在原码的基础上，最高位不变，其余位取反（0变1,1变0）
    补码：在反码的基础上加1

  • 规定2：

    正数的最高位是0，负数的最高位1
    原码：十进制的数字–>二进制值，最高位不表示数字，用来表示正负号

55（byte类型）
	原码：0011 0111
	反码：0011 0111
	补码：0011 0111
-55	（byte类型）
	原码：1011 0111
	反码：1100 1000
	补码：1100 1001

2.5.3 问题说明

  1. 为什么float的4个字节，反而存储范围比long类型的8个字节大？

    ​ 主要是由于float和double类型存储方式与整型不同导致的，整型的存储直接以二进制的方式存储，而float和double虽然也是由二进制存储，但方式不同：

    float和double的存储是这样的过程：
    第一步：先把小数转为二进制
    第二步：把二进制转为科学计数法
    第三步：存储科学计数法表示后的
    （1）符号位，0是正，1是负
    （2）指数部分，float是8位存储指数，double是11位存储指数
    （3）尾数部分，float是32-1-8=23，double是64-1-11=52

2.6 进制（二、八、十、十六进制）

2.6.1 进制概念

  1. 十进制

0-9：逢十进一；

  1. 二进制

    0-1：逢二进一；

  2. 八进制

    0-7：逢八进一；

  3. 十六进制

    0-9，a-f（A-F）：逢十六进一；

2.6.2 进制转换

  1. 二进制转换十进制

    整数部分：除二倒取余；
    在这里插入图片描述

  2. 八进制、十六进制与二进制之间的转换

    二进制–>八进制：三位二进制一组；

    二进制–>十六进制：四位二进制一组；

    说明：

    • 八进制和十六进制是为了缩进代码中表示二进制的目的；

    • 八进制与十六进制之间的转换用可以用二进制中转。

  3. 各种进制的表示方式

    二进制：数字前面加0b或0B；

    八进制：数字前面加0；

    十六进制：数字前面加0x或0X；

2.7 数据类型转换

2.7.1 自动类型转换（隐式类型转换）

  1. 当我们把存储范围小的类型的数据（变量、常量值、表达式）赋值给存储范围大的类型的变量时，我们就会发生自动类型转换；

在这里插入图片描述

int i = 'A';//char自动升级为int

double d = 10;//int自动升级为double

long num = 12345678;
//右边如果没有超过int的存储范围，按照int来表示，可以自动类型转为long，可以不加L
//但是如果超过int的范围，那么必须加L
  1. 当我们byte与byte，short与short，char与cha类型进行运算时，或者它们三个的混合运算时，都会自动升级为int；
byte b1 = 1;
byte b2 = 2;
byte b3 = b1 + b2;//编译报错，b1 + b2自动升级为int

char c1 = '0';
char c2 = 'A';
System.out.println(c1 + c2);//113 

byte b1 = 1;
byte b2 = 2;
byte b3 = b1 + b2;//报错--，右边的b1 + b2会自动升级为int，int是无法自动类型转为byte

  1. 当我们多种数据类型混合运算时，那么会自动升级为它们中最大的；
    例如：

    int + double + float + long 一起运算，结果是double
    byte + int + long 一起运算，结果是long

int i = 1;
byte b = 1;
double d = 1.0;

double sum = i + b + d;//混合运算，升级为double
  1. boolean类型不参与；

2.7.2 强制类型转换（显式类型转换）

  1. 当我们把存储范围大的类型的数据（变量、常量值、表达式）赋值给存储范围小的类型的变量时，就要求使用强制类型转换；

    **注意：**强制类型转换有风险（溢出或损失精度）。

    //转换格式：
数据类型 变量名 = （数据类型）被强转数据值；
//强制类型转换，损失精度
int a = (int)2.5;//2
//强制类型转换，溢出
i = 129; // 0000 0000 0000 0000 0000 0000 1000 0001
b = (byte)i;//1000 0001  ==>最高位是1，负数 ==>反码1000 0000==》原码1111 1111 
System.out.println("b = " + b);//-127

  2. 当我们需要把存储范围小的类型，强制提升为存储范围大的类型，也可以使用强制类型转换，这种强制类型转换没有风险；

    int m = 1;
int n = 2;
System.out.println((double)m / n);

  3. boolean不参与;

  4. String也不能强制转为基本数据类型;

    String str = "123";//	int num = (int)str;//不能这样强制

2.7.3 特殊的数据类型转换

  1. 任意数据类型的数据与String类型进行“+”运算时，结果一定是String类型；
  2. String类型不能通过强制类型转换转为其他的类型。

2.8 运算符

运算符的类别：

分类运算符
算术运算符+、-、*、/、%、++、–
赋值运算符=、+=、-=、*=、/=、%=等
关系运算符>、>=、<、<=、==、！=
逻辑运算符&、|、^、！、&&、||
三元运算符(关系表达式)?结果1:结果2;
位运算符&、|、~、^、<<、>>、>>>

2.8.1 算数运算符

算数运算符（Arithmetic Operator）;

算术运算符符号解释
+加法运算，字符串连接运算，正号
-减法运算，负号
*乘法运算
/除法运算
%求余运算，两个数字相除的余数
++ 、 --自增自减运算

**注：**当两个整数相除，结果也是整数，只保留整数部分;

  1. 加法运算

    • 对于+两边都是数值的话，+就是加法的意思；

    • 对于+两边至少有一边是字符串的话，+就是拼接的意思；

    String str2 = "Java";
// String + int --> String
System.out.println(str2 + 520); // Java520
// String + int + int --> String
System.out.println(str2 + 5 + 20); // Java520

  2. 取余运算

    • 结果的符号与被模数的符号相同；

    • 开发中，经常使用%来判断能否被除尽的情况。

  3. ++、--运算

    ++ 运算：变量自增1、--运算：变量自减1，++运算与--运算用法一致。

    • 当没有混合运算时，++在前在后没有区别；
    • 当有其他运算符一起混合运算时，++在前在后是不一样的：
      前++：++在前，先自增，再load值运算其他的。
      后++：++在后，先load值，再自增。
    • 自减：--同理；

    引入：操作数栈的概念

    int i = 1;
i = ++i;
/*
运算过程：
（1）先算++i,i=2
（2）再load  i的值'2'到“操作数栈”中
（3）把“操作数栈”中2赋值给i
*/
System.out.println("i = " + i);//2

int j = 1;
j = j++;
/*
运算过程：
（1）先load  j的值'1'到“操作数栈”中
（2）再算j++,j=2
（3）把“操作数栈”中1赋值给j
*/
System.out.println("j = " + j);//1

//例题：
int i = 1;
int j = i++ + ++i * i++;
/*
（1）先处理i++
	（A）先load i的值"1"到“操作数栈”中
	（B）i自增 i=2
（2）再处理++i
	（A）先自增 i=3
	（B）再把i的值"3"load到“操作数栈”中
（3）i++
	（A）先load i的值"3"到“操作数栈”中
	（B）i自增 i=4
（4）先算乘法
	弹出栈顶的两个数，算乘法，3*3
	得到的结果再压回“操作数栈”中
（5）再算加法
	弹出栈顶的两个数，算加法，9+1
	得到的结果再压回“操作数栈”中
（6）最后算赋值
	把“操作数栈”中值10赋值给j
*/
System.out.println("i = " + i);//4
System.out.println("j = " + j);//10

小结：

​ 前++：先自加，后使用；

​ 后++：先使用，后自加。

练习：

​ 获取一个四位数的个位，十位，百位，千位：

public class Test01 {
	public static void main (String [] args) {
		//1.定义一个四位数，例如1234
		int num = 1234;
		//2.通过运算操作求出个位，十位，百位，千位
		int ge = num % 10; // 1234 / 10  =  123......4
		int shi = num / 10 % 10; //1234 / 10 = 123%10 
		int bai = num / 100 % 10;
		int qian = num / 1000 % 10;
		
		System.out.println(num + "这个四位数个位上的数字是：" + ge);
		System.out.println(num + "这个四位数十位上的数字是：" + shi);
		System.out.println(num + "这个四位数百位上的数字是：" + bai);
		System.out.println(num + "这个四位数千位上的数字是：" + qian);
	}
}

2.8.2 赋值运算符

赋值运算符：Assign Operator

赋值运算符符号解释
=将符号右边的值，赋值给左边的变量
+=将符号左边的值和右边的值进行相加操作，最后将结果赋值给左边的变量
-=将符号左边的值和右边的值进行相减操作，最后将结果赋值给左边的变量
*=将符号左边的值和右边的值进行相乘操作，最后将结果赋值给左边的变量
/=将符号左边的值和右边的值进行相除操作，最后将结果赋值给左边的变量
%=将符号左边的值和右边的值进行取余操作，最后将结果赋值给左边的变量

  1. 基本赋值运算符

    • 基本赋值运算符为：=；

    • 右边的数据（常量值、另一个变量、表达式）的类型一定是左边的变量能够接收的类型；

  2. 扩展赋值运算

    • 扩展赋值运算符在将最后的结果赋值给左边的变量前，都做了一步强制类型转换；
public class OperatorDemo04 {
	public static void main(String[] args) {
        //b += a与b = b + a相同点：
		int a = 3;
		int b = 4;
		b += a;// 相当于 b = b + a ; 
		System.out.println(a); // 3
		System.out.println(b); // 4	
        
		//b += a与b = b + a区别：强制类型转换
		short s = 3;
		// s = s + 4; 代码编译报错，因为将int类型的结果赋值给short类型的变量s时，可能损失精度
		s += 4; // 代码没有报错
        //因为在得到int类型的结果后，JVM自动完成一步强制类型转换，将int类型强转成short
		System.out.println(s);
        
        int j = 1;
		j += ++j * j++;//相当于  j = j + (++j * j++);
		System.out.println(j);//5
	}
}

2.8.3 比较运算符

比较运算符（Compare Operator）也称为关系运算符。

关系运算符符号解释
<比较符号左边的数据是否小于右边的数据，如果小于结果是true。
>比较符号左边的数据是否大于右边的数据，如果大于结果是true。
<=比较符号左边的数据是否小于或者等于右边的数据，如果大于结果是false。
>=比较符号左边的数据是否大于或者等于右边的数据，如果小于结果是false。
==比较符号两边数据是否相等，相等结果是true。
！=不等于符号 ，如果符号两边的数据不相等，结果是true。
  1. 比较运算符，是两个数据之间进行比较的运算，运算结果一定是boolean值true或者false ；
  2. 比较运算符左右两边参与比较的数据的类型必须相同或兼容。
char c = 'a';
System.out.println(c > 'b');//false  按照编码值比较
System.out.println(c > 90);//true

2.8.4 逻辑运算符

逻辑运算符：Logic Operator

逻辑运算符符号解释符号特点
&与，且有false则false
|或有true则true
^异或相同为false，不同为true
!非非false则true，非true则false
&&双与，短路与左边为false，则右边就不看
||双或，短路或左边为true，则右边就不看

  1. 逻辑运算符，是用来连接两个布尔类型结果的运算符（!除外），运算结果一定是boolean值true或者false

  2. &&与&的区别

  • 相同点：

    • &与&&的运算结果相同；

    • 当符号左边是true时，二者都会执行符号右边的运算；

  • 不同点：

    • 当符号左边是false时，&继续执行符号右边的运算；&&不再执行符号右边的运算。
  • 开发中推荐使用短路与。
  1. ||与|的区别

  • 相同点：

    • |与||的运算结果相同；

    • 当符号左边是false时，二者都会执行符号右边的运算；

  • 不同点：

    • 当符号左边是true时，|继续执行符号右边的运算；||不再执行符号右边的运算。

  • 开发中推荐使用短路或。

练习：

在这里插入图片描述

public class LogicExer1{
	public static void main(String[] args){
		int x = 1;
		int y = 1;

		//x==2 ,x++  false  x = 2 左边为false
		//右边继续
		//++y  y==2  y=2  y==2成立  右边为true
		//false & true 结果false
		if(x++==2 & ++y==2){
			x =7;
		}
		System.out.println("x="+x+",y="+y);//x=2,y=2
	}
}

public class LogicExer2{
	public static void main(String[] args){
		int x = 1,y = 1;
		//x==2,x++  左边条件为false，x=2
		//因为短路与，右边不算
		//false && ? 结果是false
		if(x++==2 && ++y==2){
			x =7;
		}
		System.out.println("x="+x+",y="+y);//x=2,y=1
	}
}



public class LogicExer3{
	public static void main(String[] args){
		int x = 1,y = 1;

		//x==1,x++  左边为true，x=2
		//因为是逻辑与,右边继续  
		//++y, y==1  y=2 右边为false
		//条件true | false，最终为true
		if(x++==1 | ++y==1){
			x =7;
		}
		System.out.println("x="+x+",y="+y);//x=7,y=2
	}
}	

public class LogicExer4{
	public static void main(String[] args){
		int x = 1,y = 1;

		//x==1,x++  左边为true，x=2
		//因为是短路或，左边为true，右边就不看了
		//整个条件为true
		if(x++==1 || ++y==1){
			x =7;
		}
		System.out.println("x="+x+",y="+y);//x=7,y=1

	}
}

在这里插入图片描述

public class LogicExer5{
	public static void main (String []  args)  {
		boolean x = true;
		boolean y = false;
		short z = 42;
		
		//如果if((z++==42)&&(y==true))条件成立，执行z++，不成立，就不执行z++
		//左边的条件：z==42,z++  z==42成立,z++变成43
		//中间虽然是短路与，因为左边现在是true,右边还要看
		//右边 y==true   不成立
		//true && false 结果为false
		if((z++==42)&&(y==true))	z++;
	
		//左边为x=false,赋值  结果就为false
		//中间虽然为短路或，因为左边是false,右边继续看
		//++z,z==45  ++z变成44，z==45是否成立，不成立
		//false || false  结果为false
		if((x=false) || (++z==45))  z++;

		System. out.println("z="+z);//44
	}
}

class  Test4_2  {
	public static void main (String []  args)  {
		boolean x = true;
		boolean y = false;
		short z = 42;
		
		//如果if(y=true)条件成立，接着判断if((z++==42)&&(y==true))	z++;	
		//如果不成立，if((z++==42)&&(y==true))	z++;	不看的
		/*
		if(y = true)
				
		if((z++==42)&&(y==true))	z++;	
		
		if((x=false) || (++z==45))  z++;
		*/
		
		//标准
		//y=true赋值，y就被修改为true,if(true)成立
		if(y=true){
			//左边：z==42,z++  成立,z变成43
			//&&短路与，不满足短路的情况，右边继续
			//y==true 成立
			//true && true，结果为true
			if((z++==42)&&(y==true)){
				//z++变成44
				z++;
			}
		}
		//左边：x=false不成立
		//中间虽然是短路或，但是没满足短路的情况，右边继续
		//++z,z==45  ++z变成45，z==45成立
		if((x=false) || (++z==45)){
			//z++，变成46
			z++;
		}
		System. out.println("z="+z);//46
	}
}

2.8.4 三元运算符

​ 三元运算符：Condition Operator

  1. 基础概念

    一元运算符： 单目运算符，表示操作数只有一个
    例如：逻辑非 ！
    算术运算符中的：正号+，负号-，自增++，自减–

    **二元运算符：*双目运算符，表示操作数有两个
    例如：算术运算符：加+，减-，乘    ，除/，模%
    赋值运算符：=，+=，-=。。。
    比较运算符：>,<,>=,<=,==,!=
    逻辑运算符：&,|,^,&&,||

    **三元运算符：**三目运算符

  2. 三元运算符的格式

数据类型 变量名 = (关系表达式)？结果1：结果2
  1. 计算方式

  • 条件判断的结果是true，三元运算符整体结果为结果1，赋值给变量。

  • 判断条件的结果是false，三元运算符整体结果为结果2，赋值给变量。

public static void main(String[] args) {
    int i = (1==2 ? 100 : 200);
    System.out.println(i);//200
    int j = (3<=4 ? 500 : 600);
    System.out.println(j);//500
}

2.8.5 位运算符

位运算符符号解释
&按位与，当两位相同时为1时才返回1
|按位或，只要有一位为1即可返回1
~按位非，将操作数的每个位（包括符号位）全部取反
^按位异或。当两位相同时返回0，不同时返回1
<<左移运算符：左移几位就相当于乘以2的几次方
>>右移运算符：右移几位就相当于除以2的几次方
>>>无符号右移运算符：往右移动后，左边空出来的位直接补0，不看符号位

  1. 如何区分&,|,^是逻辑运算符还是位运算符？

    ​ 如果操作数是boolean类型，就是逻辑运算符，如果操作数是整数，那么就位运算符。

2.8.6 运算符优先级

System.out.println(j);//500
}




### 2.8.5 位运算符

| 位运算符 | 符号解释                                                     |
| :------: | ------------------------------------------------------------ |
|   `&`    | 按位与，当两位相同时为1时才返回1                             |
|   `|`    | 按位或，只要有一位为1即可返回1                               |
|   `~`    | 按位非，将操作数的每个位（包括符号位）全部取反               |
|   `^`    | 按位异或。当两位相同时返回0，不同时返回1                     |
|   `<<`   | 左移运算符：左移几位就相当于乘以2的几次方                    |
|   `>>`   | 右移运算符：右移几位就相当于除以2的几次方                    |
|  `>>>`   | 无符号右移运算符：往右移动后，左边空出来的位直接补0，不看符号位 |

1. 如何区分&,|,^是逻辑运算符还是位运算符？

   ​	如果操作数是boolean类型，就是逻辑运算符，如果操作数是整数，那么就位运算符。



### 2.8.6 运算符优先级

![在这里插入图片描述](https://img-blog.csdnimg.cn/20190829115511995.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjAyMzc0NA==,size_16,color_FFFFFF,t_70)
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值