java基础总结——基础语法2(语句)
1.1. 判断语句(if语句)
1.1.1. If语句的三种格式:
1.1.2. if语句特点：
- 每一种格式都是单条语句(单条不是单行,单条是一个整体)。
- 第二种格式与三元运算符的区别：三元运算符(就是if else语句的简写格式)运算完要有值出现。好处是：可以写在其他表达式中。
- 条件表达式无论写成什么样子，只看最终的结构是否是true 或者 false;
1.1.3. If语句的Demo(判断月份的春夏秋冬)
1 class IfDemoText //IfDemoText类是练习春夏秋冬的代码{ 2 3 public static void main(String[] args){ 4 5 //先排除掉不是月份的数字 6 7 int month = 3 8 9 if (month<=0 || month>12){ 10 11 System.out.println("没有相应的月份"); 12 13 } else if (month>=3 && month<=5){ //这下面就是正确月份的筛选 14 15 System.out.println("春季"); 16 17 }else if (month>=6 && month<=8) { 18 19 System.out.println("夏季"); 20 21 }else if (month>=9 && month<=11){ 22 23 System.out.println("秋季"); 24 25 }else{ //最后一个{}可以省略，建议不要省略。 26 27 System.out.println("冬季"); 28 29 } 30 31 } 32 33 }
1.2. 选择语句(switch语句)
1.2.1. Switch语句的格式
1.2.2. switch语句特点：
- switch语句选择的类型只有四种：byte，short，int ，char , 在jdk1.7中还有String
- case之间与default没有顺序。先执行第一个case，没有匹配的case执行default。
- 结束switch语句的两种情况：遇到break，执行到switch语句结束。
- 如果匹配的case或者default没有对应的break，那么程序会继续向下执行，运行可以执行的语句，直到遇到break或者switch结尾("}")结束。(特别注意)
例如:（case穿透）
1 int x = 3; 2 switch (x){ 3 case 3: 4 System.out.println("b"); 5 case 4: 6 System.out.println("c"); 7 break; 8 case 5: 9 System.out.println("c"); 10 break; 11 default: 12 System.out.println("a"); 13 }
打印结果是: b
c
1.2.3. switch语句的Test
1 class SwitchTest{ 2 public static void main(String[] args){ 3 int month = 111; 4 switch(month){ 5 case 3: 6 case 4: 7 case 5: 8 System.out.println("月份"+month+"春季"); 9 break; 10 case 6: 11 case 7: 12 case 8: 13 System.out.println("夏季"); 14 break; 15 case 9: 16 case 10: 17 case 11: 18 System.out.println("秋季"); 19 break; 20 case 1: 21 case 2: 22 case 12: 23 System.out.println("冬季"); 24 break; 25 default: 26 System.out.println("非法月份数据"); 27 break; 28 } 29 30 } 31 32 }
总结:if和switch都可以来完成季节,说明,之后在开发中要根据事件的特点来选择相应的语句
- If和switch的应用特点
If:
1.对具体的值进行判断.
2.对区间判断
3.对运算结果是boolean类型的表达式进行判断
Switch:(其实不常用)
1.对具体的值进行判断
2.值的个数通常是固定的
(对于几个固定的值判断,建议使用switch语句,因为switch语句会将具体的答应加载进内存,效率相对高)
1.3. 循环语句( while , do while , for )
1.3.1. while语句
while语句的格式:
while(条件表达式){
执行语句;
}
WhileDemo
1 /* 2 3 while循环演示 4 5 */ 6 7 class WhileDemo{ 8 9 public static void main(String[] args){ 10 11 /* 12 13 while(条件表达式)//可能进入死循环，故要控制循环次数{ 14 15 被重复执行的程序 16 17 被重复执行的程序 18 19 被重复执行的程序 20 21 被重复执行的程序 22 23 } 24 25 */ 26 27 int x = 0; 28 29 while(x<5)//结果为true，循环执行，结果是false循环结束{ 30 31 System.out.println("x="+x); 32 33 x++; 34 35 } 36 37 } 38 39 }
while语句的Test:
1 /* 2 3 使用while循环，进行加法器程序的编写 4 5 计算1+2+3+4+。。。。100=5050 6 7 ①计算100-99-98-....1 = ? 8 9 ②计算1~~100中是5的倍数有哪些?有多少个? 10 11 */ 12 13 /* 14 15 1+2+3+4+5 16 17 1+2 =3 18 19 3+3=6 20 21 6+ 4 =10 22 23 10+5=15 24 25 思路: 26 27 1.每次参与加法的数值不确定 28 29 2.每次出现的和数据也不确定 30 31 3.每一次都是加法运算在重复,并且都是和再加上下一个数值. 32 33 步骤: 34 35 1.定义一个变量,记录住参与加法运算的数据 36 37 2.定义一个变量,记录每一次出现的和 38 39 3.对于记录参与加法运算的数据进行自增 40 41 4.因为加法运算需要重复,就要想到循环结构 42 43 */ 44 45 class WhileTest{ 46 public static void main(String[] args){ 47 int x =1; 48 int sum =0; 49 while(x<=100){ 50 sum = sum + x; 51 x++; 52 } 53 System.out.println("sum="+sum); 54 } 55 }
1.3.2. do while语句
do while语句的格式:
do{
执行语句;
}
while(条件表达式)
do while语句的Test:
1 /* 2 3 do while循环语句 4 5 为什么没出现在总结文档上，是因为新手，禁用 6 7 do while 无条件循环一次，然后再判断while条件是否成立 8 9 */ 10 11 class DoWhileTest{ 12 public static void main(String[] args){ 13 int y = 0; 14 do{ 15 //被重复执行的程序 16 System.out.println("y="+y); 17 y++; 18 } 19 while (y>5); 20 } 21 }
总结:do while与while的最大区别就是:不管条件是否成立,do while都会无条件循环一次,再去判断whlie条件是否成立,这样就容易产生误会,慎用!
1.3.3. For循环语句
For循环语句格式:
For(初始化表达式;循环条件表达式;循环后的操作表达式){
执行语句;(循环体)
}
注意:
- for里面的连个表达式运行的顺序，初始化表达式只读一次，判断循环条件，为真就执行循环体，然后再执行循环后的操作表达式，接着继续判断循环条件，重复这个过程，直到条件不满足为止。
- while与for可以互换，区别在于for为了循环而定义的变量在for循环结束就是在内存中释放。而while循环使用的变量在循环结束后还可以继续使用。
- 最简单无限循环格式：while(true) {}, for(;;){},无限循环存在的原因是并不知道循环多少次，而是根据某些条件，来控制循环。
- 当对某些代码执行很多次时,使用循环结构;当对一个条件只需要进行一次判断时,可以使用if语句;进行多次判断时,可以使用while语句。
1.3.4. for语句嵌套:
for语句嵌套的演示:
1 /* 2 3 for循环嵌套演示 4 5 for循环中，还有for循环 6 7 外圈：循环不执行完毕，是不会出来的 8 9 内圈：循环不执行完毕，是不会出来的 10 11 总次数=外圈*内圈 12 13 */ 14 15 class ForForDemo{ 16 17 public static void main(String[] args){ 18 19 /*for(int x =0 ;x<5;x++)//外循环{ 20 21 for(int y=0 ;y<5 ;y++)//内循环{ 22 23 System.out.println("y="+y); 24 25 } 26 27 System.out.println("x="+x); 28 29 } 30 31 */ 32 33 for(int x = 0; x<5 ;x++){ 34 35 for(int y = 0 ; y<5; y++) { 36 37 System.out.print("*"); 38 39 } 40 41 System.out.println(); 42 43 } 44 45 /* 46 47 ***** 48 49 ***** 50 51 ***** 52 53 ***** 54 55 ***** 56 57 外圈控制行数 58 59 内圈控制每行打印的个数 60 61 */ 62 63 } 64 65 }
for语句嵌套的练习:
1 /* 2 3 利用for循环的嵌套形式 4 5 在屏幕当中，利用*，打印直角三角形 6 7 */ 8 9 class ForForTest{ 10 11 public static void main(String[] args){ 12 13 /* 14 15 ***** 16 17 **** 18 19 *** 20 21 ** 22 23 * 24 25 1.内圈星号每次都在递减 26 27 2.根据推算，内圈每次循环的次数都在递减 28 29 3.如何实现递减呢，可以让初始化变量y,每次初始化值都加1 30 31 4.需要一个第三方变量 32 33 ***** 34 35 **** 36 37 *** 38 39 40 41 */ 42 43 44 45 for(int x = 0 ;x <5; x++){ 46 47 for(int y =x;y<5 ;y++) { 48 49 System.out.print("*"); 50 51 } 52 53 System.out.println(); 54 55 } 56 57 /* 58 59 * 60 61 ** 62 63 *** 64 65 **** 66 67 ***** 68 69 内圈的循环次数是在递增 70 71 我们发现，在我们定义的循环中 72 73 有一个变量，也是在递增 x 74 75 */ 76 77 System.out.println("---------------"); 78 79 80 81 for(int x =0 ;x<5 ;x++) { 82 83 for(int y=0 ;y<=x;y++) { 84 85 System.out.print("*"); 86 87 } 88 89 System.out.println(); 90 91 } 92 93 /* 94 95 总结一下：打印直角三角形的小技巧 96 97 三角形 尖朝下：内循环的初始化变量需要修改 98 99 三角形 尖朝上：内循环的循环条件需要修改 100 101 */ 102 103 } 104 105 }
for循环嵌套练习,完成99乘法表
1 /* 2 3 嵌套for循环，完成99乘法表 4 5 1*1=1 6 7 1*2=2 2*2=4 8 9 1*3=3 2*3=6 3*3=9 10 11 尖朝上，就好办了 12 13 99乘法表，一共要打印9行 14 15 这个题，关键在于如何去打印结果 16 17 形状问题，已经搞定 18 19 */ 20 21 class NineNineTest{ 22 23 public static void main(String[] args) { 24 25 for(int x = 1;x<=9;x++) { 26 27 for(int y =1 ;y <=x ;y++){ 28 29 System.out.print(y+"*"+x+"="+(x*y)+"\t"); 30 31 } 32 33 System.out.println(); 34 35 } 36 37 /* 38 39 打印hello world 要求带双引号输出 40 41 转义字符，改变当前字符含义，使这个字符失去本身的意义，就直接变成了普通符号输出 42 43 \ 要转义谁，就放在谁的前面 44 45 \字母 \n换行 46 47 \t制表位 48 49 */ 50 51 System.out.println("\"hello world\""); 52 53 } 54 55 }
1.4. 其他流程控制语句
break(跳出)， continue(继续)
break语句：应用范围：选择结构和循环结构。
1.当break语句单独存在时,下面不要定义其他语句,因为执行不到
2.break跳出所在的当前循环
3.如果出现了循环嵌套,break想要跳出指定的循环,可以通过标号来完成
continue语句：应用于循环结构。
1.结束本次循环,继续下次循环
2.如果continue单独存在时,下面不要有任何语句,因为执行不到
2. 方法
重载(overload)
定义:在同一个类中，允许存在一个以上的同名函数，只要它们的参数个数或者参数类型不同即可。
特点:与返回值类型无关，只看参数列表。
优点:方便于阅读，优化了程序设计。
示例:(只要括号里面不同就可以,与返回值类型相不相同没有关系)
public static int function(int x, int y){}
public static void function(double a,int b){}
public static int function(double a,int b){}
方法执行到return语句后，这个方法的执行就结束了，方法可以有返回值，但可以不用这个返回值。方法首先要定义，然后才能调用。
1 public class TestMethod{
2 public static void main(String args[]){
3 m();
4 m1(3);
5 m2(2,3);
6 int i = m3(4,5);
7 System.out.println(i);
8 }
9 //以下定义的都是静态方法，静态方法可以在main()方法里面直接调用
10 public static void m(){
11 System.out.println("Hello!");
13 }
14
15 public static void m1(int i){
16 if(i==5){
17 return;
18 }
19 System.out.println(i);
20 }
21
22 public static void m2(int i,int j){
23 System.out.println(i+j);
24 }
25
26 public static int m3(int i,int j){
27 return i+j;
28 }
29 }
3. 变量的作用域
变量的作用域只在“{ }”有效，出了这个“{ }”就没有作用了
4. 递归调用
递归：在一个方法内部对自身的调用就称为递归
整个方法执行在内存中执行的过程如下图所示：
范例：使用递归计算第5个斐波那契数列数
1 /*计算第5个斐波那契数列数*/
2 /*
3 斐波那契数列特点：f(1)=1,f(2)=1,f(3)=f(1)+f(2),f(4)=(f2)+(f3)……依次类推。
4 即后一个数都是等于前两个数的和，这样的数列就是斐波那契数列。
5 */
6 /*
7 使用递归调用的方法计算
8 */
9 public class Fab{
10 public static void main(String args[]){
11 System.out.println(f(5));
12 }
13
14 public static int f(int n){
15 if(n==1||n==2){
16 return 1;
17 }else{
18 return f(n-1)+f(n-2);
19 }
20 }
21 }
整个在内存中执行过程如下图所示
5. 程序的执行过程
