【Java的方法】

方法

方法是语句的集合

• 方法是解决一类问题的步骤的有序组合
• 方法包含于类的对象中

例如：
System.out.println();
类.对象.方法

• 方法在程序中被创建，在其他地方被引用
• 一个方法最好只有一个功能
• 方法命名----驼峰原则

方法定义

/*
修饰符 返回类型 方法名（形参）{
	//方法体
	return 返回值;
}
//方法结束，返回一个返回值
public String sayHello(){
	return "hello,world";
}
public void print(){
	return ;
}
public int max(int a,int b){
	return a>b ? a : b;
}
*/

方法调用

为了方便调用 方法会有加上stastic，这样可以直接写方法命调用。

案例:add()方法

package Dome00;

public class Dome02 {
    public static void main(String[] args) {		
    	//1，2是实际参数：实际调用的参数
    	//调用二：方法返回值时，方法调用通常被当作一个值
        int sum = add(1,2);
        //调用一：类.对象.方法
        System.out.println(sum);
    }
    //a,b是形参：用来定义作用
    public static int add(int a,int b){
    	//返回相应类型的值，若void则不需要写
        return a+b;
    }
}

//值传递
public class Dome04 {
    public static void main(String[] args){	
	    int a = 1;
	    System.out.println(a);//1
		Dome04.change(a);
		System.out.ptintln(a);//1，因为是值传递，只是将a中的1传递到change方法中，但方法并没有返回值。
	}
	public static void change(int a){
		a = 10;
	}
}
//引用传递
public class Dome04 {
    public static void main(String[] args){	
    	Person person = new Person()；
    	System.out.println(person.name);//null
    	Dome05.change(person);
    	/*
    	这里change的更改是直接修改了class Person里的属性，所以下次再输出person.name的值会更改。
    	*/
    	System.out.println(person.name);//xiaoming
    }
    public static void change(Person person){
    	person.name = "xiaoming";
    }
}
//定义了一个Person类，有一个属性：name
class Person{
	String name;//初始值null
}

静态方法可以直接通过类名调用

static与类一起加载的下面可以看到第二张有红色波浪线，说明出现问题。根据上面的测试，我们知道非静态的方法需要创建实例化对象，才可以调用，而静态方法再类建立之初也一起加载，所以第二张调用一个未加载的方法会报错。

方法重载

一个类里面有两个名字相同的方法，但参数的数据类型不同，在调用时，会根据传入的数据选择相应的方法。

注意点：

• 名称必须相同
• 参数列表必须不同（参数类型，参数个数，参数排列顺序不同等)
• 方法的返回类型可以相同也可以不同
• 仅仅返回值不同不足以成为方法的重载

package Dome00;

public class Dome02 {
    public static void main(String[] args) {
    
        int result1 = max(10,20);
        int result2 = max(10.0,11.0);
        double result3 = max(12,20);
        double result4 = max(12.0,20.0);
        System.out.println(result1);//20
        System.out.println(result2);//报错：java: 不兼容的类型: 从double转换到int可能会有损失
        System.out.println(result3);//20.0
        System.out.println(result4);//20.0
        //由此可以看出方法的重载，选择哪个方法是根据传递的参数类型决定的，而不是result的类型。
    }

    //方法的重载，方法的名字相同，但传递的参数类型不同
    public static int max(int a,int b){
        if(a>b) return a;
        else return b;
    }public static double max(double a,double b){
        if(a>b) return a;
        else return b;
    }
}

可变参数

传递同类型的可变参数给一个方法
本质上和数组有点相同

注意：

• 在方法声明中，指定参数类型后面加一个省略号
• 一个方法中只能有一个可变参数，它必须是方法的最后一个参数。 任何普通参数必须在它之前声明。

package Dome00;

public class Dome03 {
    public static void main(String[] args) {		//方法的调用
        Dome03 dome03 = new Dome03();
        dome03.method(1,23,432,14,33);
    }
    //int... 可变行参数定义
    public void method(int... i){
        System.out.println(i[0]);
        System.out.println(i[1]);
        System.out.println(i[2]);
        System.out.println(i[3]);
        System.out.println(i[4]);
    }
}

输出结果：
1
23
432
14
33

递归

通俗来说，递归就是自己调用自己
递归可以将大问题转换为小问题
递归结构分为两个部分

1. 递归头：什么时候不调用自己；
2. 递归体：什么时候需要调用自己；

package Dome00;
public class Dome04 {
    public static void main(String[] args) {
        System.out.println(f(5)); 
    }
    public static int f(int n){
    	//结束调用自己的时候
        if(n==1) return 1;
        //需要调用自己的时候
        else return n*f(n-1);
    }
}

递归的深度很大，因为java是栈机制，最好不要使用递归噢！

方法的重写

子类重写父类的方法，重写的关键词不能是private。
重写就是子类和父类的方法相同但方法体不同。

为什么需要重写？
父类的功能子类不一定需要，或者不一定满足

快捷键：Alt+Insert：override；

静态方法重写

B b = new A();//父类的引用指向子类
非静态方法重写

总结：（重写需要有继承关系，而且是子类继承父类的方法）

• 方法名必须相同
• 参数列表必须相同
• 范围可以扩大但不能缩小
  public>protected>default>private
• 抛出的异常可以被缩小但不能被扩大

今日总结就是这些啦！！！
每天都要开心，没准下一秒有伤心事，趁现在没有自然要开心点！(๑>؂<๑）