02-JAVA数据类型与语句结构

发表时间：2022-03-26来源：网络

数据类型转换

数据类型概念

Java是强类型语言
对于每一种数据,都定义了明确的数据类型.
不同的数据类型,在内存当中分配不同的大空间

数据类型分类

基本数据类型 8 个

数值型整数 byte short int long 小数 float double 不同的整数类型在内存占用的内存空间大小是不一样的字符型 char 布尔型 boolean

数据类型占用空间大小

引用数据类型

类
接口
数组

常用数据类型

整数类型

byte、short、int、long

相同点都是存放整数类型的数据，不同点开辟的空间大小不一样，

Java语言的整型常量默认是 int 型

声明 long 型变量后加上 l 或 L

因小写的 l 容易和数字 1 相混淆，建议使用大写 L

byte b = 30; //8位 //b = 128; short c = 32767; // 16位 int d = 324; //32位 long e = 68978L; //64位 //默认是int类型 System.out.println(100);

小数类型

float、double
float 表示单精度类型
double 表示双精度类型
浮点类型的字面量默认是 double 类型.若要声明一个常量为 float 型，则需在常量后加上 f 或 F，double 常量后面的 D 或 d 可省略

//小数（float double） double money = 100.5; //相同点都是存放小数类型的数据，不同点开辟的空间大小不一样， //默认情况下，小数是属于double System.out.println(80.5); //float money2 = 80.5;此行错误 float money2 = 80.5f;

字符类型

什么是编码

计算机只能表示 0 和 1 两个数，于是人们做规定使用一个数字去表示一个特定的字符
比如 a 使用 97 表示

char概述

char 字符,字母和符号
char类型：表示 16位的无符号整数或者Unicode字符
Unicode收集了世界上所有语言文字中的符号，是一种跨平台的编码方式，Java的字符占两个字节，可以表示一个汉字

char常量有3种表示形式

直接使用单个字符来指定字符常量，格式如 ◆、A，7
直接作为十进制整数数值使用，但是数据范围在 [0，65535]，格式如 97，但是打印出来的值依然是 ASCII 码表对于的符号,如 97 打印出来是字符
和2一样，只不过表示的是16进制的数值，格式如'\uX'，X表示16进制整数；如：97 的16进制是 61

ASSCII表

/** 字符本质是16位无符号小数使用一个数字去表示一个特定的字符字符类型 */ System.out.println('a'); //字符型变量 char c = 'a'; c = 'b'; System.out.println(c); //编码 0 1 字符类型 char c1 = 66; //ASSIC System.out.println(c1); //直接输出的是int类型 System.out.println(65);

boolean类型

通常用于逻辑运算和程序流程控制(条件选择/循环)
该类型的值只能是 true 或 false，表示真或假
不可以使用 0 或非0 的整数来代替 false 和 true

基本数据类型转换

8个基本数据类型占用空间大小

8个基本数据类型 ------------------------------------------ 整数 byte->8 short->16 int->32 long->64 小数 float->32 double->64 字符 char->16 布尔 boolean -> 8

数据类型转换概念

把一种类型赋值给另外一种类型。
一种数据类型变换为另外一种数据类型

数据类型的转换

在运算过程当中, 如果不同的数据类型进行运算,可能运行的结果发生错误
把一种数据类型赋值给另一种数据类型
所以在运行之前,把类型进行统一

数据类型转换的原则

boolean不属于数值类型,不参与转换
系统可以完成自动类型转型
不能（直接）把一个大的数据类型直接赋值给小的数据类型

自动类型转换

当把小数据范围类型的数值或变量赋给另一个大数据范围类型变量

强制类型转换

当把大范围类型的数值或变量赋给另一个小范围类型变量时，此时系统不能自动完成转换，需要加上强制转换符
但这样的操作可能造成数据精度的降低或溢出，所以使用时要格外注意。

自动类型提升

当一个算术表达式中包含多个基本数据类型(boolean除外)的值时
整个算术表达式的数据类型将在数据运算时出现类型自动提升
所有的byte、short、char类型被自动提升到 int 类型
整个表达式的最终结果类型被提升到表达式中类型最高的类型

运行符

算术运算符

用来处理四则运算的符号

加号

在操作数值、字符、字符串时其结果是不同的，当两个字符相加得到的是ASCII码表值
当两个字符串相加时表示将两个字符串连接在一起，从而组成新的字符串

除号

整数在使用除号操作时，得到的结果仍为整数（小数部分忽略）
当整数除以0的时候，会引发算术异常

取模(求余数)

模数的符号忽略不计，结果的正负取决于被模数

//算术运算 + - * / %(取模-》求余) ++ -- System.out.println(10 + 20); System.out.println(10 - 20); System.out.println(10 * 20); System.out.println(10 / 20); //符号有谁来决定，它是有前面的数来决定 System.out.println(-10 % -3); //加在字符串相加时，它代表的是拼接 System.out.println("aaa"+"bbb"); System.out.println('a'+1);

自增++与自减--

++: 表示当前操作变量自己累加1.
--: 表示当前操作变量自己减去1.
前置（++result）: 表示对result加1之后的结果进行运算
后置（result++）: 表示对result变量加1之前的值（原始值）进行运算。

用法：必须得要使用变量的前后，
* 作用：表示当前操作的变量自己累加1 或累减1
* ++ 或 -- 写在变量前后的区别？
* 1.如果不参与运算的话，它们是没有区别。
* 2.如果参与了运算，区别就是很大了。
* 累加的结果要不要参与本次的运算，（使用累加之后值运算，还是使用累加之前的值进行运算）
* a++ 累加的结果，不参与本次运算，（使用变量的原始值进行运算）
* ++a 累加的结果，要参与本次运算（使用累加之后的值进行运算）
* 无论是前面，都会对变量值进行累加

赋值运算符

就是将符号右边的值，赋给左边的变量。

//赋值运算符 = += -= *= /= %= int a = 10; //a += 1; // a = a + 1; //a -= 1; // a = a - 1; //a *= 2; // a = a * 2; //a /= 5; // a = a / 5; a %= 2; // a = a % 2; System.out.println(a); short s = 5; s = (short)(s + 1); s += 5; //s = (short)(s + 5);

比较运算符

概述

用于比较两个变量或常量之间的关系，比较运算符的结果是boolean类型
其操作格式为:boolean result = 表达式A 比较运算符表达式B;
比较运算 == != > < >= 5 && 1 == 1/0); //false

短路或(||)

/** * 短路或(||) * 格式：逻辑表达式1 | 逻辑表达式2 * 结果：如果两个表达式结果有一个为true 那么结果就为true * 只有当两个结果都为false时，那么或的结果才为false * | 两边的表达式无论结果怎么样，都会执行 * || 只要发现了为true,就不会再去执行后面的表达式啦 */ int a = 5; System.out.println(a == 5 || 1 == 1/0);

位运算符

位运算

Java 提供了 4 种位运算符
位与运算符（bitwise and operator）：&
位或运算符（bitwise inclusive or operator）：|
位异或运算符（bitwise exclusive or operator）：^
位取反运算符（bitwise invert operator）：~
这些运算符是在二进制补码上进行操作

public static void main(String[] args) { byte a = 15; byte b = -15; System.out.println(a & b); System.out.println(a | b); System.out.println(a ^ b); System.out.println(~a); System.out.println(~b); }

一个字节数占 8 位，将 a，b 转换为二进制
a = 0000 1111
b = 1111 0001
位与运算符：仅当两个操作数同一下标的值均为 1 时，结果才为 1
a & b = 0000 1111 & 1111 0001 = 0000 0001(补) = 0000 0001(原) = 1
位或运算符：只要两个操作数同一下标的值有一个为 1 时，结果就为 1
a | b = 0000 1111 & 1111 0001 = 1111 1111(补) = 1000 0001(原) = -1
位异或运算符：只有两个操作数同意下标的值不相等时，结果才为 1
a ^ b = 0000 1111 ^ 1111 0001 = 1111 1110(补) = 1000 0010(原) = -2
位取反运算符：按位取反每一位
~a = ~0000 1111 = 1111 0000(补) = 1001 0000(原) = -16
~b = ~1111 0001 = 0000 1110(补) = 0000 1110(原) = 14

移位运算

Java 提供了 3 种移位运算符

左移运算符（left shift operator）：

>2
00000110
0000 0001
1
结论
右移几位,就是该数除以2的几次幂

运算符优先级

三元运算符

表达式

/** * 表达式：执行指定的运算， * 能够得出某一个特定的值。我们称这个式子为表达式 * 得出的值为数值开的式，是算术表达式 * 如果得出的值是boolean 称它是逻辑表达式 */ int a = 2 + 5; // 算术表达式返回值是一个数值类型 boolean t = a > 5; //逻辑表达式返回值是boolean

三元运算符格式

数据类型变量名 = 布尔类型表达式？结果1：结果2

三元运算符计算方式

布尔类型表达式结果是true，三元运算符整体结果为结果1，赋值给变量
布尔类型表达式结果是false，三元运算符整体结果为结果2，赋值给变量

int i = 5; //System.out.println(i < 3 ? 1 : 2); 2 System.out.println(i > 3 ? 1 < 2 : 3 + 5);//true

//1.求两个数和的最大值 int a1 = 3; int b1 = 20; int max = a1 > b1 ? a1 : b1; System.out.println(max);//20 //2.求一个数是偶数还是奇数 // 判断它除以2之后，有没有余数。如果余数为0 就是偶数否则就是奇数 String res = a1 % 2 == 0 ? "偶数" : "奇数"; //奇数 System.out.println(res);

顺序结构

顺序执行，根据编写的顺序，从上到下运行

if

结构

执行流程

首先判断关系表达式看其结果是true还是false
如果是true就执行语句体
如果是false就不执行语句体

执行流程图

* if(逻辑表达式){ * 要执行的语句 * } * 1.当逻辑表达式的值为true才去执行里面的语句 * 2.如果｛｝当中只有一条语句，那么{}可以省略不写的

// 如果｛｝当中只有一条语句，那么{}可以省略不写的 if(true) System.out.println("我是语句"); int age = 18; if(age >= 18) { System.out.println("恭喜你成年啦，想干嘛就去干嘛吧"); }

if...else

格式

执行流程

首先判断关系表达式看其结果是true还是false
如果是true就执行语句体1
如果是false就执行语句体2

执行流程图

/** * if(逻辑表达式){ * 要执行的语句1 只有当表达式的值为true才会执行此处的语句 * } else { * 要执行的语句2 如果逻辑表达式不为true就会执行此处的语句 * } * 两者必须得要做一个选择。 */ boolean isMan = false; if(isMan) { System.out.println("去男厕所"); }else { System.out.println("去女厕所"); }

if..else if...else

结构

执行流程

首先判断关系表达式1看其结果是true还是false
如果是true就执行语句体1
如果是false就继续判断关系表达式2看其结果是true还是false
如果是true就执行语句体2
如果是false就继续判断关系表达式…看其结果是true还是false
...
如果没有任何关系表达式为true，就执行语句体n+1

流程图

* if(逻辑表达式){ * 要执行的语句1 只有当表达式的值为true才会执行此处的语句 * }else if(逻辑表达式){ * 要执行的语句1 * } else { * 要执行的语句2 如果逻辑表达式不为true就会执行此处的语句 * } * 多次的选择 * 如果已经满足条件了，后面的语句还会不会执行？ * 如果已经满足条件了,那么后面的语句就不会再去帮你执行。

int a = 1; if(a == 1) { System.out.println("今天是星期1"); } else if(a == 1/0){ //验证是否执行了此语句，结果是没有执行该语句 System.out.println("今天是星期2"); } else if(a == 3){ System.out.println("今天是星期3"); }else if(a == 4){ System.out.println("今天是星期4"); }else if(a == 5){ System.out.println("今天是星期5"); }else if(a == 6){ System.out.println("今天是星期6"); }else if(a == 7){ System.out.println("今天是星期日"); }else { System.out.println("你想要星期几啊"); }

switch

格式

执行流程

首先计算出表达式的值
其次，和case依次比较，一旦有对应的值，就会执行相应的语句，在执行的过程中，遇到break就会结束
最后，如果所有的case都和表达式的值不匹配，就会执行default语句体部分，然后程序结束掉。

流程图

case的穿透

在switch语句中，如果case的后面不写break，将出现穿透现象，
也就是不会在判断下一个case的值，直接向后运行，直到遇到break，或者整体switch结束

* switch(整型表达式)｛ * case 值A: 执行语句; break; * case 值B: 执行语句; break; * case 值C: 执行语句; break; * .... * default:上面没有一个满足条件，就会执行此语句 * ｝

int a = 8; switch(a) { case 1 : System.out.println("星期1");break; case 2 : System.out.println("星期2");break; case 3 : System.out.println("星期3");break; case 4 : System.out.println("星期4");break; case 5 : System.out.println("星期5"); break; case 6 : System.out.println("星期6");break; case 7 : System.out.println("星期日");break; default:System.out.println("你想要星期几啊"); }

注意点: 在Jdk1.5 switch(值) 值只能是整数 byte short int long

从Jdk1.7开始,就可以支持String