方法

一、声明与调用

 　　修饰符 返回值类型 方法名（参数列表）{

　　　　　　方法体

　　　　　　return 实际值；

　　}

• 修饰符：修饰符，这是可选的，告诉编译器如何调用该方法。定义了该方法的访问类型。

• 返回值类型 ：方法可能会返回值。returnValueType是方法返回值的数据类型。有些方法执行所需的操作，但没有返回值。在这种情况下，returnValueType是关键字void。

• 方法名：是方法的实际名称。方法名和参数表共同构成方法签名。

• 参数类型：参数像是一个占位符。当方法被调用时，传递值给参数。这个值被称为实参或变量。参数列表是指方法的参数类型、顺序和参数的个数。参数是可选的，方法可以不包含任何参数。

• 方法体：方法体包含具体的语句，定义该方法的功能。

注意： 在一些其它语言中方法指过程和函数。一个返回非void类型返回值的方法称为函数；一个返回void类型返回值的方法叫做过程。

    /**
     * 交换两个数的位置
     * @param number1 值一
     * @param number2 值二
     * 
     * */
    public static void swap(int number1,int number2) {
        System.out.println("swap=>方法交换前：number1= " + number1 + ",number2 = " + number2);
        int temp = number1;
        number1 = number2;
        number2 = temp;
        System.out.println("swap=>方法交换后：number1= " + number1 + ",number2 = " + number2);
    }

二、main方法

Main方法是被JVM调用的，除此之外，main方法和其它方法没什么区别。

main方法的头部是不变的，带修饰符public和static，返回void类型值，方法名字是main。

String[]类型参数。String[]表明参数是字符串数组。

 作用：

　　①让类可执行

　　②作为方法调用的入口

　　③被jvm调用

注意：

1) 在 main()方法中， 我们可以直接调用 main 方法所在类的静态方法或静态属性。
2) 但是， 不能直接访问该类中的非静态成员， 必须创建该类的一个实例对象后， 才能通过这个对象去访问类中的非静态成员；静态方法只能访问静态成员，不能访问非静态成员

public class FunctionDemo {
　　public static void main(String[] args) {
        //调用sum方法
        int sum1 =sum(1,10);
        System.out.println("sum = " + sum1);
        
        //调用nprint方法
        nprint("hello",2);
        
        //调用swap方法
        int number1 = 10;
        int number2 = 20;
        System.out.println("main=>调用swap方法前：number1= " + number1 + ",number2 = " + number2);
        swap(number1,number2);
        System.out.println("main=>调用swap方法后：number1= " + number1 + ",number2 = " + number2);
    }

    /**
     * 求两个数的和
     * @param num1 起始值
     * @param num2 结束值
     * @return 和
     * 
     * */
    public static int sum(int num1,int num2) {
        int sum = 0;
        for (int i = num1; i<= num2; i++)
            sum += i;
        return sum;
    }
    
    /**
　　　* 打印文本
　　　* @param messge 打印的文本
     * @param num 次数
     * @return 打印文本
     * 
     * */
    public static void nprint(String messge,int num) {
        for (int k =0; k < num ; k++)
            System.out.println(messge);
    }
}

三、扩展

1、变量作用域

　　变量的范围是程序中该变量可以被引用的部分。

　　方法内定义的变量被称为局部变量。

　　局部变量的作用范围从声明开始，直到包含它的块结束。局部变量必须声明才可以使用。方法的参数范围涵盖整个方法。参数实际上是一个局部变量。

　　for循环的初始化部分声明的变量，其作用范围在整个循环。但循环体内声明的变量其适用范围是从它声明到循环体结束

2、可变参数

　　JDK 1.5 开始，Java支持传递同类型的可变参数给一个方法。

　　方法的可变参数的声明如下所示：

　　typeName... parameterName

　　在方法声明中，在指定参数类型后加一个省略号(...) 。

　　一个方法中只能指定一个可变参数，它必须是方法的最后一个参数。任何普通的参数必须在它之前声明。

public class VarargsDemo {
    
    public static void main(String args[]) {
          // 调用可变参数的方法
          printMax(34, 3, 3, 2, 56.5);
          printMax(new double[]{1, 2, 3});
       }
    
    /**
     * 打印最大数
     * @param numbers  可变参数
     */
    public static void printMax( double... numbers) {
       if (numbers.length == 0) {
          System.out.println("No argument passed");
          return;
       }
       double result = numbers[0];
       for (int i = 1; i <  numbers.length; i++) {
           if (numbers[i] >  result){
              result = numbers[i];
           }
       }
       System.out.println("The max value is " + result);
    }
}

3、finalize() 方法　　

　　Java允许定义这样的方法，它在对象被垃圾收集器析构(回收)之前调用，这个方法叫做finalize( )，它用来清除回收对象。例如，你可以使用finalize()来确保一个对象打开的文件被关闭了。

　　在finalize()方法里，你必须指定在对象销毁时候要执行的操作。

　　finalize()一般格式是：

　　protected void finalize()
　　{
  　　 // 在这里终结代码
　　}

　　关键字protected是一个限定符，它确保finalize() 方法不会被该类以外的代码调用。

　　当然，Java的内存回收可以由JVM来自动完成。如果你手动使用，则可以使用上面的方法。

四、方法重载（用于同一个类）

重载 (overloading) 是在一个类里面，方法名字相同，而参数不同。返回类型呢？可以相同也可以不同。

每个重载的方法（或者构造函数）都必须有一个独一无二的参数类型列表。

最常用的地方就是构造器的重载。

重载规则

• 被重载的方法必须改变参数列表；
• 被重载的方法可以改变返回类型；
• 被重载的方法可以改变访问修饰符；
• 被重载的方法可以声明新的或更广的检查异常；
• 方法能够在同一个类中或者在一个子类中被重载。
• 无法以返回值类型作为重载函数的区分标准。

五、方法重写（用于继承时）

重写是子类对父类的允许访问的方法的实现过程进行重新编写！返回值和形参都不能改变 

方法重写的规则

• 参数列表与被重写方法的参数列表必须完全相同。
• 返回类型与被重写方法的返回类型可以不相同，但是必须是父类返回值的派生类（java5 及更早版本返回类型要一样，java7 及更高版本可以不同）。
• 子类方法的访问权限必须大于或等于父类方法的访问权限。例如：如果父类的一个方法被声明为 public，那么在子类中重写该方法就不能声明为 protected。
• 父类的成员方法只能被它的子类重写。
• 声明为 final 的方法不能被重写。
• 声明为 static 的方法不能被重写，但是能够被再次声明。
• 子类和父类在同一个包中，那么子类可以重写父类所有方法，除了声明为 private 和 final 的方法。
• 子类和父类不在同一个包中，那么子类只能够重写父类的声明为 public 和 protected 的非 final 方法。
• 重写的方法能够抛出任何非强制异常，无论被重写的方法是否抛出异常。但是，重写的方法不能抛出新的强制性异常，或者比被重写方法声明的更广泛的强制性异常，反之则可以。
• 构造方法不能被重写。
• 如果不能继承一个方法，则不能重写这个方法。
• 访问权限不能比父类中被重写的方法的访问权限更低。例如：如果父类的一个方法被声明为 public，那么在子类中重写该方法就不能声明为 protected。

注意：当需要在子类中调用父类的被重写方法时，要使用 super 关键字。

六、重写与重载之间的区别

方法的重写 (Overriding) 和重载 (Overloading) 是 java 多态性的不同表现：方法重载是一个类的多态性表现,而方法重写是子类与父类的一种多态性表现。