-局部变量
-实例变量（也叫成员变量、全局变量）
-操作符（赋值、比较、相等、数学运算、移位、位运算、逻辑）
-类型转换（隐式、显式）
-条件语句
-循环语句
1.java中变量的介绍
程序的基本功能是处理数据
程序用变量来接收并表示数据；
程序中必须先定义变量才能使用；
定义变量是指设定变量的数据类型和变量的名字，Java语言要求变量遵循先定义，再初始化，然后使用的规则。
变量的使用有一个作用域的问题，作用域是指它的存在范围，只有在这个范围内，程序代码才能访问它。
其次，作用域决定了变量的生命周期。变量的生命周期是指从一个变量被创建并分配内存空间开始，到这个变
量被销毁并清除其所占用内存空间的过程。当一个变量被定义时，它的作用域就被确定了。按照作用域的不同，
变量可分为以下类型：
. 成员变量：在类中声明，它的作用域是整个类；
成员变量又叫做属性/实例变量
. 局部变量：在一个方法的内部或方法的一个代码块的内部声明。如果在一个方法内部声明，它的作用域是整个方法；如果在一个方法的某个代码块的内部声明，它的作用域是这个代码块。代码块是指位于一对大括号"{}"以内的代码。
. 方法参数：方法或者构造方法的参数，它的作用域是整个方法或者构造方法。
. 异常处理参数：和方法参数很相似，差别在于前者是传递参数给异常处理代码块，而后者是传递参数给方法或者构造方法。异常处理参数是指catch(Exception e)语句中的异常参数"e"，它的作用域是紧跟着catch(Exception e)语句后的代码块。
2.局部变量
-
定义在方法的内部或方法的一个代码块的内部；
public void method1() {
int a = 0; //局部变量，作用域为整个method01方法；
if(a==0){
int b = 0; //局部变量，作用域为所处的代码块；
b = a;
}
b = 20; //编译出错，b不能被访问
} 局部变量没有默认值，使用之前必须先初始化；
-
生命周期
从声明开始,到这个局部变量直接所在的代码块结束为止
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.实例变量
-
在类中声明，它的作用域是整个类；
class Test {
private int n1=0;
private int n2=0;public int add() { int result = n2 + n2; return result; }}
实例变量有默认值，使用之前可无须初始化；
注意每种变量的默认值
基本类型中的:
整型变量默认值都为0
浮点型默认值都为0.0
char默认值'\u0000'
boolean默认值false
引用类型的默认值都为null-
生命周期
从类的一个对象被创建开始,到这个对象被销毁
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(); }}
- 操作符Operator
一般情况下，不用去刻意记住操作符的优先级，当不能确定操作符的执行顺序时，可以使用圆括号来显示指定运算顺序。
-
赋值操作符：
= : int x=0,i=1,j=1;
= : a=b 等价于 a=a*b
/= : a/=b 等价于 a=a/b;
%= : a%=b 等价于 a=a%b;
+=
-=
... -
比较操作符
: 大于
= : 大于等于
< : 小于
<= : 小于等于以上操作符只适用于整数类型和浮点数类型；
int a=1,b=1;
double d=1.0;
boolean result1 = a>b; //result1的值为false;
boolean result2 = a
boolean result4 = a<=b; //result4的值为true;instanceof: 判断一个引用类型所引用的对象是否是一个类的实例。该操作符左边是一个引用类型，右边是一个类
名或接口名。形式如下：obj instanceof ClassName 或者 obj instanceof InterfaceName -
相等操作符
== : 是否等于
!= : 是否不等于既可以是基本类型，也可以是引用类型：
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; -
数学运算操作符
- : 数据类型值相加或字符串连接;
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; //a1变量的取值为2
int a2=13/5; //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 -
移位操作符
: 算术右移位运算，也称做带符号右移位运算。
int a1 = 12 >> 1; //a1变量的取值为6;
0000 1100 12
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;
注：a. 对12右移一位的过程为：舍弃二进制数的最后一位，在二进制数的开头增加一个0;
b. 对-12右移二位的过程为：舍弃二进制数的最后二位，在二进制数的开头增加二个0;
<< : 左移位运算，也称为不带符号左移位运算。
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;
-
位运算操作符
& : 与运算，对两个操作元的每个二进制位进行与运算，运算规则为：1&1->1, 1&0->0, 0&1->0, 0&0->0, 3>4&4<5->false;
（注意：1、8&4不是1，而是相当于0000...0000 0000 1000 & 0000...0000 0000 0100，每一位&运算，为0；
2、如果&两边跟的是表达式，输出结果为false或true；如果跟的是数字类型，得到的是数字，表示基于二进制计算。）
| : 或运算，对两个操作元的每个二进制位进行或运算，运算规则为：1|1->1, 1|0->1, 0|1->1, 0|0->0;
^ : 异或运算，对两个操作元的每个二进制位进行或运算，运算规则为：1^1->0, 00->0，10->1, 0^1->1,; 相同为0 不同位1 运算特点: a^0=a; a^a=0;
（如：8 ^ 4 = 12 0000...0000 0000 1000 ^ 0000...0000 0000 0100 = 0000...0000 0000 1100）
~ : 取反运算, ~1->0, ~0->1; -
逻辑操作符
短路操作符，如果能根据操作左边的布尔表达式就能推算出整个表达式的布尔值，将不执行操作符右边
的布尔表达式；&& : 左边的布尔表达式的值为false, 整个表达式值肯定为false, 此时会忽略执行右边的布尔表达式。
|| : 左边的布尔表达式的值为true, 整个表达式值肯定为true, 此时会忽略执行右边的布尔表达式。 -
条件操作符
三目运算
布尔表达式 ? 表达式1 : 表达式2如果布尔表达式的值为true, 就返回表达式1的值， 否则返回表达式2的值。
int score = 61;
String result = score>=60?"及格":"不及格";
-
类型转换
隐式转换:自动转换
基本类型:精度小可以自动转换为精度大的
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 o1 = new Object();
Student s1 = (Student) o1;
-
条件语句
有些程序代码只有满足特定条件的情况下才会被执行，Java语言支持两种条件处理语句：if语句和switch语句-
if ... else
布尔表达式指的是能返回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.println("x等于0");
}b. 假如if语句或else语句的程序代码块中包括多条语句，则必须放在大括号{}内。若程序代码块只有一条语句
则可以不用大括号{}。流程控制语句(如if...else语句)可作为一条语句看待。public void amethod(int x) { if(x>0) System.out.println("x不等于0"); else if(x==0) System.out.println("等于0"); else if(x<0) System.out.println("小于0"); }等价于:
public void amethod(int x) {
if(x>0){
System.out.println("x不等于0");
}
else{if(x==0){ System.out.println("等于0"); } else if(x<0){ System.out.println("小于0"); } }}
练习：1) 写一个方法实现分时问侯, 如是8点至12点，返回"上午好", 12点至14点，返回"中午好",
14点至18点，返回"下午好", 其它时间返回"晚上好"public String sayHello(int hour) { String msg; if(hour >=8 && hour < 12) msg = "上午好"; else if(hour>=12 && hour <14) msg = "中午好"; else if(hour>=14 && hour <18) msg = "下午好"; else msg = "晚上好"; return msg; } 2) 写一个方法判断某一年是否为闰年。 标准：1) 能被4整除，但不能被100整除; 或 2) 能被400整除； /**实现方式一*/ public boolean isLeapYear(int year) { if((year%4==0 && year%100!=0) || (year%400==0)) return true; else return false; } /**实现方式二*/ public boolean isLeapYear(int year) { boolean leap; if(year%4!=0) leap=false; else if(year%100!=0) leap=true; else if(year%400!=0) leap=false; else leap=true; return leap; } /**实现方式三*/ public boolean isLeapYear(int year) { boolean leap; if(year%4==0) { if(year%100==0) { if(year%400==0) leap=true; else leap=false; } else leap=false; } else leap=false; return leap; } -
-
switch
语法：switch(expr) {
case value1:
statements;
break;
...
case valueN
statments;
break;default: statements; break; }a. expr的类型必须是byte, short, char或者int;
b. valuesN类型必须是byte, short, char或者int, 该值必须是常量。各个case子句的valueN值不同；
c. 当switch表达式的值不与任何case子句匹配时，程序执行default子句，假如没有default子句，则程序直接
退出switch语句。default子句可以位于switch语句中的任何位置。
d. 如果switch表达式与某个case表达式匹配，或者与default情况匹配，就从这个case子句或default子句开始执行。
假如遇到break，就退出整个switch语句，否则依次执行switch语句中后续的case子句，不再检查case表达式的值。
e. switch语句的功能也可以用if...else语句来实现。但switch语句会使程序更简洁，可读性更强。而if...else功能更为强大。练习：1) 写一个方法，能实现数值星期和中文星期的转换，如0会转换为星期天, 1会转换为星期一。
public String switchWeekLabel(int week) { String result; switch(week) { case 0: result = "星期天"; break; case 1: result = "星期一"; break; case 2: result = "星期二"; break; case 3: result = "星期三"; break; case 4: result = "星期四"; break; case 5: result = "星期五"; break; case 6: result = "星期六"; break; default: result = "您输入的星期数值为"+week+",不能进行转换"; } return result; } 2) 写一个方法，返回指定月份最后一天到底是多少号？ public int getLastDay(int year, int month) { int day=30; //1 switch(month) { case 1: case 3: case 5: case 7: case 8: case 10: case 12: day=31; break; case 2: day = getLeapYear(year)? 29:28; } return day; }
- 循环语句
循环语句的作用是反复执行一段代码，直到不满足循环条件为止。循环语句一般应包括如下四部分内容：
. 初始化部分：用来设置循环的一些初始条件，比如循环控制变量的初始值；
. 循环条件： 这是一个布尔表达式，每一次循环都要对该表达式求值，以判断到底继续循环还是终止循环。
. 循环体： 这是循环操作的主体内容，可以是一条语句，也可以是多条语句；
. 迭代部分： 用来改变循环控制变量的值，从而改变循环条件表达式的值；
Java语言提供三种循环语句：for语句、while语句和do...while语句。for语句、while语句在执行循环体之前
测试循环条件，而do...while语句在执行循环体之后测试循环条件。因此for语句、while语句有可能连一次循
环都未执行，而do...while至少执行一次循环体。
-
for循环
语法：for(初始化部分；循环条件；迭代部分) {
循环体
}在执行for语句时，先执行初始化部分，这部分只会被执行一次；
接下来计算作为循环条件的布尔表达式，如果为true，就执行循环体；
接着执行迭代部分，然后再计算作为循环条件的布尔表达式，如此反复；练习：1) 写一方法，完成计算从1加到100的和；
public int sum() { int result = 0; for(int i=1;i<=100;i++) { result = result + i; } return result; } 2) 在练习一基础上，完成计算从1加到指定数值的和； public int sum(int n) { int result = 0; for(int i=1;i<=n;i++) { result = result + i; } return result; } -
while循环
语法：[初始化部分]
while(循环条件) {
循环体,包括迭代部分
}当循环条件为true时，就重复执行循环，否则终止循环；
练习：1) 用while循环完成计算从1加到指定数值的和；
public int sum(int n) { int result = 0,i=1; while(i<=n) { result = result + i; i=i+1;//i++; } return result; } -
do ... while循环
和while非常类似，只不过先执行循环体，然后再判断循环条件。语法：[初始化部分]
do {
循环体,包括迭代部分
} while(循环条件);练习：1) 用do...while循环完成计算从1加到指定数值的和；
public int sum(int n) { int result = 0,i=1; do { result = result + i; i=i+1; } while(i<=n) return result; }
以上三种循环，功能类同。作为一种编程惯例，for语句一般用在循环次数事先可确定的情况下，则
while和do...while语句则用在循环次数事先不可确定的情况下。
练习：往控制台上输出以下内容：
*
**
***
****
*****
******
*******
public void myPrint(int n){
for(int i=0;i- 循环语句中流程跳转
-
break: 终止当前或指定循环；
public int sum(int n) {
int result = 0,i=1;
while(i<=n) {
result = result + i;
i=i+1;
if(i>10)
break;
}return result;}
实现1加到n;但是i大于10的话就直接退出循环
continue: 跳过本次循环，执行下一次循环，或执行标号标识的循环体。
public int sum(int n) {
int result = 0;
for(int i=1;i<=100;i++) {
if(i%2==0)
continue;
result = result + i;
}
return result;
}
实现指定范围内奇数的和；
-
label: 标号用来标识程序中的语句，标号的名字可以是任意的合法标识符。
观察三个效果有什么不同:
public void lableTest1(){
for(int i=0;i<6;i++){
for(int j=0;j<6;j++){
System.out.print(j);} System.out.println();}
}
public void lableTest2(){
for(int i=0;i<6;i++){
for(int j=0;j<6;j++){
System.out.print(j);
if(j==3){
break;
}
}
System.out.println();
}
}
public void lableTest3(){
f1:for(int i=0;i<6;i++){
for(int j=0;j<6;j++){
System.out.print(j);
if(j==3){
break f1;
}
}
System.out.println();
}
}