Java方法、构造方法、方法调用与方法重载

一、方法的分类

1.根据方法是否有返回值，将方法分为有返回值的方法和没有返回值的方法
（1）方法如果没有返回值，返回值的地方写void。
（2）方法如果有返回值，返回值的地方写返回值的类型，返回值的类型可以是8大基本数据类型，也可以是3大引用数据类型。
      
2.调用一个方法：
（1）调用的方法没有返回值，直接调用就可以，不需要用变量去接收。
（2）调用的方法有返回值，你可以直接将返回值输出，也可以用一个对应的数据类型变量去接收这个返回值。
      
3.根据方法是否有参数列表，将方法分为有参方法和无参方法。
（1）方法如果没有参数列表，方法名后面的()中不需要写任何东西。
（2）方法如果有参数列表，方法名后面()中需要按照顺序来定义参数列表，参数的个数可以是1-n个，规则是(数据类型 变量名,数据类型 变量名,...,数据类型 变量名)。
      
4. 调用一个方法：
（1）调用的方法没有参数，直接调用，不需要传递参数。
（2）调用的方法需要有参数，调用的时候需要根据参数列表的要求传递参数，按照参数列表定义的顺序，个数、类型传递参数。
      
综上所述，方法的表现形式有：
（1）无返回值的无参方法
（2）无返回值的有参方法
（3）有返回值的无参方法
（4）有返回值的有参方法
      
5.方法调用的两个原则：
（1）要什么给什么--->根据参数列表的要求传递参数。
（2）给什么接什么--->方法返回什么类型的结果，就需要使用对应类型的比变量去接收数据。

public int test1(){//有反无参
        int num =200;
        return num;
    }
    
    public String test2(){//有反无参
        return "hello";
    }
    
    public double[] test3(){//有反无参
        double[] nums = {10.5,22};
        return nums;
    }
    
    
    public void show1(String name){//无反有参
        System.out.println(name);
    }
    
    public void show2(String name,int age){//无反有参
        System.out.println(name+"的年龄："+age);
    }
    
    //求两个int类型的数据之和
    public int sum(int num1,int num2){//有反有参
        return num1+num2;
    }

二、构造方法

1.构造方法：用来创建对象的方法

（1）构造方法的方法名与类名相同

（2）构造方法没有返回值，void也不写
（3）在声明一个类的时候，系统会给每个类默认添加一个无参构造方法，隐藏起来，不显示
（4）如果在这个类中添加了其它的构造方法，这个默认无参构造方法会被覆盖掉，如果还需要使用这个无参构造方法，可以在这个类中手动添加一个无参构造方法

public class Student {
    public String name;
    public int age;
    public char gender;
    public String address;
    public double height;
    public double weight;
    public String hobby;
    public long phone;

    public Student() {//无参构造方法
    }
    
    //方法的参数列表中的变量名没有做到见名知意，需要将变量名修改为具体的表示数据的名称
//    public Student(String a, int b, char c, String d,
//            double e, double f, String g, long h) {
//        name = a;
//        age = b;
//        gender = c;
//        address = d;
//        height = e;
//        weight = f;
//        hobby = g;
//        phone = h;
//    }

    //将参数列表中的变量名做到了见名知意，但是发现，传递的数据不能赋值给对象的对应属性，因为，传递的数据找不到要赋值给哪个对象
//    public Student(String name, int age, char gender, String address,
//            double height, double weight, String hobby, long phone) {
//        name = name;
//        age = age;
//        gender = gender;
//        address = address;
//        height = height;
//        weight = weight;
//        hobby = hobby;
//        phone = phone;
//    }
    
    public Student(String name, int age, char gender, String address,
            double height, double weight, String hobby, long phone) {//有参构造方法
        //this表示一个对象，表示当前对象，哪个对象调用这个构造方法，this就表示哪个对象
        this.name = name;
        this.age = age;
        this.gender = gender;
        this.address = address;
        this.height = height;
        this.weight = weight;
        this.hobby = hobby;
        this.phone = phone;
    }
    
    public Student(String name, int age, char gender, String address){
        this.name = name;
        this.age = age;
        this.gender = gender;
        this.address = address;
    }

三、方法的调用

1.非静态方法
非静态方法就是没有 static 修饰的方法，对于非静态方法的调用，是通过对象来调用的，表现形式如下。

对象.方法（）；

public class Teacher {

    public void c() {
        // a()方法是Student类中的方法，在Teacher类中不能直接调用，需要使用对象.方法()的形式调用
        // a();
        Student stu = new Student();
        stu.a();
        System.out.println("Teacher类中的方法c()");
    }

}

2.调用静态方法
静态方法就是用 static 修饰的方法，静态方法的调用是通过类名来调用的， 表现形式如下：

类名.方法（）；

3.方法与方法之间的调用
方法与方法之间的调用，主要是在一个方法内部如何调用其他方法。
（1）静态方法内部调用其他方法
如果在本类当中，静态方法可以直接调用静态方法，
除了在 main 方法中，还可以在自定义的静态方法中直接调用。
如果在本类当中是非静态方法，就必须通过对象来调用。

public class InvokeMethod{
    
    public static void main (String[] args){
        t2();
    }
    public static void t2(){
        System.out.println("static t2...");
    }
    public static void t1(){
        //静态方法用非静态方法需通过对象来调用
        //InvokeMethod in =new InvokeMethod();
        //in.t2();
        t2();
        System.out.println("static t1");
    }
}

（2）非静态方法内部调用
如果在本类中，非静态方法可以直接调用静态方法与非静态方法。
在不同类中，非静态方法调用其他类的静态方法，需要通过导入该类中的包，并且需要通过类名来调用
在不同类中，非静态方法调用其他类的非静态方法时，需要导入该类中的包，还需要通过创建对象来调用。
 

public class Student {

    public void a() {
        System.out.println("Student类中的a()方法");
    }

    public void b() {
        // Student stu = new Student();
        // stu.a();
        // 方法a()和方法b()在同一个类中，可以直接写方法名()方式调用，不需要创建对象调用
        a();
        System.out.println("Student类中的b()方法");
    }

}

4.在同一个类中调用方法：可以通过this关键字来调用；

public class ThisDemo01 {

    public String name;
    public String age;

    public void test1() {
        System.out.println("ThisDemo01类中的test1()方法");
    }

    public void test2() {
        // 直接调用test1()方法
        // test1();

        // 通过ThisDemo01对象调用test1()方法
        // ThisDemo01 td = new ThisDemo01();
        // td.test1();

        // 通过对象调用test1()方法
        this.test1();
        System.out.println("ThisDemo01类中的test2()方法");
    }

    public ThisDemo01() {
        System.out.println("ThisDemo01类中的无参构造方法");
    }

注意：在一个构造方法中通过this关键字调用其它构造方法的时候，this关键字需要写在构造方法中的第一行位置。

public ThisDemo01(String name, String age) {
        //在一个构造方法中通过this关键字调用其它构造方法的时候，this关键字需要写在构造方法中的第一行位置
        this();
        System.out.println("ThisDemo01类中的有参构造方法");
        //this();
        this.name = name;
        this.age = age;
        
    }

四、方法重载

1.方法重载：
（1）在同一个类中
（2）方法名相同
（3）参数列表不同（参数个数、参数顺序、参数类型）
（4）与返回值类型无关
（5）与方法的访问权限修饰符无关

public class MathUtils {
   
    //定义一个方法，求两个int类型数据之和
     static int sum(int a,int b){
        //两你传递过来的两个int类型数据进行相加，然后返回
        return a+b;
    }
    
    //定义一个方法，求三个int类型数据之和
    protected static int sum(int a,int b,int c){
        return a+b+c;
    }
    
    //定义一个方法，求两个double类型数据之和
    public static double sum(double a,double b){
        return a+b;
    }
    
    //定义一个方法，求一个int类型的数据和一个double类型数据之和
    public static double sum(int a,double b){
        return a+b;
    }
    
    //定义一个方法，求一个double类型的数据和一个int类型的数据之和
    public static double sum(double a,int b ){
        return a+b;
    }
    

}