方法的定义

public class Demo_01 {
}

Demo_01 就是一个类

public class Demo_01 {
    public static void main(String[] args) {
    }
}

而其中的 main 就是方法

• 调用方法的时候需要

  • 修饰符 比如 public

  • 返回值的类型 比如 String void

  • 方法名 比如 main

  • 返回值 return

    修饰符 返回值类型 方法名 () {
       方法体
       return 返回值;
    }

• public class Demo_01 {
      public static void main(String[] args) {
      }
      public String hello () {
          return("Hello World");
      }
  }

• 如果返回值为 void 则可以省略 return 或者

      public void hello_02() {
          return;
      }

•     public int max(int a,int b) {
          return a>b ? a :b;  //三元运算符
      }

• 方法的定义

  • 修饰符

  • 返回类型

  • break 跳出switch ，结束循环。return 结束方法，返回一个结果 (可以为空)

  • 方法名注意规范就行 见名知意

  • 参数列表: (参数类型,参数名)

  • 异常抛出

• 方法的调用

  • 静态方法 static

  • 非静态方法

  • 形参和实参

  • 值传递和引用传递

  • this 关键字

静态方法

静态方法调用只需要新建一个类

public class Student {
    public static void say (){
        System.out.println("say");
    }
}

然后直接调用

public class Demo_02 {
    public static void main(String[] args) {
        Student.say();
    }
}

非静态方法

非静态方法首先需要创建一个类

public class Student {
    public void say (){
        System.out.println("say");
    }
}

因为是非静态方法，所以无法直接通过 类名.方法名

如果需要调用，则需要实例化

public class Demo_02 {
    public static void main(String[] args) {
        Student student = new Student();
        student.say();
    }
}

对象类型 对象名 = 对象值;

特殊情况

两个普通方法可以互相调用 (类实例化之后才存在)

public class Student {
    public void a() {
        b();
    }
    public void b() {}
}

两个静态方法也可以互相调用 (和类一起加载)

public class Student {
    public static void a() {  
        b();
    }
    public static void b() {}
}

形参 实参

public class Demo_03 {
    public static void main(String[] args) {
        Demo_03.add(1,2);
    }
    public static int add (int a,int b) {
        return a+b;
    }
}

1 和 2 为实参 (实际参数)

a 和 b 为形参 (形式参数)

形式参数 和 实际参数 类型要对应

值传递

public class Demo_04 {
    public static void main(String[] args) {
        int a = 1;  //声明并赋值 a
        System.out.println(a);  //输出 a
        Demo_04.change(a);  //调用 change 参数是 a
        System.out.println(a);  //输出 a
    }
    public static void change(int a) {
        a = 10;  //改变 change 方法里的 a
    }
}

因为 change 方法没有返回值，所以没有改变 main 方法里的参数 a

引用传递

引用传递一般是传递对象，本质还是值传递

public class Demo_05 {
    public static void main(String[] args) {
        Perosn perosn = new Perosn();
        System.out.println(perosn.name);  //null
        Demo_05.change(perosn);
        System.out.println(perosn.name);  //叮当
    }
    public static void change(Perosn perosn){
        //perosn 是一个对象 指向的是 perosn 类 这是一个具体的人，可以改变属性
        perosn.name = "叮当";
    }
}
//定义了一个 Perosn类，有一个属性 name
class Perosn {
    String name;
}