Day03类型转换和运算符

1. 变量的分类

变量按照声明的位置或作用范围分为成员变量和局部变量。

1.1 成员变量

1.1.1 成员变量概念：【掌握】

直接声明在类中的变量，都是成员变量，可以放在方法的上方或者下方，成员变量与方法是平级的。

1.1.2. 成员变量作用：【了解】

成员变量用来解释这个类中的属性（面向对象重点讲，先不管）

1.1.3. 成员变量特点：【掌握】

1) 作用域范围：

在整个类中都可以使用成员变量。

2) 成员变量使用之前，如果没有值，则系统会分配一个默认值。

不同的数据类型默认值不同：

整数类型默认值：0

小数类型默认值：0.0

布尔类型默认值：false

字符类型默认值：空字符(/u0000)

引用类型默认值：null

如果main主方法中使用到成员变量，成员变量必须加上static修饰；（因为静态区域不能引用非静态上下文的变量,面向对象会讲，先不管）

1.2 局部变量

1.2.1. 局部变量概念：【掌握】

就是声明位置在方法()内或者{}中，都是局部变量。【()表示方法的形参；{}表示方法主体或者代码块；后面会讲先不管】  

1.2.2. 局部变量作用：【了解】

局部变量就是为了辅助完成一个方法的功能（后面讲，先不管）

1.2.3. 局部变量特点：【掌握】

1) 作用域范围： 在声明位置下方，到}结束，都可以使用局部变量

2) 局部变量没有默认值，使用之前，必须有值，否则语法报错。

1.3 局部变量与成员变量区别

1. 声明位置

成员变量声明在类中，局部变量声明在方法或花括号{}结构体中；

1. 作用范围

成员变量在整个类结构中均可使用，局部变量只能在当前声明的花括号{}结构体中有效；

1. 初始值

成员变量使用之前可以不赋予初始值，系统根据数据类型分配默认值，

局部变量使用之前必须赋予初始值，没有默认值。

注意事项:

同一个类中，如果成员变量与局部变量重名，实际使用到的是就近的局部变量的值。

1.4 代码案例1【掌握】

/** * *  2. 变量的分类：(掌握) 2.1. 局部变量： 2.2. 成员变量： 局部变量在栈内存 成员变量在堆内存 静态static成员在静态区内存 */ public class _01Var { /** 声明一个int类型成员变量b，不赋值 */ int b;// 成员变量是堆内存中 /** 声明一个int类型static成员变量e，不赋值 */ static int e;// 静态成员变量是静态区内存 /** 声明一个static修饰String类型str成员变量，不赋值 */ static String str; /** * main方法有static修饰，被static修饰的成员都是静态成员，被修饰的方法都是静态区。 * 所有static成员都存放在 JVM的静态区中【堆中】，在静态区中只能使用静态成员 * @param args */ public static void main(String[] args) {// args就是局部变量 // 原来声明变量是在main方法中,在方法中都是局部变量 // 声明一个int类型变量a赋值1 int a = 1;// 作用域范围：从声明这一行到main｝结束  ，在栈内存 System.out.println(a);// 1 // 声明一个int类型变量d，不赋值 int d;// 在栈内存 // System.out.println(d);// 局部变量d在使用前，必须被初始化 // 打印成员变量b // System.out.println(b);// 报错，因为非静态成员变量b不能在静态区使用 // 打印static成员变量e System.out.println(e);// 0 // 打印static成员变量str System.out.println(str);// null 【该数据主要在数组那天讲】 } {// 代码块，现在不管。【面向对象会讲，今天只是为了测试变量分类，代码块执行方式后面讲】 int c = 2;// 声明了一个int类型的局部变量c，并且赋值为2。在栈内存 // System.out.println(a);// 报错，因为出了局部变量a作用域范围了 // 打印static成员变量e System.out.println(e);// 0 } }

1.5 代码案例2【理解】

/** * 3. 就近原则：（理解） 局部变量和成员变量名字可以相同，因为存放内存区域不同。 局部变量 在内存的栈中 static修饰的成员变量在 静态区 非static修饰的成员变量在 堆 当使用一个变量的时候，优先从局部变量中查找，如果找不到，才从类中找成员变量。这就是就近原则    局部变量在栈内存 成员变量在堆内存 静态static成员在静态区内存 关于内存区域：堆、栈、静态区先不管，后面讲 */ public class _02Var { /** 声明一个int类型static成员变量a，赋值1 */ static int a = 1;// 静态成员变量a是静态区内存 public static void main(String[] args) { // 声明一个int类型局部变量a赋值2 int a = 2; // 打印变量a的时候，是用的局部变量a System.out.println(a);// 2 } }

2. 数据类型转换

2.1 类型转换概念

将数据从一种格式或结构转换为另一种格式或结构的过程。

2.2 类型转换作用

1.节约内存空间

byte short int long

2.将一些类型转换为项目所需要的类型

2.3 类型转换分类

2.3.1 自动隐式转换

定义：将小的数据类型转换大的数据类型

注意事项：

1.在Java中，boolean类型与所有其他7种类型都不能进行转换。

2.其他 7种数据类型，它们之间都可以进行转换，但是可能会存在精度损失或者其他一些变化。

byte -> short -> int  -> long-> float-> double

char -> int  -> long-> float-> double

byte与char 不能自动转换  

char与short不能自动转换

由于小数(浮点数) 的存储方式，结构和整数不一样，所以，float哪怕是4个字节、long是8个字节，表示范围也大于long类型。知道就好无须深入研究..

自动转换案例

1.

short s = 10; int num = 20; int n = num + s; System.out.println(n);

2.

int  num = 10; double b = 10.01; double  c = num + b; System.out.println(c);

3.char类型向更高长度类型（例如整型）转换时，会转换为对应的ASCII码值，再做其他类型的自动转换

char  c = 'A'; int num = 10; int a = c + num; System.out.println(a);

特例：只看类型，不看值

// 示例1: int a = 129; byte b = (byte)a;// 编译器只看容器不看值 System.out.println(b);// 结果为-127 // 示例2: byte b = 100;// 可以自动转换 float f = 1.3;// 不能自动转换 int a = 2147483647; a = a + 1; System.out.println(a);// 结果为-2147483648

2.3.2 强制转换【掌握】

定义：将大数据类型转为小数据类型

语法：小数据类型 变量名 = (小数据类型)大类型值/大类型变量名;

注意事项：

1. 高转低会导致精度丢失,有数据的溢出风险。溢出的时候，会以二进制进位。

2. 实际开发中:应该要知道被强制转换的数据,是在一个已知的范围。

3. 当int类型的具体的值，向byte、short、char类型转换的时候，值只要在其表示范围内，都会隐式转换。

代码案例:

int i1 = 123; int i2 = 456; float f1 = (float)((i1 + i2) * 1.2);// 类型大的转换为类型小的时，要加上强制转换符 short i = 99; char c = (char)i; System.out.println(c);   byte b1 = 1; byte b2 = 2; byte b3 = (byte)(b1 + b2); // byte，short，char在计算时首先转换为int，大类型（int）转换为小类型的（byte）时要加强制转换 byte t = 127;// 不报错 int a = 127; // 需要强制转换才不报错：编译器只看类型，不看值 byte b = (byte)a; System.out.println(b); // 结果为 127

2.3.3 代码案例【掌握】

/** * 4. 类型转换：(掌握)    byte  short（char）  int  long  float（单精度）  double（双精度） (只有数值类型才能相互转换)    ----------------从左到右精度越来越高-------------------->   1. 小转大，都是可以隐式转换  （从左到右）   2. 大转小，必须强制转换  （从右到左） 强制转换有数据的溢出风险。溢出的时候，会以二进制进位    强制转换语法：    小的数据类型 小的变量 = (小的数据类型)大的变量/值;          当int类型的具体的值，向byte、short、char类型转换的时候，值只要在其表示范围内，都会隐式转换     */ public class _03TypeChange { public static void main(String[] args) { // 1. 小转大，都是可以隐式转换  （从左到右） byte byt = 1;// 声明一个byte类型变量byt 赋值1 short s = byt;// 声明一个short类型变量s 赋值一个byte类型变量byt int i = s;// 声明一个int类型变量i 赋值一个short类型变量s long lon = i;// 声明一个long类型变量lon 赋值一个int类型变量i float f = lon;// 声明一个float类型变量f 赋值一个long类型变量lon double doub = f;// 声明一个double类型变量doub 赋值一个float类型变量f // 2. 大转小，必须强制转换  （从右到左） 强制转换有数据的溢出风险。溢出的时候，会以二进制进位 // 强制转换语法：小的数据类型 小的变量 = (小的数据类型)大的变量/值; float f2 = (float)doub;// 声明一个float类型变量f2,赋值为一个强制转换的double类型变量 doub long lon2 = (long)f2; byte byt2 = (byte)128;// 128是int类型，强制转换有可能发生溢出，溢出时会以二进制进位 System.out.println(byt2);// -128 int a = 1; // byte byt3 = a;// 报错，int类型a值是1，因为在编译期程序只看右边的数据类型，而不看变量中的值 byte byt4 = 1;// 不报错 } }

3. 表达式

3.1表达式概念

由一系列的常量、变量、运算符、括号()等组成的一个算术式，按照一定的运算规则计算出一个结果值。

3.2 表达式示例

例如：3 + 2；3 + 5 * (2 + 3)

注：括号可以提高运算的优先级

3.3 表达式规律：【掌握】

1) 当表达式中所有的变量类型小于int的时候，运算后的结果都会自动提升为int类型。

2) 当表达式中有变量类型大于int的时候，运算后的结果以表达式中精度最高的为主。

3.4 表达式代码案例【掌握】

/** * 表达式：（掌握） 1. 概念：就是一个算术式。 例如： 1 + 1 + 2*3 2. 规律： 1.当表达式中所有的变量类型小于 int的时候，运算后的结果都会自动提升为int类型 2.当表达式中有变量类型大于 int的时候，运算后的结果以表达式中精度最高的为主 */ public class _04Expression { public static void main(String[] args) { byte byt = 1; short s = 2; int i = 3; long lon = 5L; float f = 1.0f; double doub = 3.14; // 将上面所有变量相加，得到一个表达式 // 2.当表达式中有变量类型大于 int的时候，运算后的结果以表达式中精度最高的为主 double sum = byt + s + i + lon + f + doub; System.out.println(sum); // 1.当表达式中所有的变量类型小于 int的时候，运算后的结果都会自动提升为int类型 int sum2 = byt + s; System.out.println(sum2); } }

4. 运算符

4.1 算数运算【掌握】

算数运算（Arithmetic Operation）（掌握）

+ ：加号。只有String字符串参与的加法运算，才有拼接功能，在String之前，表示加法 运算，之后，才表示连接

-:减号。

*:乘号。

/:除号。不能除0

特殊情况：

1) 10 / 3 = 3

2) 10.0 / 3 = 3.33333…

3) 0 / 0

4) 0.0 / 0.0 结果是NaN ,任何的NaN都不等于自己（面试题）

5) 1.0 / 0.0 结果：Infinity,表示无穷大

%：模（也叫取余）相当于求余数。例如：10 % 3 ,表示求10除3的余数，结果是1

作用：1. 求余数    2. 找一个数的倍数    3. 可以拆分一个多位的数字

代码案例：

public class _05ArithmeticOperation { public static void main(String[] args) { System.out.println("============= 除法 / =============="); System.out.println(10 / 1);// 10 System.out.println(10 / 2);// 5 System.out.println(10 / 3);// 3 System.out.println(10 / 4);// 2 System.out.println(10 / 5);// 2 System.out.println(10 / 6);// 1 System.out.println(10 / 7);// 1 System.out.println(10 / 8);// 1 System.out.println(10 / 9);// 1 System.out.println(10 / 10);// 1 System.out.println(10 / 11);// 0 // System.out.println(10 / 0);// ArithmeticException算术异常 System.out.println("============= 特殊情况 =============="); /*  * 特殊情况：【了解】  1) 10/3 =3；  2) 10.0/3=3.33333…  3) 0/0  4) 0.0/0.0    结果是NaN ,任何的NaN都不等于自己（面试题）not a number不是一个数字  5) 1.0/0.0   结果：Infinity,表示无穷大  */ System.out.println(10.0 / 3); System.out.println(0.0 / 0.0);// NaN System.out.println(1.0 / 0.0);// Infinity表示无穷大 System.out.println("============== % 模（取余） =============="); System.out.println(10 % 1);// 0 System.out.println(10 % 2);// 0 System.out.println(10 % 3);// 1 System.out.println(10 % 4);// 2 System.out.println(10 % 5);// 0 System.out.println(10 % 6);// 4 System.out.println(10 % 7);// 3 System.out.println(10 % 8);// 2 System.out.println(10 % 9);// 1 System.out.println(10 % 10);// 0 System.out.println(10 % 11);// 10 // System.out.println(10 % 0);// ArithmeticException算术异常 // 请求出个十百位的值  / % int a = 127; // 求个位 int ge = a % 10; // 求十位 int shi = a / 10 % 10; // 求百位 int bai = a / 100; System.out.println(ge + " : " + shi + " : " + bai); } }

4.2 自增自减运算（重点）

自增自减运算符：++   --

注意事项：

1) 自增自减只能够用于变量，不能用于常量  

2) 自增自减运算的优先级比其他算术运算符高

3) 一般用在循环语句中

使用要点：

把整个表达式看成是一个整体。

如果变量名在前面，那么整个表达式的值就是原来值不变。

如果变量名在后面，那么整个表达式的值就是原来的值加1。

1. 变量在前 a++: 先赋值，再自增 运算步骤： step1：先将a的值赋值给  a++ 这个整体 step2：再将a的值+1 2. 变量在后 ++a:先自增，再赋值 运算步骤： step1：先将a的值+1 step2：再将a的值赋值给  a++ 这个整体

下面我们就以自增运算案例演示，子减规律完全相同，就不做演示了。

代码案例:

public class _06AddAdd { public static void main(String[] args) { // ++不能运算常量 // System.out.println(1++); // 声明一个int类型变量a，赋值1 int a = 1; /*  * 2. 变量在前 a++: 先赋值，再自增 运算步骤：   step1：先将a的值赋值给  a++ 这个整体   step2：再将a的值+1  */ int b = a++;// 相当于将a++这个整体的值，赋值给int变量b System.out.println("b = " + b);// 1 System.out.println("a = " + a);// 2 // 声明一个int类型变量i，赋值1 int i = 1; /*  * 3. 变量在后 ++a:先自增，再赋值 运算步骤：   step1：先将a的值+1   step2：再将a的值赋值给  ++a 这个整体  */ int j = ++i;// 相当于将a++这个整体的值，赋值给int变量b System.out.println("j = " + j);// 2 System.out.println("i = " + i);// 2 } }

练习题：

// 1. int i = 3; i = i++; System.out.prinltn(“i = ” + i);//3 // 2. int i = 3; i = ++i; System.out.println(“i = ” + i);//4 // 3. int i = 3; int a = i++ + i++ + i++; int b = ++i + ++i + ++i; System.out.println(“i = ” + i);  9 System.out.println(“a = ” + a);  12 System.out.println(“b = ” + b);  24

int i = 5; i++; System.out.println(“i = ” + i);//6 ++i; System.out.println(“i = ” + i);//7 int a = ++i; System.out.println(“a = ”+ a);//8 a = a++; System.out.println(“a = ” + a);//8 a = ++a; System.out.println(“a = ” + a);//9 // 5. int m = 3; int n = 2 * ++m; System.out.println(“n = ”+ n);//8

public class _07AddAdd { public static void main(String[] args) { // 声明一个int类型变量a，赋值1 int a = 1; int b = 2; // a++: 先赋值再自增 ++a:先自增再赋值 int c = a++ + ++a + b--; int d = c++ + c-- + a++ + ++b; // a = ? b = ? c = ? d = ? System.out.println("a = " + a);// a = 4 System.out.println("b = " + b);// b = 2 System.out.println("c = " + c);// c = 6 System.out.println("d = " + d);// d = 18 } }

4.3 赋值运算【掌握】

赋值运算（Assignment Operation）：是优先级最低的一种运算，等 = 后边的所有运算完毕后，才执行赋值运算。

赋值运算符的符号：

+= 累加

-= 累减

*=

/=

%=

=

以下了解即可

^=

&=

|=

..

语法：变量1 += 值/变量2;

赋值运算注意事项：

1. 从右到左，把符号右边的值赋值到左边的变量中

2. 上面符号看成是一个整体： 例如 += 看成是一个符号，不要看成两个。

3. 赋值运算有强制转换功能，可以避免类型提升.会有溢出风险

示例： int i= 3; i += 2;// 表示把2 累加到变量 i 中 i -= 1; i *= 3; i /= 3; i %= 3; // 特例 short s = 3; s += 2;// 存在隐式转换 short s = 3; s = s + 2;// 报错，因为结果值是int，int不能自动转换为short

public class _08AssignmentOperation { public static void main(String[] args) { // 声明一个int类型变量a赋值1 int a = 1; a += 5;// 表示将变量a的值累加上5，相当于a = (int)(a + 5); System.out.println(a);// 6 byte b = 127; b += 1;// b += 1相当于 ： b = (byte)(b + 1); System.out.println(b);// -128 // b = b + 1;// 报错， b + 1表达式结果是int类型 a += 1 + 3 + 5;// 会先计算 += 右边所有的运算，再执行 += 赋值运算 System.out.println(a); } }

4.4 比较运算【掌握】

比较运算(Compare Operation)：结果一定是boolean类型

>

<

>=

<=

==: 双等于或者恒等于

1. 比较基本类型，比较的是值是否相等

例如：

int a = 1;

int b = 1;

System.out.println(a == b); //true

2. 比较引用类型，比较的是地址是否相等

!=: 不等于

1. 比较基本类型，比较的是值是否不相等

2. 比较引用类型，比较的是地址是否不相等

instanceof:只能比较引用类型，一般配合条件语句使用(面向对象重点讲，今天不管)

表示判断一个变量或者值是否属于某一个引用数据类型

语法： 值/变量 instanceof 引用数据类型

例如：

1.System.out.println("约" instanceof String);

2.String str = "不约";

System.out.println(str instanceof String);

public class _09CompareOperation { public static void main(String[] args) { // 声明2个int类型变量，随便赋值 int a = 1; int b = 2; // == 比较这两个变量的值是否相等 System.out.println(a == b);// false // != 比较这两个变量的值是否  不相等 System.out.println(a != b);// true // 声明一个String变量str String str = "某菲"; // 使用 instanceof System.out.println(str instanceof String);//  true ,判断String变量str是否属于String类型 System.out.println("某飞扬" instanceof String);// true ,判断String变量str是否属于String类型 } }

4.5 三目运算【掌握】

三目(三元)运算(Binocular Operation)

语法： x ? y : z;// 表示如果x为true，执行y，x为false则执行z。

x: 是boolean类型值或者boolean表达式。

y、z: 可以是表达式，也可以是值或者变量。

y和z可以是不同的数据类型，但是如果要接收三目运算的结果，必须要求y和z的类型完全一致

三目运算可以嵌套使用

示例:

// 1.找出两个整型变量中的最大值 int a = 6, b = 9; int c = a > b ? a : b; System.out.println(c); //2.判断一个数是 奇数 还是 偶数 int j = 11; String result = j % 2 == 0 ? "偶数" : "奇数"; System.out.println(result);

代码案例

public class _10BinocularOperation { public static void main(String[] args) { String result = 2 > 3 ? "我请你们馒头" : "你们请我吃帝王蟹！"; System.out.println(result); // 需求：求两个int变量中的最大值或者最小值 int a = 3; int b = 5;  /*  *  用三目运算求最大值  *  语法： x ? y : z; x: 是boolean类型值或者boolean表达式。 y、z: 可以是表达式，也可以是值或者变量。y和z可以是不同的数据类型  */ int max = a > b ? a : b; System.out.println(max); // 求三个int类型变量的最小值    三目嵌套使用：(看不懂就用单层的) int i = 1; int j = 2; int k = 3; /*  * 先求出i和j的最小值min  * 再求min和第三个变量k的最小值，将结果重新赋值给变量min  */ int min = i < j ? i : j; min = min < k ? min : k;// 求min和第三个变量k的最小值，将结果重新赋值给变量min  System.out.println(min); // 三目嵌套使用：(看不懂就用单层的) int min2 = i < j ? (i < k ? i : k) : (j < k ? j : k); System.out.println(min2); } }