JavaDay05-面向对象基础：方法、值传递与引用传递、构造器、内存分析

方法

修饰符 返回值类型 方法名（形参类型 参数名）{
方法体
return 返回值；
}

• 方法-需要注意的点：
  1、修饰符
  2、返回类型
  3、变量名
  4、参数
  5、抛出异常
  6、return

• 静态方法与非静态方法
  1、静态方法-由static修饰，不需要实例化 可由类名直接调用；
  2、非静态方法-需要实例化生成对象后才能调用；
  3、静态方法之间、非静态方法之间可以相互调用、非静态方法可以调用静态方法（因为静态方法存在的早，随着类产生）。

public class MethodDemo01 {
    public static void main(String[] args) {
        //真正程序开发的时候只有一个主方法，并不会有这么多
        //静态方法-由static修饰，不需要实例化 可由类名直接调用
        MethodDemo01.student();//可以直接调用，不会报错
        //非静态方法-需要实例化生成对象后才能调用
        MethodDemo01 methodDemo01 = new MethodDemo01();
        methodDemo01.teacher();//必须先写上面那一句生成对象后才能调用
    }
    //静态方法-随着类生成，类存在以后此方法就存在
    public static void student(){
        System.out.println("上课");
        students();//可以调用下面的静态方法
        //不可以调用teacher()和teachers();
    }
    public static void students(){
        System.out.println("开运动会");
    }
    //非静态方法-随着对象生成，类实例化以后才会生成此方法
    public void teacher(){
        System.out.println("讲课");
    }
    //方法直接互相调用-静态方法之间、非静态方法之间可以相互调用、非静态方法可以调用静态方法（因为静态方法存在的早）
    public void teachers(){
        System.out.println("开会");
        teacher();//可以调用上面的非静态方法
        student();//可以调用上面的静态方法
    }
}

值传递与引用传递

1、值传递是指在调用函数时将实际参数复制一份传递到函数中，这样在函数中如果对参数进行修改，将不会影响到实际参数。
2、引用传递是指在调用函数时将实际参数的地址传递到函数中，那么在函数中对参数所进行的修改，将影响到实际参数。

public class MethodDemo02 {
    public static void main(String[] args) {
        //java是值传递 引用传递
        //值传递是指在调用函数时将实际参数复制一份传递到函数中，这样在函数中如果对参数进行修改，将不会影响到实际参数。
        //引用传递是指在调用函数时将实际参数的地址传递到函数中，那么在函数中对参数所进行的修改，将影响到实际参数。
        int a=10;
        //这里是值传递
        MethodDemo02.change(a);
        System.out.println(a);//输出结果为10
        Person person = new Person();
        //这里是引用传递，改变的是对象的属性，不是类的属性
        MethodDemo02.change(person);
        System.out.println(person.name);//输出结果为XY

    }
    public static int change(int a){
        a = 1;
        return a;
    }
    public static void change(Person person){
        person.name="XY";
    }
}
//可以有多个class，但只能有一个public class
class Person{
    String name;//属性
}

-Java是值传递，无论是参数值还是对象的地址，都是复制一份传递给变量。

public class MethodDemo03 {
    //Java值传递-赋值实参地址
    public static void main(String[] args) {
        Student t1 = new Student("张三", 18);
        Student t2 = new Student("李四", 19);
        swap(t1, t2);
        System.out.println(t1);
        System.out.println(t2);
    }

    private static void swap(Student t1, Student t2) {
        Student t = t1;
        t1=t2;
        t2=t;
        System.out.println("t1:"+t1);
        System.out.println("t2:"+t2);
    }
}
class Student {
    String name;
    int age;
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
    @Override
    public String toString() {
        return "Test{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

构造器：

1、方法名==类名
2、没有返回值
3、无参和有参 两种
4、无参构造器随类产生,不显式定义也默认存在
5、定义了有参构造后如果想使用无参构造，需要显式定义一个无参构造
6、构造器的作用：初始化对象的值
7、new一个方法时，本质就是在调用构造器
8、this. 指的是此类的属性

public class Room {
    //构造器：一个类中必须有一个构造器，构造器的名字和类名相同，没有返回值类型
    //alt+insert 快速生成构造器
    int windows;
    String name;
    //无参构造器
    public Room() {
    }
    //有参构造器
    public Room(int windows, String name) {
        this.windows = windows;
        this.name = name;
    }
}

创建对象内存分析

1、栈：存放main方法、局部变量
2、堆：存放对象、对象的属性和方法
3、方法区（属于堆）：存放需要加载的类的代码、常量池字符串、由static修饰的变量和方法存放在静态方法区。

public class Application {
    public static void main(String[] args) {
        Pet dog = new Pet();
        dog.name="pipi";
        dog.age=3;
        dog.shout();
        Pet cat = new Pet();
        cat.name="huahua";
        cat.age=2;
        cat.shout();
        /*
        <创建对象内存分析>
        点击运行Application.java以后：
        1、加载Application类，存放在堆中的方法区，同时存放了常量字符串；
        2、main方法入栈（出栈时程序运行结束）
        3、加载Pet类，存放在堆中的方法区，同时存放了类中的属性和方法；
        4、变量dog入栈，dog的值为Pet对象dog的地址；
        5、生成Pet对象dog，存放在堆中（非方法区），由变量dog指向。同时存放了对象的属性和方法；
        6、变量cat入栈，cat的值为Pet对象cat的地址；
        5、生成Pet对象cat，存放在堆中（非方法区），由变量cat指向。同时存放了对象的属性和方法；
         */
    }
}