黑马程序员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;
	}
}