day06循环结构（下）方法

回顾:
1.循环结构:
3)for:
2.适用情况:
3.嵌套循环:
循环中套循环，外层走一次，内层走所有次，层数越少越好，break只能跳出当前层循环
4.数组:
引用类型，相同数据类型元素的集合
int[] arr = new int[3]; //0,0,0
int[] arr = {2,5,7}; //2,5,7
int[] arr = new int[]{2,5,7}; //2,5,7
arr[0] = 100;
System.out.println(arr[arr.length-1]);
for(int i=0;i<arr.length;i++){
arr[i] = 100;
System.out.println(arr[i]);
}

正课:
1.数组:
7)数组的复制:
7.1)System.arraycopy(a,1,b,0,4);
7.2)int[] b = Arrays.copyOf(a,6);
a = Arrays.copyOf(a,a.length+1); //扩容
8)数组的排序:
8.1)Arrays.sort(arr);
2.方法:函数、过程
1)封装一段特定的业务逻辑功能
2)尽可能的独立，一个方法只干一件事
3)方法可以被反复调用多次
4)可以减少代码重复，有利于代码的维护
3.方法的定义:五要素
修饰词 返回值类型 方法名(参数列表){
方法体
}

4.方法的调用:
1)无返回值: 方法名(有参传参);
2)有返回值: 数据类型 变量 = 方法名(有参传参);
5.return:
1)return 值; //1.1)结束方法的执行 1.2)返回结果给调用方 —用在有返回值方法中
2)return; //2.1)结束方法的执行 -------------------------用在无返回值方法中

例1:
public static void main(String[] args){
say();
sayHi(“zhangsan”);
sayHello(“zhangsan”,25);
double a = getNum(); 输出a
int b=5,c=6; int d = plus(b,c); 输出d
int[] arr = testArray(); 遍历arr输出每个元素的值
}
public static void say(){}
public static void sayHi(String name){}
public static void sayHello(String name,int age){}
public static double getNum(){ return 8.88; }
public static int plus(int num1,int num2){
int num = num1+num2; return num;
}
public static int[] testArray(){
int[] arr = {3,5,6}; return arr;
}

方法可以有参，也可以无参
----有参可以使方法更加灵活

double c = Math.random(); //0.0到0.9999999999999999…

假设random()有参:
double c = Math.random(1,1000);
double c = Math.random(0,99);
double c = Math.random(25,85);

System.out. println(“hello”);
System. arraycopy(a,1,b,0,4);
Arrays. sort(arr);
int[] b = Arrays. copyOf(a,6);--------------有参数

int a = scan. nextInt();
double b = scan. nextDouble();
double c = Math. random();-----------------无参数

public static void

public static int
public static double
public static boolean
public static int[]

方法可以有返回值，也可以没有返回值:
1)无返回值: 返回值类型处设计为void
2)有返回值: 返回值类型处设计为具体的数据类型

何时有返回值？何时没有返回值？
方法执行完以后:
1)若还需要用到方法中的某个数据----------有返回值
2)若不需要用到方法中的某个数据----------无返回值

System.out.println(“hello”);
System.arraycopy(a,1,b,0,4);
Arrays.sort(arr);----------------------无返回值

int a = scan.nextInt();
double b = scan.nextDouble();
double c = Math.random();
int[] b = Arrays.copyOf(a,6);---------有返回值

System.out.println(“hello”); //输出完了就完了，目的已经达到了，不需要返回值
int a = scan.nextInt(); //接收用户输入的整数，接收到之后我得用那个数，需要返回值

最常用的、通用的方法

API----------20天讲小零件(方法)

冒泡排序(){
6句话
}

冒泡排序算法------------6句话

假设项目中有10个地方需要排序-----冒泡的那6句话得写10次

main(){
调取款()------------1行
调转帐()------------1行
调查询余额()--------1行
}

void 取款(){
500行--------------调验证密码()
}
void 转帐(){
1000行-------------调验证密码()
}
void 查询余额(){
200行--------------调验证密码()
}
void 验证密码(){

}

VB

常见的排序算法: 冒泡排序、快速排序、插入排序…

int[] a = new int[3];

数组的长度一旦定义好，就不能改变了

int[] a = {10,20,30,40,50};
int[] b = new int[6]; //0,0,0,0,0,0

for(int i=0;i<a.length;i++){
b[i] = a[i];
}

b[0] = a[0];
b[1] = a[1];
b[2] = a[2];
b[3] = a[3];
b[4] = a[4];

1.数组:
7)数组的复制:
7.1)System.arraycopy(a,1,b,0,4);

int[] a = {10,20,30,40,50};
	int[] b = new int[6]; //0,0,0,0,0,0
	//a:源数组
	//1:源数组的起始下标
	//b:目标数组
	//0:目标数组的起始下标
	//4:要复制的元素个数
	System.arraycopy(a,1,b,0,4); //灵活性好
	for(int i=0;i<b.length;i++) {
		System.out.println(b[i]);
	}

7.2)int[] b = Arrays.copyOf(a,6);

int[] a = {10,20,30,40,50};
	//a:源数组
	//b:目标数组
	//6:目标数组的长度(元素个数)
	//  ----若目标数组长度大于源数组长度，则末尾补默认值
	//  ----若目标数组长度小于源数组长度，则末尾截取
	int[] b = Arrays.copyOf(a,6);
	for(int i=0;i<b.length;i++) {
		System.out.println(b[i]);
	}

a = Arrays.copyOf(a,a.length+1); //扩容

	int[] a = {10,20,30,40,50};
	//数组的扩容(创建了一个更大的新的数组，并将源数组数据复制   进去了)
	a = Arrays.copyOf(a,a.length-1);
	for(int i=0;i<a.length;i++) {
		System.out.println(a[i]);
	}

8)数组的排序:
8.1)Arrays.sort(arr);

 int[] arr = new int[10];
	for(int i=0;i<arr.length;i++) {
		arr[i] = (int)(Math.random()*100);
		System.out.println(arr[i]);
	}
	
	Arrays.sort(arr); //对arr进行升序排列
	
	System.out.println("排序后:");
	for(int i=0;i<arr.length;i++) {
		System.out.println(arr[i]);
	}
	System.out.println("倒序输出:");
	for(int i=arr.length-1;i>=0;i--) {
		System.out.println(arr[i]);
	}

例：数组寻找最大值并且扩容后把最大值放后边

 int[] arr = new int[10];
for(int i=0;i<arr.length;i++) { //遍历arr数组
arr[i] = (int)(Math.random()*100); //给每个元素赋值为0到99之间的随    机数
System.out.println(arr[i]); //输出每个元素的值
	}
	
	int max = arr[0]; //假设第1个元素为最大值
	for(int i=1;i<arr.length;i++) { //遍历剩余元素
		if(arr[i]>max) {  //若剩余元素大于max
			max = arr[i]; //修改max为较大的那个数
		}
	}
	System.out.println("最大值为:"+max);
	
	arr = Arrays.copyOf(arr, arr.length+1); //数组的扩容
	arr[arr.length-1] = max; //将最大值赋值到最后一个元素上 
	for(int i=0;i<arr.length;i++) {
		System.out.println(arr[i]);
	}
	
}

2.方法:函数、过程
1)封装一段特定的业务逻辑功能
2)尽可能的独立，一个方法只干一件事
3)方法可以被反复调用多次
4)可以减少代码重复，有利于代码的维护（清晰，能找到确定的位置）
3.方法的定义:五要素
修饰词 返回值类型 方法名(参数列表){
方法体
}

4.方法的调用:
1)无返回值: 方法名(有参传参);
2)有返回值: 数据类型 变量 = 方法名(有参传参);
5.return:
1)return 值; //1.1)结束方法的执行 1.2)返回结果给调用方 —用在有返回值方法中
2)return; //2.1)结束方法的执行 -------------------------用在无返回值方法中

例1：

package day07;

public class MethodDemo {

public static void main(String[] args) {
	
	       say();
	
			
			//sayHi(); //编译错误，有参必须传参
			//sayHi(250); //编译错误，参数类型不匹配
			sayHi("zhangsan"); //String name="zhangsan"
			sayHi("lisi"); //String name="lisi"
			

}------------------------------------main的大括号，下面写的方法要与大括号平齐，一条线上

    //无参无返回值
public static void say() {
	System.out.println("大家好，我叫WKJ，今年37岁了");
}
		
	//有参无返回值
public static void sayHi(String name) {
	System.out.println("大家好，我叫"+name+"，今年37岁了");
}

例2：
package day07;

public class MethodDemo {

public static void main(String[] args) {
	
	    
	double a = getNum(); //getNum()的值就是return后的那个数
	System.out.println(a); //8.88----模拟对返回值的后续操作
	


	int b = plus(5,6);  //-------实参(实际参数)
	System.out.println(b); //11----模拟对返回值的后续操作
	
	int m=5,n=6;
	int c = plus(m,n); //传的是m和n里面的数---------------实参
	System.out.println(c); //11----模拟对返回值的后续操作
	

}//-----------------------------//main


//有参有返回值
public static int plus(int num1,int num2) { //------形参(形式参数)
	int num = num1+num2;
	return num; //返回的是num里面的那个数
		//return num1+num2; //返回的是num1与num2的和
}
	//无参有返回值
public static double getNum() {
		//java规定:对于有返回值的方法，要求方法中必须有return关键字出现，
		//并且return后必须跟一个数，并且这个数的类型必须与返回值类型相匹配
		
		//return; //编译错误，return后必须跟一个数
		//return "abc"; //编译错误，return的数的类型必须与返回值类型匹配
	return 8.88; //1)结束方法的执行  2)返回结果给调用方
}
	


 }

例3：
package day07;
public class MethodDemo {
public static void main(String[] args) {

	sayHello("zhangsan",25); //String name="zhangsan",int age=25
	sayHello("zhaoliu",28); //String name="zhaoliu",int age=28
		

}//------------//main


//有参无返回值
public static void sayHello(String name,int age) {
	if(age>=50) { //在某种特殊条件下，提前结束方法
		return; //结束方法的执行
	}
	System.out.println("大家好，我叫"+name+"，今年"+age+"岁了");
}

例4：
package day07;

public class MethodDemo {
public static void main(String[] args) {

	int[] arr = testArray();
	for(int i=0;i<arr.length;i++) { //模拟对返回值的后续操作
		System.out.println(arr[i]); //后续操作随意(遍历输出、输出长度、排序)
	}
	
}-------------//main

//无参有返回值
public static int[] testArray() {
	int[] arr = {2,5,7,9};
	return arr;
}		

}

例5：
package day07;
public class MethodDemo {
public static void main(String[] args) {

	a(); //111,333,222,444
	System.out.println(444);
	
	
}//-------------//main


public static void a() {
	System.out.println(111);
	b(); //演示方法的嵌套调用
	System.out.println(222);
}
public static void b() {
	System.out.println(333);
}

}