JAVA之面向对象

数组几种情况的内存图

1、一个数组的内存图

2、两个数组的内存图

3、两个引用指向同一个数组的内存图

一、什么是面向对象？

面向过程：当需要实现一个功能的时候，每一个具体的步骤都需要亲力亲为，详细处理每一个细节。
面向过程：当需要实现一个功能的时候，不关心具体的步骤，而是找一个已经具有该功能的人来帮我做事。简单来说就是“偷懒”，功能已经有了找一个人帮我们做事。

举例：
洗衣服：

• 面向过程：把衣服脱下来–>找个盆–>放点洗衣粉–>加点水–>浸泡十分钟–>揉一揉–>清洗衣服–>拧干–>晾起来
• 面向过程：把衣服脱下来–>打开洗衣机->扔衣服–>按钮–>晾起来

区别：

• 面向过程：强调步骤
• 面向对象：强调对象，三大特点 【封装性，继承性，多态性】

面向过程如下：

//要求打印出数组，格式为：[arr1,arr2,arr3]
        int[] array = { 10, 20, 30, 40, 50 };
        System.out.print("[");
        for (int i = 0; i < array.length; i++) {
            if (i == array.length - 1) {
                System.out.println(array[i] + "]");
            }else {
                System.out.print(array[i] + ",");
            }
        }

面向对象如下：

System.out.println(Arrays.toString(array));

面向对象就是找一个JDK给我们提供的Arrays类，其中有一个toString类，直接就能把数组变成想要的格式的字符串。

二、成员变量和成员方法

1、成员变量和成员方法的定义

package test;


/**
 * 注意事项：
 * 1、成员变量直接定义在类当中，在方法外边
 * 2、成员方法不要写 static 关键字
 */

public class Student {
    //成员变量
    String name;
    int age;
    //成员方法
    public void eat() {
        System.out.println("吃饭饭！");
    }

    public void sleep() {
        System.out.println("睡觉觉！");
    }

    public void study() {
        System.out.println("学习！");
    }
}

2、成员变量和成员方法的调用

package test;
/**1、导包：也就是需要使用的类在什么位置
 * 格式：import 包名称.类名称
 * 对于和当前类在一个包的情况下，可以省略包不写
 *
 * 2、通常情况下，一个类不能直接使用，需要创建一个对象
 * 格式：类名称 对象名 = new 类名称()
 *
 * 3、使用，分为两种情况：
 * 使用成员变量：对象名.成员变量名
 * 使用成员方法：对象名.成员方法名(参数)
 * 也就是说想要使用谁，就【对象名.谁】
 *
 * 注意事项：
 * 如果成员变量没有进行赋值，那么会有一个默认值，规则和数组一样
 * 整型   默认值为 0
 * 浮点型  默认值为 0.0
 * 字符型  默认值为 '\n0000'
 * 引用型  默认值为 null
 */


public class Student01 {
    public static void main(String[] args) {
        //1、导包

        //2、创建一个对象名为 stu 对象
        Student stu = new Student();

        //3、使用成员变量，并赋值
        stu.name = "123";
        stu.age = 20;
        System.out.println("姓名为：" + stu.name);
        System.out.println("年龄为：" + stu.age);

        //4、使用成员方法
        stu.eat();
        stu.sleep();
        stu.study();
    }

}

栈（Stack）：运行的方法必须进栈（先进后出）
堆（Heap）：只要是 new 实例化的东西全保存在堆内存中
方法区（Method Area）：保存的是 .class

①、一个对象的内存图如下：

②、两个对象的内存图如下：

③、两个引用指向了同一个对象内存图如下：

④、使用对象类型作为方法的参数内存图如下：

⑤、使用对象类型作为方法的返回值内存图如下：

3、成员变量和局部变量的区别

①、定义的位置不同【重点】
局部变量：在方法的内部定义
成员变量：在方法的外部，直接写在类当中
②、作用范围不一样【重点】
局部变量：只有方法当中才可以使用，出了方法体就不能使用
成员变量：可以在这个类的任何位置使用
③、默认值不一样【重点】
局部变量：没有默认值，如果想使用，必须手动进行赋值
成员变量：如果没有赋值，会有默认值，规则和数组一样
④、内存的位置不一样【了解】
局部变量：位于栈内存当中
成员变量：位于堆内存当中
⑤、生命周期不一样【了解】
局部变量：随着方法进栈而诞生，出栈而消失
成员变量：随着对象创建二诞生，对象被垃圾回收而消失

三、封装性

面向对象的三大特征：封装、继承、多态

封装性在Java中的调体现：
①、方法就是一种封装
②、关键字 private 也是一种封装

1、封装就是把一些细节信息隐藏起来，对于外界不可见。

成员方法的定义：

package test;
/**
 * 问题定义：定义 person 的年龄时，限制年龄必须大于0
 * 解决方法：用 private 关键字将需要保护的成员变量修饰
 *
 * 一旦使用 private 进行修饰之后，name本类当中仍然可以随意访问
 *
 * 间接访问 private 成员变量，就是定义一对 Getter/Setter 方法。对于Getter来说，不能有参数，返回类型必须和成员变量对应。对于Setter来说，不能有返回值，参数类型和成员变量对应。
 */

public class Method {
    //定义成员变量
    String name;
    private int age;

    //定义成员方法
    public void show() {
        System.out.println("我叫：" + name + "，年龄：" + age);
    }

    //一旦被private修饰，必须使用 Setter/Getter 方法
    public void setAge(int num) {
        if (num > 100 || num < 0) {
            System.out.println("输入的年龄不合法！！");
        } else {
            age = num;
        }
    }

    public int getAge() {
        return age;
    }
}

成员方法的调用：

package test;

public class Method01 {

    public static void main(String[] args) {
        //实例化
        Method person = new Method();

        person.show();

        //给成员变量赋值
        person.name = "仓央";
        person.setAge(120);

        person.show();

    }
}

特例：对于基本类型中的 boolean 值，Getter方法一定要写成isXxx的形式，二setXxx不用变。

2、this关键字（在重名的情况下起到区别的作用）
当方法的局部变量和类的成员重名的时候，根据“ 就近原则 ”，有限使用局部变量。如果需要访问本类当中的成员变量，需要使用格式：this.成员变量名“通过谁调用的方法，谁就是this”

3、构造方法
构造方法就是专门用来创建对象的方法。格式：
public 类名称(参数类型 参数名称){
方法体
}

注意事项：
①、构造方法的名称必须和所在的类名称完全一样，就连大小写也要一样
②、构造方法不要写返回类型，连 void 也不要写
③、构造方法不能 return 一个具体的返回值
④、如果没有编写任何构造方法，那么编译器就会默认创建一个空的构造方法
⑤、一旦编写了至少一个构造方法，那么编译器将不再创建
⑥、构造方法可以重载【方法名相同，参数不同】

package test;
/**
 * 1、构造方法的名称必须和类型称一样
 * 2、构造方法不要写返回类型，连 void 也不要写
 * 3、构造方法不能 return 一个具体的返回值
 * 4、如果没有编写任何构造方法，那么编译器就会默认创建一个空的构造方法
 * 5、一旦编写了至少一个构造方法，那么编译器将不再创建
 * 6、构造方法可以重载【方法名相同，参数不同】
 */

public class StructureMethod {

    private String name;
    private int age;

    //定义一个无参构造方法
    public StructureMethod () {
        System.out.println("无参构造方法的执行");
    }

    //定义一个全参构造方法
    public StructureMethod (String name, int age) {
        System.out.println("全参构造方法的执行");
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}