第七章 面向对象基础

第七章 面向对象基础

---

前言

提示：这里可以添加本文要记录的大概内容：

面向：找、拿
对象：东西
面向对象编程：找或拿东西过来编程
面向对象编程的好处：符合人类思维习惯，编程更简单、更好理解

---

提示：以下是本篇文章正文内容，下面案例可供参考

一、设计对象并使用

1、设计类，创建对象并使用

• 类（设计图）：是对象共同特征的描述
• 对象：是真实存在的具体案例
• 结论：在Java中，必须先设计类，才能创建对象并使用
• 如何设计类？
  
• 如何得到类的对象
  
• 如何适用对象
  

2、定义类的几个补充注意事项

package com.itheima.createobject;

import java.sql.SQLOutput;

/**
    目标：理解定义类的几个补充注意事项，为后续知识的学习做准备
 */
public class Test2 {
    public static void main(String[] args) {
        /* 1、类名首字母建议大写，且有意义，满足“驼峰模式”，不能是关键字，
            必须是合法标识符，且有意义。*/

        /* 2、一个Java文件中可以定义多个class类，且只能一个类是public修饰，
            而且public修饰的类名必须成为代码文件名。
            注意：实际开发花时间一一个代码只定义一个类*/

        /* 3、成员变量的完整定义格式是：修饰符 数据类型 变量名称 = 初始化值；
            一般无需指定初始化值，存在默认值。

            默认值规则
            byte、short、int、long     0
            float、double             0.0
            boolean                  false
            String等引用类型           null
         */
       Student s = new Student();
       System.out.println(s.name);
       System.out.println(s.flag);
    }
}

• 对象的成员变量的默认值规则
  

二、对象在内存中的运行机制

1、多个对象的内存图

• 两个对象内存图
  
  

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

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

---

三、面向对象编程训练：模拟购物车模块

需求分析、架构搭建

添加商品到购物车、查看购物车信息

修改购买数量

结算金额

Goods代码

package com.itheima.demo;

public class Goods {
    int id;  //编号
    String name;  //名称
    double price;  //价格
    int buyNumber;  //购买数量
}

shopCarTest代码

package com.itheima.demo;

import java.util.Scanner;

/**
    目标：面向对象编程训练，购物车模块模拟
 */
public class ShopCarTest {
    public static void main(String[] args) {
        //1、定义商品类，用于后期创建商品对象
        //2、定义购物车对象，使用一个数组对象表示
        Goods[] shopCar = new Goods[100]; //[null, null, ...]
        //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":
                    //结算购买商品的金额
                    pay(shopCar);
                    break;
                default:
                    System.out.println("没有该功能！");
            }
        }
    }

    public static void pay(Goods[] shopCar) {
        queryGoods(shopCar);
        //1、定义一个求和变量累加金额
        double money = 0;
        //2、遍历购物车数组中的全部商品对象，累加单价*数量
        //[g1, g2, null, ......]
        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){
        //shopCar = [g1, g2, g3, null, null, ...]
        for (int i = 0; i < shopCar.length; i++) {
            Goods g = shopCar[i];
            if(g != null){
                //判断这个商品对象的id是否是我们要找的
                if (g.id == id){
                    return g;
                }
            }else {
                return null;  //找完了前面存在的商品，都没有找到
            }
        }
        return null;  //找完了100个商品，没有找到
    }

    /**
        查询购物车中的商品对象信息，并展示出来
     */
    public static void queryGoods(Goods[] shopCar) {
        System.out.println("============查询购物车信息============");
        System.out.println("编号\t\t名称\t\t\t价格\t\t\t购买数量");
        //shopCar = [g1, g2, g3, null, null, ...]
        for (int i = 0; i < shopCar.length; i++) {
            Goods g = shopCar[i];
            if (g != null){
                //展示这个商品对象
                System.out.println(g.id + "\t\t" + g.name + "\t\t\t" + g.price + "\t\t\t" + 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.id = id;
        g.name = name;
        g.buyNumber = buyNumber;
        g.price = price;
        
        //3、把这个商品对象添加到购物车数组中去
        //shopCar = [a, a2, null, ......]
        //                    i
        for (int i = 0; i < shopCar.length; i++) {
            if (shopCar[i] == null){
                //说明此位置没有元素存入，把我们新买的商品添加到此处即可
                shopCar[i] = g;
                break; //结束，因为商品已经存入成功了，不需要继续找位置了
            }
        }
        System.out.println("您的商品：" + g.name + "已成功添加到购物车！");
    }
}

四、构造器

目的：

1、真正知道对象具体是通过调用什么代码得到的
2、能够掌握为对象赋值的其他简便写法
3、为以后学习面向对象编程的其他内容做支撑

构造器的作用

• 定义在类中的，可以用于初始化一个类的对象，并返回对象的地址。

构造器的格式

调用构造器得到对象的格式

构造器的分类和作用

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

Car代码

package com.itheima.constructor;

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;
    }
}

Test代码

package com.itheima.constructor;

/**
    目标：认识构造器，明白两种类型的构造器的作用
 */
public class Test {
    public static void main(String[] args) {
        //通过调用构造器得到对象
        Car c = new Car();
        c.name = "宝马";
        c.price = 38.9;
        System.out.println(c.name);
        System.out.println(c.price);

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

构造器的注意事项

• 任何类定义出来，默认就自带了无参数构造器，写不写都有。
• 一旦定义了有参数构造器，那么无参数构造器就没有了，如果还想用无参数构造器，此时就需要自己手写一个无参数构造器了。
  
  

五、this关键字

this关键字是什么

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

this关键字的作用

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

六、封装

封装思想概述

封装

• 面向对象的三大特征：封装，继承，多态。
• 封装：告诉我们，如何正确设计对象的属性和方法。
• 封装的原则：对象代表什么，就得封装对应的数据，并提供数据对应的行为。
  
  
  
  

如何更好的封装

• 一般建议对成员变量使用private（私有、隐藏）关键字修饰（private修饰的成员只能在当前类中访问）。
• 为每个成员变量提供配套public修饰的getter、setter方法暴露其取值和赋值。
  
  

七、标准JavaBean

JavaBean

• 也可以称为实体类，其对象可以用于在程序中封装数据。
  

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

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

补充知识：成员变量、局部变量区别

面向对象综合案例

movie代码

package com.itheima.demo;

public class Movie {
    //1、成员变量
    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;
    }

    //2、getter + setter

    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;
    }
}

Test代码

package com.itheima.demo;

/**
    目标：完成电影信息的展示案例，理解面向对象编程的代码

    “《长津湖》” ， 9.7 ，“吴京”
    “《我和我的父辈》” ， 9.6 ，“吴京”
    “《五个扑水的少年》” ， 9.5 ，“王川”
 */
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 ,"王川");

        //4、遍历数组中的每个电影对象，然后获取她的信息展示出来
        for (int i = 0; i < movies.length; i++) {
            Movie m = movies[i];
            System.out.println("电影名：" + m.getName());
            System.out.println("评分：" + m.getScore());
            System.out.println("主演：" + m.getActor());
            System.out.println("---------------------");
        }
    }
}

结论：数组中存储的元素并不是对象本身，而是对象的地址。

总结

以上是Java面向对象编程的基础知识。