Java方法创建及调用--------06

一、静态方法

1.1含义

特定功能的代码块

1.2好处

减少代码的冗余，提高了代码的可读性和可维护性 

1.3语法结构

访问修饰符 static 返回值类型 方法名(参数列表){
                        ...代码块...
  } 

1.4注意

1.方法声明的位置：在类里
2.方法与方法之间是平级关系（千万不要在一个方法中声明另外一个方法）
3.方法中可以声明变量叫做局部变量，其作用域在方法内部（a方法中可以有int类型的变量i，b方法中也可以有int类型的变量i，不冲突）
4.方法不被调用，就是个摆设！（运行程序时，主方法是被JVM调用）

1.5无参数无返回值的方法

语法结构：
                public static void 方法名(){
                    ...代码块...
                }

1.6需求 

设计一个方法，打印三角形    

public class Test01{
	
	public static void main(String[] args){
		
		//调用静态方法(使用类名调用)
		Test01.run();
		Test01.play();
		Test01.run();
		Test01.run();
		Test01.play();
		Test01.run();
		
		method();
		method();
		
	}
	
	public static void method(){
		for(int i = 0;i<5;i++){
			for(int j = 0;j<=i;j++){
				System.out.print("*");
			}
			System.out.println();
		}
	}
}

 1.7带参数的方法

语法结构：
     public static void 方法名(参数列表){
           ...代码块...
     }

设计思想：将外界的数据传入到方法内部 

 1.8注意

1.声明方法时，设置方法的参数，这个参数叫做形式参数（形参）
2.调用方法时，传入的具体参数，这个参数叫做实际参数（实参）
3.形式参数必须规定类型
4.形参属于该方法的局部变量
5.多个形参使用逗号分隔
6.实参的类型必须和形参兼容 

1.9需求 

设计一个方法，打印三角形，打印内容和行数由调用方指定 

public class Test02{
	public static void main(String[] args){
		
		method("$",3);
		method("%",5);
		
		String str = "@";
	}
	
	public static void method(String str, int num){
		
		for(int i = 0;i<num;i++){
			for(int j = 0;j<=i;j++){
				System.out.print(str);
			}
			System.out.println();
		}
	}
}

 需求：设计一个方法，传入两个int值，输出最大值

public class Test02{
	public static void main(String[] args){
		getMax(10,20);
	}
	
	public static void getMax(int a,int b){
		int max = (a>b)?a:b;
		System.out.println("最大值为：" + max);
	}
	
}

 1.11带参数的方法

语法结构：
    public static void 方法名(参数列表){
	    ...代码块...
	}

设计思想：将外界的数据传入到方法内部

1.12注意 

1.声明方法时，设置方法的参数，这个参数叫做形式参数（形参）
 2.调用方法时，传入的具体参数，这个参数叫做实际参数（实参）
 3.形式参数必须规定类型

 4.形参属于该方法的局部变量
 5.多个形参使用逗号分隔
 6.实参的类型必须和形参兼容 

1.22需求 

设计一个方法，打印三角形，打印内容和行数由调用方指定

import java.util.Scanner;
public class Test03{
	public static void main(String[] args){
		
		        Scanner scan = new Scanner(System.in);
        System.out.println("打印行数：");
        int a = scan.nextInt();
        //方法可以互相套用
        method(a);
    }
    public static void method(int a){
        for(int i=0;i<a;i++){
            for(int j=0;j<i;j++){
                System.out.print("*");
            }
            System.out.println();
        }
	}
	
}

二、方法的重载

2.1含义

方法与方法之间的关系 

条件：
            1.在同一个类中
            2.方法名一致
            3.参数列表的个数或者类型不一致
            4.与返回值无关 

 2.2好处

系统会根据传入的具体实参的类型和个数自动匹配到对应的方法 

2.3应用场景 

应用场景：在同一个类中，多个方法的功能大致一样（说明方法名可以是相同的），细节实现不一样，就可以考虑使用重载 

2.4需求 

设计一个方法，传入两个int值，返回最大值 

设计一个方法，传入两个int值，返回最大值
设计一个方法，传入三个int值，返回最大值
设计一个方法，传入两个double值，返回最大值
设计一个方法，传入三个double值，返回最大值

public class Test04{
	
	public static void main(String[] args){
		
		//注意：可以直接打印方法，前提是该方法必须有返回值
		System.out.println(getMax(10.1,20.2,30.1));
	}
	
	public static int getMax(int a, int b){
		return (a>b)?a:b;
	}
	
	public static int getMax(int a, int b, int c){
		int max = getMax(a,b);
		max = getMax(max,c);
		return max;
	}
	
	public static double getMax(double a, double b){
		return (a>b)?a:b;
	}
	
	public static double getMax(double a, double b, double c){
		double max = getMax(a,b);
		max = getMax(max,c);
		return max;
	}
	
}

 三、方法的递归

3.1方法调用方法自身

public class Test05{
	
	public static void main(String[] args){
		
		method();
	}
	
	//递归的错误示范 - 栈内存溢出的错误
	//出现原因：调用方法就会在栈内存中开辟空间，用于存放该方法的局部变量，
	//			死循环的调用方法，就会使栈内存满载并溢出，最终导致项目崩溃
	public static void method(){
		method();
	}
	
}

3.2需求

需求：设置一个方法，传入一个int值n，求n的阶乘
        
        5! = 1*2*3*4*5    -->    5! = 4!*5
        4! = 1*2*3*4    --> 4! = 3!*4
        3! = 1*2*3        --> 3! = 2!*3
        2! = 1*2        -->    2! = 1!*2
        1! = 1            --> 1! = 1
        
        找规律：n! = (n-1)! * n
        找出口：1! = 1

public class Test06{
	
	public static void main(String[] args){
		
		int num = method(5);
		System.out.println(num);//120
	}
	
	public static int method(int n){
		if(n == 1){
			return 1;
		}else{
			return method(n-1)*n;
		}
	}
	
}

3.2.1递归理解图 

 

 

 需求：不死神兔
            有一对兔子，从出生后第3个月起每个月都生一对兔子，
            小兔子长到第三个月后每个月又生一对兔子， 假如兔子都不死，
            问第n月的兔子对数为多少？

public class Test07{
	
	public static void main(String[] args){
	
		int num = getRabbit(9);
		System.out.println(num);
	}
	
	public static int getRabbit(int n){
		if(n == 1 || n == 2){   //先找到出口再找规律不然就会进入死循环  
			return 1;
		}else{
			return getRabbit(n-1) + getRabbit(n-2);
		}
		
	}
	
}

 四、一维数组

4.1含义

一组数据的集合(容器)

作用：存储多个数据

 4.2概念

1.数组中的数据又叫做元素
2.每个元素都有编号叫做下标/索引
3.下标从0开始
4.数组是引用数据类型
5.数组一旦初始化后，长度不可以改变（意味着数组不可以添加和删除）
6.数组存放元素的空间是连续的

4.3数组声明

数据类型[] 数组名  => 例如  String[] 字符串数组   int[] 整型数组

4.4数组初始化 

1.静态初始化：数据由程序员指定，系统自动分配空间
2.动态初始化 

public class Test08{
	public static void main(String[] args){
		
		//静态初始化1
		//String[] names = new String[]{"椎名空","爱田奈奈","水野朝阳","铃原爱蜜莉","桃谷绘里香"};
		
		//静态初始化2：先声明，再初始化
		//String[] names;
		//names = new String[]{"椎名空","爱田奈奈","水野朝阳","铃原爱蜜莉","桃谷绘里香"};
		
		//静态初始化3：简化静态初始化1
		String[] names = {"椎名空","爱田奈奈","水野朝阳","铃原爱蜜莉","桃谷绘里香"};
		
		//通过下标设置元素
		names[2] = "高正";
		
		//通过下标获取元素
		String str = names[2];
		System.out.println("通过下标获取元素：" + str);
		
		//获取元素个数
		int len = names.length;
		System.out.println("获取元素个数：" + len);//5
		
		System.out.println("------------");
		
		//遍历数组：for循环
		for(int i = 0;i<names.length;i++){
			System.out.println(names[i]);
		}
		
		System.out.println("------------");
		
		//遍历数组：foreach/增强for循环
		//依次取出数组中的元素赋值给element
		for(String element : names){
			System.out.println(element);
		}
		
		/**
			for vs foreach
			循环遍历数组时，使用到下标了，就采用for循环
			循环遍历数组时，没有使用到下标，就采用foreach
		*/
		
		
	}

}

4.4.1一维数组静态初始化内存图

4.41动态初始化：长度由程序员指定，系统自动分配默认值

整数类型默认：0
浮点类型默认：0.0
字符类型默认：' '
布尔类型默认：false
引用类型默认：null-空

静态初始化 vs 动态初始化
一开始就知道数据，就使用静态初始化
一开始只知道长度，就使用动态初始化

public class Test09{
	public static void main(String[] args){
		
		//动态初始化1
		//String[] names = new String[5];//开辟5个连续的空间
		
		//动态初始化2
		String[] names;
		names = new String[5];
		
		//通过下标设置元素
		names[0] = "aaa";
		names[1] = "bbb";
		names[2] = "高正";
		names[3] = "ccc";
		names[4] = "ddd";
		
		//ArrayIndexOutOfBoundsException - 数组下标越界异常
		//names[5] = "xxx";
		
		
		//通过下标获取元素
		String str = names[2];
		System.out.println("通过下标获取元素：" + str);
		
		//获取元素个数
		int len = names.length;
		System.out.println("获取元素个数：" + len);//5
		
		System.out.println("------------");
		
		//遍历数组：for循环
		for(int i = 0;i<names.length;i++){
			System.out.println(names[i]);
		}
		
		System.out.println("------------");
		
		//遍历数组：foreach/增强for循环
		//依次取出数组中的元素赋值给element
		for(String element : names){
			System.out.println(element);
		}
		
		/**
			for vs foreach
			循环遍历数组时，使用到下标了，就采用for循环
			循环遍历数组时，没有使用到下标，就采用foreach
		*/
		
		
	}

}

 4.5一维数组案列

需求：声明一个5个元素的int数组，获取最大值
注意：数组都是引用数据类型（int类型的数组也是引用数据类型）

public class Test10{
	public static void main(String[] args){
		
		int[] is = {45,66,13,28,55};
		
		//假设下标为0的元素是最大值
		int max = is[0];
		
		for(int i = 1;i<is.length;i++){
			if(max < is[i]){
				max = is[i];
			}
		}
		
		System.out.println("最大值为：" + max);
	}

}

 五、内存简介图

六、总结

1.静态方法（概念、好处、注意事项）
        无参数无返回值的方法
        带参数的方法（形参和实参）
        带返回值的方法（返回值类型）

2.方法的重载（含义、条件、应用场景）

3.方法的递归（找出口、找规律）