目标:1. 操作符;
2. 条件语句;
3. 循环语句;
4. 变量
----------------------------------------------
1.java中变量的介绍
程序的基本功能是处理数据
程序用变量来接收并表示数据;
程序中必须先定义变量才能使用;
定义变量是指设定变量的数据类型和变量的名字,Java语言要求变量遵循先定义,再初始化,然后使用的规则。
变量的使用有一个作用域的问题,作用域是指它的存在范围,只有在这个范围内,程序代码才能访问它。
其次,作用域决定了变量的生命周期。变量的生命周期是指从一个变量被创建并分配内存空间开始,到这个变
量被销毁并清除其所占用内存空间的过程。当一个变量被定义时,它的作用域就被确定了。按照作用域的不同,
变量可分为以下类型:
. 成员变量:在类中声明,它的作用域是整个类;
成员变量又叫做属性/实例变量
. 局部变量:在一个方法的内部或方法的一个代码块的内部声明。如果在一个方法内部声明,它的作用域是整个方法;如果在一个方法的某个代码块的内部声明,它的作用域是这个代码块。代码块是指位于一对大括号"{}"以内的代码。
. 方法参数:方法或者构造方法的参数,它的作用域是整个方法或者构造方法。
. 异常处理参数:和方法参数很相似,差别在于前者是传递参数给异常处理代码块,而后者是传递参数给方法或者构造方法。异常处理参数是指catch(Exception e)语句中的异常参数"e",它的作用域是紧跟着catch(Exception e)语句后的代码块。
2.局部变量
1) 定义在方法的内部或方法的一个代码块的内部;
public void method1() {
int a = 0; //局部变量,作用域为整个method01方法;
if(a==0){
int b = 0; //局部变量,作用域为所处的代码块;
b = a;
}
b = 20; //编译出错,b不能被访问
}
2) 局部变量没有默认值,使用之前必须先初始化;
3) 生命周期
从声明开始,到这个局部变量直接所在的代码块结束为止
public class Sample {
public int add() {
int addResult = 1;
addResult = addResult+2;
return addResult;
}
public int subtract() {
int subResult = 1;
subResult = subResult-2;
return subResult;
}
public static void main(String[] args) {
Sample s = new Sample();
s.add();
s.add();
}
}
3.实例变量
1) 在类中声明,它的作用域是整个类;
class Test {
private int n1=0;
private int n2=0;
public int add() {
int result = n2 + n2;
return result;
}
}
2) 实例变量有默认值,使用之前可无须初始化;
注意每种变量的默认值
基本类型中的:
整型变量默认值都为0
浮点型默认值都为0.0
char默认值'\u0000'
boolean默认值false
引用类型的默认值都为null
3) 生命周期
从类的一个对象被创建开始,到这个对象被销毁
class Test {
private int n1=0;
private int n2=0;
public int add() {
int result = n2 + n2;
n1 = n1+1;
n2 = n2+2;
return result;
}
public static void main(String[] args) {
Test t1 = new Test();
Test t2 = new Test();
t1.add();
t1.add();
t2.add();
}
}
4. 操作符Operator
一般情况下,不用去刻意记住操作符的优先级,当不能确定操作符的执行顺序时,可以使用圆括号来显示指定运算顺序。
1) 赋值操作符:
= : int x=0,i=1,j=1;
*= : a*=b 等价于 a=a*b
/= : a/=b 等价于 a=a/b;
%= : a%=b 等价于 a=a%b;
+=
byte a=10;
a+=1; // a = a+1
int a = 15;
int b = 7;
-=
...
a++ ++a
2) 比较操作符
> : 大于
>= : 大于等于
< : 小于
<= : 小于等于
以上操作符只适用于整数类型和浮点数类型;
int a=1,b=1;
double d=1.0;
boolean result1 = a>b; //result1的值为false;
boolean result2 = a<b; //result2的值为false;
boolean result3 = a>=d; //result3的值为true;
boolean result4 = a<=b; //result4的值为true;
Object s
s instanceof com.briup.Student
Teacher t = new Teacher();
instanceof: 判断一个引用类型所引用的对象是否是一个类的实例。该操作符左边是一个引用类型,右边是一个类
名或接口名。形式如下:
obj instanceof ClassName
或者
obj instanceof InterfaceName
3) 相等操作符
int a = 10;
int b = 10;
a == b
a != b
== : 是否等于
!= : 是否不等于
既可以是基本类型,也可以是引用类型:
a. 基本类型:
int a=1,b=1;
float c=1.0f;
double d=1.0;
System.out.println(a==b); //输出true;
System.out.println(a==c); //输出true;
System.out.println(a==d); //输出true;
System.out.println(c==d); //输出true;
b. 引用类型:
这两个引用变量必须都引用同一个对象,结果才为true.
Student s1 = new Student("zs",25,100);
Student s2 = new Student("zs",25,100);
Student s3 = s1;
System.out.println(s1 == s2); //输出false;
System.out.println(s1 == s3); //输出true;
System.out.println(s2 == s3); //输出false;
4) 数学运算操作符
+ : 数据类型值相加或字符串连接;
a. 数据类型值相加;
int a=1+2; //a值为3;
double b=1+2; //b值为3.0;
double b=1+2.0; //c值为3.0;
b. 字符串连接;
System.out.println(1+2+"a"); //输出3a
System.out.println(1+2.0+"a"); //输出3.0a
System.out.println(1+2.0+"a"+true); //输出3.0atrue
System.out.println("a"+1+2); //输出a12
System.out.println(1+"a"+2); //输出1a2
/ : 整除, 如操作数均为整数,运算结果为商的整数部分
int a1=12/5; 2.4 //a1变量的取值为2
int a2=13/5; 2.6 //a2变量的取值为2
int a3=-12/5; //a3变量的取值为-2
int a4=-13/5; //a4变量的取值为-2
int a5=1/5; //a5变量的取值为0
double a6=12/5; //a6变量的取值为2.0
double a7=12/-5.0; //a7变量的取值为-2.4
% : 取模操作符, 如操作数均为整数,运算结果为商的整数部分
int a1=1%5; //a1变量的取值为1
int a2=13%5; //a2变量的取值为3
double a3=1%5; //a3变量的取值为1.0
double a4=12%5.1; //a4变量的取值为1.8000000000000007
5) 移位操作符
>> >>> <<
>> : 算术右移位运算,也称做带符号右移位运算。
int a1 = 12 >> 1; //a1变量的取值为6;
13 / 2
0000 1101
00000 110
0000 1100 13
-----------
000 0110 >>1
-----------
0000 0110 补位 因为是正数所以补0 结果为6
int a2 = 128 >> 2; //a2变量的取值为32;
int a3 = 129 >> 2; //a3变量的取值为32;
int a5 = -12 >> 1; //a4变量的取值为-6;
0000 1100 12
---------
1111 0011 取反
---------
1111 0100 +1 这个就是-12的二进制形式
----------
111 1010 >>1
1111 1010 补位 因为是负数所以补1 这个负数就是最终结果
---------
1111 1001 -1
---------
0000 0110 取反 结果为6 所以上面的最终结果是 -6
int a6 = -12 >> 2; //a4变量的取值为-3;
0000 1100 12
---------
1111 0011 取反
---------
1111 0100 +1 这个就是-12的二进制形式
----------
11 1101 >>2
1111 1101 补位 因为是负数所以补1 这个负数就是最终结果
---------
1111 1100 -1
---------
0000 0011 取反 结果为3 所以上面的最终结果是 -3
注:a. 对12右移一位的过程为:舍弃二进制数的最后一位,在二进制数的开头增加一位符号位,由于12是正整数,因此增加的符号位为0;
b. 对-12右移俩位的过程为:舍弃二进制数的最后俩位,在二进制数的开头增加俩位符号位,由于-12是负整数,因此增加的符号位为1;
>>> : 逻辑右移位运算,也称为不带符号右移位运算。
int a1 = 12 >>> 1; //a1变量的取值为6;
int a2 = -12 >>> 2; //a2变量的取值为1073741821;
1111.... 0100
001111.... 01
注:a. 对12右移一位的过程为:舍弃二进制数的最后一位,在二进制数的开头增加一个0;
b. 对-12右移二位的过程为:舍弃二进制数的最后二位,在二进制数的开头增加二个0;
<< : 左移位运算,也称为不带符号左移位运算。
12 << 2
00.... 110000
-12 << 2
0000 .... 1100
1111 .... 0011
11 .... 010000
00 .... 110000 48
int a1 = 12 << 1; //a1变量的取值为24;
int a2 = -12 << 2; //a2变量的取值为-48;
int a3 = 128 << 2; //a3变量的取值为512;
int a4 = 129 << 2; //a4变量的取值为516;
注:a. 对12左移一位的过程为:舍弃二进制数的开头一位,在二进制数的尾部增加一个0;
b. 对-12左移二位的过程为:舍弃二进制数的开头二位,在二进制数的尾部增加二个0;
6) 位运算操作符
& : 与运算,对两个操作元的每个二进制位进行与运算,运算规则为:1&1->1, 1&0->0, 0&1->0, 0&0->0;
12&6 = 4
12|6=14
0000 .... 1100
0000 .... 0110
0000 .... 1110
| : 或运算,对两个操作元的每个二进制位进行或运算,运算规则为:1|1->1, 1|0->1, 0|1->1, 0|0->0;
^ : 异或运算,对两个操作元的每个二进制位进行或运算,运算规则为:1^1->0, 0^0->
0,1^0->1, 0^1->1,; 相同为0 不同位1 运算特点: a^0=a; a^a=0;
int a = 10;int b =20;
a = a^b;
b = a^b;
a = a^b;
a= a+b
b = a-b;
a = a-b;
~ : 取反运算, ~1->0, ~0->1;
~12
0000 .... 1100
1111 .... 0011
0000 .... 1101 -13
7) 逻辑操作符
短路操作符,如果能根据操作左边的布尔表达式就能推算出整个表达式的布尔值,将不执行操作符右边
的布尔表达式;
&& : 左边的布尔表达式的值为false, 整个表达式值肯定为false, 此时会忽略执行右边的布尔表达式。
|| : 左边的布尔表达式的值为true, 整个表达式值肯定为true, 此时会忽略执行右边的布尔表达式。
8) 条件操作符
三目运算 ?:
布尔表达式 ? 表达式1 : 表达式2
if(布尔表达式){
表达式1
}else{
表达式2
}
boolean gender ;
String str = gender?"男":"女";
如果布尔表达式的值为true, 就返回表达式1的值, 否则返回表达式2的值。
int score = 61;
String result = score>=60?"及格":"不及格";
5. 引用类型之间转换
隐式转换:自动转换
基本类型:精度小可以自动转换为精度大的
byte b = 1;
int a = b;
引用类型:子类类类型可以自动转换为父类类型
Student s = new Student();
Object o = s;
显式转换:强制类型转换
基本类型:精度大的可以强制类型转换为精度小的,但是可能损失精度
int a = 1;
byte b = (byte)a;
引用类型:父类类型可以强制类型转换转换为子类类型,但是可能出现类型转换错误
Object类 是 Student类的父类
//这个是正确的
Object o = new Student();
Student s = (Student)o;
Object o = new String("hello");
Student s = (Student)o;
//这个会报错
Object o1 = new Object();
Student s1 = (Student) o1;
为了防止产生强转后,编译通过,但是报类型不匹配异常,可以先用instanceof
6. 条件语句
有些程序代码只有满足特定条件的情况下才会被执行,Java语言支持两种条件处理语句:if语句和switch语句
1) if ... else
int num =5
if(num >3){
1
}
if(num >2){
2
}
if(num <3) {
3
}
布尔表达式指的是能返回true或者false的运算式子: 1<2 1==1 1!=2
a. if后面的表达式必须是布尔表达式,而不能为数字类型,例如下面的if(x)是非法的。
int x=0;
//编译出错
if(x) {
System.out.println("x不等于0");
} else {
System.out.println("x等于0");
}
int x=0;
//正确
if(x!=0) {
System.out.println("x不等于0");
} else {
System.out