Day02-数据类型和运算符

最新推荐文章于 2024-07-08 17:49:05 发布
最新推荐文章于 2024-07-08 17:49:05 发布
阅读量985 收藏 10
点赞数 32
分类专栏： javase 文章标签： 开发语言 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cainiao_123456/article/details/139902711
版权

Day02-数据类型和运算符

Java学习笔记-JavaSE_Day02-数据类型和运算符

1 计算机如何存储数据

计算机世界中只有二进制。那么在计算机中存储和运算的所有数据都要转为二进制。包括数字、字符、图片、声音、视频等。

1.1 进制 (不需要做重点学习)

11.1 进制的分类
十进制二进制八进制十六进制
数字范围0-90-10-70-9，a-f
进位规则逢十进一逢二进一逢八进一逢十六进一
示例125011111011757D
说明每三位二进制是一位八进制值每四位二进制是一位十六进制值
1.1.2 进制的换算
十进制二进制八进制十六进制
0000
1111
21022
31133
410044
510155
611066
711177
81000108
91001119
10101012a或A
11101113b或B
12110014c或C
13110115d或D
14111016e或E
15111117f或F
16100002010

  • **十进制数据转成二进制数据：**使用除以2倒取余数的方式
    在这里插入图片描述

  • 二进制数据转成十进制数据：

    从右边开始依次是2的0次，2的1次，2的2次。。。。
    在这里插入图片描述

  • 二进制数据转八进制数据

    从右边开始，三位一组

    在这里插入图片描述

  • 二进制数据转十六进制数据

    从右边开始，四位一组

    在这里插入图片描述

1.1.3 程序员模式计算器
项目说明
HEX十六进制
DEC十进制
OCT八进制
BIN二进制

在这里插入图片描述

1.1.4 在代码中如何表示四种进制的常量值

请分别用四种类型的进制来表示10，并输出它的结果：（了解）

（1）十进制：正常表示

System.out.println(10);

（2）二进制：0b或0B开头

System.out.println(0B10);

（3）八进制：0开头

System.out.println(010);

（4）十六进制：0x或0X开头

System.out.println(0X10);

2 计算机存储单位

  • **字节（Byte）：**是计算机信息技术用于计量存储容量的一种计量单位，一字节等于八位。

  • **位（bit）：**是数据存储的最小单位。也就是二进制。二进制数系统中，每个0或1就是一个位，叫做bit（比特），其中8 bit 就称为一个字节(Byte)。

  • 转换关系：

    • 8 bit = 1 Byte
    • 1024 Byte = 1 KB
    • 1024 KB = 1 MB
    • 1024 MB = 1 GB
    • 1024 GB = 1 TB

3 Java的基本数据类型的存储范围（掌握）

在这里插入图片描述

float：单精度浮点型，占内存：4个字节，精度：科学记数法的小数点后6~7位

double：双精度浮点型，占内存：8个字节，精度：科学记数法的小数点后15~16位

4 计算机如何表示数据

4.1 原码、反码、补码与符号位概念

计算机数据的存储使用二进制补码形式存储，并且最高位是符号位，最高位1是负数，最高位0是正数。

规定：正数的补码与反码、原码一样，称为三码合一；

    *负数的补码与反码、原码不一样：*

   *负数的原码：把十进制转为二进制，然后最高位设置为1*

   *负数的反码：在原码的基础上，最高位不变，其余位取反（0变1,1变0）*

   *负数的补码：反码+1*
4.2 如何表示boolean类型的值

true底层使用1表示。

false底层使用0表示。

4.3 如何表示整数？
以byte整数为例byte类型（1个字节，8位）：
正数：25   00000000 00000000 000000000 00011001（原码）
正数：25   00000000 00000000 000000000 00011001（反码）
正数：25   00000000 00000000 000000000 00011001（补码）

负数：-25  10000000 00000000 000000000 00011001（原码）
负数：-25  11111111 11111111 111111111 11100110（反码）
负数：-25  11111111 11111111 111111111 11100111（补码）

一个字节可以存储的整数范围是多少？

1个字节：8位

0000 0001  ~  0111 111 ==> 1~127

1000 0001 ~ 1111 1111 ==> -127 ~ -1

0000 0000 ==>0

1000 0000 ==> -128（特殊规定）=-127-1
4.4 如何表示小数？

了解小数如何存储是为了理解如下问题：

  • 为什么float（4个字节）比long（8个字节）的存储范围大？
  • 为什么float和double不精确？
  • 为什么double（8个字节）比float（4个字节）精度范围大？

因为float、double底层也是二进制，先把小数转为二进制，然后把二进制表示为科学记数法，然后只保存：

①符号位②指数位（需要移位）③尾数位

在这里插入图片描述

float：符号位（1位），指数位（8位，偏移127），尾数位（23位）
double：符号位（1位），指数位（11位，偏移1023），尾数为（52位）
float指数-126~+127
double指数-1022~+1023

float类型
小数：8.25 1000.01
           1.00001（科学计数法）*2的3次，小数点往左移动3位
		   符号位0，指数位3+127（偏移量）=130->10000010，尾数00001
		   0 10000010 00001000000000000000000  原码
		   0 10000010 00001000000000000000000  反码
		   0 10000010 00001000000000000000000  补码
		   
小数：-8.25 -1000.01（原码）
		   1 10000010 00001000000000000000000  原码
		   1 01111101 11110111111111111111111  反码
		   1 01111101 11111000000000000000000  补码
		     
double类型：
小数：8.25 1000.01
           1.00001（科学计数法）
		   符号位0，指数位3+1023（偏移量）=1026->10000000010，尾数00001
		   0 10000000010  0000 10000000 00000000 00000000 00000000 00000000 00000000 原码
		   0 10000000010  0000 10000000 00000000 00000000 00000000 00000000 00000000 反码
		   0 10000000010  0000 10000000 00000000 00000000 00000000 00000000 00000000 补码
		   
double类型：
小数：-8.25 -1000.01（原码）
           1.00001（科学计数法）
		   符号位0，指数位3+1023（偏移量）=1026->10000000010，尾数00001
		   1 10000000010  0000 10000000 00000000 00000000 00000000 00000000 00000000 原码
		   1 01111111101  1111 01111111 11111111 11111111 11111111 11111111 11111111 反码
		   1 01111111101  1111 10000000 00000000 00000000 00000000 00000000 00000000 补码
		   
为什么float类型指数位偏移127，double类型指数位偏移1023。
因为指数+3，偏移127就是130		   
因为指数-3，偏移127就是124
130>124，比较大小比较方便。

在这里插入图片描述

4.5 Java程序中如何表示和处理单个字符？

（1）使用单引号将单个字符引起来：例如：‘A’，‘0’，‘尚’

char c = '尚';//使用单引号
String s = '尚';//错误的，哪怕是一个字符，也要使用双引号
		
char kongChar = '';//错误，单引号中有且只能有一个字符
String kongStr = "";//可以，双引号中可以没有其他字符，表示是空字符串

（2）特殊的转义字符

\n：换行
\r：回车
\t：Tab键
\\：\
\"："
\'：'
\b：删除键Backspace

public class TestEscapeCharacter {
    public static void main(String[] args){
        System.out.println("hello\tjava");
        System.out.println("hello\rjava");
        System.out.println("hello\njava");
        System.out.println("hello\\world");
        System.out.println("\"hello\"");
        char shuang = '"';
        System.out.println(shuang + "hello" + shuang);
        System.out.println("'hello'");
        char dan ='\'';
        System.out.println(dan + "hello" + dan);
    }
}

public class TestTab {
    public static void main(String[] args){
        System.out.println("hello\tworld\tjava.");
        System.out.println("atguigu\tis\tgood.");
        System.out.println("姓名\t基本工资\t年龄");
        System.out.println("张三\t10000.0\t23");
    }
}

（3）用十进制的0~65535之间的Unicode编码值，表示一个字符

在JVM内存中，一个字符占2个字节，Java使用Unicode字符集来表示每一个字符，即每一个字符对应一个唯一的Unicode编码值。char类型的数值参与算术运算或比较大小时，都是用编码值进行计算的。

字符Unicode编码值
‘0’48
‘1’49
‘A’65
‘B’66
‘a’97
‘b’98
‘尚’23578
char c1 = 23578;
System.out.println(c1);//尚

char c2 = 97;
System.out.println(c2);//a

//如何查看某个字符的Unicode编码？
//将一个字符赋值给int类型的变量即可
int codeOfA = 'A';
System.out.println(codeOfA);

int codeOfShang = '尚';
System.out.println(codeOfShang);

int codeOfTab = '\t';
System.out.println(codeOfTab);

（4）\u字符的Unicode编码值的十六进制型

例如：‘\u5c1a’代表’尚’

char c = '\u0041'; //十进制Unicode值65，对应十六进制是41，但是\u后面必须写4位
char c = '\u5c1a'; //十进制Unicode值23578，对应十六进制是5c1a
4.6 一个字符到底占几个字节？

在JVM内存中，一个字符占2个字节，Java使用Unicode字符集来表示每一个字符，即每一个字符对应一个唯一的Unicode编码值。char类型的数值参与算术运算或比较大小时，都是用编码值进行计算的。

在文件中保存或网络中传输时文本数据时，和环境编码有关。如果环境编码选择ISO8859-1（又名Latin），那么一个字符占一个字节；如果环境编码选择GBK，那么一个字符占1个或2个字节；如果环境编码选择UTF-8，那么一个字符占1-4个字节。（后面讲String类时再详细讲解）

2 基本数据类型转换（Conversion）

在Java程序中，不同的基本数据类型的值经常需要进行相互转换。Java语言所提供的七种数值类型之间可以相互转换，基本数据类型转换有两种转换方式：自动类型转换和强制类型转换。boolean类型不参与。

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

自动转换：

  • 将取值范围小的类型自动提升为取值范围大的类型 。

基本数据类型的转换规则如图所示：

在这里插入图片描述

（1）当把存储范围小的值（常量值、变量的值、表达式计算的结果值）赋值给了存储范围大的变量时。

int i = 'A';//char自动升级为int，其实就是把字符的编码值赋值给i变量了
double d = 10;//int自动升级为double

byte b = 127; //右边的整数常量值必须在-128~127范围内
//byte bigB = 130;//错误，右边的整数常量值超过byte范围
long num = 1234567; //右边的整数常量值如果在int范围呢，编译和运行都可以通过，这里涉及到数据类型转换
long bigNum = 12345678912L;//右边的整数常量值如果超过int范围，必须加L，否则编译不通过

（2）当存储范围小的数据类型与存储范围大的数据类型一起混合运算时，会按照其中最大的类型运算。

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

double sum = i + b + d;//混合运算，升级为double

（3）当byte,short,char数据类型进行算术运算时，按照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

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

将1.5 赋值到int 类型变量会发生什么？产生编译失败，肯定无法赋值。

int i = 3.14; // 错误

想要赋值成功，只有通过强制类型转换，将double 类型强制转换成int 类型才能赋值。

  • 强制类型转换：将取值范围大的类型强制转换成取值范围小的类型。

比较而言，自动转换是Java自动执行的，而强制转换需要我们自己手动执行。

转换格式：

数据类型 变量名 = （数据类型）被强转数据值;  //()中的数据类型必须<=变量的数据类型，一般都是=

（1）当把存储范围大的值（常量值、变量的值、表达式计算的结果值）赋值给了存储范围小的变量时，需要强制类型转换，提示：有风险，可能会损失精度或溢出

int i = (int)3.14;//强制类型转换，损失精度

double d = 1.2;
int num = (int)d;//损失精度

int i = 200;
byte b = (byte)i;//溢出

（2）当某个值想要提升数据类型时，也可以使用强制类型转换

int i = 1;
int j = 2;
double shang = (double)i/j;

提示：这个情况的强制类型转换是没有风险的。

2.3 基本数据类型与字符串类型的转换

1、任意数据类型的数据与String类型进行“+”运算时，结果一定是String类型

System.out.println("" + 1 + 2);//12

2、但是String类型不能通过强制类型()转换，转为其他的类型

String str = "123";
int num = (int)str;//错误的
int num = Integer.parseInt(str);//后面才能讲到，借助包装类的方法才能转

3 运算符（Operator）（掌握）

在Java8中，一共有38个运算符。

在这里插入图片描述

3.1 运算符的分类

（1）按照功能分：算术运算符、赋值运算符、比较运算符、逻辑运算、条件运算符、Lambda运算符

分类运算符
算术运算符（7个）+、-、*、/、%、++、–
赋值运算符（12个）=、+=、-=、*=、/=、%=、>>=、<<=、>>>=、&=、|=、^=等
关系、比较运算符（6个）>、>=、<、<=、==、!=
逻辑运算符（6个）&、|、^、!、&&、||
条件运算符（2个）条件表达式?结果1:结果2
位运算符（7个）&、|、^、~、<<、>>、>>>
Lambda运算符（1个）->（后面学）

（2）按照操作数个数分：一元运算符（单目运算符）、二元运算符（双目运算符）、三元运算符 （三目运算符）

分类运算符
一元运算符（单目运算符）正号（+）、负号（-）、++、–、!、~
二元运算符（双目运算符）除了一元和三元运算符剩下的都是二元运算符
三元运算符 （三目运算符）(条件表达式)?结果1:结果2

3.2 赋值运算符（上）

赋值运算符分为两种：

  • 最基础的赋值运算符：=
  • 组合的赋值运算符：+=、-=、*=、/=、%=、>>=、<<=、>>>=、&=、|=、^=等
public class AssignOperator1 {
	public static void main(String[] args) {
		int a = 3;
		int b = 4;
        int c = a + b;        

		System.out.println(a); // 3
		System.out.println(b); // 4	
        System.out.println(c); //7
        System.out.println("--------------------------");
        
        a = b;
        System.out.println(a); // 4	  a被重新赋值为b变量的值4
		System.out.println(b); // 4	  b并没有被重新赋值
        System.out.println(c); //7	  7并没有被重新赋值
    }
}

运算规则和要求：

（1）=左边一定是一个变量，右边可以是常量、变量、表达式
（2）赋值运算一定是最后算的，优先级最低
（3）=右边值的类型必须 “小于等于” 左边变量的类型

3.3 算术运算符

算术运算符符号解释
+加法运算，字符串连接运算，正号
-减法运算，负号
*乘法运算
/除法运算，整数/整数结果还是整数
%求余运算，余数的符号只看被除数
++ 、 --自增自减运算
3.3.1加减乘除模
public class OperatorDemo01 {
	public static void main(String[] args) {
		int a = 3;
		int b = 4;
		
		System.out.println(a + b);// 7
		System.out.println(a - b);// -1
		System.out.println(a * b);// 12
		System.out.println(a / b);// 计算机结果是0，为什么不是0.75呢？
		System.out.println(a % b);// 3
        
        System.out.println(5%2);//1
		System.out.println(5%-2);//1
		System.out.println(-5%2);//-1
		System.out.println(-5%-2);//-1		
		//商*除数 + 余数 = 被除数
		//5%-2  ==>商是-2，余数时1    (-2)*(-2)+1 = 5
		//-5%2  ==>商是-2，余数是-1   (-2)*2+(-1) = -4-1=-5
	}
}
3.1.2 “+”号的三种用法
  • 第一种：对于+两边都是数值的话，+就是加法的意思
  • 第二种：对于+两边至少有一边是字符串的话，+就是拼接的意思
  • 第三种：对于+作为一元运算符的话，+就是表示正号的意思
public class OperatorDemo02 {
	public static void main(String[] args) {
		// 字符串类型的变量基本使用
		// 数据类型 变量名称 = 数据值;
		String str1 = "Hello";
		System.out.println(str1); // Hello
		
		System.out.println("Hello" + "World"); // HelloWorld
		
		String str2 = "Java";
		// String + int --> String
		System.out.println(str2 + 520); // Java520
		// String + int + int
		// String		+ int
		// String
		System.out.println(str2 + 5 + 20); // Java520
        
        int a = 5;
        int b = +a;
        int c = -a;
        System.out.println("a = " + a);
        System.out.println("b = " + b);
        System.out.println("c = " + c);
	}
}
3.1.3 自加自减运算

理解：++ 运算，变量自己的值加1。反之，-- 运算，变量自己的值减少1，用法与++ 一致。

1、单独使用

  • 变量在单独运算的时候，变量前++和变量后++，变量的是一样的；
  • 变量前++ ：例如 ++a 。
  • 变量后++ ：例如 a++ 。
public class OperatorDemo3 {
	public static void main(String[] args) {
		// 定义一个int类型的变量a
		int a = 3;
		//++a;
		a++;
        // 无论是变量前++还是变量后++，结果都是4
		System.out.println(a);
	}
}

2、复合使用

  • 和其他变量放在一起使用或者和输出语句放在一起使用，前++和后++就产生了不同。
  • 变量前++ ：变量先自身加1，然后再取值。
  • 变量后++ ：变量先取值，然后再自身加1。
public class OperatorDemo03 {
	public static void main(String[] args) {
		// 其他变量放在一起使用
		int x = 3;
		//int y = ++x; // y的值是4，x的值是4，
		int y = x++; // y的值是3，x的值是4
		
		System.out.println(x);
		System.out.println(y);
		System.out.println("==========");
        
		// 和输出语句一起
		int z = 5;
		//System.out.println(++z);// 输出结果是6，z的值也是6
		System.out.println(z++);// 输出结果是5，z的值是6
		System.out.println(z);
        
        int a = 1;
        a = a++;//(1)先取a的值“1”放操作数栈(2)a再自增,a=2(3)再把操作数栈中的"1"赋值给a,a=1

        int i = 1;
        int j = i++ + ++i * i++;
        /*
        从左往右加载
        (1)先算i++
        ①取i的值“1”放操作数栈
        ②i再自增 i=2
        （2）再算++i
        ①i先自增 i=3
        ②再取i的值“3”放操作数栈
        （3）再算i++
        ①取i的值“3”放操作数栈
        ②i再自增 i=4
        （4）先算乘法
        用操作数栈中3 * 3 = 9，并把9压会操作数栈
        （5）再算求和
        用操作数栈中的 1 + 9 = 10
        （6）最后算赋值
        j = 10
        */
	} 
}
  • 小结：
    • ++在前，先自加，后使用；
    • ++在后，先使用，后自加。
  • 分析
public class TestIncrementOperator1{
	public static void main(String[] args){
		int i = 1;
		i++;
		++i;
	}
}

在这里插入图片描述

public class TestIncrementOperator2{
	public static void main(String[] args){
		int i = 1;
		i = i++;
	}
}

在这里插入图片描述

public class TestIncrementOperator3{
	public static void main(String[] args){
		int i = 1;
		i = ++i;
	}
}

在这里插入图片描述

3.4 关系运算符/比较运算符

关系运算符符号解释
<比较符号左边的数据是否小于右边的数据，如果小于结果是true。
>比较符号左边的数据是否大于右边的数据，如果大于结果是true。
<=比较符号左边的数据是否小于或者等于右边的数据，如果大于结果是false。
>=比较符号左边的数据是否大于或者等于右边的数据，如果小于结果是false。
==比较符号两边数据是否相等，相等结果是true。
！=不等于符号 ，如果符号两边的数据不相等，结果是true。
  • 比较运算符，是两个数据之间进行比较的运算，运算结果一定是boolean值true或者false 。
  • 其中>,<,>=,<=不支持boolean，String类型，==和!=支持boolean和String。
public class OperatorDemo05 {
	public static void main(String[] args) {
		int a = 3;
		int b = 4;

		System.out.println(a < b); // true
		System.out.println(a > b); // false
		System.out.println(a <= b); // true
		System.out.println(a >= b); // false
		System.out.println(a == b); // false
		System.out.println(a != b); // true
	}
}

3.5 逻辑运算符

  • 逻辑运算符，是用来连接两个布尔类型值的运算符（!除外），运算结果也是boolean值true或者false
逻辑运算符符号解释符号特点
&与，且有false则false
``或
^异或相同为false，不同为true
!非非false则true，非true则false
&&双与，短路与左边为false，则右边就不看
``

&&和&区别，||和|区别：

  • **&&和&**区别：
    • &&和&结果一样，&&有短路效果，左边为false，右边不执行；&左边无论是什么，右边都会执行。
  • **||和|**区别：
    • ||和|结果一样，||有短路效果，左边为true，右边不执行；|左边无论是什么，右边都会执行。
public class OperatorDemo06 {
	public static void main(String[] args) {
		int a = 3;
		int b = 4;
		int c = 5;

		// & 与，且；有false则false
		System.out.println((a > b) & (a > c)); 
		System.out.println((a > b) & (a < c)); 
		System.out.println((a < b) & (a > c)); 
		System.out.println((a < b) & (a < c)); 
		System.out.println("===============");
		// | 或；有true则true
		System.out.println((a > b) | (a > c)); 
		System.out.println((a > b) | (a < c)); 
		System.out.println((a < b) | (a > c));
		System.out.println((a < b) | (a < c));
		System.out.println("===============");
		// ^ 异或；相同为false，不同为true
		System.out.println((a > b) ^ (a > c));
		System.out.println((a > b) ^ (a < c)); 
		System.out.println((a < b) ^ (a > c)); 
		System.out.println((a < b) ^ (a < c)); 
		System.out.println("===============");
		// ! 非；非false则true，非true则false
		System.out.println(!false);
		System.out.println(!true);
        
        //&和&&的区别
        System.out.println((a > b) & (a++ > c)); 
        System.out.println("a = " + a);
        System.out.println((a > b) && (a++ > c)); 
        System.out.println("a = " + a);
        System.out.println((a == b) && (a++ > c)); 
        System.out.println("a = " + a);
        
        //|和||的区别
        System.out.println((a > b) | (a++ > c)); 
        System.out.println("a = " + a);
        System.out.println((a > b) || (a++ > c)); 
        System.out.println("a = " + a);
        System.out.println((a == b) || (a++ > c)); 
        System.out.println("a = " + a);
	}
}

/*
3、逻辑运算符
逻辑与：&
	true & true 结果是true
	true & false 结果是false
	false & true 结果是false
	false & false 结果是false
	
	只有两个边都是true，结果才为true。

逻辑或：|
	true | true 结果是true
	true | false 结果是true
	false | true 结果是true
	false | false 结果是false
	
	只要有一边是true，结果就为true。
	
逻辑非：!
	!true  变为false
	!false 变为true
	
逻辑异或：^
	true | true 结果是false
	true | false 结果是true
	false | true 结果是true
	false | false 结果是false
	
	只有两边不一样，一个是true，一个是false，结果才为true。
	
短路与：&&
	true && true 结果是true
	true && false 结果是false
	false && ? 结果是false
	false && ? 结果是false
	
	只有两个边都是true，结果才为true。
	但是它如果左边已经是false，右边不看。这样的好处就是可以提高效率。

	
短路或：||
	true || ？ 结果是true
	true || ？ 结果是true
	false || true 结果是true
	false || false 结果是false
	
	只要有一边是true，结果就为true。
	但是它如果左边已经是true，右边就不看了。这样的好处就是可以提高效率。

特殊：
（1）逻辑运算符的操作数必须是boolean值
（2）逻辑运算符的结果也是boolean值

*/
public class LogicOperator{
	public static void main(String[] args){
		/*
		表示条件，成绩必须在[0,100]之间
		成绩是int类型变量score
		*/
		int score = 56;
		
		//System.out.println(0<=score<=100);
		/*
		LogicOperator.java:23: 错误: 二元运算符 '<=' 的操作数类型错误
                System.out.println(0<=score<=100);
                                           ^
		  第一个类型:  boolean    0<=score的结果 true
		  第二个类型: int
		  
		  true <= 100？不对的
		1 个错误*/
		
		System.out.println(0<=score  & score<=100);
		
	}
}

3.6 条件运算符

  • 条件运算符格式：
条件表达式？结果1：结果2
  • 条件运算符计算方式：
    • 条件判断的结果是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
}

public class ConditionOperator{
	public static void main(String[] args){
		//判断两个变量a,b谁大，把大的变量赋值给max
		int a = 2;
		int b = 2;
		int max = a >= b ? a : b;
		//如果a>=b成立，就取a的值赋给max，否则取b的值赋给max
		System.out.println(max);
		
		boolean marry = false;
		System.out.println(marry ? "已婚" : "未婚"  );
	}
}

3.7 位运算符

位运算符符号解释
&按位与，当两位相同时为1时才返回1
``
~按位非，将操作数的每个位（包括符号位）全部取反
^按位异或。当两位相同时返回0，不同时返回1
<<左移运算符
>>右移运算符
>>>无符号右移运算符
  • 位运算符的运算过程都是基于补码运算，但是看结果，我们得换成原码，再换成十进制看结果
  • 从二进制到十进制都是基于原码
  • 正数的原码反码补码都一样，负数原码反码补码不一样
  • byte,short,char在计算时按照int类型处理

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

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

3.7.1 左移：<<
运算规则：左移几位就相当于乘以2的几次方

**注意：**当左移的位数n超过该数据类型的总位数时，相当于左移（n-总位数）位

			byte,short,char在计算时按照int类型处理

3<<4  类似于  3*2的4次= 3*16 = 48

在这里插入图片描述

-3<<4  类似于  -3*2的4次= -3*16 = -48

在这里插入图片描述

3.7.2 右移：>>

快速运算：类似于除以2的n次，如果不能整除，向下取整

69>>4  类似于  69/2的4次 = 69/16 =4

在这里插入图片描述

-69>>4  类似于  -69/2的4次 = -69/16 = -5

在这里插入图片描述

3.7.3 无符号右移：>>>

运算规则：往右移动后，左边空出来的位直接补0，不看符号位

正数：和右移一样

负数：右边移出去几位，左边补几个0，结果变为正数

69>>>4  类似于  69/2的4次 = 69/16 =4

在这里插入图片描述

-69>>>4   结果：268435451

在这里插入图片描述

3.7.4 按位与：&

运算规则：对应位都是1才为1

	1 & 1 结果为1

	1 & 0 结果为0

	0 & 1 结果为0

	0 & 0 结果为0

9&7 = 1

在这里插入图片描述

-9&7 = 7

在这里插入图片描述

3.7.5 按位或：|

运算规则：对应位只要有1即为1

	1 | 1 结果为1

	1 | 0 结果为1

	0 | 1 结果为1

	0 & 0 结果为0

9|7  结果： 15

在这里插入图片描述

-9|7 结果： -9

在这里插入图片描述

3.7.6 按位异或：^
运算规则：对应位一个为1一个为0，才为1

	1 ^ 1 结果为0

	1 ^ 0 结果为1

	0 ^ 1 结果为1

	0 ^ 0 结果为0

9^7  结果为14

在这里插入图片描述

-9^7 结果为-16

在这里插入图片描述

3.7.7 按位取反：~

运算规则：~0就是1

		   ~1就是0

~9  结果：-10

在这里插入图片描述

~-9  结果：8

在这里插入图片描述

3.7.8 程序员模式计算器
项目说明
BYTE1个字节
WORD2个字节
DWORD4个字节
QWORD8个字节
AND按位与 &
OR按位或 |
NOT按位取反 ~
XOR按位异或 ^
<<（算术移位）左移 <<
>>（算术移位）右移 >>
>>（逻辑移位）无符号右移 >>>

在这里插入图片描述

3.8 赋值运算符（下）

运算符符号解释
=将右边的常量值/变量值/表达式的值，赋值给左边的变量
+=将左边变量的值和右边的常量值/变量值/表达式的值进行相加，最后将结果赋值给左边的变量
-=将左边变量的值和右边的常量值/变量值/表达式的值进行相减，最后将结果赋值给左边的变量
*=将左边变量的值和右边的常量值/变量值/表达式的值进行相乘，最后将结果赋值给左边的变量
/=将左边变量的值和右边的常量值/变量值/表达式的值进行相除，最后将结果赋值给左边的变量
%=将左边变量的值和右边的常量值/变量值/表达式的值进行相模，最后将结果赋值给左边的变量
<<=将左边变量的值左移右边常量/变量值/表达式的值的相应位，最后将结果赋值给左边的变量
>>=将左边变量的值右移右边常量/变量值/表达式的值的相应位，最后将结果赋值给左边的变量
>>>=将左边变量的值无符号右移右边常量/变量值/表达式的值的相应位，最后将结果赋值给左边的变量
&=将左边变量的值和右边的常量值/变量值/表达式的值进行按位与，最后将结果赋值给左边的变量
|=将左边变量的值和右边的常量值/变量值/表达式的值进行按位或，最后将结果赋值给左边的变量
^=将左边变量的值和右边的常量值/变量值/表达式的值进行按位异或，最后将结果赋值给左边的变量
public class OperatorDemo04 {
	public static void main(String[] args) {
		int a = 3;
		int b = 4;
        int c = a + b;        
        
		b += a;// 相当于 b = b + a ; 
		System.out.println(a); // 3
		System.out.println(b); // 7	
        System.out.println(c); //7
		
		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
        
        int m = 1;
        m <<= 2;
        System.out.println(m);
	}
}

运算规则和要求：

（1）=左边一定是一个变量，右边可以是常量、变量、表达式
（2）赋值运算一定是最后算的，优先级最低
（3）如果是=赋值运算符，那么=右边值的类型必须 “小于等于” 左边变量的类型
    如果是+=，-=等组合赋值运算符，那么
    	要是最后计算计算结果值的类型 “小于等于” 左边变量的类型 时，正常赋值；
    	要是最后计算计算结果值的类型 “大于” 左边变量的类型时，会隐式的发生强制类型转换。

3.9 运算符优先级

在这里插入图片描述

提示说明：

（1）表达式不要太复杂

（2）先算的、或表示整体的使用()

口诀：

单目运算排第一；

乘除余二加减三；

移位四，关系五；

等和不等排第六；

位与、异或和位或；

短路与和短路或；

依次从七到十一；

条件排在第十二；

赋值一定是最后；

int i = 1;
int x = i++ * (i++ + 1);

4 标点符号（Separators）

在Java8中一共有12个标点符号。（从一开始就需要开始留意代码中不同位置使用的不同标点符号，训练眼力）

在这里插入图片描述

  • 小括号/圆括号()用于强制类型转换、表示优先运算表达式、方法参数列表
  • 大括号/花括号{}用于数组元素列表、类体、方法体、复合语句代码块边界符
  • 中括号/方括号[]用于数组
  • 分号;用于结束语句
  • 逗号,用于多个赋值表达式的分隔符和方法参数列表分隔符
  • 英文句号.用于成员访问和包目录结构分隔符
  • 英文省略号…用于可变参数
  • @用于注解
  • 双冒号::用于方法引用

各个标点符号以后会有说明。

class Sign{
	public static void main(String[] args){
		int x,y,z;//声明了3个int类型的变量
		int a = 1, b = 2, c = 1;//声明了3个int类型的变量，并且初始化
		//int m = n = 1;//n没有声明
	}
}

声明：本人还是一个Java学习者如果有错误的地方还请指正，望各位大佬不吝赐教

小鱼儿y
关注
  • 32
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
day03-基础语法-运算符
12-12
需要注意的是，当不同类型的数据（如整数和字符）进行运算时，会进行类型转换。 2. 赋值运算符：最常见的赋值运算符是等号（=），用于将右边的值赋给左边的变量。此外，还有复合赋值运算符，如 `+=`、`-=`、`*=`、`...
day02 【数据类型转换、运算符、方法入门】.zip
12-11
在这个"day02 【数据类型转换、运算符、方法入门】"的学习资料中，我们将深入探讨这些关键概念。 首先，我们来讨论数据类型转换。在Java中，主要有两种类型的转换：自动类型转换（也称为隐式转换）和强制类型转换...
day02-运算符及控制台.pdf
01-16
算术运算符在处理不同数据类型时，遵循自动类型提升的规则。例如，`byte`、`short`和`char`类型会被提升为`int`，`float`会被提升为`double`。需要注意的是，整数除法只返回整数部分，如果想要得到小数，至少有一个...
day01数据类型和运算符.txt
08-22
day01数据类型和运算符,数据属性,js 的引用,打印语句输出，如何检测数据类型，变量声明 ，运算符
新型开发语言的试用感受-仓颉语言发布之际
opendba的专栏
07-03 1158
Zig、Odin、Mojo、codon、carbon、nim等语言的使用感受
JVM原理（十一）：JVM虚拟机六种必需对类进行初始化的情况
zuodingquan666的博客
07-03 531
Java虚拟机把描述类的数据从Class文件加载到内存，并对数据进行校验、转换解析和初始化，最终形成可以被虚拟机直接使用的Java类型，这个过程被称作虚拟机的类加载机制。Java天生可以动态扩展的语言特性就是依赖运行期间动态加载和动态链接这个特点实现的。
已解决 javax.xml.transform.TransformerFactoryConfigurationError 异常的正确解决方法，亲测有效！！！
小明的Java问道之路
07-08 553
已解决 javax.xml.transform.TransformerFactoryConfigurationError 异常的正确解决方法，亲测有效！！！
如何在淘客返利系统中实现高效的搜索与推荐算法
微赚淘客开发者博客
07-08 370
本文介绍了如何在淘客返利系统中实现高效的搜索与推荐算法，涵盖了倒排索引技术、搜索结果排序优化以及协同过滤、基于内容的推荐算法的实现方法和示例。通过合理选择和优化算法，可以显著提升系统的搜索效率和推荐精度，从而增强用户体验和平台的竞争力。微赚淘客系统3.0小编出品，必属精品，转载请注明出处！
springboot中抽离日志
qq_24223159的博客
07-08 160
【代码】springboot中抽离日志。
ShardingSphere
Casual_Lei的博客
07-04 655
ShardingSphere 通过提供数据分片、分布式事务、数据加密和读写分离等功能，帮助开发者轻松构建高性能、高可用的分布式数据库系统。其灵活的架构设计和丰富的功能模块，使其成为现代分布式数据库中间件的优秀选择。
maven配置使用nexus仓库
ApexPredator的博客
07-03 227
maven配置使用nexus仓库
图片压缩代码和实际操作页面
英雄汉孑的博客
07-05 921
轻盈视界，高清依旧 —— 智能图片压缩，大容量，小体积，精彩不打折
JavaSE阶段面试题（一）
tq02的博客
07-03 608
本章节主要讲述SE阶段的常见面试题
返回值处理器器【Spring源码学习】
weixin_44794897的博客
07-05 265
定义返回值类型处理器的组合；测试使用的controller测试方法。
学习mybatis
最新发布
weixin_45621552的博客
07-08 372
【代码】学习mybatis。
使用Mybatis批量插入大量数据的实践
做从未做的事，叫成长；做不愿做的事，叫改变；做不敢做的事，叫突破。
07-05 1259
在项目开发过程中，我们经常会有批量插入的需求，例如：定时统计任务但是受限于MySQL中参数限制，5.7版本默认值为4M，这显然不太符合我们的需求，当然我们也可以通过修改此值来适应我们业务，今天分享在不修改此值的情况下，如何在客户端优雅的处理此场景现在整个世界都变优雅了！
Android | RxJava 中的调度器（Schedulers）的主要作用是什么？
liuruiaaa的博客
07-03 291
Android | RxJava 中的调度器（Schedulers）的主要作用是什么？
001 进程和线程
m0_46695127的博客
07-04 183
001 进程和线程
2022吉林大学《C语言程序设计基础》课程-第三章-数据类型运算符与表达式精选ppt.ppt
11-14
"2022吉林大学《C语言程序设计基础》课程的第三章主要讲解了数据类型、运算符和表达式。本章涵盖了C语言中的数据类型，包括常量与变量，以及各种类型的数值数据，如整型、浮点型和字符型。此外，还介绍了变量赋初值...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值