java面向对象.day17（回顾方法及加深）

方法的定义

1. 修饰符

2. 返回类型

3. break和return的区别

   1. break：跳出switch，结束循环

   2. return：结束方法，代表方法结束

4. 方法名：注意规范，见名知意

5. 参数列表：方法名后面的（）内，写法为（参数类型 参数名）例如public int max(int a,int b)

6. 异常抛出

代码示例：

// Demoe1是-类
public class Demoe1 {
    // main是-方法，一个类里面只有一个mian方法
    public static void main(string[] args) {
    
    }
    
    /*方法的定义
    修饰符     返回值类型   方法名(形式参数){
        方法体
        return返回值;
    }
    */
    public string sayHello(){
        return "hello,wor1d" ;
    }
    
    //当返回值类型为void时，不用返回-return，当然也可以使用return但必须写为"return;",这样是返回空的意思
      public void sayHello(){
        return;
    }
    
    public int max(int a,int b){
        return a>b ? a : b; //三元运算符!，如果a>b输出a否则输出b
    }
    
    //异常抛出示例
    public void readFile(string file) throws IOException{
        
    }
​
}
​

方法的调用

1. 静态方法(有修饰符--static)

2. 非静态方法(没有修饰符--static)

3. 形参和实参（调用方法时实参类型要和调用方法的形参类型一样）

4. 值传递和引用传递

5. this关键字（代表当前这个东西）

   静态方法调用（两个java文件都在不同类里面）

//被调用的方法
public class Student {
    //非静态方法
    public static void say(){
        System.out.print1n("学生信息");
    }
}
​

//要调用方法的类
public class Demoe2 {
    public static void main(String[] args) {
        //类名.方法名
        Student.say();
    }
}

非静态方法（两个java文件都在不同类里面）

//被调用的方法
public class Student {
    //非静态方法 没有修饰符--static
    public void say(){
        System.out.print1n("学生信息");
    }
}
​

//要调用方法的类
public class Demoe2 {
    public static void main(String[] args) {
        //对象类型对象名=对象值;
        Student student = new student();//实例化这个类new
        student.say();
        //调用Student类里面的say方法
}

非静态方法和静态方法的扩充

public class Demoe2 {
    
    //有static时，该方法a与类同时加载
    public static void a(){
        new Demoe2.b();//因为b不是静态方法所以需要实例化才能使用
    }
    //没有static时，需要实例化才能调用方法b
    public void b(){
        
    }
}

形参和实参

public class Demo03 {
    public static void main(String[] args) {
        //这里的1,2是实际参数
        int add = Demoe3.add(1,2);
        System.out.println(add);
    }
        //这里的int a,int b是形式参数
    public static int add(int a,int b){
        return a+b;
    }
}

值传递和引用传递

1. 值传递

在Java中，基本数据类型（如int、double、char等）是按值传递的，而不是按引用传递。这意味着当你将一个基本数据类型的值作为参数传递给一个方法时，实际上传递的是该值的一个副本，而不是原始值本身。因此，在方法内部对参数所做的任何修改都不会影响到原始变量

//值传递
public class Demoe4 {
    public static void main(String[] args) {
        int a = 1;
        System.out.println(a); // 输出 1
        Demoe4.change(a); // 调用 change 方法，但 a 的值不会改变
        System.out.println(a); // 输出 1，因为 a 的值没有被 change 方法改变
    }
​
    public static void change(int a) {
        a = 10; // 这里修改的是参数 a 的副本，而不是 main 方法中的变量 a
    }
}

当你调用 Demoe4.change(a) 时，你实际上是传递了变量 a 的一个副本给 change 方法。在 change 方法内部，你将这个副本的值修改为10，但这并不会影响到 main 方法中的变量 a。因此，当 change 方法执行完毕后，main 方法中的变量 a 依然保持其原始值1。

如果你想要改变 main 方法中变量 a 的值，你需要使用引用类型（如对象）来封装这个值，并通过修改这个对象的状态来改变值。或者，你可以使用数组或者包装类（如 Integer）来实现这一点，因为数组和对象是按引用传递的。

例如，使用 Integer 包装类：

public class Demoe4 {
    public static void main(String[] args) {
        Integer a = 1; // 使用 Integer 包装类
        System.out.println(a); // 输出 1
        Demoe4.change(a); // 调用 change 方法，这次 a 的值会被改变
        System.out.println(a); // 输出 10，因为 a 的值被 change 方法改变了
    }
​
    public static void change(Integer a) {
        a = 10; // 这里修改的是引用指向的对象的状态
    }
}

在这个修改后的例子中，change 方法接收的是一个 Integer 对象的引用，而不是一个基本数据类型的副本。因此，当我们在 change 方法内部修改 a 指向的 Integer 对象时，main 方法中的 a 也会看到这种变化，因为 a 和 change 方法中的参数 a 指向的是同一个对象。

1. 引用传递

//引用传递:对象，本质还是值传递
public class Demoo5 {
    public static void main(string[]args) {
        //Perosn实列化
        Perosn perosn = new Perosn();
        //查看Perosn里面的name
        system.out.println(perosn.name); //输出null
        //调用change方法给Perosn里面的name设置为赵曦
        Demoe5.change(perosn);
        //查看Perosn里面的name
        system.out.println(perosn.name);//输出赵曦
    }
    public static void change(Perosn perosn){
        //perosn是一个对象指向Perosn perosn = new Perosn();
        perosn.name ="赵曦";
    }
}
//定义了一个Perosn类，有一个属性: name
//一个java类里面，可以有多个class但只有一个public class
    class Perosn{
        String name; //null
    }