面向对象——方法的调用

面向对象——方法的调用

方法的调用包括：

• 静态方法
• 非静态方法
• 形参和实参
• 值传递和引用传递
• this关键词（在继承中学习）

package（包）com.du.OOP：类Demo02（方法的调用）

package com.du.OOP;

//方法的调用
public class Demo02 {
    public static void main(String[] args) {

        //static 静态方法可以直接使用:类名.方法 进行方法调用
        //如下：
        Student.say();//可以成功调用

        //非静态方法的调用：
        //先实例化这个类（使用关键词）：new
        //可以这样写直接进行调用：
        new Student().study();//可以成功调用

        //也可以这样写：对象类型  对象名 = 对象值；
        Student student = new Student();
        student.study();//可以成功调用

    }

    //假设有方法a()和方法b()
    public void a(){
        b();//当方法a()和方法b()都是非静态方法时方法a()中可以成功调用方法b()
    }
    public void b(){

    }

    //假设有静态方法a()和静态方法b()
    public static void a(){
        b();//当方法a()和方法b()都是静态方法时方法a()中可以成功调用方法b()
    }
    public static void b(){

    }

    //假设有静态方法a()和非静态静态方法b()
    public static void a(){
        b();//当方法a()是静态方法，方法b()是非静态方法时方法a()中无法调用方法b()
    }
    public void b(){

    }

    //假设有非静态方法a()和静态静态方法b()
    public void a(){
        b();//当方法a()是非静态方法，方法b()是静态方法时方法a()中可以成功调用方法b()
    }
    public static void b(){

    }
    /*出现此现象的原因：static静态方法加载的时间线很早，是和类一起加载的
    * 而非静态方法加载的时间线晚一些，是在类实例化之后才加载的
    * 所以当a()是静态方法时无法调用不是非静态方法的b()，相当于调用b()时b()还没加载，不存在此方法
    * */
}

package（包）com.du.OOP：类Student（方法的调用）

package com.du.OOP;

//同个包下创建一个类 ： 学生
public class Student {

    //定义一个静态方法
    public static void say() {
        System.out.println("学生在说话！");
    }

    //定义一个非静态方法
    public void study () {
        System.out.println("学生在学习！");
    }
}

package（包）com.du.OOP：类Demo03（形参和实参）

package com.du.OOP;

//形参和实参
public class Demo03 {
    public static void main(String[] args) {
        Demo03 demo03 = new Demo03();
        demo03.add(1,2);//此时1和2是实参
    }
    public int add(int a,int b){//此时a和b是形参
        return a+b;
    }
}

package（包）com.du.OOP：类Demo04（值传递）

package com.du.OOP;

//值传递
public class Demo04 {
    public static void main(String[] args) {
        int a = 1;
        System.out.println(a);//打印结果为1

        Demo04 demo04 = new Demo04();
        demo04.change(a);
        System.out.println(a);//此时结果还是1，因为cahnge()中a是形式参数

    }
    //返回值为空
    public void change(int a){
        a = 10;
    }
}

package（包）com.du.OOP：类Demo05 类Person（引用传递）

package com.du.OOP;

//引用传递：传递对象，本质也是值传递
public class Demo05 {
    public static void main(String[] args) {
        //实例化一个Person类
        Person person = new Person();
        System.out.println(person.name);//现在打印出来是null

        Demo05 demo05 = new Demo05();
        demo05.change(person);
        System.out.println(person.name);//现在打印出来的是张三
        /*
            分析：此时cahnge()方法中更改的是person.name，也就是Person类中的name，就是引用传递
         */
    }
    public void change(Person person){
        //person是一个对象，指向的--->Person person = new Person();这是一个具体的人，可以改变属性
        person.name = "张三";
    }
}
//定义了一个Person类，有一个属性:name
class Person{
    String name;
}