黑马程序员_编程基础之第二篇---java语言基础二

 

 

一.循环结构 while 、do while、for三种

 

1.while

 

a.while语句格式： 

while（条件表达式） 

{ 

执行语句； 

} 

b.特点：先判断条件，只有条件满足才执行循环体 

c.规律：条件为true，开始 转圈；只要不干预他，就一直转；条件不满足，停止转圈； 

d.用法： 

定义初始化表达式； 

while（条件表达式） 

{ 

循环体（执行语句）； 

} 

2.do while 

a.do while语句格式： 

do 

{ 

执行语句； 

} 

while（条件表达式）； 

b.特点：do while的特点是条件无论是否满足，循环体至少被执行一次。 

while比较常见，do while相对于少一点； 

3.for 

a.格式： 

for（初始化表达式；循环条件表达式；循环后的操作表达式） 

{ 

　　执行语句； 

} 

b.流程 

1.初始化表达式 

2.判断循环条件表达式真假 

3.为真执行语句 

4.循环后的操作表达式 

5.2-3-4步循环操作直到表达式为假 

c.特点：1.初始化表达式只执行一次 

2.条件不满足，跳出for循环 

4.for和while的区别： 

特点： 

1.作用域不同 

for的变量是在循环里定义的，作用范围仅限于for语句内部，for语句执行完毕，该变量在内存中释放； 

for（int x=0;x<3;x++） 

{ 

　　System.out.println(x); 

}仅用于控制循环次数，只为循环增量存在，优化内存； 

而 while的变量，用完后仍然在内存中； 

for与while是可以互换的，如过需要定义循环增量，用for更为合适； 

总结：什么时候使用循环结构？ 

当要对某些语句执行很多次时，就使用循环结构。 

面试题可能会遇到： 

无限循环的最简单表现形式：

 

for（；；）{}

 

对于for来讲，不写条件表达式默认为true；

 

while（true）{} 

for练习： 

1.需求：获取1-10的和，并打印
  思路：1.初始化一个变量 int i=1；
          2.写出循环条件表达式 i<=10
          3.循环后的操作表达式i++
          4.定义并初始化接收和的变量int sum=0；
1 2 3 4 5
1 3=2+1 6=3+3 10=4+6 15=5+10
*/
//定义变量用于存储不断变化的和。
int sum=0;
//定义变量，记录住不断变化的被加的数and定义循环，重复加法的过程
for(int i=1;i<=10;i++)
{
sum+=i;
}
System.out.println(sum); 

循环注意事项：一定要明确哪些语句需要参与循环，哪些不需要； 

2. 

需求：1-100之间的7的倍数，并打印  

/*思路： 1.定义初始化变量 int i=1；  

　　　　 2.定义循环判断条件 i<=100 循环操作语句 i++  

            3.在循环中定义判断，只要是7的倍数即可，使用if语句 

　　 定义一个接收循环次数的变量 s*/ 

for(int i=1;i<=100;i++)  

{  

　　if(i%7==0)  

{  

System.out.println("1-100之间7的倍数有："+i);  

}  

} 

其实这就是累加思想。 

初始化变量和int sum=0；

累加 sum+=i;

原理：通过变量记录住每次变化的结果。 

通过循环的形式，进行累加动作。 

计数器思想：通过一个变量记录住数据的状态变化，通过循环来完成。

 

5.for嵌套 

语句嵌套，其实就是语句中含有语句，即循环中含有循环。 

for（int x=0;x<3;x++） 

{ 

　　for（int y=0;y<4;y++） 

{ 

　　System.out.print("ok"); 

} 

} 

12次ok 

外循环控制的是行数，内循环控制的是每一行的列数； 

练习： 

1.需求
*****
****
***
**
*
思路： 

1.发现图形中有很多行，每个行有很多列，使用循环嵌套
2.for嵌套中外圈控制行数，内圈控制列数（行数int i=0；i<=5;i++）(列数 int h=5；h>=1;h--)
3.输出语句 

4.设置一个接收列数变化的变量
for (int x=0;x<5;x++ ) //外循环控制行数
{
for (int y=x;y<5;y++ )
{
　　System.out.print("*");
}
System.out.println();
}
*/
2.需求

*
**
***
****
*****
for (int i=1;i<=5;i++ )
{
for (int h=1;h<=i;h++ )
{
System.out.print("*");
}
System.out.println();
} 

3.九九乘法表 

1*1=1 

1*2=2 2*2=2 

1*3=3 2*3=6 3*3=9 

该程序类似于上面的练习2 

for (int x=1;x<=9;x++ )
{
for (int y=1;y<=x;y++ )
{

System.out.print(y+"*"+x+"="+y*x+" ");
}
System.out.println();
} 

嵌套for循环的规律： 

尖朝上，可以通过改变内循环的循环条件y<=x;让条件随着外循环变化； 

尖朝下，可以初始化内循环的变量y=x，让初始化随着外循环变化； 

6.其他流程控制语句 break continue 

break（跳出）continue（继续） 

break：应用范围：选择结构和循环结构---跳出循环 

continue：只能应用于循环结构------继续循环 

需求：打印1-10之内的偶数和

思路：1.打印1-10的和

         2.加以判断，如果是奇数，跳过，只计算偶数的和

 这就用到了continue，跳出次循环继续下一循环

for（int x=1;x<=10;x++） 

{ 

if(x%2==1) 

continue; 

System.out.println("x="+x); 

} 

结果：2 4 6 8 10 

由此可知：continue的特点是：结束本次循环，继续下一次循环。 

总结：1.记住break和continue作用的范围（选择或者循环结构中） 

2.注意事项：break和continue单独存在时，下面不可以有任何语句。 

二.函数部分 

· 函数的定义 

1.定义 

函数就是定义在类中的具有特定功能的一段独立小程序。函数也称为方法。 

java中函数就是方法，方法就是函数。 

int x=4； 

System.out.println(x*3+4); 

int x=6; 

System.out.println(x*3+4); 

以上的运算，因为获取不同的数据的运算结果，代码出现了重复。 

为了提高代码的复用性，对代码进行抽取，将这个部分定义成一个独立的功能，方便于日后使用。java中对功能的定义是通过函数的形式来体现的。 

2.格式 

修饰符 返回值类型 函数名（参数类型 形参1，参数类型 形参2.....） 

{ 

执行语句； 

return 返回值； 

} 

返回值类型：函数运行后的结果的数据类型 

参数 类型 ：是形式参数的数据类型 

形式参数 ：是一个（变量），用于存储调用函数时传递给函数的实际参数 

实际参数 ：传递给形式参数的具体数值 

return ：用于结束函数 

返回值 ：谁调用函数，就把值返回给谁 

//定义具有（a*3+5）功能的函数 

public static int getResult(int a)
{
return a*3+5; //将运算后的结果返回给调用者
} 

在主函数中调用 getResult（4）； 

· 函数的特点

 

1.定义函数可以将功能代码进行封装，便于对该功能进行复用 

2.函数只有被调用才会被执行 

3.函数的出现提高了代码的复用性 

4.当函数运算后，没有具体的返回值时，这时用一个特殊的关键字来标识。 

该关键字就是void，代表函数没有具体返回值的情况。 

当函数的返回值类型是void时，函数中的return语句可以省略不写，写上也可以； 

注意： 

1.主函数中只能调用函数，不可以在主函数内部定义函数，函数之间的关系是平级的。 

2.定义函数时，函数的结果应该返回给调用者，交给调用者处理；在主函数中执行； 

· 函数的应用

 

我们在编写程序，实际就是在不断的实现功能，而在java中最小的功能单元就是函数。 

在以后写代码时，只要再处理或者定义功能，都把它定义到独立的函数中去，而不要再把它们都塞到主函数中，这样方便代码的复用 

主函数的功能只有一个，就是调用函数； 

3.思想 

如何定义一个函数呢？ 

明确两点就能把函数写出来了 

1.既然函数是一个独立的功能，那么该功能的运算结果是什么？ 

因为这是在明确函数的返回值类型； 

2.再明确在定义该功能的过程中，是否需要未知的内容参与运算。 

因为这是在明确函数的参数列表； 

（定义一个函数功能内部细节的时候，这个细节是可以完全独立可以编写完，还是依靠调用者给我们一些数据才可以完成细节的编写） 

1.需求：定义一个功能完成3+4的运算，并将结果返回给调用者。
思路：1.明确功能的结果：是一个整数的和
         2.在实现该功能的过程中是否有未知内容参与运算，这里是没有的
  其实，这两个功能就是在明确函数的定义
         1.是在明确函数的返回值类型
         2.明确函数的参数列表（参数类型和参数个数）
public static void main(String[] args)
{
int z=getSum();
System.out.println(z);
}
public static int getSum()
{
return 3+4;
} 

这个函数的功能，结果是固定的，毫无扩展性而言。 

练习1的扩展： 

2.需求：为了方便用户需求，由用户来指定加数和被加数，这样，功能才有意义 

思路： 

1.明确功能的结果，是一个整数的和 

2.在实现该功能的过程中是否有未知内容参与运算，加数和被加数是未知的 

public static void main(String[] args)
{
int z=getSum(3,5);
System.out.println(z);
}
public static int getSum(int n1,int n2)
{
return n1+n2;
} 

3.需求：判断两个数是否相同
思路：1.明确功能返回的结果
2.明确是否有未知内容参与运算
public static void main(String[] args)
{
getResult(3,4);
getResult(4,4);
}
public static void getResult(int n1,int n2)
{
if(n1==n2)
{
System.out.println("这两个数相同");
}
else
{
System.out.println("这两个数不相同");
}
} 

4.需求：定义功能，对两个数进行比较，获取较大的数
思路：1.明确功能返回的结果，最大值
2.是否有未知内容参与运算（两个数）
3.获取两者中的最大值
public static void main(String[] args)
{
int c=max(3,2);
System.out.println(c);
}
public static int max(int n1,int n2)
{
return（n1>n2）?n1:n2;
} 

函数练习： 

1.需求：定义一个功能，用于打印矩形。用户自己指定大小的矩形 

思路：1.明确返回的结果，没有。因为直接打印，所以返回类型是void 

2.是否有未知内容参与运算，有，矩形的行和列不确定，由用户指定。 

public static void main(String[] args) 

{ 

draw(8,8); 

} 

public static void draw（int row,int col） 

{ 

for(int x=0;x<row;x++) 

{ 

　　for(int y=0;y<col;y++) 

　　{ 

　　　　System.out.println("*"); 

} 

System.out.println(); 

} 

2.需求：定义一个打印99乘法表功能的函数。 

思路：1.明确返回的结果，一个int类型的积 

         2.是否有未知内容参与运算（两个int类型的参数） 

public static void main(String[] args)  

{  

print99(); 

}  

public static void print99()  

{ 

for(int x=1;x<=9;x++) 

{ 

for(int y=1;y<=x;y++) 

{ 

System.out.print(y+"*"+x+"="+y*x+"\t"); 

} 

System.out.println(); 

} 

} 

· 函数的重载

 1.重载的概念

在同一个类中，允许存在一个以上的同名函数，只要它们的参数个数或者参数类型不同即可。

注意：重载只和参数列表有关。

2.重载的特点：

与返回值无关，只看参数列表。

3.重载的例子

public static void main(String[] args)
 {
  getSum(1,2);
  getSum(3,4,4);
 }
需求：定义一个加法运算，获取两个整数的和
 public static int getSum(int x,int y)
 {
   return x+y;
 }
需求：定义一个加法运算，获取三个整数的和
 public static int getSum(int x,int y,int z)
 {
   return x+y+z;
 }

4.什么时候用重载呢？

当定义的功能相同，但参与运算的未知内容不同。

那么，这时定义一个函数名称以表示其功能，方便阅读，而通过参数列表的不同来区分多个同名函数。

上面的程序可以优化一下：

public static void main(String[] args)
{
  getSum(1,2);
  getSum(3,4,4);
}
需求：定义一个加法运算，获取两个整数的和
public static int getSum(int x,int y)
{
   return x+y;
}
 需求：定义一个加法运算，获取三个整数的和
public static int getSum(int x,int y,int z)
{
   return getSum(x,y)+z;
}

示例2：

打印九九乘法表

用户可以自己定义打印到几

public static void main(String[] args)
 {
  print99(4);
 }
 //用户自定义的乘法表
 public static void print99(int num)
  {
      for(int i=1;i<=num;i++)
      {
    
            for(int s=1;s<=i;s++)
       {
      System.out.print(s+"*"+i+"="+s*i+"\t");
       }
       System.out.println();
         }
 
     }
 //打印九九乘法表
    public static void print99()
  {
       print99(9);
     }

不难发现：上面的两个函数里面的代码一致，

可以对重复的代码作进一步优化：

 public static void print99(int num)
  {
      for(int i=1;i<=num;i++)
      {
    
            for(int s=1;s<=i;s++)
       {
      System.out.print(s+"*"+i+"="+s*i+"\t");
       }
       System.out.println();
         }

     }
//打印九九乘法表
    public static void print99()
  {
       print99(9);
     }

5.重载的好处：
方便于阅读，优化了程序设计。

重载的练习

判断下列哪个函数构成了重载

void show（int a,char b,double c）

a.void show(int x,char y,double z)//没有，因为和原函数一样的

b.int show(int a,double c,char b)//重载，因为参数类型不同 需要注意：重载和返回类型无关

c.void show(int a,double c,char b)//重载，因为参数类型不同

d.boolean show(int c,char b)//重载，因为参数个数不同

e.void show(double c)//重载，因为参数个数不同

f.double show(int x,char y,double z)//没有，因为这两个参数列表一致，与返回类型无关

需要注意：

1.不管任何返回类型的函数，只要参数列表中参数个数或参数类型不同，便可构成重载

2.参数列表中类型不同情况下，参数的顺序不同，也是可以构成重载的

3.重载与返回类型无关，并不代表了返回类型不同就不能构成重载。 

 

详细请查看：http://edu.csdn.net/heima/