009——面向对象基础

「已注销」

已于 2022-09-25 14:30:56 修改

阅读量126

点赞数

分类专栏： JavaSE 文章标签： java

于 2022-09-24 14:08:15 首次发布

本文链接：https://blog.csdn.net/qq_60740014/article/details/127024581

版权

JavaSE 专栏收录该内容

37 篇文章 1 订阅

订阅专栏

这目录

面向对象编程基础

面向对象编程基础

概述

面向：找、拿。
对象：东西。
面向对象编程：找或拿东西过来编程。

设计对象并使用

设计类，创建对象并使用

类(设计图)：是对象共同特征的描述；
对象：是真实存在的具体实例。
结论：在Java中，必须先设计类，才能创建对象并使用

如何设计类

如何创建对象

格式：

类名 对象名 = new 类名();

拿到对象后怎么访问对象的信息？

对象.成员变量；

对象.成员方法(…)

代码演示

package com.google.createobject;

/**
 * @author North
 * @date 2022/9/19 14:59
 */
public class Car {
    /**
     * 成员变量
     */

    String name;
    double price;

    /**
     * 成员方法
     */
    public void start() {
        System.out.println(name + "启动了……");
    }

    public void run() {
        System.out.println("价格是：" + price + " 的 " +name + "跑的很快");
    }


}

package com.google.createobject;

/**
 * @author North
 * @date 2022/9/19 15:00
 */
public class Test01 {
    public static void main(String[] args) {
        // 目标：学会设计对象并使用

        /**
         * 创建对象 ，并调用
         */

        Car car_1 = new Car();

        car_1.name = "宝马";
        car_1.price = 38.8;
        System.out.println(car_1.name);
        System.out.println(car_1.price);
        car_1.start();
        car_1.run();

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

        // 再次创建对象 ，并调用
        Car car_2 = new Car();
        car_2.name = "奔驰";
        car_2.price = 39.8;
        System.out.println(car_2.name);
        System.out.println(car_2.price);
        car_2.start();
        car_2.run();
    }
}

定义类的补充注意事项

成员变量的默认值规则

对象在内存中的运行机制

多个对象的内存图

对象到底是放在哪个位置的？

堆内存中

Car c = new Car(); c变量名中存储的是什么？

存储的是对象在堆内存中的地址。

成员变量（name、price）的数据放在哪里，存在于哪个位置？

对象中，存在于堆内存中。

两个变量指向同一个对象内存图

代码演示：

package com.google.memory;

/**
 * @author North
 * @date 2022/9/19 21:35
 */
public class Test {
    public static void main(String[] args) {
        /**
         * 目标 ： 理解两个变量指向同一个对象的内存运行机制
         */
        Student stu_1 = new Student();
        stu_1.name = "Tom";
        stu_1.sex = '男';
        stu_1.hobby = "唱 ， 跳 ， rap ， 篮球";
        stu_1.study();

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

        Student stu_2 = stu_1;
        stu_2.hobby = "说唱";
        stu_2.study();

    }
}

package com.google.memory;

/**
 * @author North
 * @date 2022/9/19 21:36
 */
public class Student {

    String name;
    char sex;
    String hobby;

    public void study() {
        System.out.println("姓名：" + name + ", 性别" + sex + " , 爱好：" + hobby + " 的学生，开始学习");
    }

}

垃圾回收

注意：当堆内存中的对象，没有被任何变量引用（指向）时，就会被判定为内存中的**“垃圾”。**

构造器

学习构造器的目的

构造器的作用

初始化类的对象，并返回对象的地址。

构造器有几种，各自的作用是什么？

无参数构造器：初始化对象时，成员变量的数据均采用默认值。
有参数构造器：在初始化对象的时候，同时可以接收参数为对象进行赋值。

构造器有哪些注意事项？

任何类定义出来，默认就自带了无参数构造器，写不写都有。
一旦定义了有参数构造器，无参数构造器就没有了，此时就需要自己写无参数构造器了。

代码演示

package com.google.constructor;

/**
 * @author North
 * @date 2022/9/21 14:48
 */
public class Car {
    String name;
    double price;

    public Car() {
        System.out.println("无参构造器被调用了");
    }


    public Car(String n , double p) {
        System.out.println("有参构造器被调用了");
        name = n;
        price = p;
    }
}

package com.google.constructor;

/**
 * @author North
 * @date 2022/9/21 14:41
 */
public class Test {
    public static void main(String[] args) {
        /**
         * 目标 ： 认识构造器 ， 明白两种类型的构造器的作用
         */

        // 调用无参构造器
        Car car = new Car();
        car.name = "奥迪";
        car.price = 39.9;

        System.out.println(car.name);
        System.out.println(car.price);
        System.out.println("---------------------------------------------");


        // 调用有参构造器
        Car car_1 = new Car("奔驰"  , 49.9);
        System.out.println(car_1.name);
        System.out.println(car_1.price);


    }
}

this关键字

this关键字是什么

可以出现在构造器、方法中
代表当前对象的地址。

缺少this时
在这里插入图片描述
含有this时

this关键字代码演示

测试类

package com.google.thisdemo;

/**
 * @author North
 * @date 2022/9/21 15:12
 */
public class Test {
    public static void main(String[] args) {
        /**
         *  目标：理解this关键字的作用
         */

        // 创建对象
        Car car = new Car();

        car.run();

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

        Car car1 = new Car("奔驰" , 39.9);
        System.out.println(car1.name);
        System.out.println(car1.price);

        car1.game("宝马"  , 39.9);
    }
}

package com.google.thisdemo;

/**
 * @author North
 * @date 2022/9/21 15:16
 */
public class Car {

    String name;
    double price;


    public Car() {
        System.out.println("无参构造中的this : " + this);
    }

    // 有参构造
    public Car(String name , double price) {
        this.name = name;
        this.price = price;
    }

    public void run() {
        System.out.println("方法中的this: " + this);
    }

    public void game(String name , double price) {
        System.out.println(name + "和" +  this.name + "正在比赛");
    }
}

this关键字的作用

可以用于指定访问当前对象的成员变量、成员方法。

this关键字在构造器中、成员方法中可以做什么?

可以用于指定访问当前对象的成员。

封装

面向对象的三大特征：封装，继承，多态。
封装：告诉我们，如何正确设计对象的属性和方法。

封装的原则

封装的原则：对象代表什么，就得封装对应的数据，并提供数据对应的行为。

我对面向对象封装的理解

就拿人关门举例：
- 人关门，是人关的吗？哈哈哈哈，这还用问？肯定是人关的啦， No No No 事实并非如此，在面向对象的世界中，是这个门自己关的，只不过是门把这个关门的这个动作进行封装成一个方法供你调用

理解封装思想有啥好处？

让编程变得很简单，有什么事，找对象，调方法就行。
降低我们的学习成本，可以少学、少记，或者说压根不用学，
不用记对象的那么多方法，有需要时去找就行。

如何进行更好的封装

**一般会把成员变量使用****private隐藏起来，对外就不能直接访问了。
提供public修饰的getter和setter方法暴露其取值和赋值。

代码演示

学生类

package com.google.encapsulation;

/**
 * @author North
 * @date 2022/9/24 14:24
 */
public class Student {
    // 1. 成员变量 ， 使用private修饰 ， 只能在本类中访问了
    private int age;

    /**
     *  2. 提供成套的getter和setter方式 ， 为其取值和赋值
     */

    public void setAge(int age) {
        if (age > 0 && age < 200) {
            this.age = age;
        } else {
            System.out.println("你输入的年龄数据有误");
        }
    }

    public int getAge() {

        return age;
    }

}

测试类

package com.google.encapsulation;

/**
 * @author North
 * @date 2022/9/24 14:23
 *
 * 目标 ：学习如何进行更好的封装
 */
public class Test01 {
    public static void main(String[] args) {
        Student student = new Student();
        student.setAge(-10);
        System.out.println(student.getAge());
    }
}

标准 JavaBean

JavaBean

也可以称为实体类，其对象可以用于在程序中封装数据。
如：学生类，汽车类 ……………………

标准JavaBean须满足如下书写要求：

成员变量使用 private 修饰。
提供成员变量对应的 setXxx() /getXxx()方法。
必须提供一个无参构造器；有参数构造器是可写可不写的。

代码演示

package com.google.javabean;

/**
 * @author North
 * @date 2022/9/24 14:55
 */
public class User {
    // 1. 成员变量建议使用private私有
    private String name;
    private double height;
    private double salary;

    /**
     *  3. 提供有参 和 无参构造器
     */
    public User() {

    }

    public User(String name , double height , double salary) {
        this.name = name;
        this.height = height;
        this.salary = salary;
    }

    /**
     *  2. 必须为成员变量提供成套的setter 和 getter 方法
     */

    public String getName() {
        return name;
    }

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

    public double getHeight() {
        return height;
    }

    public void setHeight(double height) {
        this.height = height;
    }

    public double getSalary() {
        return salary;
    }

    public void setSalary(double salary) {
        this.salary = salary;
    }
}

package com.google.javabean;

/**
 * @author North
 * @date 2022/9/24 14:54
 *
 * 目标 ：记住JavaBean的书写要求
 */
public class Test {
    public static void main(String[] args) {
        User user_1 = new User();

        user_1.setName("陈平安");
        user_1.setHeight(178.8);
        user_1.setSalary(8000);

        System.out.println(user_1.getName());
        System.out.println(user_1.getHeight());
        System.out.println(user_1.getSalary());

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

        User user_2 = new User("徐凤年" , 183.8 , 800000);
        System.out.println(user_2.getName());
        System.out.println(user_2.getHeight());
        System.out.println(user_2.getSalary());

    }
}

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

面向对象综合案例

案例代码

package com.google.moviedemo;

/**
 * @author North
 * @date 2022/9/24 15:58
 */
public class Movie {
    private String name;
    private double score;
    private String actor;


    public Movie() {

    }

    // 创建有参构造
    public Movie(String name , double score , String actor) {
        this.name = name;
        this.score = score;
        this.actor = actor;
    }

    public String getName() {
        return name;
    }

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

    public double getScore() {
        return score;
    }

    public void setScore(double score) {
        this.score = score;
    }

    public String getActor() {
        return actor;
    }

    public void setActor(String actor) {
        this.actor = actor;
    }
}

package com.google.moviedemo;

/**
 * @author North
 * @date 2022/9/24 15:43
 *
 * 目标 ： 完成电影信息的展示案例 ， 理解面向对象编程的代码
 */
public class Test {
    public static void main(String[] args) {

        /**
         *  1. 设计电影类
         *  2. 创建3个电影对象 ， 封装电影的信息
         *  3. 定义一个电影类型的数组 ， 存储3部电影对象
         *
         */

        Movie[] movies = new Movie[3];
        movies[0] = new Movie("《长津湖》" , 9.7 , "吴京");
        movies[1] = new Movie("《我和我的父辈》" , 9.6 , "吴京");
        movies[2] = new Movie("《补水少年》" , 9.5 , "王川");

        // 遍历数组
        for (int number = 0 ; number < movies.length ; number++) {
            // 存放数组地址
            Movie movie = movies[number];
            System.out.println("电影名称" + movie.getName());
            System.out.println("电影评分" + movie.getScore());
            System.out.println("电影演员" + movie.getActor());
            System.out.println();
            System.out.println();
            System.out.println("------------------------------");
        }

    }
}