关于:循环嵌套,方法,return,方法的重载,递归的理解与案例

循环嵌套
for(条件初始化;条件判断;条件变化){
//代码
for(条件初始化;条件判断;条件变化){
//代码
}
//代码
}
举例
public class Demo02 {
public static void main(String[] args) {
/*
＊＊＊＊＊
＊＊＊＊＊
＊＊＊＊＊
＊＊＊＊＊
＊＊＊＊＊
/
int count=0; //计数器
for(int i=1;i<=25;i++){
System.out.print("＊");
count++;
if(count==5){
System.out.println(); //换行
count=0; //计数器归零
}
}
System.out.println("----------------------------");
//双重循环完成 外层循环变量i来控制行数
for(int i=1;i<=5;i++){
//内层循环控制列
for(int j=1;j<=5;j++){
System.out.print(" ");
}
//换行
System.out.println();
}

	/*
		* * * * *
		*		*		 
		*       *
		*       *
		* * * * *
	*/
	for(int i=1;i<=5;i++){
		//内层循环控制列
		for(int j=1;j<=5;j++){
			if(i==1 || i==5 || j==1 || j==5){
				System.out.print("* ");
			}else{
				System.out.print("  ");
			}
		}
		//换行
		System.out.println();
	}
	
	/*
		* * * * * * *
		* * * * * * *
		* * * * * * *
		* * * * * * *
	*/
	for(int i=1;i<=4;i++){
		//内层循环控制列
		for(int j=1;j<=7;j++){
			System.out.print("* ");
		}
		//换行
		System.out.println();
	}
	/*
		* * * * * * *
		* 		       *
		* 		       *
		* * * * * * *
	*/
	for(int i=1;i<=4;i++){
		//内层循环控制列
		for(int j=1;j<=7;j++){
			if(i==1 || i==4 || j==1 || j==7){
				System.out.print("* ");
			}else{
				System.out.print("  ");
			}
		}
		//换行
		System.out.println();
	}
	
	/*
		* 					1
		* * 				2
		* * * 				3
		* * * * 			4
		* * * * *			5
		每行打印的星星个数就是当前行数
	*/
	for(int i=1;i<=5;i++){
		for(int j=1;j<=i;j++){
			System.out.print("* ");
		}
		//换行
		System.out.println();
	}
	
	/*
			*
			* *
			*   *
			*     *
			* * * * *
	*/
	for(int i=1;i<=5;i++){
		for(int j=1;j<=i;j++){
			if(i==5 || j==1 || j==i){
				System.out.print("* ");
			}else{
				System.out.print("  ");
			}
		}
		//换行
		System.out.println();
	}
	//九九乘法表
	for(int i=1;i<=9;i++){
		for(int j=1;j<=i;j++){
			System.out.print(j+"*"+i+"="+j*i+"\t");
		}
		//换行
		System.out.println();
	}
}

}

============================================================================================
方法:实现具体功能的代码段
使用方法好处: 提高代码的复用性

注意:
	1.方法要定义在类中方法外,方法不能嵌套
	2.不调用不执行
	
语法:
	有返回值类型的方法
		修饰符 返回值类型 方法名([参数列表]){
			具有某些功能的代码块;
			return 返回值;
		}
		修饰符:访问权限修饰符,public static默认,具体等到面向对象再说
		返回值类型:方法运行后的结果的数据类型-->返回值类型的方法就是要得到这个返回值
			引用数据类型|基本数据类型(四类八种)
		方法名:方法的名字 ,根据方法名字调用方法
			   标识符->遵循规则和规范
		()->参数列表:方法执行过程当中,是否存在未知的变量,如果有定义再参数列表中
			参数列表可以定义,可以不定义
			参数可以存在0个,可以存在多个
			数据类型 参数名1,数据类型 参数名2,...
		return:
			1)提前结束方法
			2)带出返回值
			一个又返回至类型的方法必须存在return,return后面必须有返回值
	
	没有返回值类型的方法
		修饰符 void 方法名([参数列表])){
			方法体语句;
			[return;]
		}
		void : 没有返回值
		return : 提前结束方法
	
	
	又返回至类型的方法的调用:  --执行方法中的代码
		1.直接调用: 方法名();								---没有使用到返回值
		2.赋值调用: 返回值类型  变量名= 方法名();
		3.输出调用: System.out.println(方法名());
	没有返回值的方法:
		直接调用,不能赋值调用不能输出调用
	
	参数:
		形式参数:形参 :方法定义的时候()中的参数
		实际参数:实参 :方法调用的时候()中的参数
		形参和实参要一一对应
		个数,顺序,数据类型要统一

举例:
public class Function03 {

public static void main(String[] args) { 
	int num=getSum(3,5);  //实参  局部 变量的赋值
	System.out.println(num);
	System.out.println(getSum(7,8));
	
	System.out.println(getPI());
	
	//没有返回值没有参数的方法
	print();
	
	getSum2(7,6);
	
	System.out.println(equals(5,7));
	
}

/*求2个整数的和
	返回值:需要返回值			参数:由  2个  int a,int b
*/
public static int getSum(int a,int b){  //形参  局部变量的声明
	System.out.println("哈哈哈哈求2个数的和");
	return a+b;
}


//返回π的值,封住成一个方法
//返回值:有 double		参数:不需要参数
public static  double getPI(){
	System.out.println("又返回值没有参数的方法");
	return 3.141592653;
}

/*
	打印99乘法表
	返回值: 不需要  参数:不要
*/
public static void print(){
	for(int i=1;i<=9;i++){
		for(int j=1;j<=i;j++){
			System.out.print(j+"*"+i+"="+j*i+" ");
		}
		System.out.println();
	}
}

/*
	求某个区间内所有整数的和
	返回值:没有     参数:有    int x,int y 要求:第一个参数不能大于第二个参数
*/
public static void getSum2(int x,int y){
	if(x>y){
		System.out.println("第一个参数不能大于第二个参数");
		return; 
	}
	//求和
	int sum=0;
	for(int i=x;i<=y;i++){
		sum+=i;

============================================================================================
return :
有返回值类型的方法中: 1)结束方法 2)带出返回值
没有返回值类型的方法中: 1)结束方法

出现不可达语句的几种的情况:
							1.如果再一定会执行的return后面出现的语句
							2.break后面
							3.continue
							4.死循环后面
							5.while(false){...}
		
兼容类型:
	1.参数: 形参>=实参的数据类型
	2.return后面数据的类型<=方法的返回值类型<=接收返回值的变量类型

举例:
public class ReturnDemo04 {
public static void main(String[] args) {
/*
while(false){
System.out.println(“hahah”);
}
*/
byte w=3;
long i=getArea(w,5);

}

public static int getArea(int w,int h){
	if(w==0){
		return -1;
		//return -2;
		//System.out.println("hahah");
	}
	return (short)(w*h);
}

}

============================================================================================
方法的重载
在同一个类中,有多个方法,相同的方法名,不同的参数列表(方法签名不同: 方法名+参数列表 ->方法的唯一标识)
满足方法重载的几个条件:
1.同一个类
2.多个方法,方法名相同
3.参数列表不同
参数的个数不同
参数的数据类型不同
参数顺序不同,前提是数据类型不同

如何决定调用重载方法中的哪个方法?
	由实参决定
	
方法的重载和方法的修饰符无关
方法的重载和方法有没有返回值类型无关
方法的重载和方法返回值类型无关
方法的重载和方法参数名无关
	
方法的重载是一个类中多态的一种体现

方法是一个类中封装的一种体现

举例:public class Overload05 {
public static void main(String[] args) {

	getSum(1.1 , 2.2 ,3.3);
}

public static void getSum(int a,int b){
	System.out.println("2个int类型求和");
}

private static int getSum(int x,int y){
	System.out.println("2个int类型求和");
	return -1;
}

public static void getSum(int a,int b,int c){
	System.out.println("3个int类型求和");
}

public static void getSum(double a,double b){
	System.out.println("2个double类型求和");
}
public static void getSum(double a,double b,double c){
	System.out.println("3个double类型求和");
	
}

public static void getSum(int a,double b){
	System.out.println("int a,double b类型求和");
}

public static void getSum(double a,int b){
	System.out.println("double a,int b类型求和");
}

============================================================================================

递归: 自己调用自己

	临界条件: 		让递归停下来的条件
	递归前进段: 到临界条件之前一直自己调用自己
	递归后退段: 到达临界条件之后,把结果返回给上一层

举例:
public class Recursion06 {
public static void main(String[] args) {
System.out.println(rec(3));
}

//求阶乘参数  
//返回值:需要int 	参数:int n   5*4*3*2*1 -->5!= 5*4!
public static int rec(int n){
	if(n==1){
		return 1;
	}
	return  n*rec(n-1);
}

}