黑马程序员java学习日记——函数

------- android培训、java培训、期待与您交流！
----------
一、     
嵌套

1、定义：是指不同语句间可以相互包含

2、常见的嵌套格式：
A：if语句的嵌套
 
需求：把a,b,c中最大的数据输出。

class If2Demo
{
public static void main(String[] args)
{
int a = 10;
int b = 20;
int c = 30;

if(a>=b)
{
if(a>=c)
{
System.out.println(a);
}
else
{
System.out.println(c);
}
}
else
{
if(b>=c)
{
System.out.println(b);
}
else
{
System.out.println(c);
}
}
}
}

B：for循环嵌套：
 
注意：在同一对{}内不能有重复的变量定义

/*
请在控制台输出如下形状：

*****
****
***
**
*

*/
class For2Demo2
{
public static void main(String[] args)
{
//外循环控制行，内循环控制列

for(int x=1; x<=5; x++)
{
for(int y=1; y<=5; y++)
{
System.out.print("*");
}
System.out.println();
}
System.out.println("---------------------------");

//但是，现在是有问题的，这种做法上，内循环必须是固定的。
//而我们给出的图形中，列数是变化的。也就是说内循环的次数是变化的。
//怎么变化：
//5,4,3,2,1
//y = 1, 5 -- 5
//y = 2, 5 -- 4
//y = 3, 5 -- 3
//y = 4, 5 -- 2
//y = 5, 5 -- 1
//那么，也就是说，y=1这里是变化的。
//怎么办呢？我们定义一个变量z，让z开始等于1。在内循环结束后z++
int z = 1;

for(int x=1; x<=5; x++)
{
//y=1,5
//y=2,5
for(int y=z; y<=5; y++)
{
System.out.print("*");
}
System.out.println();
z++;
}

//这样做，已经可以了，但是，我们来看看x的变化：
//x=1,2,3,4,5
//在回顾z的变化：z=1,2,3,4,5
//我们发现，x的变化和z的变化是一致的。所以，没有必要再重新定义变量了。
System.out.println("---------------------------");
for(int x=1; x<=5; x++)
{
//x=1,2,3,4,5
for(int y=x; y<=5; y++)
{
System.out.print("*");
//*****
//****
//***
//**
//*
}
System.out.println();
}
}
}

需求：
*
**
***
****
*****
 
规律：
如果打印的是正三角，内循环的循环条件变化。
如果打印的是倒三角，内循环的初始化条件变化。
代码示例：

class For2Demo3
{
public static void main(String[] args)
{
for(int x=1; x<=5; x++)
{
for(int y=1; y<=5; y++)
{
System.out.print("*");
}
System.out.println();
}
System.out.println("------------------");

//这个时候，我们一样发现了列数是变化的。
//1,2,3,4,5变化的。
//y=1,1 -- 1
//y=1,2 -- 2
//y=1,3 -- 3
//y=1,4 -- 4
//y=1,5 -- 5
int z = 1;
for(int x=1; x<=5; x++)
{
for(int y=1; y<=z; y++)
{
System.out.print("*");
}
System.out.println();
z++;
}
System.out.println("------------------");

//跟刚才一样，z和x的变化是一致的。
for(int x=1; x<=5; x++)
{
for(int y=1; y<=x; y++)
{
System.out.print("*");
}
System.out.println();
}
}
}

需求：在控制台上打印九九乘法表。
1*1=1
1*2=2 2*2=4
1*3=3 2*3=6 3*3=9
...
代码：

class For2Test
{
public static void main(String[] args)
{
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();
}
/*
在java中，有些字符通过\可以转义成其他的还有特殊意义的字符：
\t: 代表的是一个tab键
\r: 回车符
\n: 换行符
*/
}
}

二、     
break和continue的用法：
1、break和continue都可以控制循环的流程
2、使用场景：
  
break：用在循环结构或者switch语句中
  
continue：只能用在循环语句中
3、注意事项：

A:他们只能在自己的适用场景中使用。

B:在满足条件使用的时候，后面不能跟语句，因为执行不到。

C:break是结束当前循环(结束整个循环),continue是结束本次循环(结束一次循环)。
代码示例：

class OtherDemo
{
public static void main(String[] args)
{
//break;
//continue;
//System.out.println("haha");

for(int x=1; x<10; x++)
{
//break;
//continue;

//break;
if(x%2==0)
{
//continue; //本次循环结束
break;
}
System.out.println(x); //1,3,5,7,9
}
}
}

3、跳出多次循环
  
在java里面提供了带有标号的标签，可以用于定位。
   
这种做法，可以直接跳出多层循环。但是一般不用。
  
代码示例：
 

class OtherDemo2
{
public static void main(String[] args)
{
wc:for(int x=0; x<5; x++)
{
nc:for(int y=0; y<4; y++)
{
System.out.println(x);
//break;
//continue;
break wc;
}
//break;
}
}
}

需求：输出1-10之间的偶数
 代码示例：

class OtherTest
{
public static void main(String[] args)
{
for(int x=1; x<=10; x++)
{
if(x%2!=0)
{
continue;
//break;
}
System.out.println(x);
}
}
}

三、什么是函数？

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

函数也称为方法。
四、函数的格式：
修饰符
返回值类型
函数名（参数类型
形式参数1，参数类型
形式参数2，…）
{

      
执行语句;

      
return返回值;
}

其中，返回值类型：函数运行后的结果的数据类型。

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

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

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

     
return：用于结束函数

     
返回值：该值会返回给调用者。
五、函数的特点：

定义函数可以将功能代码进行封装

便于对该功能进行复用

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

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

对于函数没有具体返回值的情况，返回值类型用关键字void表示，那么该函数中的return语句如果在最后一行可以省略不写。

注意：1、函数只能调用函数，不可以在函数内部定义函数。

     
2、定义函数时，函数的结果应该返回给调用者，交由调用者处理。
六、函数的调用：

            
A:非void类型函数

                   
a:单独调用，没有意义。

                   
b:输出调用，可以，但是，如果结果还要参与运算，就不推荐使用。

                   
c:赋值调用，函数的返回值是什么数据类型，你就应该用什么数据类型的变量接收。

 

            
B:void类型函数

                   
a:单独调用。
七、如何定义一个函数？

答：1、既然函数是一个独立的功能，那么先明确该功能的运算结果是什么。因为这是在明确函数的返回值类型。

2、在明确在定义该功能的过程中是否需要未知的内容参与运算。因为这是明确函数的参数列表（参数的类型和参数的个数）
八、函数的重载（overload）

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

重载的特点：与返回值无关，只看参数列表。

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

//返回两个整数的和

int add(int x,int y){return x+y;}

//返回三个整数的和

int add(int x,int y,int,z){return x+y+z;}

//返回两个小数的和

double add(double x,double y){return x+y;}
什么时候用重载？

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

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

重载例子：

class FunctionOverload
{
public static void main(String[] args)
{

//		add(4,5);//调用参数个数为2的函数
//		add(4,5,6);//调用参数个数为3的函数
print99();//调用打印99乘法表的函数

}
public static void print99(int num)
{
for(int x=1; x<=num; x++)
{
for(int y=1; y<=x; y++)
{
System.out.print(y+"*"+x+"="+y*x+"\t");
}
System.out.println();
}
}
//打印99乘法表
public static void print99()
{
print99(9);
}
//定义一个加法运算，获取两个整数的和。
public static int add(int x,int y)
{
return x+y;
}

//定义一个加法，获取三个整数的和。
public static int add(int x,int y,int z)
{
return add(x,y)+z;
}
}