2.回顾方法及加深

方法的定义：

1. 修饰符：public 权限修饰符 static 静态的
2. 返回值类型：void无返回值类型，四类八种，string，或者自定义的
3. break：结束整个循环，跳出switch；continue：结束本次循环； return：结束方法体，返回一个结果
4. 方法名：注意规范，简明知意，就ok
5. 参数列表：（参数类型，参数名） ... 可变参数
6. 异常抛出

 1 package com.oop.demo01;
 2 
 3 import java.io.IOException;
 4 
 5 //Demo01  类
 6 public class Demo01 {
 7 
 8     //main方法
 9     public static void main(String[] args) {
10         
11     }
12 
13     /*
14     修饰符 返回值类型  方法名(...){
15         //方法体
16         return  返回值;
17         //return作用：结束方法，返回一个结果。结果可以是任意类型(与返回值类型对应)的数据，也可以为空(void)。
18         //return代表方法体的结束，return下面的代码unreachable statement无效的语句;
19         //return返回一个结果，与返回值类型相同的结果.也可以不带参数，返回值类型为void
20 
21         //break代表跳出循环，跳出switch; continue代表结束本次循环。
22     }
23 
24     */
25     public String sayHello() {
26         return "Hello,World！";
27     }
28 
29     public void print() {
30         return;
31     }
32 
33     public int max(int a, int b) {
34         return a > b ? a : b;//三元运算符
35     }
36 
37     //数组下标异常  ：ArrayIndexOutOfBoundsException:
38     public void readFile(String file)throws IOException{
39 
40     }
41 
42 }

 

方法的调用：递归

1. 静态方法：被static修饰的方法，从属于类，随类加载
2. 非静态方法：除静态方法以外的方法，从属于对象，实例化后才可调用

 1 package com.oop.demo01;
 2 
 3 public class Demo02 {
 4     public static void main(String[] args) {
 5         //静态方法：直接类名.方法名调用即可
 6         Student.say();
 7         //非静态方法：
 8         //实例化这个类,对象类型 对象名 = 对象值；
 9         //然后对象名.方法名调用
10         Student student = new Student();
11         student.joke();
12     }
13 
14     //被static修饰的方法是和类一起加载的，从属于类。
15     //静态的只能调用静态的方法
16     public static void a() {
17         b();
18     }
19 
20     public static void b() {
21 
22     }
23 
24     //类实例化之后才存在，非静态方法从属于对象
25     public void c() {
26 
27     }
28 }
29 
30 package com.oop.demo01;
31 
32 //学生类
33 public class Student {
34 
35     //静态方法
36     public static void say() {
37         System.out.println("学生说话了");
38     }
39 
40     //非静态方法
41     public void joke() {
42         System.out.println("学生爱开玩笑");
43     }
44 }

3. 形参和实参：实际参数(具体的值)和形式参数(它只是一个名字)的类型要对应！

 1 package com.oop.demo01;
 2 
 3 public class Demo03 {
 4 
 5     public static void main(String[] args) {
 6 
 7         //实际参数(具体的值)和形式参数(它只是一个名字)的类型要对应！
 8         Demo03 demo03 = new Demo03();
 9         int add = demo03.add(1, 2);
10         System.out.println(add);
11 
12         int i = Demo03.subtractExact(1, 2);
13         System.out.println(Demo03.subtractExact(1, 2));
14 
15     }
16 
17     public int add(int a, int b) {
18         return a + b;
19     }
20 
21     public static int subtractExact(int a, int b) {
22         return a - b;
23     }
24 }

4. 值传递和引用传递：

 1 package com.oop.demo01;
 2 
 3 //值传递
 4 public class Demo04 {
 5     public static void main(String[] args) {
 6 
 7         int a = 1;
 8         System.out.println(a);//1
 9 
10         Demo04.change(a);
11 
12         System.out.println(a);//1
13     }
14 
15     //返回值为空
16     public static void change(int a) {
17         a = 10;
18     }
19 }

 1 package com.oop.demo01;
 2 
 3 //引用传递：传递一个对象，本质还是值传递
 4 public class Demo05 {
 5     public static void main(String[] args) {
 6         Person person = new Person();
 7 
 8         System.out.println(person.name);//null
 9 
10         Demo05.change(person);
11 
12         System.out.println(person.name);//雷伟
13     }
14 
15     public static void change(Person person) {
16         person.name = "雷伟";
17     }
18 }
19 
20 //一个类只能有一个public class，可以有多个class
21 //定义了一个Person类;有一个属性:name
22 
23 class Person {
24     String name;//null
25 }

5. this关键字：以后说