1 循环嵌套
循环嵌套(多重循环):一个循环结构中的循环体包含其他的循环结构。
任意两种循环结构都可以相互嵌套。
for(表达式1;表达式2;表达式3){
for(表达式1;表达式2;表达式3){
}
}
特点:外层循环执行1次,内层循环有可能执行多次。
只有当内层循环执行结束后，才会执行下次的外层循环。
示例1：打印3行8列的矩形矩形
public class TestLoop{
public static void main(String[] args){
//外层循环控制行数
for(int i=0;i<3;i++){
//内层循环控制每行打印的列数
for(int j=0;j<8;j++){
System.out.print("*");
}
System.out.println();//换行
}
}
}示例2：打印倒直角三角形
//外层循环控制行数
for(int i=0;i<3;i++){
//内层循环控制每行打印*的个数
for(int j=0;j<3-i;j++){
System.out.print("*");
}
System.out.println();//换行
}示例3：打印平行四边形
分析:每行是有空格和星号组成
//外层循环控制行数
for(int i=0;i<3;i++){
//控制空格个数
for(int j=0;j<2-i;j++){
System.out.print(" ");
}
//空格星号的个数
for(int j=0;j<8;j++){
System.out.print("*");
}
System.out.println();//换行
}2 打印101~150之间的所有素数（goto）
Goto：带标签的break和continue
public class TestGoto{
public static void main(String[] args){
int count=0;
outer:for(int i=101;i<150;i++){
for(int j=2;j<i-1;j++){
if(i%j==0){
continue outer;
}
}
System.out.print(i+"\t");
}
}3 经典循环嵌套例题
例题1：打印99乘法表
public class Ex01{
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");
}
System.out.println();
}
}
}例题2：百元百鸡：公鸡5元/只,母鸡3元/只,小鸡1元3只，问100元买100只鸡如果购买?
public class Ex02{
public static void main(String[] args){
for(int x=0;x<20;x++){//公鸡的个数
for(int y=0;y<33;y++){//母鸡的个数
for(int z=0;z<100;z++){//小鸡的个数
if((x+y+z==100)&&(15*x+9*y+z==300)){
System.out.println("公鸡:"+x+",母鸡:"+y+",小鸡:"+z);
}
}
}
}
}
}例题3：兔子问题:1对兔子，从第三个月开始每个月可以生一对小兔子，小兔子从三个月开始每个月也可以再生一对小兔子，假设兔子不死，问1年后共多少对兔子？（斐波那契数列）
斐波那契数列:
1 1 2 3 5 8 13....
f(n)=f(n-1)+f(n-2); n>=3
public class Ex03{
public static void main(String[] args){
int f_1=1;//f(n-1)
int f_2=1;//f(n-2)
int f_n=0;//f(n) 第N个月的兔子总数
for(int i=3;i<=12;i++){
f_n = f_1+f_2;
f_2 = f_1;
f_1 = f_n;
}
System.out.println("共有"+f_n+"对兔子！");
}
}3 方法的定义
方法:为了完成某些功能而封装了某些代码的集合。
方法的定义:
[修饰符] 返回值类型 方法名(形参列表){
方法体;
return 返回值;
}
修饰符:封装时会详细介绍，今天代码的修饰符:public static
返回值类型:如果有返回值，其返回值类型可以是任何类型，如果没有返回值，可以定义为void
是否需要返回值的判断依据:其他方法是否需要使用当前方法的处理结果。
如果其他方法需要使用当前方法的处理结果，需要返回值，否则可以不要返回值
方法名:满足标识符的命名规则
参数列表:可以有参数，也可以没有参数。
是否需要参数的判断依据:当前方法是否需要使用其他的方法中的值。
如果当前方法需要使用其他方法的值，需要以参数的方式进行传入，否则可以不要参数
返回值:java中返回值只有1个，其类型必须与返回值类型向对应。
参数:
形式参数:在方法定义时，用于限制该方法需要的参数的类型和个数。(int rows,int cols)
实际参数:在方法调用时，具体传入的值。(5,10)
注意:在方法调用时,实际参数的类型和个数必须与形式参数相对应。
方法的调用:
情况1:如果在同一个类中，直接使用方法名就可以调用。printRectangle();
情况2:通用的静态方法的调用方式: 类名.方法名(); TestMethod.printRectangle();
示例1：
public class TestMethod{
//无参数，无返回值
public static void printRectangle(){
for(int i=0;i<3;i++){
for(int j=0;j<8;j++){
System.out.print("*");
}
System.out.println();//换行
}
}
//有参数,无返回值
public static void printRectangle2(int rows,int cols){
for(int i=0;i<rows;i++){
for(int j=0;j<cols;j++){
System.out.print("*");
}
System.out.println();
}
}
//无参数,有返回值
public static double calcArea(){
int r=2;//半径
final double PI=3.14;
double s = PI*r*r;
return s;//返回值
}
//有参数,有返回值
public static double calcArea2(int r){
final double PI=3.14;
double s = PI*r*r;
return s;
}
public static void main(String[] args){
//printRectangle();
//TestMethod.printRectangle(); //无参数,无返回值
//TestMethod.printRectangle2(15,10);//有参数,无返回值
//double s = TestMethod.calcArea();//无参数,有返回值
double s = TestMethod.calcArea2(4);//有参数,有返回值
System.out.println("圆的面积为:"+s);
}
}4 方法的重载
方法的重载: 在同一个类中，方法名相同，参数列表不同。(同名不同参)
参数列表不同:
1.个数不同: System.out.println(); System.out.println(String s);
2.类型不同: System.out.println(int i);System.out.println(double d);
3.顺序不同: add(int a,double b); add(double a,int b);
在方法调用时，会根据参数的类型、个数和顺序自动匹配到相应的方法
示例1：
public class TestMethod2{
public static int add(int a,int b){
return a+b;
}
public static double add(int a,double b){
return a+b;
}
public static double add(double a,int b){
return a+b;
}
public static double add(double a,double b){
return a+b;
}
public static void main(String[] args){
double result = TestMethod2.add(1.0,2.0);
System.out.println("result="+result);
}
}5 递归
递归:在程序中方法(函数)自身调用自身。
使用场景:将一个复杂的问题可以分解为若干子问题，每个子问题的解决方案与上一层一致。
编写递归时需要注意:递归的条件和递归体
递归条件:类似于循环条件，做什么时候为止不再调用自身，如果缺少条件将会造成死循环。
递归体:类似于循环体，重复做的事情。
递归的优点:编写简单，更加贴近人类的思维习惯。
递归的缺点: 1.大量占用系统堆栈，对内存的消耗较大。
2.递归调用耗时较长。
注意:所有利用递归解决的问题都可以使用循环(迭代)解决；不推荐过多使用递归，应为递归既耗时又耗用资源。
示例1：
public class TestMethod3{
//计算N的阶乘
public static long factorial(int n){
if(n==1){
return 1;
}else{
return n*factorial(n-1);
}
}
//斐波那契数列:f(n)=f(n-1)+f(n-2)
public static long fibonacci(int n){
if(n==1||n==2){
return 1;
}else{
return fibonacci(n-1)+fibonacci(n-2);
}
}
public static void main(String[] args){
//long result = factorial(5);
long result = fibonacci(12);
System.out.println("result="+result);
}
}
