java的方法

一、方法的概述

概述：方法是将具有独立功能的代码块组织成一个整体，使其具有特殊功能的代码集

• 方法必须先创建才可以使用，该过程称为方法定义；
• 方法创建后不是直接运行的，需要手动使用后才执行，该过程称为方法调用。

二、方法的定义和调用

public class void 方法名(){
    方法体;
}
public class void main(String[] args){
    方法名;
}

//典例：输出较大数
public class max{
    public static void main(String[] args) {
        getMax();
    }
    public static void getMax(){
        int x=10,y=20;
        if(x>y){
            System.out.println(x);
        }else{
            System.out.println(y);
        }
    }
}

1.带参数方法的定义和调用

public static void 方法名(数据类型 变量名1，数据类型 变量名2，…){
//方法体；
}

//典例：较大数
public class max{
  public static void main(String[] args) {
    int a=10,b=20;
    getMax(a,b);//实参：方法调用中的参数，等同于使用变量或者常量，
  }                  //例如这里的10,20,a,b;*
  public static void getMax(int x,int y){//行参：方法定义中的参数，等同于变量定义的格式，
    if(x>y){             //例如这里的int x，int y
     System.out.println(x);
    }else{
     System.out.println(y);
    }
  }
  }
*//重点：调用方法的时候，要几个给几个

2.带返回值方法的定义和调用

public static 数据类型 方法名(参数){
return 数据;
}
重点：定义方法是return后面的返回值与方法定义上的数据类型要匹配，否则程序将报错。

• 方法的返回值通常会使用变量接受，否则该返回值无意义

格式1：方法名(参数); //可以用输出语句输出;
格式2：数据类型 变量名=方法名(参数);

public class max{
    public static void main(String[] args) {
    int a=10,b=20;
    //格式1：System.out.println(getMax(a,b));
    //格式2：int c=getMax(a,b); System.out.println(c);
  }
  public static int getMax(int x,int y){
    if(x>y){
      return x;
    }else{
      return y;
    }
  }
}

方法的注意事项：

• 方法不能嵌套定义
• void表示无返回值，可以省略return，也可以单独书写return，后面不加数据

三、方法的重载

1.方法重载的概述：

重载是指同一个类中定义的多个方法之间的关系

满足的条件：

• 多个方法在同一个类中
• 多个方法具有相同的方法名
• 多个方法的参数不同（类型不同或者数量不同）

2.方法重载的特点

• 重载仅对应方法的定义，与方法的调用无关，调用方式参照标准格式。
• 重载仅针对同一个类中方法名称与参数的识别，*与返回值无关*，换一句话说不能通过返回值来判断两个方法是否相互构成重载。

//典例：判断是否相同
public class Main1Controller {
    public static void main(String[] args) {
        System.out.println(compare(10,20));
        System.out.println(compare((long)10,(long)20));
        System.out.println(compare((short)10,(short)20));
        System.out.println(compare((byte)10,(byte)20));
    }
    public static boolean compare(int a,int b){
        System.out.println("int");
        return a==b;
    }
    public static boolean compare(long a,long b){
        System.out.println("long");
        return a==b;
    }
    public static boolean compare(short a,short b){
        System.out.println("short");
        return a==b;
    }
    public static boolean compare(byte a,byte b){
        System.out.println("boolean");
        return a==b;
    }
}

四、方法的重写

1.重写的概述

在子类中如果创建了一个与父类中相同名称、相同返回值类型、相同参数列表的方法，只是方法体中的实现不同，以实现不同于父类的功能，这种方式被称为方法重写（override），又称为方法覆盖。当父类中的方法无法满足子类需求或子类具有特有功能的时候，需要方法重写。

2.在重写方法时，需要遵循下面的规则

• 参数列表必须完全与被重写的方法参数列表相同。
• 返回的类型必须与被重写的方法的返回类型相同（Java1.5 版本之前返回值类型必须一样，之后的 Java 版本放宽了限制，返回值类型必须小于或者等于父类方法的返回值类型）。
• 访问权限不能比父类中被重写方法的访问权限更低（public>protected>default>private）。
• 重写方法一定不能抛出新的检査异常或者比被重写方法声明更加宽泛的检査型异常。例如，父类的一个方法声明了一个检査异常 IOException，在重写这个方法时就不能抛出 Exception，只能拋出 IOException 的子类异常，可以抛出非检査异常。

3.方法的重写例题

//小曾继承大曾
public class TestOverRide {
    public static void main (String args[]){
        Student student = new Student();
        Person person = new Person();
        person.setAge(50);
        person.setName("大曾");
        student.setAge(21);
        student.setName("小曾");
        student.setSchool("大学");
        System.out.println(person.getInfo());
        System.out.println(student.getInfo());
    }
}
class Person{
    private int age;
    private String name;
    public void setAge(int age){
        this.age = age;
    }
    public void setName(String name){
        this.name = name;
    }
    public int getAge(){
        return age;
    }
    public String getName(){
        return name;
    }
    public String getInfo(){
        return "Name is:"+name+",Age is "+age;
    }
}
class Student extends Person{

    private String school;

    public void setSchool(String school){
        this.school = school;
    }
    public String getSchool(){
        return school;
    }
    public String getInfo(){
        return "Name is:"+getName()+",Age is "+getAge()+",School is:"+school;
    }
}