Java02---数据类型与运算符_数据类型代码 202-CSDN博客

本文链接：https://blog.csdn.net/qq_44241861/article/details/107298211

文章目录

常量的概述和使用
变量的概述及格式
Java数据类型：四类八种
- - 数据类型的转换
字符和字符串参与运算
运算符

常量的概述和使用

什么是常量

就是在程序的执行过程中其值不发生改变的量。

Java中常量的分类

(1):字面值常量
(2):自定义常量(面向对象博客详解)

字面值常量的分类

(1): 字符串常量：双引号所括的单个/多个字符，例如： “a”、“abc”、“你好”、“hello world”、" a"
(2): 整数常量：所有整数 12,23
(3): 小数常量：所有小数 12.34,56.78
(4): 字符常量：单引号括的单个字符例如：'a'、'1'、'你'、' '(注意事项：单引号中只能是单个字母，单个数字，单个符号。)
(5): 布尔常量： true和false
(6): 空常量： null(数组博客详解)

小练习：输出字面值常量举例

//输出字面值常量举例
class Constant {
	public static void main(String[] args) {
		System.out.println(1);
		System.out.println(1.2);
		System.out.println(true);
		System.out.println(' ');//空字符
		System.out.println('1');
		System.out.println(" a");
		System.out.println("Hello World!");
	}
}

/*输出结果为
1
1.2
true

1
 a
Hello World!

*/

变量的概述及格式

变量就是在程序执行的过程中，在某个范围内可以发生改变的量。
定义变量的过程就意味着在内存中申请一块对应数据类型的内存空间
定义变量可以用来不断地存放同一类型的数据(即变量的重新赋值)，并重复使用，减少内存的占用

变量例如商品的价格，价格的浮动有范围也有数据类型，因此变量需要通过数据类型来约束变量范围大小和取值类型。

Java数据类型：四类八种

数据类型作用

决定了存储空间的大小以及对应于这种数据类型的有关操作集合，比如数值型可以做加减乘除等数学运算，但是字符类型和布尔类型就不行

数据类型的分类
在这里插入图片描述
定义变量格式：数据类型变量名=值，其中变量命名规范：一般小写，或驼峰式

定义不同数据类型变量值的注意事项：

long值后可加L，数值超过int类型若不加L会报错，因此无论何值若要定义long类型加上L即可long d=2L;
float 占4个字节定义时值后加F，表示为float类型，否则报错
字符型 char ，定义时值需要用单引号引起来的单个字符，(此处常量也有字符常量，定义方法相同，字符变量就是字符常量的赋值运算，GBK码表一个汉字占2个字节，因此char类型可以装下汉字字符)
作用域的问题：大括号{}括起来的范围是作用域，一个作用域内不能定两个同名的变量
初始化的问题：变量没有初始化不能使用
在一行上最好只定义一个变量

小练习：定义不同数据类型变量

class Constant {
	public static void main(String[] args) {
	
	byte a=127;
	short b=200;
	int c=5000;
	//定义long类型的变量时，值后面加一个后缀L来表示这是一个long类的值。
	//定义long类型的值，这个值没有超过int类型的范围，你没加后缀L不报错，但是超过了int类的值不加L就会报错。
	long d=20000000000L;
	//定义float类型的变量时，值的后面要必须要加上后缀F 表示这是一个float类型的值
	float e=3.1F;
	double f=3.2;
	boolean g=false;
	char ch=' ';//定义char类型的变量时，值需要用'' 引起来的单个字符。
	System.out.println(a);
	System.out.println(b);
	System.out.println(c);
	System.out.println(d);
	System.out.println(e);
	System.out.println(f);
	System.out.println(g);
	System.out.println(ch);

//定义变量的注意事项1：一对{}内不能定义2个同名变量，但是可以给变量赋值
	int aa =100;
	    aa=30;//aa重新赋值为30
//定义变量的注意事项2：变量必须赋值才能使用
//定义变量的方式2
	int bb;
	bb=30; 
	System.out.println(aa);
	System.out.println(bb);
	}
}

/* 输出结果：
127
200
5000
20000000000
3.1
3.2
false

30
30
*/

数据类型的转换

隐式转换，也叫自动类型提升
- byte、short、char在参与运算时会全部自动提升为int型
- 如果有long float double参与运算会相应的提升为long float double，
- byte short char 三者之间不互相转换只会提升为int型，boolean不参与数学运算

byte a=10;
byte b=10;
byte c=a+b;
//报错：提示你——不兼容的类型: 从int转换到byte可能会有损失
//原因：byte在计算时自动提升为int类型，继续用byte接收运算结果类型不匹配

强制类型转换，原理是把多余字节丢弃，保留目标数据类型的字节，有可能发生精度损失，不建议使用

class Constant {
	public static void main(String[] args) {
	
	byte r1=(byte)130;//强制将int转换为byte 输出为-126
	System.out.println(r1); //-126
	
	}
}

int型130转byte类型为-126，原理如下：

130的补码为00000000 00000000 00000000 10000010 去掉三个字节为10000010
补码：1 0000010（第一位为符号位）
反码：1 0000001
原码：1 1111110 （第一位为符号位，值为 -126）

常量优化机制：多个常量参与运算时，会先计算结果是否在定义的数据类型范围内，如果在系统会强制帮你转为相应的数据类型，就不报错。否则，就报错。例如：

byte f1=10+20; //整数10与20默认为int型
System.out.println(f1);//30，不会报错，因为byte可以装下30，
byte f2=129+1;  // 报错，不兼容的类型，从int到byte会有损失

注意：整数：默认int，小数默认double，因此定义float一定要加F；
赋值运算符的强制类型转换与强制类型转换格式(类型)有精度损失但不会报错，而常量优化机制如果在强制类型转换超出范围时就会报错

字符和字符串参与运算

字符参与运算

byte、short、char在参与运算时会自动提升为int型，因此字符参与计算时使用int型接收
字符参与运算时，编译器会自动的把它们转换为相应的ASCII码值，然后进行运算。ASCII码表上需要记住几个重要的值，‘0’的ASCII码值为48，‘A’的ASCII码值为65，‘a’的ASCII码值为97。
如果是中文字符，就在GBK码表中找中文对应的值。

class Constant {
	public static void main(String[] args) {
	char ch='A';//A的AscII码为97
	int r=ch+1;
	System.out.println(r);//98
	}
}

字符串参与运算

+在有字符串参与中被称为字符串连接符。+有两个作用，一个就是对数值进行相加运算，还有就是字符串连接符的作用。加号只要任意一端是字符串，就起拼接作用

class Constant {
	public static void main(String[] args) {
	System.out.println("2"+3+3);//"233"，加号起拼接作用,一端为字符串就会一直拼接 
	System.out.println('2'+3+"hello");//53hello 加号此处是2个作用相加与拼接,'2'的ASCII码为50
	}
}

运算符

运算符是指对常量和变量进行操作的符号。

运算符的分类：

算术运算符:（+ , - , * , / , % , ++ , – ）
赋值运算符:（=、+=、-=、*=、/=、%=）
关系运算符 : (== != < > <= >=)
逻辑运算符: & (并且) , |(或者), !(非) , ^(异或) , &&(短路与) , ||(短路或)
位运算符: &(与)，|(或)，^(异或) , ~(按位取反) , <<(左移) ,>>(右移) ,>>>(无符号右移)
三目运算符：

(关系表达式) ？表达式1 ：表达式2；
如果关系表达式为真，整个表达式的结果为表达式1，否则为表达式2

算数运算符的基本用法

整数相除只能得到整数。如果想得到小数，请使用浮点数
/获取的是除法操作的商，%获取的是除法操作的余数
%运算结果的符号，取决于参与运算时一边的符号

class Constant {
	public static void main(String[] args) {
	System.out.println(3/1); 
	System.out.println(3/2);//1。 /获取的是除法操作的商，两个int相除，结果为int
	System.out.println(3/1.3); //2.307.. int与double相除类型为double
	System.out.println(3.0%2); //1.0。
	}
}

++与–

单独使用：++自身+1，–自身减1，单独使用时放变量左右没有区别（大量使用）
混合使用：(少量使用)
放在操作数的前面，先自增或者自减，然后再参与运算。
放在操作数的后面，先参与运算，再自增或者自减。

    class Constant {
	public static void main(String[] args) {
	// ++自身+1，--自身减1，单独使用时放变量前后没有区别
	int i=1;
	++i; //2
	i++; //3
	--i;//2
	i--;//1

	int j=1;
	int h=++j;//h为2.先对j加1此时j为2，再赋值给h
		h=j++;//h为2，先将j==2的值赋给h，再将j自身加1，因此j为3
	System.out.println("j:"+j); // j:3
	System.out.println("h:"+h); //h:2
		
	}
}

小练习：体会++与—-的位置的影响

不影响t自身的值，只影响w的值

class Constant {
	public static void main(String[] args) {
	// ++自身+1，--自身减1，单独使用时放变量前后没有区别
	int i=1;
	++i; //2
	i++; //3
	--i;//2
	i--;//1

	int t=1;
//练习1 
	int w=2+(t++)+2+(++t)-3+(--t)+2+(t--)+2;
	System.out.println("t:"+t); //t:1  ++与--的位置不影响t自身的值，只影响w的值
	System.out.println("w:"+w); //w:13

	int a = 10;
	int b = 10;
	int c = 10;
//练习2
	a = b++;//a==10 b==11
	c = --a;//a==9 c==9
	b = ++a;//a==10 b==10
	a = c--; //a==9 c==8


	int x = 4;
    // y = (x++)+(++x)+ (x*10) 结果为70，计算时从左往右计算
	int y =(x*10)+(x++)+(++x) ; //结果为50 计算顺序为从左往右
	
	System.out.println("x:"+x); //x:6
	System.out.println("y:"+y); //y:50
	System.out.println(y*++x); //350 表明++的优先级在*之前
	}
}

赋值运算符

+=、-=、*=、/=、%=赋值运算符会自动强制类型转换,不会报错，但是会造成精度损失，比如130超过byte类型赋值给byte类型变量后此变量值为-126
先看一个现象：

byte b=10;
b=b+20; //报错，需要手动强转为byte类型
byte b=10;
b+=20;//不报错，为什么？该赋值运算符会帮助你自动强制类型转换
//这个也可以说是+=、-=、*=、/=、%=赋值运算符的优点

再举例：

class Constant {
	public static void main(String[] args) {
	int a=10;//常量10赋给int型变量a

//b+=10的作用
	int b=20;
		b+=10; //等价于b=b+10
	System.out.println("b:"+b);// b:30

//b+=10与b=b+10的区别
	byte i=20;
//由于i为byte类型，与int型整数相加会自动提升为int型，而赋值给byte型i就会报错
		i=i+10; //报错不兼容的类型: 从int转换到byte可能会有损失

//+=会自动的强制类型转换相当于：j=(byte)j+10;	
	byte j=1;
	j+=130;//将int型的值30强制转换为byte型再赋值给j
	System.out.println("j:"+j);//j:-125  精度损失
	}
}

关系运算符

== != < > <= >=

关系运算符的运算结果为布尔类型

class Constant {
	public static void main(String[] args) {
	int a=10;
	int b=20;
	boolean f=a==b;//将a==b的判断结果赋值给布尔变量f
			f=a!=b;//重新赋值f
			f=a<=b;
	System.out.println(a==b);//false
	System.out.println("f:"+f);// f:true
	}
}

逻辑运算符

& (并且) , |(或者), !(非) , ^(异或) , &&(短路与) , ||(短路或)

逻辑运算符一般用于连接boolean类型的表达式或者布尔值，结果也为布尔值；
逻辑运算符与位运算符的区分：& | ^ 如果两端是布尔类型，那就是逻辑运算符；& | ^两端为数值则表示位运算符；

逻辑运算符的用法：

&逻辑与:有false则false。
|逻辑或:有true则true。
^逻辑异或:相同为false，不同为true。
!逻辑非:非false则true，非true则false。
特点：偶数个不改变本身。

public class 逻辑运算符的用法01 {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        //&的用法 只要有一端为false结果为false，所有端为true结果为ture，
        boolean f = a == b & a < b;
        boolean f1=true&true;
        System.out.println(f);//false
        System.out.println(f1);//true

        // |或的用法  一端有true结果为true
        boolean flag=true|false|false;
        boolean flag1=a>b| a==b|a<b;

        System.out.println(flag);//true
        System.out.println(flag1);//true
        System.out.println(!true);//取反 结果为false

        //异或^（不常用） 同为false，异为true
        System.out.println(true^false);//true
        System.out.println((a<b)^(a>b));//true



    }

}

& && 、| || 区别：结果没有区别，效率有区别，因此常用&&与||

public class 短路与_短路或02 {
    public static void main(String[] args) {
        int a=1;
        int b=2;
        //& 左右两端表达式都需要执行来判断结果，耗费时间
        //&&左端为false时已经可以确定结果因此不执行右端表达式，左端为ture时不确定结果，才会计算右端表达式。
        boolean f2=a>b && (b++)>0; //常用&&
        System.out.println(b);//2,左端表达式为true，不执行有段表达式，b不加1


        // |两端表达式都需要执行才决定最终结果
        // ||当左端为true时 可以确定最终结果不执行右端表达式，j不加1
        int i=2;
        int j=3;
        boolean f4 = i<j || (j++)>0;
        System.out.println(j);//3

位运算符

&(与)，|(或)，^(异或) , ~(按位取反) , <<(左移) ,>>(右移) ,>>>(无符号右移)

位运算是直接对二进制补码进行运算。运算效率高一些
例如乘法，2*40=80 而10<<3结果也为80，还需要转换为+法，<<直接对于补码运算效率更高/
位运算符使用条件： &、|、^两端为数值，为位运算符

&：有0则0。参与运算的两数各对应的二进位相与。只有对应的两个二进位均为1时，结果位才为1，否则为0
9&5:
00001001——>9
00000101——>5
00000001——>1 // 9&5结果为1

|：有1则1。参与运算的两数对应的二进位相或，只要对应的二进位当中有一个为1时，结果就为1，否则为0
9|5：
00001001——>9
00000101——>5
00001101——>13

^：相同则0，不同则1。参与运算的两数对应的二进位相异或，当两对应的二进位相异时结果为1，否则为0
9|5：
00001001——>9
00000101——>5
00001100——>12

~：求反运算符为单目运算符，具有右结合性，对参与运算的数的二进制位按位求反
~9：
00001001——>9
11110110——>最后结果的补码，我们还需要将它转换为原码，才是我们最终可见的结果，最终求得 10001010，也就是~9=-10，简便方法：对a取反最终得到：-（a+1）

<<：左移高位丢弃，低位补0。
>>:右移被移位的二进制最高位为0，右移空缺位补0；最高位是1，右移空缺位补1。
>>>：无符号右移被移位二进制最高位无论是0或者是1，空缺位都用0补。

位异或运算符的特点
^的特点：一个数据被另一个数据位异或两次，该数本身不变。
自己位异或自己是0 8^8 结果是0


public class 位运算符的用法03 {
    public static void main(String[] args) {
        //&: 公式有0则0
        //3&4: 0 0000011 & 0 0000100 结果为00000000
        System.out.println(3&4);//0

        //| ：有1则1(指的是二进制补码) 0 00000011
        //          0 00000100
        // 写出3和4的补码，每一位相与，只要有1就为1，因此结果为0 0000111 等于7
        System.out.println(3 | 4); //7

        // ^:位异或，相同则0，不同则1(指的是二进制补码) 即自己跟自己位异或，结果是0
        System.out.println(3^3); //0
        System.out.println(3^4); //7

        //^ 公式：一个数被另一个数位异或2次，该数不变
        int a=1;
        int b=2;
        System.out.println(a^b^b); //1 a被b位异或2次，结果为a
        System.out.println(a^b^a); //2 b被a位异或2次 结果为b的值
        System.out.println(1^2^2); //1


        // ~按位取反：0-1,1-0符号位也包含在内取反。因此要考虑原反补的计算 0 0000011 --1 1111100---1 1111011 ---1 0000100转换为源码
        System.out.println(~3);//-4

        // <<:左移 左边数据乘2的右次数值幂 10<<3 : 10*2^3=80
        System.out.println(10<<3);//80

        // >>右移 左边数据除2的右次数值幂
        System.out.println(10>>3); // 10/2^3=1 小数去掉

        // >>>:无符号右移 被移位二进制最高位无论是0或者是1，空缺位都用0补。
        System.out.println(-3>>>2);

    }
}

小练习：位异或实现两个整数变量的交换，但是常用通过中间变量的方式。

//值的交换，通过中间变量掌握第一种方式
public class 值得交换04 {
    public static void main(String[] args) {
        //方式1：通过中间变量 最常用的方式
        int a=10;
        int b=20;
        int t=a;
        a=b;
        b=t;
        System.out.println(a);
        System.out.println(b);

        //方式2：利用^位异或的特点，一个数被另一个数位异或2次值不变
        a=a^b;
        b=a^b;//a^b^b 结果为a
        a=a^b; //a^b^a 结果为b

        //方式3
        a=a+b;
        b=a-b;
        a=a-b;

        //方式4
        a=(a+b)-(b=a);


    }
}

三元运算符

表达式?结果1：结果2

三元运算符的执行流程：
计算关系表达式的值，如果为true，运算后的结果是表达式1；
如果为false，运算后的结果是表达式2；

小练习：求2个数的最大值与三个数的最大值

public class 三元运算符05 {
    public static void main(String[] args) {
        int a=20;
        int b=200;
        int c=500;
        int max=a>b?a:b;//200 a>b为true返回结果1，false返回结果2
        System.out.println("max="+max);
//方式一：求三个数的最大值，嵌套使用阅读性差，不建议
        int max1=(a<b?b:a)<c?c:(a<b?b:a);
//方式2：求三个数的最大值.分开写
        int max3 = max>c?max:c;
		System.out.println("max3="+max3);

    }
}

通过录入数据实现求最大值

如何实现键盘录入呢?

a:导包
格式：
import java.util.Scanner;
位置：
在class上面。
b:创建键盘录入对象：
格式：
Scanner sc = new Scanner(System.in);
c:通过对象获取数据，此时键盘要输入数据：
格式：
int x = sc.nextInt();

import java.util.Scanner;
public class 输入数据06 {
    public static void main(String[] args) {
        //2. 创建对象scanner alt+enter自动补全
        Scanner scanner = new Scanner(System.in);//键盘要求输入一个数据，System.in为创建对象的参数
        System.out.println("请输入第一个数据");
        //录入用户输入的数据
        int one=scanner.nextInt();//输入整数
        System.out.println("请输入一个第二个数据：");
        int two=scanner.nextInt();

        //对数据处理
        int max=one>two?one:two;
        System.out.println(max);
    }
}