程序中的变量分为实例变量和局部变量：
实例变量(又称属性、全局变量、成员变量)：
位置： 直接定义在中类,属于类中的一种成员(成员变量/成员方法)，例如： public class Student{ public String name; } 作用范围： 是指变量定义之后,都在哪些地方可以被访问到，由于实例变量是直接定义在类中的,所以在定义的时候可以使用修饰符进行修饰，例如： 这四种修饰符的作用之后会介绍到 public class Student{ public String name1; protected String name2; String name3; private String name4; }以上是使用了四种访问权限控制修饰符来修饰了这四个变量，但是不管是哪种修饰符情况,实例变量在当前类中的每一个方法都是可以被访问到的(static修饰的静态方法除外)
public class Student{ public String name1; protected String name2; String name3; private String name4; //类中的方法里面可以直接访问实例变量 public void run(){ System.out.println(name1); System.out.println(name2); System.out.println(name3); System.out.println(name4); } } 默认值： 类的中实例变量声明后,如果我们没有显式赋值的话,每种实例变量其实都是有自己的默认值的。 实例变量的赋值分为隐式赋值和显式赋值： 隐式赋值：就是JVM给它赋的值(就是说的默认值) 显式赋值：就是我们主动给它赋的值，例如： public class Student{ public int a; public float f; public char c; public boolean b; public String str; /* 基本类型的实例变量: 整型 :默认值为 0 浮点型 :默认值为 0.0 布尔型 :默认值为 false 字符型 :默认值为 0 或者 '\u0000' 引用类型的实例变量: 默认值都是 null */ public void println(){ System.out.println(a); System.out.println(f); System.out.println(c); System.out.println(b); System.out.println(str); } } 生命周期： 实例变量是属于对象的,一个对象被创建出来的时候,这个对象中的实例变量就有了,直到这个对象被GC当做垃圾回收之后,这个实例变量也就没有了。局部变量：
位置： 定义在方法的代码块中或者方法的参数列表中，例如：a b c d四个都是局部变量 public void test(int a){ int b; { int c; } if(true){ int d; } } 作用范围： 如果是定义在方法的参数列表中,那么在当前方法的任何位置都可以访问该局部变量，例如： public void test(int a){ System.out.println(a); { System.out.println(a); } if(true){ System.out.println(a); } }如果是定义在方法中,那么就要看这个局部变量是"直接"位于哪一对大口号内，例如：
public void test(){ int a; { int b; } if(true){ int c; } }观察局部变量a/b/c三个分别是"直接"位于哪一对大括号内,那么这个局部变量的作用范围就在那一对大括号内，如果访问的地方出了这个范围,那么是访问不到这个局部变量的。
默认值： 局部变量是"没有"默认值的,我们只能显式的赋值之后才能使用该变量,否则会编译报错，例如： //编译通过 //只定义了变量但是没有使用 public void test(){ int a; } //编译报错 //因为在使用局部变量之前没有赋值 public void test(){ int a; System.out.println("a = "+a); } //编译通过 //只有在使用之前赋值就可以了 //int a = 1; //当然声明的同时就赋值也是可以的 public void test(){ int a; a = 1; System.out.println("a = "+a); } 生命周期： 码执行到局部变量的声明这一刻开当方法被调用,代始,这个局部变量就出现了,直到局部变量"直接"位于的大括号内中的代码执行结束的时候,该变量在内存中也就释放消失了，例如： //test方法执行完,变量a就没有了 public void test(){ int a; } //if代码块执行完,变量b就没有了 public void test(){ if(true){ int b; } //这里是访问不到变量b的,编译报错 System.out.println("b = "+b); }= 例如：
int x=0,i=1,j=1;*= 例如：
a*=b 等价于 a=a*b/= 例如：
a/=b 等价于 a=a/b;%= 例如：
a%=b 等价于 a=a%b;+= 例如：
a+=b 等价于 a=a+b;-= 例如：
a-=b 等价于 a=a-b;其他的都是类似情况 特殊情况：i++ 和 ++i i++表示先使用i的值,然后再让i自增1。 ++i表示先让i的值自增1,然后再使用i的值。
比较操作符： > : 大于 >= : 大于等于 < : 小于 <= : 小于等于注意:以上操作符只适用于整数类型和浮点数类型,例如：
int a=1,b=1; double d=1.0; System.out.println(a>b);//false System.out.println(a<b);//false System.out.println(a>=d);//true System.out.println(a<=b);//trueinstanceof:：判断一个引用类型变量所指向的对象是不是属于某个类型。
Student s = new Student(); System.out.println(s instanceof Object);//true System.out.println(s instanceof Student);//true //编译报错,因为Student类型和String没有任何子父类关系 System.out.println(s instanceof String);注意:最终判断的是s所指向对象的类型是不是属于某类型，而不是判断变量s的类型是不是属于某个类型，例如:
Object o = new Student();变量o的类型是Object,但是o指向的对象类是Studnet.可以这样写的原因是因为Object是Studnet的父类.这是java的高级特性"多态"的一种表现方式。
相等操作符：== : 判断俩个数据 是否 等于 != : 判断俩个数据 是否 不等于 既可以应用在基本类型的比较，也可以应用在引用类型的比较： 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); //s1中存储的对象内存地址赋给变量s3 Student s3 = s1; //比较俩个引用所指向对象的堆区内存地址是否一样 //俩个对象的内存地址一样相比较才会是true System.out.println(s1 == s2); //输出false; System.out.println(s1 == s3); //输出true; 相加操作符：“+” : 数据类型值相加或字符串连接 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 int a2=13/5; //2 int a3=-12/5; //-2 int a4=-13/5; //-2 int a5=1/5; //0 double a6=12/5; //2.0 double a7=12/5.0; //2.4% : 取模操作符, 如操作数均为整数，运算结果为商的整数部分
int a1=1%5; //1 int a2=13%5; //3 double a3=1%5; //1.0 double a4=12%5.1; //1.8000000000000007 位运算操作符：& 与运算：1&1->1, 1&0->0, 0&1->0, 0&0->0;
| 或运算：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;
~ 取反运算：~1->0, ~0->1;
逻辑操作符：短路操作符，如果能根据操作左边的布尔表达式就能推算出整个表达式的布尔值，将不执行操作符右边的布尔表达式； 短路与：&& 左边的布尔表达式的值为false, 整个表达式值肯定为false, 此时会忽略执行右边的布尔表达式，例如：
false&&true int a = 1; int b = 2; int c = 3; a>b&&c>b //没有短路功能 a>b&c>b短路或：|| 左边的布尔表达式的值为true, 整个表达式值肯定为true, 此时会忽略执行右边的布尔表达式。
三目运算： 形式：布尔表达式 ? 表达式1 : 表达式2; 如果上面布尔表达式的值为true, 就返回表达式1的值， 否则返回表达式2的值，例如： int score = 61; String result = (score>=60?"及格":"不及格");隐式转换(自动转换)：
byte a = 1; //a是byte类型(8位),b是int类型的(32) //编译通过,类型自动转换(隐式转换) int b = a;特点:小的可以自动转换(隐式转换)为大的,因为无非就是在前面多补几个0而已,不会影响数据值
显式转换：
//编译报错,32位的值给8位的变量 int a = 100; byte b = a; //编译通过 //这时候需要类型强制转换(俗称强转,也就是显式转换) int a = 100; byte b = (byte)a;特点:大的值给小的变量,需要强制转换,但是转换后的结果JVM不会保证还是正确的,因为这是程序员自己的个人行为.
引用类型之间的转换：隐式转换：
//编译通过,类型自动转换(隐式转换) Student s = new Student(); Object o = s;特点:子类类型的变量可以自动转换(隐式转换)为父类类型
显式转换：
//编译通过,运行后也不报错 //因为引用o本来指向的就是Student对象 Object o = new Student(); Student s = (Student)o; //编译通过,运行后报错 //因为o本来指向的时候Teacher对象 //而Teacher类型对象和Student类型没有任何关系 Object o = new Teacher(); Student s = (Student)o;程序中if语句的代码块只有满足特定条件的情况下才会被执行。
if语句： if(true|false) { //执行代码 } if-else语句： if(true|false){ //执行代码1 }else{ //执行代码2 } if-else if-else： if(true|false){ //执行代码1 } else if(true|false){ //执行代码2 } .... else{ //执行代码3 }简写形式：不管是if还是elseif还是else,只要其后面执行的代码"只有一句",那么就可以把大括号去掉,执行效果也是一样的，例如：
public void test(int x) { if(x>10) System.out.println("参数大于10"); else if(x>5) System.out.println("参数大于5"); else if(x>0) System.out.println("参数大于0"); else System.out.println("参数小于等于0"); }相关例子：写一个方法实现分时问侯, 如是8点至12点，返回"上午好", 12点至14点，返回"中午好",14点至18点，返回"下午好", 其它时间返回"晚上好"。 注：方法中使用return可以把数据返回给方法的调用者
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; }写一个方法判断某一年是否为闰年 标准:能被4整除,但不能被100整除;或者能被400整除
//返回true表示是闰年,false表示不是闰年 public boolean isLeapYear(int year) { if((year%4==0 && year%100!=0) || (year%400==0)) return true; else return false; }使用switch语句完成的功能,使用if语句同样也能完成。但是使用if语句完成的功能,使用switch语句却不一定能完成。不过在某些特定的情况下,switch还是有着自己的独特之处。 语法 注意：break关键字表示直接退出整个switch代码块
switch(变量) { case value1: //执行代码1; break; ... case valueN //执行代码n; break; default: //执行代码; break; }注：switch只能接收byte, short, char或者int类型的变量,如果是JKD1.7那么也可以接收String类型的变量，例如：
int day = 4; String result; switch(day) { 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 = "参数有误"; break; } System.out.println(day+" : "+result);特殊情况：如果switch的变量与某个case的值匹配,那么就从这个case中的代码开始执行。假如遇到break，就退出整个switch语句，否则依次执行switch语句中后续的case子句，而且不再检查case的值。 例如:写一个方法，返回指定月份有多少天
public int getLastDay(int year, int month) { int day = 30; 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; }语法：
for(<初始化>; <条件表达式>; <增量>) { //要循环执行的代码 }直到某一次增量执行后,条件表达式的值为false则循环结束 例如：使用循环打印10次hello world
public int sum() { int result = 0; for(int i=1;i<=100;i++) { //result = result + i; result+=i; } return result; }例如：写一个方法，完成计算从1加到n的和
public int sum(int n) { int result = 0; for(int i=1;i<=n;i++) { result = result + i; } return result; }语法：
while(循环条件) { //循环体 }当循环条件为true时，就执行循环代码，否则终止循环，例如：用while循环完成计算从1加到n的和
public int sum(int n) { int result = 0; int i=1; while(i<=n) { result = result + i; i++; } return result; }语法：
do{ 循环体 } while(循环条件);例如：用do-while循环完成计算从1加到n的和
public int sum(int n) { int result = 0; int i = 1; do { result = result + i; i++; } while(i<=n) return result; }注意:while和do-while循环用在循环次数事先不可确定的情况下
例如:打印出五行每行十个☆
//这个循环可以打出五个换行 for(int i=0;i<5;i++){ System.out.println(); } //这个循环可以连着打印出10个☆ //但是不会换行 //注意print方法和println方法的区别 for(int j=0;j<10;j++){ System.out.print("☆"); } 那么把俩个循环嵌套在一起即可完成功能 for(int i=0;i<5;i++){ for(int j=0;j<10;j++){ System.out.print("☆"); } System.out.println(); }例如：往控制台上输出以下内容： * ** *** **** ***** ****** *******
public void print(int n){ for(int i=0;i<n;i++){ for(int j=0;j<i+1;j++){ System.out.print("*"); } System.out.println(); } }注:break和continue一般都是要结合循环使用的(for/while/do-while) break：终止当前或指定循环
for(int i=0;i<10;i++){ if(i==3){ break; } System.out.println("i = "+i); } 输出结果: i = 0 i = 1 i = 2continue：跳过本次循环，执行下一次循环
for(int i=0;i<10;i++){ if(i==3){ continue; } System.out.println("i = "+i); } 输出结果: i = 0 i = 1 i = 2 i = 4 i = 5 i = 6 i = 7 i = 8 i = 9在循环嵌套的时候,使用label可以让break或者continue作用到指定的循环上,否则break或者continue只会默认作用到当前所处的循环上。 例如：这个break跳出的是当前循环(也就是这里的内循环)
for(int i=0;i<3;i++){ for(int j=0;j<5;j++){ if(j==3){ break; } System.out.println("j = "+j); } } 输出结果: j = 0 j = 1 j = 2 j = 0 j = 1 j = 2 j = 0 j = 1 j = 2例如：这个break跳出的是外循环(因为使用了label)
f1:for(int i=0;i<3;i++){ for(int j=0;j<5;j++){ if(j==3){ break f1; } System.out.println("j = "+j); } } 输出结果: j = 0 j = 1 j = 2本次内容到此为止，更多有关Spring的学习内容见后续发表文章
