自学javase的回顾（3/10）

最新推荐文章于 2024-03-26 23:29:56 发布

AKA俄语人Лев

最新推荐文章于 2024-03-26 23:29:56 发布

阅读量226

点赞数

分类专栏：小白自学java 文章标签： java

本文链接：https://blog.csdn.net/weixin_47592060/article/details/110390965

版权

小白自学java 专栏收录该内容

10 篇文章 2 订阅

订阅专栏

自学javase的回顾（3/10）

1、Java控制语句及案例

2、Java方法基本理解

3、Java方法重载深入

4、Java方法递归深入

5、Java方法调用深入

一、Java控制语句

1、条件控制语句，if if else switch
2、循环控制语句，for while dowhile
3、改变控制语句，break，continue
注意；①关系符号== < > 和逻辑符号(且或非)输出都为布尔类型
①if和else同级得平行对齐，但在一个if else作用域（平行对齐），写java语句或者嵌套注意缩进换行之后打tab,
②a=4是赋值关系（结果确定），将赋值给a，因此a就固定赋值为4了，无变化了确定了。
而a==4是比较大小关系（结果不确定），比较的是赋值之后保存进去计算机的数值的大小关系
输出只能为布尔true/false，因此并不是固定的答案要看a的取值，如果a取值不为
4输出false，反之true。

A、条件控制语句
在这里插入图片描述
if和if else 举例

/*
[0,150]年龄 [0,5]幼儿 [6,10]少儿 [11,18]青少年 
[19,35]青年 [36,55]中年 [56,150]老年
 */     

public class Ifage//第二种方法，①接受键盘用户输入 年龄【输入的时候必须输入数字，看上面第二步】，分为3个步骤
{								//②根据业务编辑逻辑			
	public static void main(String[]args){
		java.util.Scanner s = new java.util.Scanner(System.in);//1由java使用扫描对象的自定义赋值s转变到新的扫描对象即变为dos系统输入,再返回一个变量s.next()给你
		//通俗一点就是创建一个新对象跟系统面对面交流，等于自己去查询四级分数步骤一样。
		System.out.print("请输入您的年龄：");//2可换行ln，可以不换行不加，这一步是输出提示信息，不然用户不知道你要干啥

		int age = s.nextInt();//3这一步是停下来等待用户输入，
		
		//4中间敲代码，让系统来时为你根据需求进行业务逻辑判断

		//5最后System.out.println("age = " + age);//输入之后系统自动接收，再赋值给age,再返还给你信息告诉你结果

		//五步骤通俗点是告诉你，第一,键盘创建新对象（创建一个新的问题）。第二,系统System.out(请用户回答什么问题).
		//第三,接收对象，声明赋值=s.next()（停下来等用户下一步回答） 第四，敲代码
		//第五，最后系统System.out（系统在返回结果给你）
		
		//根据需求进行业务逻辑判断

  			String str = "老年";//这个为默认值，一般写最后else后面的内容即如果最后要求都不符合则输出第一个这个，
		if( age<0 || age>150 ){  //如果下面符合则那个符合输出那个下面优先输出
			 str = "您提供的年龄不合法，年龄值需要在[0-150]之间";
		}else if( age<=5 ){
			 str = "幼儿";
		}else if( age<=10 ){
			 str = "少儿";
		}else if( age<=18 ){
			 str = "青少年";
		}else if( age<=35 ){
			 str = "青年";
		}else if( age<=55 ){
			 str = "中年";
		}
        //System.out.println(str);这种没有bug
		System.out.println("您处于生命周期的：" + str +"阶段" );
		//这种有bug就是超范围他会说，您处于生命周期的：您提供的年龄不合法，年龄值需要在[0-150]之间阶段
			
	}
}

//修改上面的bug三种方法
//第一种将系统控制台的str内容具体改到if分支里面，但是字会多打点
public class Ifage
{									
	public static void main(String[]args){
		java.util.Scanner s = new java.util.Scanner(System.in);
		System.out.print("请输入您的年龄：");
		int age = s.nextInt();
  			String str = "您处于生命周期的老年阶段";
		if( age<0 || age>150 ){  
			 str = "您提供的年龄不合法，年龄值需要在[0-150]之间";
		}else if( age<=5 ){
			 str = "您处于生命周期的幼儿阶段";
		}else if( age<=10 ){
			 str = "您处于生命周期的少儿阶段";
		}else if( age<=18 ){
			 str = "您处于生命周期的青少年阶段";
		}else if( age<=35 ){
			 str = "您处于生命周期的青年阶段";
		}else if( age<=55 ){
			 str = "您处于生命周期的中年阶段";
		}
        
		System.out.println(str);
		
	}
}

//第二种,另起一行重写一个if语句，将bug那种情况和正常情况的输出结果分别列出

public class Ifage
{									
	public static void main(String[]args){
		java.util.Scanner s = new java.util.Scanner(System.in);
		System.out.print("请输入您的年龄：");
		int age = s.nextInt();
	
  			String str = "老年";
		if( age<0 || age>150 ){  
			 str = "您提供的年龄不合法，年龄值需要在[0-150]之间";
		}else if( age<=5 ){
			 str = "幼儿";
		}else if( age<=10 ){
			 str = "少儿";
		}else if( age<=18 ){
			 str = "青少年";
		}else if( age<=35 ){
			 str = "青年";
		}else if( age<=55 ){
			 str = "中年";
		}

		if(age<0 || age>150 ){//填age>=0 && age<=150也行上下system调转
			System.out.println(str);//这里不能接着上面写else if，因为已经不是判断属于什么年龄了
		}else{//而是另一种判断输出什么结果，是属于system的判断，而套中嵌套是指条件的多重改变
			System.out.println("您处于生命周期的：" + str +"阶段");
		}
       
		
		
	}
}

//第三种 混合system和str
java.util.Scanner s = new java.util.Scanner(System.in);
		System.out.print("请输入您的年龄：");
		int age = s.nextInt();
		

  			String str = "老年";
		if( age<0 || age>150 ){  
			System.out.print("您提供的年龄不合法，年龄值需要在[0-150]之间");
		}else if( age<=5 ){
			 str = "幼儿";
		}else if( age<=10 ){
			 str = "少儿";
		}else if( age<=18 ){
			 str = "青少年";
		}else if( age<=35 ){
			 str = "青年";
		}else if( age<=55 ){
			 str = "中年";
		} 
			
			System.out.println("您处于生命周期的：" + str +"阶段");
       
	}
}

switch语句举例（简单计算机）

public class Switch
{
	public static void main(String[]args){
		java.util.Scanner s = new java.util.Scanner(System.in);
		System.out.println("欢迎使用简单计算机"); 
		System.out.print("请输入第一个数字");
		int num1 = s.nextInt();
		System.out.print("请输入运算符");
		String operator = s.next();
		System.out.print("请输入第二个数字");
		int num2 = s.nextInt();

		int result = 0;

		switch (operator){
			case "+":
				result = num1+num2;
				break;
			case "-":
				result = num1-num2;
				break;
			case "*":
				result = num1*num2;
				break;
			default:
				System.out.print("您输入的值有误");
		}
				System.out.print("输出结果为："+num1+operator+num2+"="+result);
	}
}

B、循环控制语句和改变控制语句 在这里插入图片描述
for循环例子1（99乘法表）

//用for循环嵌套做一个9*9乘法表
/*思路:                     第一 一共循环九行即第一个循环要九次
                            第二  每一行都有一个特点就是  行号决定每一行个数
                                   第1行 1-1（1个）  第2行  1-2（2个）   i 是行数
  1*1                              第3行 1-3（3个）  第4行  1-4（4个）   j 是数字   因此j<=i
  2*1 2*2  不2*3            第三  第一行每循环一个数字，第二行嵌套都要反复重来
  3*1 3*2 3*3  不3*4
  ... ...
  9*1 9*2 9*3 9*4 9*5 9*6 9*7 9*8 9*9
*/
public class For3
{
	public static void main(String[]args){
		for(int i = 1;i<=9;i++){  //一共九行  
			for(int j = 1;j <= i;j++){
				System.out.print(i + "*" + j + "="+ i*j + "\t");//最后一个是制表符号  这里的print不换行是指循环每一行的具体内容不换行
			}
			System.out.print("\n");//换行符号  或者System.out.prinln(不加东西);也行	这里print换行是指每次循环完每一行后，整体换行	
		}
		
	}
}
/*总结  第一个循环i表示循环行号和不变量 例如上面每一行的第一个数字都固定

，第二个循环j表示要循环的变量数字和个数。如果范围是j<100这种固定的值则是固定值，如果范围是j<i这种变量，则每一行个数会随之变化

system输出则表示两个循环之间的关系  是加减乘除余数之类的，还是直接输出值

1*1=1
2*1=2   2*2=4 循环每一行具体内容的时候不要换行，但是循环完之后就整体换行
3*1=3   3*2=6   3*3=9
4*1=4   4*2=8   4*3=12  4*4=16
5*1=5   5*2=10  5*3=15  5*4=20  5*5=25
6*1=6   6*2=12  6*3=18  6*4=24  6*5=30  6*6=36
7*1=7   7*2=14  7*3=21  7*4=28  7*5=35  7*6=42  7*7=49
8*1=8   8*2=16  8*3=24  8*4=32  8*5=40  8*6=48  8*7=56  8*8=64
9*1=9   9*2=18  9*3=27  9*4=36  9*5=45  9*6=54  9*7=63  9*8=72  9*9=81*/

for循环例子2（累加篮子标记）

//老杜老师讲的，你要学会模仿，你这个阶段永远是写不出这个思路，你只有模仿去培养，去独立分析和理解思路即可
//语句和其作用域一定要分清楚，特别是for

//求1-100的当中奇数的和，累加符号sum+=，最开始第一行要设置一个篮子int sum = 0，往里面逐次追加


public class For2
{
	public static void main(String[]args){
		int sum = 0 ;
		             //sum += i;写这里报错不在main作用域中
		for(int i = 1;i<=100;i+=2){ 
					//int sum = 0;不能写这里，因为这里是循环体，每次循环之后都会变为初始值，最后只输出1-100的奇数
		sum += i;	 //第一次循环sum为0+1，第二次循环，此时sum已经变为0+1，因此第二次为0+1+3，相当于数列 
			     //这里System.out.println("sum = " + sum);求和时不能放这里
				 //因为每次求完一次和就会输出，求完一次就输出一次，虽然答案对，但是效率低，输出1-2500
		}	
			System.out.println("sum = " + sum);//2500，system放外面是输出最后一个结果或者总结果
	}
}
//总结：求和时声明和输出都要在for循环之外，都不能放在循环体里面
//不然每次都归零，就无效了，要全部循环完毕再统一输出整个sum

for循环例子3（布尔篮子标记t）

//下面这题是语句循环+条件+改变组合编程
//找1到100的素数，除了1和自身之外不被整除的叫做素数也叫质数
//两层for多用于一个大范围取两个数之间的乘机和余数 求和等等
/* 思路
   7%1=0       不变的全是7则表示第一层i
               设置一个boolean，表示是否为素数
   7%2！=0     1-7 变化的则表示第二层j
   7%3！=0     判断余数不为0则必为非素数false，则break跳出，
   7%4！=0     再判断为素数的话则输出i
   7%5！=0 
   7%6！=0 
   7%7==0*/

public class For4//优先选择第一种，效率高  
{
	public static void main(String[]args){
		
		for(int i = 2;i<=100;i++){ 
			boolean isSuShu = true; //设置一个变量（标记），来作为两个值比较之后产生新的数值的结果
			for(int j = 2;j<i;j++){  //2只属于直接在第二部分就跳出循环的，也可以是素数
		    //boolean isSuShu = true;这里不能写，因为声明和最后if语句作用域不一致，直接报错
				if(i % j == 0){  //不能写不等于0，因为一个不等于0只可能是素数，但是一个等于0必定不是素数
					isSuShu = false;
					break;    //这一步把所有非素数全部跳出false掉，剩下都是素数即为true
				
				}
			}
			if(isSuShu){  //if要写在第二个for外，第一个for中，因为布尔isSuShu作用域再第一个for中
				System.out.println(i);  //是素数的话则输出i即可，要看题目最终要你求什么，就system什么
			}
				
		}//第一个for作用域终结地方	
	}
}
//总结；声明和语句和输出的作用域都要相匹配，不然会报错，或者最后结果不对。内对内，外对外
//声明变量篮子，
//声明在for内一直被重置默认值，不会变
//声明在for外，不断更新追加数值
//第一个求和程序和第二个程序的java语句声明时你会发现，int num 和 boolean一个是在for外一个在for内
//这是因为写在for内那么语句将会一直被重置不断循环原值（不会变），而放外面则会自上而下更新自己的值（随下面语句变化而变）（一般放里面）
//像第一个求sum就是不断的累加num来一直求和，而下面的boolean则是要一直循环看是否为真假，不然会出错

//system 一般写在第一个for里面表示的是全部数据都要一一输出出来或者全部数据进行比较选择后剩下的都表示出来（一般写里面）
//system 写for外面表示作用域变化了，表示是输出最后一个使循环跳出结束的结果或者总结果，比如累加求和，但是声明变量也要写外面不然作用域报错
//system输出,在for内，数据全部一一输出
//for外，经过筛选后的总结果

二、Java方法理解

1、方法的语法结构;=等于一个新的作用域
A.方法结构：【修饰符列表】 + 返回值类型 + 方法名（形式参数列表）{ public static void main(String[]args)
方法体;
}
B.方法调用；类名.方法名(实际参数列表); Method.SumInt(实参10,20);

2、方法结构体详解：
①修饰符列表；
*可选项，不是必须的
*目前统一写成public static（公共的）/private(私有的)

*方法的修饰列表当中‘有static关键字怎么调用?
-类名.方法名(实际参数列表); 类似于求和方法Method.SumInt(实参); 意思为调类名的方法名为什么什么

②返回值类型；汽车工厂(class类名){输入(原料=实参)——生产(车间=方法)——输出(产出=返回值)}

*什么是返回值？
调用一个方法来完成某个功能，功能结束最后给予并返回一个最终具体数据(字面值的类型要一致包括基本和引用数据类型)，
*如果不返回或者返回的类型不一致，就会报错。
*也可以不返回任何结果，但是必须得写上关键字void, 例如 (public static void main方法)

*但是如何对待返回值，你可以选择接受或者不接受，但必须保证有返回值。

*返回值的代码语法结构：
return 数值; （如果返回值写了一个void，但是又返回return ，也给你报错）
retuen 值; 和 return; 不一样

*注意：只要有return这种关键字就是强行中断所在的方法和方法作用域那里GG结束，不是JVM结束

③方法名
*首字母小写，遵循驼峰命名
*最好见名知意，合法标志符
*最好是动词

④形式参数列表，放新的变量名，简称形参
而具体调用那里用来赋值的实际数字叫做实参，

形参是一种局部变量，就是一个int a byte b
形参可以多个并且相互之间用逗号隔开
形参中起决定性作用的是其数据类型，形参名字无所谓
*实参和形参列表必须满足数量个数相同，类型对应相同.inta对应10 intb对应20 个数和类型一致
pulic static int sum(int a ，int b){}
sum(“abc”,“efg”);数据类型不一致报错
sum(10,20);//实际参数

3、方法执行顺序？？？？？
规则；一切从主方法开始,自上而下依次执行，当前这行的代码没有结束时候，下一行代码不可能被执行.

4、方法怎么调用？？？？？？
*方法只定义不去调用，是不会执行的，只有在调用才会去执行
①起点 public static void main(String[]args){
sum(“abc”,“efg”);数据类型不一致报错
sum(10,20);//实际参数
}
②为什么写在main中，这个main方法是sun公司规定的程序入口位置，所有程序必须这样开头写，并且一定会被执行
因此作为起点，可以在这里编写java语句来调用方法

③方法的调用带有static关键字时，完整的调用为类名.方法名(实参列表);
但是，在同一个类中，带static的“类名.”可以省略
调方法时，类名，同类可省略，跨类不可以省略。

④pulic static void sum(int a ，int b){
System.out.println(a+b);
}
这个叫做定义方法的地方，在main方法作用域之外另外开创的一个方法出来，
里面是用来定义a和b之间关系，最后系统输出结果到控制台，但不能在里面调用方法，调用得去主方法调用

4、方法作用？？？？？？？？？？
1、在某个新开辟的作用去实现某个特殊功能，
2、简化main方法的作用域，main方法一般都是用来测试的。不要写太多东西
java的普通方法就是为了节约main方法的代码冗杂，拆为方法去传进去实现某个功能。

 public class Method{
	 public static void main(String[]args){//这里是主方法，程序入口，一定会会被jvm执行，因此可以调用
		 Method.sum(10,20);      //类名.方法名();

		 int a = 100;          //调用方法时，取决定性作用的是数据类型和数值，只要类型一样，有字面值即可。变量名无所谓
		 Method.sum(a,20);      //因此调用时，传递的是值不是变量.
		                       //一个方法可以被重复使用，且遵循自上而下的顺序执行
	     int k = 90;
		 int f = 10;
         Method.sum(k,f);      //符合数据类型，有值即可
	 }
	 public static void sum(int i,int j){ //这是自义定的方法入口，不能用来调自己的方法，
		 System.out.println(i+"+"+j+"="+(i+j));
	 }
 }
      

	  //其实执行到第六十四行第一个方法调用时时，main方法就会暂停，进入sum方法执行，
	  //sum方法结束之后，表示main方法64行第一个方法调用也结束了，意思就是自上而下有序执行。程序的严谨性

5、深入return语句
在同一作用域下，return语句下面不能编写任何东西，return 值;语句和return;(不是语句)这两种都不行，切记！
因为return代表停止访问了，下面的东西永远无法访问到，直接报错

6、区别return 值;语句和return; 和break的区别91集？？？？？？
*return 值;有void不能用
*return; 有void可以用，因为void在方法中主要是为了用来结束当前的方法，比如下面例子结束了整个p方法，并不是返回的意思，
而是结束了整个其所在方法和他的作用域全部结束
*而break是终结当前循环语句的,还可以防止switch中case分支穿透现象。跳出并且结束当前的循环终止了for循环
但是还要继续其所在方法的其他的语句和程序输出，break只能在循环语句当中使用不然报错
*continue语句是跳出限制他的当前循环语句条件，跳出之后还要继续下一步的循环，直到结束

if + for + 方法封装 + return + break（综合大案例）

//下面这题是语句循环+条件+改变+方法封装的程序

/*编写一个方法，输出大于某个正整数n的最小的质数也叫素数，比如这个正整数是2
例如大于2的最小质数为3，大于9的最小质数为11.


思路；
1、首先系统一定会给你一个正整数n，然后你要基于这个数去n++，
2、接着每加一得到的新数就要去判断一下是否为质数

*/ 
//简化版本，基于下面的思路封装方法改进
/*第一步假如int n =5
			while(true){
				n++;
			if(n是质数){ //判断n是否为质数即可，所以用boolean方法最好，用真假来判断。
				System.out.print(n);
				break;
  1.定义一个专门的方法，来判断某个数字是否为质数，判断是否题目，一般用方法返回布尔类型的比较好，只有是和不是。
  2.这个方法的形式参数是；被判断的数字num
  3.这个方法的返回值类型是boolean布尔类型，ture表示的是质数，是false表示非质数 除了1和自身能被整除的，所以2起步，并且被除数只能小于不能等于自己

  对单独的一个方法进行测试
  boolean flag = isZhiShu();  然后进入方法去判断
  出来之后就用if或者三元去输出即可
  System.out.print(flag?"质数":"非质数"); 
*/
public class For2  
{
	public static void main(String[]args){   //这个主方法就用来调方法实参参数n的，而上面是有固定范围的所以不用传参数，直接全部求
		printZuiXiaoZhiShu(5);                //上面第二种第二个方法可以省略。。。
		printZuiXiaoZhiShu(10);
		printZuiXiaoZhiShu(100);
	}                                                //这里传进去的数字=int n
	public static void printZuiXiaoZhiShu(int n){   //这个方法就是用来判断后打印输出最小质数的方法
		while(true){ //这里写true很low，但是是固定这么写的。 
			n++;
			boolean flag = isZhiShu(n); //传去布尔方法那里时，实际参数(n)=int n ，n++= int num 。定义方法时形参变量名可随意，类型符合即可
			if(flag){        //如果return返回的是一个false，则if语句不会输出执行，就会返回去while n++再去Boolean方法继续判断，
				System.out.print(n);//下面布尔方法那里返回结果为ture是为大于n的质数就直接输出n即可   
				break;//这里为什么要break，因为只要求一个质数就行，不然会true会一直循环while下去
			}
		}	
	}
	public static boolean isZhiShu(int num){ //这个方法是定义一个专门的方法，来判断某个数字是否为质数，最好用布尔。
		for(int i = 2; i < num; i++){
			if(num % i==0){    //余数有一个为0说明不是质数，则会给上面的Boolean flag返回一个false。
				return false;  //这里不用break中断，因为只要判断一个数就可以结束这个方法，而上面那个程序判断的是1-100范围里面
			}
		}
		return true;//上面if如果结果是false，则不会执行输出，会跳过来执行到这里。说明他已经是质数了，可以返回去给第一个if输出了
	}               //这里要在for循环外面写，因为if是false的话整个for就结束了，不会执行这里了
}	            //而第二个例子是两层for所以第二层for不写，要写在第二层for外，这里要写在第一层for外


//用return 值；可用在if或者for或者两者嵌套一般是返回一个值然后结束方法作用域，
//因为已经得到想要的，没有利用价值了，return后不能写任何语句
//用break有两种if用的话，中断当前循环结束程序，防止循环语句嵌套if时候会继续循环，
//for用的话就是当某个条件符合的话终结这个循环。
/*当return 值;有void不能用
*当return; 有void可以用，因为void在方法中主要是为了用来结束当前的方法，比如下面例子结束了整个p方法，并不是返回的意思，
 而是结束了整个其所在方法和他的作用域全部结束
*而break是终结当前的循环语句的,还可以防止switch中case分支穿透现象，
但是还要继续其所在方法的其他的语句和程序输出，break只能在循环语句用。不然报错
*continue语句是跳出限制他的当前语句，跳出之后还要继续下一步，直到结束*/

3、Java方法重载深入

一、Overload重载的含义：
1、在java中，如果有功能类似，可以使用相同的名字来定义不同功能方法；
【1】所谓的不同功能：不是主体功能不同，而是形式参数不同。
【2】参数不同包括：数量、类型、顺序不同（3者其1不同即可）

2、方法重载条件：
①必须在同一个类的范围之内
②方法名相同
③形式参数列表必须不同[个数，顺序，类型]）】
④方法重载只和形式参数列表有关，和修饰符列表、返回值类型无关，
⑤作用：
（增加代码可读性，减少代码复用。做法（参数）不同，但是做的都是同一件事情，实现相似功能）
（从代码角度就是即可以传递多个不同参数，去实现同一个求和或者其他的功能）
（静态编译时具有多态性，因此重载也是多态性的体现：一个内容，可以实现多个功能）

3、注意：使用重载的时候：一定不要将两个功能完全不一样的方法进行重载！！！
从代码的角度来说，上面做法是可以的，但是从业务逻辑和代码的可读性、应用型的角度来说不可以这么做。

4、案例!!!

package 重载01;

public class U {
	public static void p(byte a) {
		System.out.println(a);
	}
	public static void p(short b) {
		System.out.println(b);
	}
	public static void p(char c) {
		System.out.println(c);
}
	public static void p(int d) {
		System.out.println(d);
}
	public static void p(long e) {
		System.out.println(e);
}
	public static void p(float f) {
		System.out.println(f);
}
	public static void p(double g) {
		System.out.println(g);
}
	public static void p(String h) {
		System.out.println(h);
}
}

package 重载01;

public class 调用重载U类p方法 {
	public static void main(String[]args) {
		int a = 100; 
		U.p(a);                    
		U.p("HelloWorld");	 //实现多个类似功能
	}
}

4、Java方法递归深入

/*什么是递归？

1、方法自身调用自身，看下面例子
a(){ a方法入口（执行方法程序过程的地方）
a(); 一般是在别的入口调的，但这里却是在自己入口调自己，这就叫递归，递归很耗费栈内存，一般别用
}
2、即使有结束条件，也扔可能发生递归栈内存溢出错误，因为递归的太深了，因此少用。
*/

案例1（递归死循环）

public class Digui01 {
	public static void main(String[]args) {
		doSome();
		
	} 
	public static void doSome() {
		System.out.println("doSome begin");
		doSome();//这里用了递归，自己调自己，如果这一行不结束，下一行程序无法执行。因此一要有结束条件
		System.out.println("doSome over");//这个程序为死循环，栈内存溢出，发生错误，JVM终止工作
	}
}

案例2（递归求和）

public class Digui03 { //用递归方法给计算1-n的求和
	public static void main(String[]args) {
		
		System.out.println(sum(3));
	} 
	public static int sum(int n) { //开辟一个新方法，即对应作用域,只要有方法一定最后返回一个值
		if(n == 1) {  //为什么这里不用给声明，因为上面已经声明了int n了，不能重复声明，并且必须对应作用域变量也得有n，
			return 1; //因为int n是作为参数传入到该作用域使用其封装方法重载机制的 。所以要有对应的n，要不就重新声明
		}
			return n+sum(n-1);//这里把else去掉单独写一个也行的,这里调的时候先执行sum方法，sum方法结束之后在执行加号的
		}	//假如n传3进来，到这里为3+sum(3-1)；,接着再递归回去sum(3-1)方法变为2+sum(2-1)到1.到1之后就结束了整个sum方法返回1。
		//所以一开始的sum(3-1)结束了后为2+1。最后为3+2+1再返回输出
	}    
//为什么上面不可以用if elseif ？
//因为编译器只认识语法，他不能判断你的结果值。
//所以上面的用if elseif他不能判断你是否最后会return一个值，但是if else一定能返回一个值。
//而下面的题目他已经固定了一个值，再去判断，语法没错，最多最后没有输出结果而已，但是编译器不管，运行器没结果而已。
//但是下面代码也有问题，太累赘，判断条件（n==1和n！=1）是互为对立的时候直接用else就行，或者另起一行。。。。。

案例3（递归1-n的乘积）

public class Chengjie {
	public static void main(String[]args) {
		 
		System.out.println(ChengJie(3));
	}
	public static int ChengJie(int n) { //形参可以和实参的声明不一样，但是形参对应的作用域必须用到该参数，因为他是作为参数传入的
		int num = 10;      //不用到的话就自己重新声明一个新的，这里的int num作废
		if(n==1){
			return 1;
		}else {
			return n*ChengJie(n-1); 
		}
	}
}

5、Java方法调用深入

方法调用时的参数传递;
第一种：方法调用时的局部变量类型参数传递
第二种：方法调用时的实例变量类型参数传递
注意：方法调用这两种参数传递，是有区别的！！！！！

第一种

public class 方法调用时的局部变量参数传递 {
	public static void main(String[]args){
		int i = 10;
		add(i);
		System.out.println(i);//10  因为下面方add法返回类型是void，所以i=11后就结束释放弹栈了，不影响这例输出     
	}
	public static void add(int i){ //这里也可以定义int n 形参和实参的变量名字可以不一样
		i++;
		System.out.println(i);//11  这里是第一步输出的，后入栈先弹栈。
	}
}

第二种

public class 方法调用时的实例变量参数传递 {
	public static void main(String[]args){
		Person p = new Person();
		p.age = 10; 
		add(p);
		System.out.println(p.age);    //11 , 这里为什么不是10？？？？？？？？、
		           //因为下面add方法虽然返回类型是void，但是实例变量p.age++自加为11后，是存储在堆内存的10变为的11，而不是像局部变量在栈内存
			      //堆内存的实例变量age（只能通过p.age修改赋值才能改变）,不会被存在栈内存的方法比如void而改变
//堆内存是另一个空间的事情。
	}
	public static void add(Person p){ 
		  p.age++;
		  System.out.println( p.age);//11 不解释自加1
		  
		  }
}




class Person{  //人物属性
	int age;
}

区别？？？？？？?？？？?
1、局部变量存在栈内存中，会受到方法void等限制影响参数最后结果。（传递的是字面值）
2、而实例变量存在堆内存中，不受任何栈内存方法void等限制影响。（传递的是引用地址）
例如，堆内存的实例变量age（只能通过p.age修改赋值才能改变）,不会被存在栈内存的方法比如void而改变
堆内存是另一个空间的事情。