Java学习笔记-基础day-5-面向对象入门（类和对象）

1、类和对象

//需求:打印数组中所有的元素,打印格式为: [元素1，元素2，元素3，元素，...，元素n]

public class Test {
    public static void main(String[] args) {
        /*
            面向过程编程思想
                - 强调的是过程,必须清楚每一个步骤,然后按照步骤一步一步去实现

            面向对象编程思想
                - 强调的是对象, 通过调用对象的行为来实现功能，而不是自己一步一步的去操作实现。
                - 相当于找对应行业的人做对应的事情，而不是自己一步一步去做。
         */
        // 需求:打印数组中所有的元素,打印格式为: [元素1，元素2，元素3，元素，...，元素n]
        
        // 1 定义一个数组,并且初始化数组中的元素
        int[] arr = {10, 20, 30, 40, 50};

        // 面向过程:
        // 2.循环遍历数组
        for (int i = 0; i < arr.length; i++) {
            // 3.在循环中,获取遍历出来的元素
            int e = arr[i];
            // 4.判断该元素:
            if (i == 0) {
                // 4.1 如果该元素是第一个元素,打印格式: [ + 元素 + 逗号空格  不换行
                System.out.print("[" + e + ", ");
            } else if (i == arr.length - 1) {
                // 4.2 如果该元素是最后一个元素,打印格式: 元素 + ]
                System.out.println(e + "]");
            } else {
                // 4.3 如果该元素是中间元素,打印格式为: 元素 + 逗号空格   不换行
                System.out.print(e + ", ");
            }
        }

        System.out.println("==================================");

        // 面向对象:
        // jdk的api中有一个Arrays类toString()方法,可以帮助我们按照这种格式打印数组中的所有元素
        System.out.println(Arrays.toString(arr));
    }
}

小结

• 面向过程:是一种编程思想
• 面向对象:是一种编程思想
• 区别:
  • 面向过程:注重的是过程,必须清楚每一个步骤,按照步骤一步一步去实现
  • 面向对象:注重的是对象,无须清楚每一个步骤,只需要使用对象调用行为来完成需求

2、 类的定义

复习类的组成

类的组成是由属性和行为两部分组成

• 属性：该类事物的状态信息,在类中通过成员变量来体现（类中方法外的变量）
• 行为：该类事物有什么功能,在类中通过成员方法来体现（和前面的方法相比去掉static关键字即可）

类的定义步骤

• 定义类
• 编写类的成员变量
• 编写类的成员方法

类的定义格式

public class 类名 {// 定义一个类
	// 类里面:属性(成员变量),行为(成员方法)
    // 定义成员变量
    数据类型 变量名1;
    数据类型 变量名2;
    ...
        
    // 定义成员方法
    方法;  去掉static
}

3、对象的创建和使用

	创建对象的格式:
        类名 对象名 = new 类名();
    使用对象:
        访问类的成员变量:
                获取成员变量的值: 对象名.成员变量名
                给成员变量赋值:   对象名.成员变量名 = 值;

        访问类的成员方法:
            成员方法无返回值:  对象名.成员方法(实参);
            成员方法有返回值:
                             对象名.成员方法(实参);  直接调用
                             数据类型 变量名 = 对象名.成员方法(实参); 赋值调用
                             System.out.println(对象名.成员方法(实参));输出调用

4、单个对象内存图

public class Student {
    // 成员变量: 属性
    /**
     * 姓名
     */
    String name;
    /**
     * 年龄
     */
    int age;

    // 成员方法: 行为
    /**
     * 学习的功能
     */
    public void study(){
        System.out.println("学生正在学习Java...");
    }

    /**
     * 做作业的功能
     */
    public void doHomeWork(){
        System.out.println("学生正在做作业敲代码...");
    }
}

public class Test {
    public static void main(String[] args) {
        // 创建Student对象
        Student stu = new Student();
        System.out.println(stu);// 十六进制数地址值

        // 访问成员变量
        stu.name = "冰冰";
        stu.age = 18;
        System.out.println(stu.name+","+stu.age);

        // 访问成员方法
        stu.study();
        stu.doHomeWork();
    }
}

小结

• 只要创建对象,就会在堆区开辟一块空间(凡是new就会在堆区开辟一块新的空间)
• 只要调用方法,就会在栈区开辟一块空间,用来执行该方法

4、 多个对象内存图

程序案例

public class Student {
    // 成员变量: 属性
    /**
     * 姓名
     */
    String name;
    /**
     * 年龄
     */
    int age;

    // 成员方法: 行为
    /**
     * 学习的功能
     */
    public void study(){
        System.out.println("学生正在学习Java...");
    }

    /**
     * 做作业的功能
     */
    public void doHomeWork(){
        System.out.println("学生正在做作业敲代码...");
    }
}

public class Test {
    public static void main(String[] args) {
        // 创建Student对象  shift+f6+fn 批量修改名称
        Student stu1 = new Student();
        System.out.println(stu1);// 十六进制数地址值

        // 访问成员变量
        stu1.name = "张三";
        stu1.age = 18;
        System.out.println(stu1.name+","+stu1.age);// 冰冰,18

        // 访问成员方法
        stu1.study();
        
        System.out.println("==========================");

        Student stu2 = new Student();
		stu2.name = "李四";
        stu2.age = 19;
        System.out.println(stu2.name+","+stu2.age);// 李四,19
        stu2.study();
    }
}

小结

• 多个对象在堆内存中，都有不同的内存划分，成员变量存储在各自对象的内存区域中，成员方法多个对象共用的一份
• 凡是new就会重新在堆区开辟一块新空间
• 对象和对象之间的关系是相互独立的

5、多个变量指向相同对象内存图

查看程序案例

public class Student {
    // 成员变量: 属性
    /**
     * 姓名
     */
    String name;
    /**
     * 年龄
     */
    int age;

    // 成员方法: 行为
    /**
     * 学习的功能
     */
    public void study(){
        System.out.println("学生正在学习Java...");
    }

    /**
     * 做作业的功能
     */
    public void doHomeWork(){
        System.out.println("学生正在做作业敲代码...");
    }
}
public class Test {
    public static void main(String[] args) {
        // 创建Student对象
        Student stu1 = new Student();

        // 访问学生对象的成员变量
        stu1.name = "张三";
        stu1.age = 18;
        System.out.println(stu1.name + "," + stu1.age);// 张三,18

        // 访问学生对象的成员方法
        stu1.study();

        System.out.println("============================");
        // 定义一个Student类型的变量,并把之前创建的学生对象赋值给该变量
        Student stu2 = stu1;
		stu2.name = "李四";
        stu2.age = 19;
        // 再使用新的变量访问成员变量
        System.out.println(stu2.name + "," + stu2.age);// 李四,19
        // 再使用新的变量访问成员方法
        stu2.study();
    }
}

小结

• 当多个对象的引用指向同一个内存空间（变量所记录的地址值是一样的）
• 只要有任何一个对象修改了内存中的数据，随后，无论使用哪一个对象进行数据获取，都是修改后的数据。
• 引用类型传递的是地址值

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

• 类中位置不同：成员变量（类中方法外）局部变量（方法内部或方法声明上）
• 内存中位置不同：成员变量（堆内存）局部变量（栈内存）
• 生命周期不同：成员变量（随着对象的存在而存在，随着对象的消失而消失）局部变量（随着方法的调用而存在，随着方法的调用完毕而消失）
• 初始化值不同：成员变量（有默认初始化值）局部变量（没有默认初始化值，必须先定义，赋值才能使用）

public class Car {
    String color;// 成员变量

    // 成员方法
    public void drive(){
        int speed = 80; // 局部变量
        System.out.println("汽车正在以"+speed+"速度行驶");
    }
}

public class Test {
    public static void main(String[] args) {
         // 创建Car对象
        Car car = new Car();
        // 调用方法
        car.drive();
    }
}