java打印方法用多长时间 java打印方法的调用

复习回顾

1、数组的特点
	长度固定, 存储的数据类型一致

2、数组的两种初始化格式？
	动态初始化
		int[] arr = new int[5];
	静态初始化
		int[] arr = new int[]{1,2,3};
		int[] arr = {1,2,3,4};

4、数组索引的特点
	索引 : 元素的编号,从0开始, 到数组长度减1

5、如何访问数组元素？如何获取数组长度？
	数组名[索引]  
	数组名.length

6、数组元素的默认初始化值？
	整数  0
    浮点数 0.0
    布尔类型  false
    字符型  空字符
    引用类型  null

7、数组遍历
	int[] arr = {1,2,3,4};
for(int i=0; i<arr.length; i++){
    System.out.println(arr[i]);
}

1 方法的概述

目标：理解什么是方法以及方法的作用

什么是方法

方法是将具有独立功能的代码组成一个整体，使其成为具有特殊功能的代码块。

方法的两个注意

• 方法必须先定义才能使用。（方法定义）
• 方法定义后不会自动运行，需要手动调用才能执行方法的功能。（方法调用）

2 方法的定义和调用

2.1 方法的定义格式1

定义格式

public static void 方法名(){
    方法体代码; //需要在方法内完成的代码
    
}

调用格式：

通过方法名调用

方法名();

示例代码：

/*
	需求:
		1. 定义一个方法,方法名为: printHelloWorld
		2. 在方法中使用循环打印5次hello world.
		3. 在main方法中调用执行 printHelloWorld 方法.
*/
public class MethodDemo {
	
    
}

2.2 方法调用图解（了解）

[外链图片转存失败(img-DTDYVcYZ-1563073256636)(/assets/1559404209171.png)]

方法在栈中的调用执行过程：

结论:
1、栈是方法运行的内存区域。
2、先调用的方法先入栈，后调用的方法后入栈，后入栈的方法先执行完毕，并在栈内存中消失。
3、main方法是最先开始执行，最晚从内存中消失的。

练习案例

/*
【方法练习】设计方法printMax打印两个数的较大值 
*/

public class MethodDemo {
    public static void main(String[] args) {
        //2 在main方法中调用执行
        printMax();

    }
	//1 定义方法打印两个数的较大值
    public static void printMax(){
        int a = 10;
        int b = 20;

        if(a > b) {
            System.out.println(a);
        } else {
            System.out.println(b);
        }
    }
}

2.3 带参数的方法

定义格式：

public static void 方法名( 参数类型1 参数名1, 参数类型2 参数名2, ...){
    方法体代码; 
}

注意：
	方法的参数，可以是一个，也可以是多个，如果是多个参数，中间需要以逗号分隔。

调用格式：

在main方法中，通过方法名调用，并传入对应的参数值

方法名(参数值1, 参数值2);

调用带参方法的注意事项

• 调用带参方法，传入方法括号里的参数，无论个数和类型，都必须和方法定义时的个数和类型匹配。
• 传入方法的参数，可以是变量，也可以是常量。

示例代码：

/*
	需求：定义一个方法，该方法接收一个参数，判断该数据是否是偶数
    
*/
public class MethodDemo {
    public static void main(String[] args) {
        //1.常量值的调用
        isEvenNumber(10);

        //变量的调用
        int number = 10;
        isEvenNumber(number);
    }

    //定义方法，判断一个数是否是偶数
    public static void isEvenNumber(int number) {
        if(number%2 == 0) {
            System.out.println(true);
        } else {
            System.out.println(false);
        }
    }

}

2.4 形参和实参

• 形参，也叫形式参数，指的是定义方法的时候，方法小括号中定义的参数。
• 实参，也叫实际参数，指的是调用方法的时候，传入小括号中的常量或变量。

[外链图片转存失败(img-9M5roJFr-1563073256637)(assets/1556537548082.png)]

2.5 带参数方法练习

示例代码：

/*
    需求：
        设计一个方法，方法可以接收两个整数，在方法内进行逻辑判断，
        打印出两个数中的较大值。
 */
public class MethodTest {
    public static void main(String[] args) {
        //调用方式1：实际参数为常量
        getMax(10,20);
       
        //调用方式2：实际参数为变量
        int a = 10;
        int b = 20;
        getMax(a, b);
    }

	//定义方法，打印两个整数的较大值
    public static void getMax(int a,int b) {
        
        if(a > b) {
            System.out.println(a);
        } else {
            System.out.println(b);
        }  
    }
}

练习案例：

/*
需求1:
	定义printHelloWorld方法，接收一个整数n，在控制台打印n次HelloWorld。
*/
public class MethodDemo2 {


    //定义printHelloWorld方法，接收一个整数n，在控制台打印n次HelloWorld。
    public static void printHelloWorld(int n){ 
        // 在控制台打印n次HelloWorld。
        for (int i = 0; i < n ; i++) {
            System.out.println("hello world");
        }
    }

    public static void main(String[] args) {
        // 方法调用
        printHelloWorld(10);
        System.out.println("----------------");
        printHelloWorld(2); 
    }

}

/*
需求2:
	定义sum方法，接收两个整数，计算并打印两个整数的和。
*/

思考：sum方法计算出的两个整数的和，能否返回给调用者继续使用？

2.6 带返回值的方法

定义格式：

public static 数据类型 方法名(参数列表){
	方法体代码;
	return 数据值;
}

1) 格式要求

有返回值类型，就必须要有return语句。

返回值必须和返回值类型相匹配。

2) return语句的作用？

return语句用于将方法的运算结果返回给调用者。

return语句一旦执行，方法的调用就结束了。

return语句后面不能直接跟其他代码

3） 有返回值的方法是否一定要接收返回结果？

举例：

超市买东西，付钱后给的小票，可以拿也可以不要。如果把付钱的功能定义成一个方法，付钱后给的小票可以理解为方法执行后返回的数据，返回的数据可以接收也可以不接收（相当于小票可以拿走也可以不要）。

结论：

调用有返回值的方法时，方法的返回值可以接收也可以不接收，根据实际需要确定。如果不接收，该返回值就会丢失。大部分情况下，需要接收返回结果的。

4） 有返回值的方法调用方式

1. 直接调用：该方式会丢失返回值数据。
	方法名(参数值);

2. 输出调用：在输出语句中调用，直接使用结果。
	System.out.println( 方法名(参数值) );

3. 赋值调用：调用方法，并定义变量接收返回值。 （使用最多的方式）
	数据类型  变量名 =  方法名(参数值);

示例代码：

//定义方法求两个数的较大值，并返回较大的数

public class MethodDemo {
    public static void main(String[] args) {
      	//赋值调用
        int result = getMax(10,20);
        System.out.println(result);

        //输出调用
        System.out.println(getMax(10,20));
    }

    //定义一个方法，用于获取两个数字中的较大数
    public static int getMax(int a, int b) {
		//使用if判断并返回a和b中较大的
        if(a > b) {
            return a;
        } else {
            return b;
        }
    }
}

有返回值的方法练习:

/*
	需求：
		1. 定义求和方法,方法名为sum
		2. 方法中接收两个int类型整数.
		3. 计算并返回两个整数的和.
*/

public class MethodDemo {
    /*
        两个明确：
            明确参数：两个整数变量
            明确返回值：有返回值，类型是int
     */
    public static int sum(int a, int b){
        return  a + b;
    }

    public static void main(String[] args) {
        //有返回值的方法调用
        // 1、直接调用
        sum(10,20); //丢失方法了返回值

        // 2、输出调用
        // 直接将返回结果在控制台输出
        System.out.println( sum(10,20) );

        // 3、赋值调用（最常用的方式）
        int result = sum(10,20);

        //赋值调用的好处：拿到返回值后可以同时做多种操作
        //操作1：打印结果
        System.out.println(result); 
        //操作2：计算平均值
        System.out.println( result/2 );
    }
}

2.6 方法使用注意事项

1） 方法与方法之间是平级关系，不允许嵌套定义。

2） 方法有明确返回值类型时，必须要有return语句返回对应的数据。

3） 返回值类型为void，则代表无返回值，可以省略return语句，也可以单独使用return关键字，

用于结束方法，但是return后面不能跟任何数值。

4） 方法有形参时，调用时必须传递实参，传递的实参个数和类型必须和形参匹配。

5） return语句后面不能直接跟其他代码。

案例代码：

//定义方法，求两个整数的较大值，并返回较大的值。
public class MethodDemo2 {
    public static void main(String[] args) {
    }

    // 定义方法，求两个整数的较大值，并返回较大的值。
  
    // 该方法会编译报错，因为编译器认为只要是if语句，就有可能不执行，方法就有可能没有return语句。
    public static int getMax(int a, int b){
        if(a>b){
            return a;
        }
		
        if(a<=b){
            return b;
        }
       
    }
}

2.7 方法的通用格式

public static  返回值类型  方法名(参数类型  参数名1, 参数类型  参数名2, ...){
    方法体代码;
    return 返回值;
}

格式说明：

**public static：**public和static都是关键字，具有特殊的含义。（先这样写着，后续讲解）

**返回值类型：**方法有返回值时写返回值类型（基本数据类型、引用数据类型），没有返回值时写void。

**方法名：**用于方法调用时使用。

**( )：**括号里面写参数列表，多个参数使用逗号隔开，没有参数时直接写 ( ) 即可。

**参数类型：**限定传入方法的参数的数据类型。（基本数据类型、引用数据类型）

**参数名：**用于接收传入方法的数据。

**{ }：**大括号和里面的代码称为方法体。

**return：**方法有返回值时需要使用return关键字，返回对应的类型的数据。

没有返回值（void）时不用写return语句。

定义方法的两个明确：

1. 明确返回值类型：确定方法是否需要返回值，以及返回值的类型。
2. 明确参数：明确参数的类型和个数。

调用方法注意：

1. void类型的方法，直接调用即可。
2. 非void类型的方法，推荐使用变量接收调用。
3. 方法有参数时，调用时需要传参。

//【练习】
//需求：定义方法，方法中接收一个整型数组，对数组所有元素累加求和，并返回求和的结果。
public class MethodDemo7 {

    /*
        方法定义的两个明确:
            明确返回值类型 : int类型
            明确参数 : 有参数, 参数类型为数组
     */
    public static int getSum(int[] arr){

        //对数组所有元素累加求和
        int sum = 0;
        for(int i=0; i<arr.length; i++){
            sum+=arr[i];
        }

        return sum;
    }

    public static void main(String[] args) {

        int[] arr = {1,2,3,4,5};
        int he = getSum(arr);
        System.out.println("数组求和的结果为:"+he);
    }

}

上午回顾

方法的概述:
	具有特定功能的代码块

无参数无返回值的方法
    定义格式:
    public static void 方法名(){
        //方法体;
    }
    调用格式:
    直接调用: 方法名();

有参数无返回值的方法
	定义格式:
    public static void 方法名(数据类型  变量名1, 数据类型 变量名2...  ){
        //方法体;
    }
	调用格式:
	方法名(参数值1, 参数值2...);
	
	要求:  参数个数和类型要与定义时的参数列表一致
	
形式参数: 简称形参,方法定义的时候的参数  ,格式为:数据类型  变量名1
实际参数: 简称实参,方法调用的时候的参数 , 可以是常量值/变量名 

有返回值有参数的方法
	定义格式:
    public static 数据类型 方法名(数据类型  变量名1, 数据类型 变量名2...  ){
         //方法体;
        return 数据值/变量名;
    }

调用格式:
	单独调用 : 方法名(参数值1, 参数值2...);
			 会丢失返回值.
    输出调用: System.out.println( 方法名(参数值1, 参数值2...)  );
	
	赋值调用: 数据类型 变量名 = 方法名(参数值1, 参数值2...);  //使用最多的方式, 也是推荐使用的方式

3 方法重载

3.1 什么是方法重载

同一个类中，出现了多个同名的方法，叫做方法重载。

3.2 构成方法重载的条件（重点）

1. 多个方法在同一个类中。
2. 多个方法名称相同。
3. 多个方法的参数列表不同（个数或者类型不同）。

注意：
	方法重载与返回值和参数名称无关。
	
简单总结： 
	同一类中，方法名称相同，参数列表不同，即构成方法重载。

3.3 方法重载的作用

方便程序员对参数不同，但是功能相同或相似的方法进行统一的命名和调用。

3.4 调用重载的方法

调用时，虚拟机会根据参数列表的不同来区分调用对应的重载方法。

正确范例：

/*
	方法名相同，参数类型不同，构成方法重载
*/
public class MethodDemo {
	public static void fn(int a) {
    	//方法体
    }
    public static int fn(double a) {
    	//方法体
    }
}


/*
	同一类中，方法名fn相同，参数列表不同（个数不同），构成方法重载
*/
public class MethodDemo {
	public static float fn(int a) {
    	//方法体
    }
    public static int fn(int a , int b) {
    	//方法体
    }
}

错误范例：

/*
	参数列表相同，无法构成重载
*/
public class MethodDemo {
	public static void fn(int a) {
    	//方法体
    }
    public static int fn(int a) { 	
    	//方法体
    }
}

/*
	方法不在同一个类中，没有重载的概念
*/
public class MethodDemo01 {
    public static void fn(int a) {
        //方法体
    }
} 
public class MethodDemo02 {
    public static int fn(double a) {
        //方法体
    }
}

练习案例1：

/*
    方法重载的条件：
        1. 多个方法在同一个类中。
        2. 多个方法名称相同。
        3. 多个方法的参数列表不同（个数或者类型不同）。
 */
public class MethodDemo {
    public static void main(String[] args) {
        //调用方法
        int result = sum(10,20);
        System.out.println(result);

        double result2 = sum(10.0,20.0);
        System.out.println(result2);

        int result3 = sum(10,20,30);
        System.out.println(result3);
    }

    //1. 定义sum方法返回两个int整数的和
    public static int sum(int a, int b) {
        return a + b;
    }

    //2. 定义重载的sum方法返回两个double浮点数的和
    public static double sum(double a, double b) {
        return a + b;
    }

    //3. 定义重载的sum方法返回三个整数的和
    public static int sum(int a, int b, int c) {
        return a + b + c;
    }

}

练习案例2：

/*
 * 定义重载的方法 分别比较 两个byte数、两个short数、两个int数、两个long数 是否相等
 */
public class MethodOverLoad {
	// 方法1：判断两个byte数是否相等
	public static boolean compare(byte a, byte b) {
		System.out.println("byte");
		return a == b;
	}
	// 方法2：判断两个short数是否相等
	public static boolean compare(short a, short b) {
		System.out.println("short");
		return a == b;
	}
	// 方法3：判断两个int数是否相等
	public static boolean compare(int a, int b) {
		System.out.println("int");
		return a == b;
	}
	// 方法4：判断两个long数是否相等
	public static boolean compare(long a, long b) {
		System.out.println("long");
		return a == b;
	}
	//测试方法重载的调用
	public static void main(String[] args) {
		//输出调用
		System.out.println( compare(10, 20) );//整数默认是int类型，所以会调用int参数的重载方法
		System.out.println( compare((byte)10, (byte)20) ); //byte
		System.out.println( compare((short)10, (short)20) ); //short
		System.out.println( compare(10L, 20L) );//long
	}
	
}

【多选题】判断下面属于方法重载的是？（ DE ）  

A：
	int   fun(int a, float b){...}  
	float fun(int a, float b){...}  
	//参数列表相同, 不符合重载
B:
	float fun(int a, float b){...}
	float fun(int x, float y){...} 
	//参数列表相同, 不符合重载

C:
	float fun1(int a, float b){...}
	float fun2(int a, float b){...} 
	//方法名不同, 不符合重载

D:
	float fun(float a){...}
	float fun(float a, float b){...}

E：
	float fun(int a, float b){...}  
	float fun(float b, int a){...}  
	//构成重载 ,但是没有意义

说明:
	/*
     *   以下两个fun方法也构成了方法重载, 因为对应位置的参数的类型并不相同
     *   但是这种重载是没有意义的,因为最后的结果都是求一个整数和一个小数的和.
     */
    public static float fun(int a, float b){
        return a+b;
    }

    public static float fun(float b, int a){
        return a+b;
    }

4 方法参数传递

5.1 方法参数传递基本类型

结论：

方法参数为基本数据类型时，参数为值传递，形式参数的改变不影响实际参数

代码：

/*
参数传递为基本数据类型
*/
public class MethodDemo4 {
    public static void main(String[] args) {
        int num  = 5;
        add(num);
        System.out.println(num);
    }

    //方法形参为基本数据类型
    public static void add(int num){
        num+=10; //num = 15;
    }
}

图解：

[外链图片转存失败(img-qEioWywc-1563073256640)(assets/1559479663751.png)]

//分析以下程序的输出结果？
public static void main(String[] args) {
		int a = 10;
		int b =20;
		
		System.out.println(a); //10 
		System.out.println(b);   //20
		
		sum(a,b);
		
		System.out.println(a); //10
		System.out.println(b);  //20
	}
	
	public static void sum(int a, int b){  
		a = b ; //a=20
		b = a+b; //b=40
		
		System.out.println(a); //20
		System.out.println(b); //40
	}

5.2 方法参数传递引用类型

什么是引用类型数据？

在堆内存中创建，并产生了一个地址值的数据。（数组、对象，接口）

结论：

方法参数为引用数据类型时，参数为地址传递，形式参数的改变会影响实际参数。

代码：

/*
参数传递为引用类型
*/
public class MethodDemo5 {
    public static void main(String[] args) {

        int[] arr = {10,20,30};
        System.out.println("调用前："+arr[0]); //10

        change(arr);

        System.out.println("调用后："+arr[0]); //100
    }

    //方法形参为引用类型
    public static void change(int[] arr) {
        arr[0] = 100;
    }
}

图解：

[外链图片转存失败(img-iTXvtxnx-1563073256641)(assets/1559481608759.png)]

//需求：设计一个方法用于获取数组中元素的最大值，并将得到的最大值返回。

总结

方法重载:
	条件: 同一个类中,方法名相同, 参数列表不同(类型或者个数不同)
	作用: 方便方法的定义和调用
	
方法的参数传递:
	参数为基本类型时的传递:
		值传递, 形参的改变不会影响实参.
            
    参数为引用类型时的传递:
		地址传递, 形参的改变直接影响实参.
            
方法的通用格式:
    public static 数据类型  方法名(数据类型 变量名, ....){
        方法体;
        return 数据值; //如果返回类型为void, 此处省略
    }

方法的注意事项:
	定义位置:	在类中,其他方法外.(不能嵌套定义)
    
    方法要先定义,再调用
    
    调用时,实参的类型和个数要与形参完全一致.
        
    如果方法有返回值, 一般会定义变量接收方法的返回结果
    	数据类型  变量名 = 方法名(实参);

] arr = {10,20,30};
System.out.println(“调用前：”+arr[0]); //10

change(arr);

    System.out.println("调用后："+arr[0]); //100
}

//方法形参为引用类型
public static void change(int[] arr) {
    arr[0] = 100;
}

}

图解：

[外链图片转存中...(img-iTXvtxnx-1563073256641)]

```java
//需求：设计一个方法用于获取数组中元素的最大值，并将得到的最大值返回。

总结

方法重载:
	条件: 同一个类中,方法名相同, 参数列表不同(类型或者个数不同)
	作用: 方便方法的定义和调用
	
方法的参数传递:
	参数为基本类型时的传递:
		值传递, 形参的改变不会影响实参.
            
    参数为引用类型时的传递:
		地址传递, 形参的改变直接影响实参.
            
方法的通用格式:
    public static 数据类型  方法名(数据类型 变量名, ....){
        方法体;
        return 数据值; //如果返回类型为void, 此处省略
    }

方法的注意事项:
	定义位置:	在类中,其他方法外.(不能嵌套定义)
    
    方法要先定义,再调用
    
    调用时,实参的类型和个数要与形参完全一致.
        
    如果方法有返回值, 一般会定义变量接收方法的返回结果
    	数据类型  变量名 = 方法名(实参);