【Java学习笔记】Java面向对象基础

该文章为Java自学笔记面向对象基础部分学习视频为https://www.bilibili.com/video/av250694651

前言1.什么是面向对象？2.设计对象并使用

设计类，创建对象并使用定义类的几个补充注意事项 3.对象内存图

多个对象内存图两个变量指向同一个对象内存图扩展：垃圾回收机制 4.面向对象变成训练：模拟购物车模块5.构造器6.this关键字

this出现在有参数构造器中的用法：this出现在成员方法中的用法: 7.封装8.标准JavaBean9.使用标准JavaBean改造面向对象实例10.补充知识：成员变量、局部变量区别

面向对象介绍：

并不是一个技术，而是一种编程指导思想。把现实世界的具体事物全部看成一个一个的对象来解决问题。

为什么要用面向对象编程：

生活中我们解决问题就是按照对象化的方式进行的。如果程序也能够按照生活的中的方式来解决问题，那么程序就更符合人类的思维习惯，代码看起来会更易理解、更简单。 2.设计对象并使用 设计类，创建对象并使用

在Java中，必须先设计类，才能获得对象。

类(设计图)：是对象共同特征的描述；对象：是真实存在的具体实例。

//如何定义类
public class 类名 {
	1、成员变量（代表属性,一般是名词)
	2、成员方法（代表行为,一般是动词）
	3、构造器 （后面学习）
	4、代码块 （后面学习）
	5、内部类 （后面学习）
}
//实例
public class Car {
    //属性（成员变量）
    String name;
    double price;

    //行为（方法）
    public void start(){
        System.out.println(name + "价格是："+ price+" 启动了~~");
    }
    public void run(){
        System.out.println(name + "价格是："+ price+" 跑得很快~~");
    }
}

public static void main(String[] args) {
        //如何得到类的对象
		类名 对象名 = new 类名();
		//实例
		Car c = new Car();

		//如何使用对象
		访问属性: 对象名.成员变量
		访问行为: 对象名.方法名(…)
		//实例
        c.name = "奔驰GLC";
        c.price = 39.78;
        c.start();
        c.run();
    }

成员变量的完整定义格式是：修饰符 数据类型 变量名称 = 初始化值； 一般无需指定初始化值，存在默认值。类名首字母建议大写，且有意义，满足“驼峰模式”。一个Java文件中可以定义多个class类，且只能一个类是public修饰，而且public修饰的类名必须成为代码文件名。实际开发中建议还是一个文件定义一个class类。 3.对象内存图 多个对象内存图

public class Test {
    public static void main(String[] args) {
        Car c = new Car();
        c.name = "奔驰GLC";
        c.price = 39.78;
        System.out.println(c.name);
        System.out.println(c.price);
        c.start();
        c.run();

        Car c2 = new Car();
        c2.name = "宝马X3";
        c2.price = 38.98;
        System.out.println(c2.name);
        System.out.println(c2.price);
        c2.start();
        c2.run();
    }
}

加载存在main函数的Test类，将Test字节码文件放入方法区，并开始执行main函数。在执行到Car c = new Car();语句等号左边Car c时，首先将Car类的字节码文件读取放入方法区，然后在栈内存中建立了一个对象c。然后执行等号右边new Car()，此时在堆内存中根据Car类创建了一块内存，包括成员变量与成员方法，由于成员变量初始未赋值，因此设定为默认值，因在实际项目中成员方法可能数量很多，所以并未被拷贝进堆内存中占用位置，而是找到了在方法区中的Car字节码文件中的成员方法地址，将这一地址留在了这块内存中用来引用成员方法。将堆内存中创建的这块内存的地址，存入栈内存中的变量c内部。
通过为c.name和c.price赋值，更改堆内存中的值。输出c.name和c.price时，先通过c中存储的地址找到堆内存中的一片内存，进而输出。在访问成员方法时，同理找到这片内存，然后根据成员方法引用地址，找到方法区中的Car字节码文件，进而找到成员方法，将成员方法放到栈中运行。创建下一个变量c2时操作同理，在访问方法时，方法内部调用的成员变量由调用成员方法的变量决定(严格讲是由这一变量存储的地址指向的内存决定)。

注意：

对象放在哪个位置？

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

存储的是对象在堆内存中的地址。 成员变量（name、price）的数据放在哪里，存在于哪个位置？

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

public class Student {
    String name;
    char sex;
    String hobby; // 爱好
    public void study(){
        System.out.println("名称：" + name + "，性别：" + sex + "，爱好：" + hobby + "的学生：开始学习了！");
    }
}

public class Test {
    public static void main(String[] args) {
        Student s1 = new Student();
        s1.name = "小明";
        s1.sex = '男';
        s1.hobby = "游戏、睡觉、听课";
        s1.study();
// 把学生类型的s1变量赋值给学生类型的s2变量
        Student s2 = s1;
        s2.hobby = "爱提问";
        System.out.println(s2.name);
        System.out.println(s2.sex);
        System.out.println(s1.hobby);
        s2.study();
    }
}

主要流程与之前相同，区别在于两个变量存储地址相同，即指向同一个堆内存地址，因此两个变量操作成员变量时操作的是同一片内存。 扩展：垃圾回收机制

垃圾回收：

注意：当堆内存中的类对象或数组对象，没有被任何变量引用（指向）时，就会被判定为内存中的“垃圾”。Java存在自动垃圾回收器，会定期进行清理。

public class ShopCarTest {
    public static void main(String[] args) {
        //1、定义商品类，用于后期创建商品对象
        //2、定义购物车对象，使用一个数组对象表示
        Goods[] shopCar = new Goods[100];
        //3、搭建操作架构
        while (true) {
            System.out.println("请您选择如下命令进行操作");
            System.out.println("添加商品到购物车：add");
            System.out.println("查询购物车商品展示：query");
            System.out.println("修改商品购买数量：update");
            System.out.println("结算购买商品的余额：pay");
            Scanner sc = new Scanner(System.in);
            System.out.println("请您输入命令：");
            String command = sc.next();
            switch (command){
                case "add":
                    //添加商品到购物车
                    addGoods(shopCar , sc);
                    break;
                case "query":
                    //查询购物车商品展示
                    queryGoods(shopCar);
                    break;
                case "update":
                    //修改商品购买数量
                    updateGoods(shopCar ,sc);
                    break;
                case "pay":
                    //结算购买商品的余额
                    payGoods(shopCar);
                    break;
            }
        }
    }

    //结算金额
    public static void payGoods(Goods[] shopCar) {
        queryGoods(shopCar);
        //1、定义一个求和变量累计金额
        double money = 0;
        //2、遍历购物车中的全部商品对象，累加单价*数量
        for (int i = 0; i < shopCar.length; i++) {
            Goods g = shopCar[i];
            if(g != null){
                money += g.price * g.buynumber;
            }else{
                break;
            }
        }
        System.out.println("订单总金额为：" + money);
    }

    public static void updateGoods(Goods[] shopCar ,Scanner sc) {
        //让用户输入要修改商品的id，根据id查询出要修改的商品对象
        while (true) {
            System.out.println("请您输入要修改的商品id：");
            int id = sc.nextInt();
            Goods g = getGoodsById(shopCar ,id);
            if(g == null){
                //修改的商品不存在
                System.out.println("对不起，不存在该商品！！");
            }else{
                //存在该商品，可以修改
                System.out.println("请您输入"+g.name+"商品最新购买数量：");
                int buyNumber = sc.nextInt();
                g.buynumber = buyNumber;
                System.out.println("修改完成！！");
                queryGoods(shopCar);
                break;
            }
        }
    }
    public static Goods getGoodsById(Goods[] shopCar ,int id){
        for (int i = 0; i < shopCar.length; i++) {
            Goods g = shopCar[i];
            if(g != null){
                if(g.id == id){
                    return g;
                }
            }else{
                return null;
            }
        }
        return null;
    }

    //查询购物车中的商品对象信息，并展示出来
    public static void queryGoods(Goods[] shopCar) {
        System.out.println("===============查询购物车信息如下=================");
        System.out.println("编号tt名称ttt价格ttt购买数量");
        for (int i = 0; i < shopCar.length; i++) {
            Goods g = shopCar[i];
            if(g != null){
                System.out.println(g.id+"tt"+g.name+"ttt"+g.price+"ttt"+g.buynumber);
            }else{
                //遍历完毕
                break;
            }
        }
    }

    //完成商品添加到购物车的功能
    public static void addGoods(Goods[] shopCar ,Scanner sc) {
        //1、录入用户输入的商品购买的信息
        System.out.println("请您输入商品购买的编号（不重复）：");
        int id = sc.nextInt();
        System.out.println("请您输入商品名称：");
        String name = sc.next();
        System.out.println("请您输入商品购买数量：");
        int buynumber = sc.nextInt();
        System.out.println("请您输入商品价格：");
        double price = sc.nextDouble();

        //2、把这个购买商品的信息封装成一个商品对象
        Goods g =new Goods();
        g.buynumber = buynumber;
        g.id = id;
        g.name = name;
        g.price = price;

        //3、把这个商品对象添加到购物车数组中去
        for (int i = 0; i < shopCar.length; i++) {
            if(shopCar[i] == null){
                //说明此位置没有元素
                shopCar[i] = g;
                break;//商品已经存好，不需要再遍历
            }
        }

        System.out.println("您的商品"+name+"添加到购物车完成！！");
    }
}

学构造器的目的：

真正知道对象具体是通过调用什么代码完成的。能够掌握为对象属性赋值的其他写法。

构造器的作用：用于初始化一个类的对象，并返回对象的地址。
构造器的分类：

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

构造器定义格式：
修饰符 类名(形参列表){
	...
}
public class Car {
	...
    // 无参数构造器，若没有写有参构造器，这个可以不写
    public Car(){
	...
    }
    // 有参数构造器，这里写了有参构造器，上面的无参构造器就必须写了
    public Car(String n, String b){
	...
    }
}

注意：

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

作用：出现在成员方法、构造器中代表当前对象的地址，用于访问当前对象的成员变量、成员方法。

public class Car {
    String name;
    double price;

    public Car(String name ,double price){
        name = name;
        price = price;
    }
}
public static void main(String[] args) {
        Car car = new Car("奔驰",5000);
        赋值失败！！！！
        System.out.println(car.name);//null
        System.out.println(car.price);//0.0
}

这里赋值失败是由于”奔驰“传入Car构造器的name中，之后将值”奔驰“，赋值给name本身，对car对象没有影响。

正确做法：

public class Car {
    String name;
    double price;

    public Car(String name ,double price){
        this.name = name;//this.name代表当前对象的name
        this.price = price;//this。price代表当前对象的price
    }
}

public class Car {
    String name;
    double price;

    public Car(String name ,double price){
        this.name = name;
        this.price = price;
    }
    public void goWith(String name){
        System.out.println(name + "正在和" + name + "一起比赛！！");
    }
}
public static void main(String[] args) {
        Car car = new Car("奔驰",5000);
        car.goWith("宝马");//宝马正在和宝马一起比赛！！
}

这里运行错误是由于成员方法中的两个name都被认为是传入形参的name
正确做法：

public void goWith(String name){
        System.out.println(this.name + "正在和" + name + "一起比赛！！");
        //这里的this.name代表当前对象的name
}

面向对象的三大特征：封装，继承，多态。
什么是封装： 隐藏实现细节，暴露出合适的访问方式。（合理隐藏、合理暴露）
为什么要用封装：

public class Student {
	int age;
}
Student s = new Student();
s.age = -23;//允许随意赋值会导致面对异常数据无法反应

封装的实现步骤:

一般对成员变量使用private(私有)关键字修饰进行隐藏，private修饰后该成员变量就只能在当前类中访问。提供public修饰的公开的getter、setter方法暴露其取值和赋值。

public class Student {
    private int age;
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        if (age >= 0 && age <= 200) {
            this.age = age;
        } else {
            System.out.println("请检查年龄数值");
        }
    }
}

封装的好处小结

加强了程序代码的安全性。适当的封装可以提升开发效率，同时可以让程序更容易理解与维护。 8.标准JavaBean

标准JavaBean：也可以理解成实体类，其对象可以用于在程序中封装数据。

标准JavaBean须满足如下要求：

成员变量使用 private 修饰。提供每一个成员变量对应的 setXxx() / getXxx()。必须提供一个无参构造器。

//改造前
public class User{
	String name; // 名称
	double price; // 售价
}
//改造后
public class User {
    //成员变量私有
    private String name;
    private double price;
    private double salary;

    //必须有无参数构造器
    public User() {
    }

    //有参数构造器（不是必须要有，可以选择）
    public User(String name, double price, double salary) {
        this.name = name;
        this.price = price;
        this.salary = salary;
    }

    //必须提供成套的getter，setter方法暴露成员变量的取值
    public String getName() {
        return name;
    }

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

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }

    public double getSalary() {
        return salary;
    }

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

注意：IDEA可以通过快捷键直接生成

面向对象基础部分完结