Bootstrap

二.变量、数据类型、运算符

一、变量

1.1 概念

在程序运行中，可以发生改变的量。

在内存中，需要一个空间，临时存储数据。

1.2 变量的组成及定义

  • 数据类型 变量名 值

  • 声明的同时并赋值

    • 数据类型 变量名 = 值;

  • 先声明，后赋值

    • 数据类型 变量名; 变量名 = 值

  • 多个同类型的变量声明与赋值。

    • 数据类型 变量名1,变量名2,变量名3;
    • 变量名1 = 值；变量名2 = 值；变量名3 = 值；

  • 代码实现：

    • public class VarTest{
	public static void main(String[] args){
		//1.声明同时 赋值
		int a = 10;
		
		System.out.println(a);
		
		//2.先声明，后赋值
		int b;
		b = 20;
		System.out.println(b);
		
		//3.同类型的声明与赋值（了解）
		int c = 30,d,e;
		//c = 30;
		//d = 40;
		e = 50;
		System.out.println(c);
		System.out.println(d);
		System.out.println(e);
	}
}

    1.3 变量的使用注意事项

    public class VarTest1{
	public static void main(String[] args){
		//1.变量不初始化，不能使用
		int a = 20;
		
		System.out.println(a);
		//2.在相同作用域（{}作用域）中，不能定义重名的变量
		//int a = 30;
		//System.out.println(a);
		
		//3.变量在使用时，可以与""字符串拼接
		int b = 20;
		int c = 30;
		int d = 40;
		//+在Java中，任何变量与字符串相加，实为拼接。
		System.out.println("b="+b+",c="+c+",d="+d);
		//b=20,c=30,d=40
		
		//4.变量在作用域中，可以更改值
		d = 128;
		System.out.println("d="+d);
	}
}

二、数据类型

2.1 概念

  • 不同的数据，分配不同的空间，来存储数据。避免空间的不足、空间的浪费。
  • 基本数据类型：
    • 4类8种
    • 整数型：byte 1字节、short 2字节、int 4字节、long 8字节
    • 浮点数型：float 4字节、double 8字节
    • 字符型：char 2字节
    • 布尔型：boolean 1字节
  • 引用数据类型：
    • 基本数据类型以外的全是引用数据类型

2.2 计算机存储单位

  • 字节->kb->mb->gb->tb->pb
  • 以上单位都是1024进制。
  • bit（位）->字节 8个bit ->1字节
  • 0111 1111

2.3 整数类型

/*
	byte   1  -2^7 ~ 2^7-1   -128 ~ 127
	short  2  -2^15 ~ 2^15-1
	int    4  -2147483648~2147483647
	long   8  -922京 ~ 922京
	
	1、int是Java中整数的默认类型。 超过int类型，则提示过大的整数
	2、超过int范围的数字，要存储在long里，要加l/L的标识
*/
public class IntTest{
	public static void main(String[] args){
		byte b = 127;
		System.out.println("b="+b);
		
		short s = 32767;
		System.out.println("s="+s);
		
		int i = 21_4748_3647;
		System.out.println("i="+i);
		
		long l = 2147483648L;
		System.out.println("l="+l);
	}
	
}

2.4 浮点数类型

/*
	float:  4   单精度
	double: 8   双精度
	   符号位  指数位  尾数位
float 	 1       8      23    838_8608  = 7位精确小数
double   1       11     52     4503_5996_2737_0496   16位精确小数  最高

	
	1、浮点数的默认类型是double
	2、存储float类型的数据，要加f/F的标识
	3、能精确模拟的小数，就不会保留多余的位数
	4、要用小数做运算的场景，不会用float和double，BigDecimal
	5、浮点数类型的范围>整数类型。
*/
public class DoubleTest{
	public static void main(String[] args){
		float f = 3.14F;
		System.out.println("f="+f);
		
		double d = 3.14;
		System.out.println("d="+d);
		
		double dd = 3.111111111111111111111111111;
		System.out.println(dd);
		
		double d1 = 0.1;
		double d2 = 0.2;
		System.out.println(d1+d2);//0.30000000000000004
		
		double d3 = 0.3;
		System.out.println(d3);
		
		double score = 99.5;
	
	}
	
}

2.5 字符类型

/*
	char 表示单个字符  0101  ASCII   本质存储的是字符的编码值
	
	1、Java中char存储的unicode编码 所有的国家的文字都可以表示
	2、char可以存储字符，字符会转换为编码值，也可以直接存储编码值
	3、char不能直接存储空字符''  '\0'可以  空格也可以。
*/
public class CharTest{
	public static void main(String[] args){
		//0 1   男  女
		//char c7 = ' ';
		char c7 = '\0';
		System.out.println("c7="+c7);
		
		char c = 'A';
		System.out.println("c="+c);
		
		char c2 = 'の';
		System.out.println("c2="+c2);
		
		char c3 = '你';
		System.out.println("c3="+c3);
		
		char c4 = 65;
		System.out.println("c4="+c4);
		
		char c5 = 20320;
		System.out.println("c5="+c5);
		
		//了解
		char c6 = '\u4f60';
		System.out.println("c6="+c6);
	}
	
}

转义字符：

/*
	转义字符：
		\：将普通字符转换为特殊的符号
			将特殊符号转换为普通字符
	\n：换行
	\t：一个水平制表位  大空格
	\"：将字符串的"转换为普通符号
	\': 字符的符号转换为普通符号
	\b：退格
	\r：回车  回到开头
*/
public class CharTest2{
	public static void main(String[] args){
		System.out.println("白日依山尽，\n黄河入海流。");
		
		System.out.println("白日依山尽，\t黄河入海流。");
		
		System.out.println("\"白日依山尽，\"\t黄河入海流。");
		
		System.out.println("白日依山尽，'黄河入海流。");
		
		System.out.println("白日依山尽，\b黄河入海流。");
		
		System.out.println("白日依山尽，\r黄河入海流。");
		
		char c = '\'';
		System.out.println(c);
	}
	
}

2.6 boolean类型 布尔

/*
	boolean 类型 取值  true  false
*/
public class BooleanTest{
	public static void main(String[] args){
		boolean b = true;
		b = false;
		System.out.println("b="+b);
		
		//做为判断的结果
		System.out.println(3 > 2);
	}
	
}

2.7 String 引用数据类型

  • String代表的是字符串，不属于基本数据类型，属于引用数据类型，类型是String，本质上是一个类，但是String类型定义赋值的时候，而是和基本数据类型一样。

  • public class StringTest{
	public static void main(String[] args){
		String s = "我是一个好人！";
		System.out.println(s);
		System.out.println("s="+s);
		System.out.println("请输入菜单的选项：");
		System.out.println("1：注册");
		System.out.println("2：登录");
	}
	
}

三、进制（了解）

3.1 进制的转换

十进制二进制八进制十六进制
0000
1111
21022
31133
410044
510155
611066
711177
81000108
91001119
10101012a或A
11101113b或B
12110014c或C
13110115d或D
14111016e或E
15111117f或F
16100002010

在这里插入图片描述

3.2 二进制存储

/*	
	无论是什么进制，最终计算机存储的都是二进制
	二进制是如何表示整数的：
		1.二进制存储的是补码  最高位 是符号位 0正数  1 负数
		2.正整数 三码合一 原码、 反码、补码是一样的。
		3.负整数
			原码：10进制转换为2进制 且最高位是1
			反码：最高位不变 其余位取反 
			补码：反码+1
		
		-6
			原码：1000 0110
			反码：1111 1001
			补码：1111 1010   计算机存储的
		-25 
			原码：1001 1001
			反码：1110 0110
			补码：1110 0111  计算机存储的
		
		
	byte = 1字节 = 8位
	1000 0000 
	0000 0000 0000 0000 
*/

public class DataTest{
	public static void main(String[] args){
		System.out.println(100);
		
		System.out.println("二进制：");
		System.out.println(0b110);
		System.out.println(0B110);
		
		System.out.println("八进制");
		System.out.println(0110);
		
		System.out.println("十六进制");
		System.out.println(0x11);
	}
}

四、数据类型转换

4.1 数据类型转换概念

  • 数据类型转换发生在7个基本数据类型里，除了boolean。
  • 等号左右两侧的类型不一致时，就会发生数据类型转换。

4.2 自动类型提升

/*
	byte    1   水杯
	short   2   水壶
	char    2   水壶
	int     4   水桶
	float   4   水缸
	long    8   水池
	double  8   大河
	
	自动类型提升：
		1.小的数据类型的值赋值给大的数据类型
		2.如果多个类型的值做运算，结果是最大的类型
		3.特殊：任何数据类型和String做+拼接时，结果都是String类型。
*/
public class ConvertTest{
	public static void main(String[] args){
		
		//System.out.println(9+7+"HelloWorld");
		System.out.println(9+"HelloWorld"+7);
		
		
		//2.如果多个类型的值做运算，结果是最大的类型
		float result = 30+20L+3.14F;
		System.out.println(result);
		
		//1.将小的数据类型的值赋值给大的数据类型
		byte b = 10;
		int i = b;
		System.out.println(i);
		
		char c = 'c';//99
		int i2 = c;
		System.out.println(i2);
		
		int i3 = 200;
		float f = i3;
		System.out.println(f);
		
		long l = 300;
		float f2 = l;
		System.out.println(f2);
	}
}

4.3 强制类型转换

/*
	byte    1   水杯
	short   2   水壶  -32768 ~ 32767
	char    2   水壶  无符号 0~65535
	int     4   水桶
	float   4   水缸
	long    8   水池
	double  8   大河
	
	自动类型提升：
		1.小的数据类型的值赋值给大的数据类型
		2.如果多个类型的值做运算，结果是最大的类型
		3.特殊：任何数据类型和String做+拼接时，结果都是String类型。
	强制类型转换：
		1.将大的数据类型的值赋值给小的数据类型
			小数据类型 变量名 = (小数据类型)大的数据类型值;
		2.小数转换为整数时，没有四舍五入，将小数位全部舍掉
*/
public class ConvertTest2{
	public static void main(String[] args){
								//128  64  8 
		int i5 = 200;//0000 0000 1100 1000
							//-128 64 8 = 
		byte b2 = (byte)i5;//1100 1000
		System.out.println(b2);
		
		//较大的整数转换为较小的整数，会发生数据截断和符号位发生改变
		int i4 = 128;
		byte b = (byte)i4;
		System.out.println(b);
		
		//整数转换为字符，在编码范围内的，不会丢失
		int i3 = 65555;
		char c = (char)i3;//超过取值范围，会发生数据截断。
		System.out.println(c);
		
		
		
		
		//1.小数转整数，小数位丢失
		double d = 3.99;
		int i = (int)d;
		System.out.println(i);
		
		float f = 9.6F;
		int i2 = (int)f;
		System.out.println(i2);
		
		
	}
	
}

4.4 表达式运算结果类型提升

/*
	
	常量值运算不会发生数据类型提升。
	byte、short、char类型的变量参与运算，结果都会提升为int
*/
public class ConvertTest3{
	public static void main(String[] args){
		//后边表达式是值与值的运算，
		byte b = 10 + 10;
		System.out.println(b);
		/*
		byte b2 = 10;
		byte b3 = b2 + 10;
		System.out.println(b3);
		*/
		char c = 'A'+1;
		System.out.println(c);
		
		char c2 = (char)(c+1);
		System.out.println(c2);
		
		
		
		//String str1 = 4;                       //判断对错： 错
		String str2 = 3.5f + "";               //判断str2对错：对 任意类型与字符串+都为拼接
		System.out.println(str2);
		System.out .println(3+4+"Hello!");     //输出：7Hello
		System.out.println("Hello!"+3+4);      //输出：Hello!34
		System.out.println('a'+1+"Hello!");    //输出：   98Hello!
		System.out.println("Hello"+'a'+1);     //输出：Helloa1
	
	}
}

五、运算符

5.1 算数运算符

算术运算符（7个） +、-、*、/、%、++、–

/*
 * 算数运算符：
 *   +
 *       加法运算
 *       字符串拼接
 *       正号
 *   -
 *       减法运算
 *       负号
 *   *
 *       乘法
 *   /
 *       除法
 *   %
 *       模运算
 *        取余数
 * */
public class OperatorTest1 {
    public static void main(String[] args) {
        System.out.println("********* % *********");
        System.out.println(5 % 2);//1
        System.out.println(5 % -2);//1  以被除数为准
        System.out.println(-5 % -2);

        System.out.println("********* + *********");
        int a = 10;
        int b = 20;
        System.out.println(a + b);
        int c = +30;
        System.out.println("c = " + c);
        System.out.println(9 + 6 + "HelloWorld");//拼接

        System.out.println("********* - *********");
        System.out.println(5 - 2);
        System.out.println(-20);
        System.out.println(5 - 2.5);

        System.out.println("********* * *********");
        System.out.println(2 * 3);
        System.out.println(2.5 * 2);

        System.out.println("********* / *********");
//        表达式中，整数与整数运算，除不尽时，只保留整数。小数位直接舍掉
        System.out.println(5 / 2);
//        System.out.println(5 / 0);//会报错：除数不能为0
        System.out.println(5.0 / 2);
    }
}


/*
*  ++
*   前++
*       ++a ： 先+1，再运算
*   后++
*       a++ ： 先运算，再加1
*  --
*
* */
class OperatorTest3{
    public static void main(String[] args) {
        int a= 5;
//        System.out.println(--a);
//        int result = --a + a + a--;
//        System.out.println("result = " + result);
    }
}
public class OperatorTest2 {
    public static void main(String[] args) {
        int a = 5;
//        System.out.println(++a); 6
//        System.out.println(a++);
//        System.out.println(a);
        //           5     6
//        int result = a++ + a;
        //            6    6
//        int result = ++a + a;
//        System.out.println("result = " + result);

        ++a;
        System.out.println(a);
    }
}

5.2 赋值运算符

赋值运算符符号解释
=等号右边的值，赋值给等号左边的变量
+=将符号左边的值和右边的值进行相加操作，最后将结果赋值给左边的变量
-=将符号左边的值和右边的值进行相减操作，最后将结果赋值给左边的变量
*=将符号左边的值和右边的值进行相乘操作，最后将结果赋值给左边的变量
/=将符号左边的值和右边的值进行相除操作，最后将结果赋值给左边的变量
%=将符号左边的值和右边的值进行取余操作，最后将结果赋值给左边的变量
/*
* 赋值运算符
*    =
*   +=
*   -=
*   *=
*   /=
*   %=
* 注意：不会更改原有的数据类型，在编译后，如果接受的变量的是小类型 会自动强转
* */
public class FuZhiTest {
    public static void main(String[] args) {
        int a = 10;
//        a = a + 10;
        a +=10;
        System.out.println("a = " + a);
        a-=5;//a = a-5;
        System.out.println("a = " + a);
        a*=10;// a= a* 10;
        System.out.println("a = " + a);
        a/=10;// a = a/10;
        System.out.println("a = " + a);
        a%=2;
        System.out.println("a = " + a);
        System.out.println("===========万恶的分割线=========");
        byte b = 20;
//        b = (byte)(b + 10);
        b +=10;
        System.out.println("b = " + b);

        char c = 'A';
//        c = c + 32;
        c +=32;
        System.out.println("c = " + c);

    }
}

5.3 关系/比较运算符

/*
* 关系/比较运算符
*  ==
*  !=
*  >
*  <
*  <=
*  >=
*  注意：关系运算符，比较的结果都是boolean类型
* */
public class CompareTest {
    public static void main(String[] args) {
        int a = 20;
        int b = 10;
        System.out.println(a == b);//false
        System.out.println(a != b);//true
        System.out.println(a > b);//true
        System.out.println(a < b);//false
        System.out.println(a <= b);//false
        System.out.println(a >= b);//true
    }
}

5.4 逻辑运算符

/*
 *逻辑运算符：
 *   & ：前后都为true，结果才为true
 *   | :有true，结果就为true
 *   ! :非 取反  true为false。 false为true
 *   ^ ：相同为false  不同为true
 *
 * */
public class LogicTest {
    public static void main(String[] args) {
        boolean b1 = true;
        boolean b2 = true;
        boolean b3 = false ,b4 = false;

        System.out.println("-------- &与 ---------");
        System.out.println(b1 & b2 & b3);

        System.out.println("-------- |或 ---------");
        System.out.println(b1 | b2 | b3);
        System.out.println(b1 | b4 | b3);

        System.out.println("--------- !非 --------");
        System.out.println(!b1);//取反 false
        System.out.println(!b3);//取反 true
        System.out.println(!(b1 | b4 | b3));//false

        System.out.println("--------- ^异或 --------");
        System.out.println(b1 ^ b2);
        System.out.println(b1 ^ b3);
        System.out.println(b3 ^ b4);

        System.out.println("============ ");
        System.out.println(3 > 2 & 1>3);//false
        System.out.println(3 > 2 | 1>3);//true
        System.out.println(3 > 2 ^ 1>3);//true
    }
}

开发原则：逻辑的判断用&& ||

/*
 *逻辑运算符：
 *   & ：前后都为true，结果才为true
 *       &前面的表达式为false，后续的仍会执行
 *   | :有true，结果就为true
 *      |前面的表达式是true，后续的仍然会执行
 *   ! :非 取反  true为false。 false为true
 *   ^ ：相同为false  不同为true
 * ------------------
 *  &&：短路与
 *       如果&&前面的表达式是false，则后续的不再执行。
 *  ||：短路或
 *      如果||前面的表达式是true，则后续的不再执行
 * */
public class LogicTest2 {
    public static void main(String[] args) {
        boolean b1 = true;
        boolean b2 = true;
        boolean b3 = false ,b4 = false;

        System.out.println("-------- && 短路与 --------");
//        System.out.println(b1 && b2 && b4);//false
        int m = 10,n=20;
//        boolean result = m > n & ++m < n;

        boolean result = m > n && ++m < n;
        System.out.println("result = " + result+",m="+m);

        System.out.println("---------- || 短路或 ---------");
//        System.out.println(b3 | b4 | b1);

        int a = 10,b=20;
//        boolean flag = a<b | ++a >b;  //不短路
        boolean flag = a<b || ++a >b;   //短路
        System.out.println("flag = " + flag+",a="+a);

    }
}

5.5 条件运算符

/*
 * 条件运算符/三元运算符/三目运算符
 * 表达式1?表达式2:表达式3;
 * x?y:z
 *   y :true --->x
 *   z :false ---> x
 * */
public class TjTest {
    public static void main(String[] args) {
        int age = 16;
        //                 x      y       z
        //          boolean表达式 true     false
        String result = age > 18 ? "已成年" : "未成年";
        System.out.println("result = " + result);

        boolean isMarry = true;
//        String str = isMarry == true ?"已婚":"未婚";
        String str = isMarry ? "已婚" : "未婚";
        System.out.println("str = " + str);

        int a = 100;
        int b = 200;

        int max = a > b ? a : b;
        System.out.println("max = " + max);
    }
}

小练习

public class TjTest2 {
    public static void main(String[] args) {
        /*
         * 求三个数中 最大的。
         * */
        int a = 1000, b = 200, c = 50;
        //获取前两个数中最大值。
        /*int max1 = a>b? a:b;
        //再用最大值和第三个值做比较
        int max2 = max1 > c?max1:c;
        System.out.println("max2 = " + max2);*/

        int max = a > b ? (a > c ? a : c) : (b > c ? b : c);
        System.out.println("max = " + max);


    }
}

5.6 位运算符

/*
* &:上下都为1，结果为1
* |:上下有1，则为1
* ^:上下相同为0，不同为1
* ~:1变0 0变1 取反  补码
* 负整数先算出来补码， 正整数的三码合一
*
* &
*   1.前后都是boolean 是逻辑运算符
*   2.前后都是整数，是位运算符
*
* */
public class BitTest {
    public static void main(String[] args) {
        /*
        * 1 0 1
        * 0 1 1
        *       &
        * ------
        * 0 0 1 = 1
        * */
        System.out.println(5 & 3);
        /*
         * 1 0 1
         * 0 1 1
         *       |
         * ------
         * 1 1 1 = 7
         * */
        System.out.println(5 | 3);
        /*
         * 1 0 1
         * 0 1 1
         *       ^
         * ------
         * 1 1 0 = 6
         * */
        System.out.println(5 ^ 3);
        /*
        * 0000 0101
        * 1111 1010 = -6
        * */
        System.out.println(~5);
        /*
        * 1000 0101 原码
        * 1111 1010 反码
        * 1111 1011 补码
        * 0000 0011
        * 0000 0011 3
        * */
        System.out.println(-5 & 3);
    }
}


/*
* << 左移  *2^位移数方
* >> 右移  /2^位移数方 正数空缺位补0   负数空缺位补1
*
* >>> 无符号右移  ：无论正负数，空缺位都补0
*       0
*       1
* */
public class BitTest2 {
    public static void main(String[] args) {
        System.out.println("-------- << --------");
        System.out.println(4);//0100
        System.out.println(4 << 1);//1000
        System.out.println(4 << 2);//0001 0000
        System.out.println(4 << 3);//0010 0000

        System.out.println("-------- >> --------");
        System.out.println(16);//10000
        System.out.println(16 >> 1);//1000
        System.out.println(16 >> 2);//100
        System.out.println(16 >> 3);//10
        //1110 1111 1111 0000
        System.out.println(-16 >> 1);//1111 0000 >> 1111 1000
        System.out.println(-16 >> 3);

        System.out.println("--------- >>> ---------");
        //0000 0000 0000 0000 0000 0000 1001 0000
        System.out.println(0b00000000000000000000000000010000);
        //10000000000000000000000000010000
        //11111111111111111111111111101111
        //11111111111111111111111111110000
        System.out.println(0b11111111111111111111111111110000);
        //11111111111111111111111111110000 >>> 1
        //01111111111111111111111111111000
        System.out.println(0b01111111111111111111111111111000);
        System.out.println(-16 >>> 1);

    }
}

5.7 运算符优先级

优先级运算符说明Java运算符
1括号()、[]、{}
2正负号+、-
3单元运算符++、--、~、！
4乘法、除法、求余*、/、%
5加法、减法+、-
6移位运算符<<、>>、>>>
7关系运算符<、<=、>=、>、instanceof
8等价运算符==、!=
9按位与&
10按位异或^
11按位或`
12条件与&&
13条件或`
14三元运算符? :
15赋值运算符=、+=、-=、*=、/=、%=
16位赋值运算符&=、`
package com.atguigu.a_operator;
/*
* 运算符优先级：不要记那些运算符优先。
*   想优先执行的，加()
* ()会提高代码的可读性
* 注意：表达式不要太长！
* */
public class OperatorYxjTest {
    public static void main(String[] args) {
        int num = 6;

        int result = num + (10 >> 1);

        System.out.println("result = " + result);

        int a = 1000, b = 200, c = 50;

        int max = a > b ? (a > c ? a : c) : (b > c ? b : c);
        System.out.println("max = " + max);
    }
}

悦读

道可道，非常道；名可名，非常名。 无名，天地之始，有名，万物之母。 故常无欲，以观其妙，常有欲，以观其徼。 此两者，同出而异名，同谓之玄，玄之又玄，众妙之门。

最新收录
bp神经网络可以预测什么,BP神经网络算法优缺点
Java——Stream流
ubuntu如何彻底卸载android studio？
VSCode自定义插件创建教程
技术选型注意事项
LLM之RAG理论（二）| RAG综述论文详解
计算机专业必要了解的知识----干货
实时手势识别 【手部跟踪】Mediapipe中的hand
达梦数据库DM8-索引篇
目标检测(object detection)
;