数据类型概念
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;
比较运算 == != > < >= <=
比较运算符的结果是一个布尔类型 boolean
比较运算符
逻辑运算符
是用来连接两个布尔类型结果的运算符，运算结果都是布尔值 true 或者 false
逻辑运算符
* 所有的逻辑运算符结果都为布尔类型
* 与（&）
* 或（|）
* 非（！）
* 异或（^）
* 短路与(&&)
* 短路或(||)
与(&)
/**
* 1.与（&） 结果是布尔类型
* 格式： 逻辑表达式1 & 逻辑表达式2
* 结果： 如果两个表达结果有一个为false 那么与的结果就为false
* 两个表达式的结果都为true， 那么与的结果才为true
*/
System.out.println(true & false);//false
System.out.println(true & true);//true
System.out.println(false & false);//false
或(|)
/* 2.或（|）
* 格式： 逻辑表达式1 | 逻辑表达式2
* 结果： 如果两个表达式结果有一个为true 那么结果就为true
* 只有当两个结果都为false时， 那么或的结果才为false
*/
System.out.println(true | false);//true
System.out.println(true | true);//true
System.out.println(false | false);//false
非(!)
/**
* 3.非（！） 对一个布尔类型取操作 (取反操作)
* 格式： ！布尔类型
*/
System.out.println(!false);//true
异或(^)
/**
* 异或（^）
* 格式 ： 逻辑表达式1 ^ 逻辑表达式2
* 表达式结果相同为false 不同时为true
*/
System.out.println(false ^ true);
短路与(&&)
/**
* 短路与(&&)
* 格式 ： 逻辑表达式1 && 逻辑表达式2
* 结果： 如果两个表达结果有一个为false 那么与的结果就为false
* 两个表达式的结果都为true， 那么与的结果才为true
* & 两边的表达式无论结果怎么样，都会执行
* && 只要发现了为false,就不会再去执行后面的表达式啦
*/
int a = 5;
System.out.println(a > 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）：<<
规则
左移几位,就在最低位补几个0
示例
3<<2 3乘2的2次方法 = 12
0000001100
3<< 3 3乘2的3次方法 = 24
00000011000
结论
左移几位,就是该数乘以2的几次方法
右移运算符（right shift operator）：>>
规则
对于高位出现的空位,原来高位是什么,就拿什么来补
示例
6>>1
00000110
0000 0011
3
6>>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
循环结构
概述
循环语句可以在满足循环条件的情况下
反复执行某一段代码，这段被重复执行的代码被称为循环体语句
当反复 执行这个循环体时，需要在合适的时候把循环判断条件修改为false，
从而结束循环，否则循环将一直执行下去，形 成死循环。
while
结构
执行过程
先判断表达式，若为true就执行循环体，否则，跳过循环体。
流程图
int count = 0;
while(count < 2) {
System.out.println("你很帅");
count++;
}
System.out.println("ending");
//2.打印1 到 100所有的数字
int num = 1;
while(num <= 100) {
System.out.println(num);
num++;
}
do while
结构
执行流程
先执行一次循环体，再判断表达式，若为true就执行循环体，否则，跳过循环体。
也就是说do while是先执行后判断，即使判断条件为false，该循环至少会执行一次
流程图
/**
* do{
* 循环体
* }while(逻辑表达式)
*
* 不管逻辑表达式为不为真，上来先执行一次循环体。
*/
int count = 0;
do {
System.out.println("你很帅");
count++;
}while( count < 5);
for
结构
执行流程
初始化语句：表示对循环进行初始化，只在循环开始时执行一次,定义一个变量,并赋值。
boolean表达式：表达式为false时，循环终止,为true,才执行循环体。
循环后操作语句：循环每次迭代之后会调用该语句，一般的该语句都是递增或递减操作。
流程图
* for(初始化的语句; 逻辑表达式 ; 循环之后的操作语句)｛
* 循环体
* ｝
* 1.初始化的语句 (只会执行一次)
* 2.会执行逻辑表达式
* true: 执行循环体
* false: 跳过循环
* 3. 执行循环体
* 4. 执行循环体之后的操作语句
* 5. 进入到第二步继续判断
for(
int count = 0; //1.初始化语句
count < 5; //2.逻辑表达式
count++ //3.循环之后的操作语句
)
{
System.out.println("你很帅"); //4. 循环体
}
for(int num = 1; num <= 100; num++) {
System.out.println(num);
}
死循环
也就是循环中的条件永远为true，死循环的是永不结束的循
while
do while
for
嵌套循环
一个循环的循环体是另一个循环。比如for循环里面还有一个for循环
控制循环结构
break语句
终止当前所在的循环
break之后的语句执行不了,所以不能编写.
for(int i = 1; i<= 100; i++) {
System.out.println(i);
if(i == 10) {
break;
}
}
//打印1到100之间前5个偶数
for(int i = 1; i<=100; i++) {
if(i % 2 == 0) {
System.out.println(i);
count++;
}
if(count == 5) {
break;
}
}
System.out.println("end................");
continue语句
跳过当前的循环,进入下一次循环操作
return
表示结束循环所在的方法，方法都结束了，循环结构自然也就结束了
总结
* break:终止循环，跳出循环。继续执行后续的代码
* continue:跳出本次循环，后续的循环继续执行，循环执行完毕，后续的代码继续执行。
* return:循环终止，后续的代码也不执行了。
控制外层循环
标签就是给某个循环起的别名，不过该别名得满足标识符的规范。
若要控制外层循环,就在break或continue后面跟上循环的标签名称
outter : for(int count= 1; count <= 5; count++) {
inner : for(int i = 0; i < count;i++) {
if(count == 3) {
break outter;
}
System.out.print("*");
}
System.out.println();
}
循环练习
水仙花数
打印 100 到 1000 之间的所有水仙花数
什么是水仙花数
水仙花数 是指 一个 3位数
它的每个位上的数字的 3次幂之和等于它本身
1^3 + 5^3 + 3^3 = 153
1*1*1 + 5*5*5 + 3*3*3
1 + 125 + 27 = 153
如何求百位数 十位数 和个位数
百位
求百位: 153 / 100 = 1
十位
求十位: 153 / 10 % 10 = 5
个位
求个位: 153 % 10 = 3
算法实现
方式一
for (int i = 100; i < 1000; i++) {
int bw = i / 100;
int sw = i / 10 % 10;
int gw = i % 10;
if(bw * bw * bw + sw * sw * sw + gw * gw *gw == i){
System.out.println(i);
}
}
方式二
for (int i = 100; i < 1000; i++) {
int bw = i / 100;
int sw = i / 10 % 10;
int gw = i % 10;
if (Math.pow(bw,3) + Math.pow(sw,3) + Math.pow(gw,3) == i) {
System.out.println(i);
}
}
练习1
练习2
练习3