02--Java数据类型和运算符

憨憨浩浩

已于 2023-12-06 20:36:34 修改

阅读量158

点赞数 6

分类专栏： JavaSE学习记录文章标签： java 开发语言

于 2023-12-06 20:32:34 首次发布

本文链接：https://blog.csdn.net/weixin_46612641/article/details/134840040

版权

JavaSE学习记录专栏收录该内容

35 篇文章 1 订阅

订阅专栏

1、数据类型

作用：用于定义变量的，然后约束变量只能存储什么类型的数据。

1.1 基本数据类型

八种基本数据类型

注意：
a.随便写整数，默认是int类型，要当成long 加L l。
b.随便写小数，默认是double类型，要当成float 加F f。

1.1.1 整型

// 1、byte字节型  占1个字节  -128 - 127
byte number = 98;
System.out.println(number);
// byte number2 = 128; // 报错！

// 2、short短整型 占2个字节
short money = 30000;
System.out.println(money);

// 3、int 整型 默认的类型 占4个字节(默认使用的类型)
int it = 232442442;
System.out.println(it);

// 4、long长整型 占8个字节
long lg = 133244244;
// 注意：随便写一个整数字面量默认是int类型的，
// 133244244虽然没有超过long的范围，但是它超过了本身int类型的表示范围。
// 如果希望随便写一个整数字面量当成long类型，需要在其后加L/l
long lg2 = 132223243244244L;
System.out.println(it);

1.1.2 浮点型

// 1、浮点型（小数）
// float单精度 占4个字节
// 注意：随便写一个小数字面量默认是double类型，
// 如果希望随便写一个小数字面量是float类型的需要在其后加上 F / f
float score = 98.5F;
System.out.println(score);

// 2、double双精度 占8个字节
double score2 = 999.99;
System.out.println(score2);

1.1.3 字符类型

// 字符类型：char
char ch = 'a';
// char ch = '中国'; //报错
// 1.''内有且仅有一个字符
char ch1 = '中';
// 2.unicode值 为16进制数字
char ch2 = '\u0036';
// 3.转义字符 \t \n
char ch3 = '\n'
// 4.数字 转成ASCII值 A 65   a 97  差值32
char ch4 = 97;

1.1.4 布尔类型

// 布尔类型 boolean
boolean rs = true;
boolean rs2 = false;

1.2 引用数据类型

引用数据类型：不是基本数据类型的就是引用数据类型，例如类Class（String）、数组Array、接口Interface、枚举Enum、注解Annotation、记录Record

1.3 类型转换

1.3.1 自动类型转换

为什么自动类型转换？ 存在小范围类型的变量赋值给大范围类型的变量。
基本语法规则 小范围类型的变量可以直接赋值给大范围类型的变量。
范围规则：
在这里插入图片描述

public class TypeDemo1 {
    public static void main(String[] args) {
        byte a = 20;
        int b = a; // 发生了自动类型转换
        System.out.println(a);
        System.out.println(b);

        int age = 23;
        double db = age; // 自动类型转换
        System.out.println(db);

        char ch = 'a'; // 00000000 01100001
        int code = ch; // 00000000 00000000 00000000 01100001
        System.out.println(code);
    }
}

1.3.2 表达式的自动类型转换

规则：

表达式的最终结果类型是由表达式中的最高类型决定的。
byte、short、char直接提升成int运算的。

public class TypeDemo2 {
    public static void main(String[] args) {
        byte a = 10;
        int b = 20;
        double c = 1.0;
        double rs = a + b + c;
        System.out.println(rs);

        double rs2 = a + b - 2.3;
        System.out.println(rs2);

        byte i = 100;
        byte j = 120;
        int k = i + j;
        System.out.println(k);
    }
}

1.3.3 强制类型转换

形式：大范围类型的变量赋值给小范围类型的变量会出现错误，需要强制类型转换。
格式：数据类型变量2 = (数据类型)变量1
注意事项：
a.强制类型转换可能出现数据丢失。

int i = 2223;
byte j = (byte)i;

b.小数强制转换成整数，会截断小数部分，直接返回整数.

public class TypeDemo3 {
    public static void main(String[] args) {
    	double num = 23.45;
		int i = (int)num;
		
        int a = 20;
        byte b = (byte)a;
        System.out.println(a);
        System.out.println(b);

        int i = 1500;
        byte j = (byte) i;
        System.out.println(j);

        double score = 99.5;
        int it = (int) score;
        System.out.println(it); // 99
    }
}

2、常量

2.1 字面量

字面量：可以直接看到的数据，整数、小数、字符（必须用单引号围起来，有且仅能包含一个字符，特殊字符’\t’、‘\n’）、字符串（必须用双引号围起来，内容可以随意）、布尔型（false、true）、空（null）

在这里插入图片描述

字符、字符串的字面量的格式要求？

字符必须单引号围起来，有且仅能一个字符。
字符串必须用双引号围起来。
布尔类型只有2个值：false 、true

public class LiteralDemo {
    public static void main(String[] args) {
        // 1、整数
        System.out.println(66);
        System.out.println(-23);

        // 2、小数
        System.out.println(99.5);

        // 3、字符：必须单引号围起来，有且仅能有一个字符
        System.out.println('中');
        System.out.println('0');
        System.out.println('\n'); // \n换行
        System.out.println('\t'); // \t空格
        System.out.println('a');

        // 4、字符串：必须双引号围起来，内容可以随意
        System.out.println("");
        System.out.println("我爱你中国！abc");
        System.out.println("    学习Java使我快乐！~~~");

        // 5、布尔类型：true false
        System.out.println(true);
        System.out.println(false);

        // 6、空类型 null (以后再详细说明！)
    }
}

2.2 final修饰

被final修饰的常量不能被修改，不能被重新赋值。一旦赋值，不能被修改。

// 定义一个final修饰的常量
final double PI = 3.14;
final int STUDENT_NUMBER = 40;

3、运算符

3.1 算术运算符

常用算术运算符：+ - * / %

注：做除法，如果都是整数，结果一定是整数
取模后，结果与被取模的符号相同。

public class OperatorDemo1 {
    public static void main(String[] args) {
        // 算术算术运算符的使用：+ - * / %
        int a = 10;
        int b = 3;
        System.out.println(a + b);			// 13
        System.out.println(a - b);			// 7
        System.out.println(a * b);			// 30
        System.out.println(a / b); 			// 3.3333  ==>  3
        System.out.println(a * 1.0 / b); 	// 3.3333
        System.out.println(3 / 2);			// 1
        System.out.println(3 * 1.0 / 2); 	// 1.5
        System.out.println(3  / 2 * 1.0); 	// 1.0
        System.out.println(a % b); 			// 1
		System.out.println(-15 % 2);		// -1
        System.out.println(15 % 2);			// 1
    }
}

3.2 赋值运算符

常用赋值运算符：= += -= *= /= %=

从右往左执行。
a += b 等价于 a = （a的类型）(a + b)，扩展运算符自带了强制类型转换。

public class OperatorDemo2 {
    public static void main(String[] args) {
        // 赋值运算符：= += -= *= /= %=
        int a = 10;
        int b = 200;
        // a = a + b;
        a += b; // a = (int)(a + b)
        System.out.println(a);

        byte i = 10;
        byte j = 20;
        // i = (byte) (i + j);
        i += j; // i = (byte) (i + j);
        System.out.println(i);

        int m = 10;
        int n = 5;
        // m += n;
        // m -= n;  // 等价于： m = (int)(m - n)
        // m *= n;  // 等价于： m = (int)(m * n)
		// m /= n;  // 等价于： m = (int)(m / n)
        m %= n;  	// 等价于： m = (int)(m % n)
        System.out.println(m);
    }
}

3.3 自增自减运算符

++     --

注：在变量前后单独使用的情况，无区别，a++、++a
++,–如果在变量前后使用，并且包含其他操作，赋值或者在表达式中，放在前后有明显区别。
在变量前面：先加减再使用，在变量后面：先使用再加减。

public class OperatorDemo3 {
    public static void main(String[] args) {
        // 自增自减运算符： ++ --
        int a = 10;
        // a++; 	// a = a + 1
        ++a; 		// a = a + 1
        System.out.println(a);		// 11

        int b = 10;
        //b--; // b = b -1
        --b;
        System.out.println(b);

        System.out.println("------------------------------");
        // 在表达式中或者不是单独操作的情况，++ -- 在变量前后存在区别
        // ++ -- 在变量前面。先+1 -1 再使用。
        int i = 10;
        int j = ++i;
        System.out.println(i); // 11
        System.out.println(j); // 11

        // ++ -- 在变量的后面 先使用再+1 -1
        int m = 10;
        int n = m++;
        System.out.println(m); // 11
        System.out.println(n); // 10

        System.out.println("-----------拓展案例（可以了解和参考）--------------");
        int k = 3;
        int p = 5;
        // k  3 4 5 4
        // p  5 4 3 4
        // rs    3  +  5  -   4  + 4   - 5   +  4 + 2
        int rs = k++ + ++k - --p + p-- - k-- + ++p + 2;
        System.out.println(k); // 4
        System.out.println(p); // 4
        System.out.println(rs); // 9
    }
}

3.4 比较运算符

==      !=      <       <=      >       >=

返回的结果是布尔类型

public class OperatorDemo4 {
    public static void main(String[] args) {
        // 关系运算符。
        int i = 10;
        int j = 5;
		
        System.out.println(i == j); 	// false
        System.out.println(i != j); 	// true
        System.out.println(i > j); 		// true
        System.out.println(i >= j); 	// true
        System.out.println(i < j); 		// false
        System.out.println(i <= j); 	// false
    }
}

3.5 逻辑运算符

&       &&      |       ||      !       ^

逻辑运算符

public class OperatorDemo5 {
    public static void main(String[] args) {
        // 逻辑运算符
        double size = 9.8;
        double storage = 6;
        // 需求：尺寸大于等于6.95 内存要大于等于8GB
        // 注意：必须前后都是true结果才是true
        System.out.println(size >= 6.95 & storage >=8);

        // 需求：要么内存大于等于8 要么尺寸大于等于6.95
        // 注意：只要有一个是true 结果就一定是true
        System.out.println(size >= 6.95 | storage >=8);

        System.out.println(!true);
        System.out.println(!false);

        // 逻辑异或：必须两个不同结果才是true
        System.out.println(false ^ true); // true
        System.out.println(true ^ false); // true
        System.out.println(true ^ true); // false
        System.out.println(false ^ false); // false

        System.out.println("-----------&&  &  || |的区别-------------------");
        int a = 10;
        int b = 20;
        // System.out.println(a > 100 && ++b > 10);
        System.out.println(a > 100 & ++b > 10);
        System.out.println(b);

        int i = 10;
        int j = 20;
        //System.out.println(i > 2 || ++j > 10);
        System.out.println(i > 2 | ++j > 10);
        System.out.println(j);
    }
}

3.6 三元运算符

作用：根据条件作出分支选择，返回对应的值。
格式：条件表达式？值1 ：值2

public class OperatorDemo6 {
    public static void main(String[] args) {
        // 三元运算符
        double score = 18;
        String rs = score >= 60 ? "考试通过" : "挂科";
        System.out.println(rs);

        // 需求：需要从2个整数中找出较大值
        int a = 10000;
        int b = 2000;
        int max = a > b ? a : b;
        System.out.println(max);

        System.out.println("-------------------------");
        int i = 10;
        int j = 30;
        int k = 50;
        // 1、找出2个整数的较大值
        int temp = i > j ? i : j;
        // 2、拿临时变量与第三个变量的值继续比较
        int rsMax = temp > k ? temp : k;
        System.out.println(rsMax);

        System.out.println("-------------拓展知识-------------");
        int rsMax1 = i > j ? (i > k ? i : k) : (j > k ? j : k);
        System.out.println(rsMax1);
    }
}

3.7 String字符串操作

+号与字符串一起会做连接符，连接后的结果还是字符串。
注：能算则算，不能算就在一起
String可以使用的操作有+、+=、==、!=

public class OperatorDemo7 {
    public static void main(String[] args) {
		
        // +符号做连接符的识别
        int a = 5 ;
        System.out.println("abc" + 'a'); // abca
        System.out.println("abc" + a);   // abc5
        System.out.println(5 + a); // 10
        System.out.println("abc" + 5 + 'a'); // abc5a
        System.out.println(15 + "abc" + 15); // 15abc15
        System.out.println(a + 'a'); // 102		a转成数字为97
        System.out.println(a + "" +'a'); // 5a
        System.out.println(a + 'a'+" itheima "); // 102 itheima
        System.out.println("itheima"+ a + 'a'); // itheima5a
        System.out.println("itheima"+ ( a + 'a' ));// itheima102
		
    }
}

3.8 运算符优先级

最高优先级是（）

public class OperatorDemo8 {
    public static void main(String[] args) {
        // 目标：优先级问题
        System.out.println(10 > 3 || 10 > 3 && 10 < 3);  //true

        System.out.println( (10 > 3 || 10 > 3 ) && 10 < 3); // false

    }
}

4、进制转换

常用进制

class BinaryTest {
	public static void main(String[] args) {
		
		int num1 = 123;		//十进制
		int num2 = 0b101;	//二进制
		int num3 = 0127;	//八进制
		int num4 = 0x12aF;	//十六进制

		System.out.println(num1);	// 123
		System.out.println(num2);	// 5
		System.out.println(num3);	// 87
		System.out.println(num4);	// 4783

	}
}