目录
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;
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
}
}
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 CompareOperation {
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);