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.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; |
2.
int num = 10; |
3.char类型向更高长度类型(例如整型)转换时,会转换为对应的ASCII码值,再做其他类型的自动转换
char c = 'A'; |
特例:只看类型,不看值
// 示例1: |
2.3.2 强制转换【掌握】
定义:将大数据类型转为小数据类型
语法:小数据类型 变量名 = (小数据类型)大类型值/大类型变量名;
注意事项:
1. 高转低会导致精度丢失,有数据的溢出风险。溢出的时候,会以二进制进位。
2. 实际开发中:应该要知道被强制转换的数据,是在一个已知的范围。
3. 当int类型的具体的值,向byte、short、char类型转换的时候,值只要在其表示范围内,都会隐式转换。
代码案例:
int i1 = 123; |
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. |
|
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. 赋值运算有强制转换功能,可以避免类型提升.会有溢出风险
示例: |
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.找出两个整型变量中的最大值 |
代码案例 |
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); } } |