美文网首页
9.面向对象基础之构造器,封装,JavaBean,内存图,thi

9.面向对象基础之构造器,封装,JavaBean,内存图,thi

作者: 每天起床都想摆 | 来源:发表于2022-01-11 22:52 被阅读0次

面向对象基础

面向对象三大基本特征:封装,继承,多态


image.png

设计对象并使用

设计类,创建对象并使用

  • 类:是对象共同特征的描述

  • 对象:是真实存在的具体实例

  • 定义类:

    public class 类名{
        1.成员变量(代表属性,一般是名词)
        2.成员方法(代表行为,一般是动词)
        3.构造器
        4.代码块
        5.内部类
    }
    
  • 定义对象

    类名 对象名 = new 类名();
    
  • 使用对象

    • 访问属性:对象名.成员变量
    • 访问行为:对象名.方法名(……)

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

  • 成员变量的完整定义格式:

    访问级修饰符 数据类型 变量名称 = 初始化值;  // 一般无需指定初始化值,存在默认值
    
  • 对象的成员变量的默认值规则

    数据类型 明细 默认值
    基本类型 byte,short,char,int,long 0
    float,double 0.0
    boolean false
    引用类型 类,接口,数组,String null
  • 类名的首字母大写,命名有意义,并且满足“驼峰模式”

  • 一个Java文件中可以定义多个class类,且只能一个类是public修饰,而且public修饰的类名必须成为代码文件名

    实际开发中还是建议一个文件编写一个class类

对象内存图

  • 两个对象的内存图:


    image.png

在首次加载成员变量和成员方法的时候,成员变量是以默认值的状态存在堆内存,成员方法则以引用地址的形式存放

对象存放在堆内存中

Car c = new Car(); 变量c存储的是对象在堆内存中的地址,其为引用类型

成员变量的数据存放在对象中,而对象又存放于堆内存中

  • 两个变量指向同一个对象的内存图(如下:将学生类型的变量s1赋值给学生类型的s2)

    image.png

垃圾回收

  • 当堆内存中的类对象或数组对象,没有被任何变量引用(指向)时,就会被判定为内存中的“垃圾”
  • Java存在自动垃圾回收器,会定期清理垃圾

构造器

对象是通过构造器得到的

  • 构造器的作用:用于初始化一个类的对象,并返回对象的地址

  • 构造器的定义格式

    修饰符 类名(形参列表){
      ……
    }
    
  • 构造器的分类

    • 无参构造器(默认存在的):初始化对象时,成员变量的数据均采用默认值
    • 有参构造器:在初始化对象的时候,同时可以为对象进行赋值
    public class Car(){
        ……
        //无参数构造器
        public Car(){
            ……
        }
        //有参构造器
        public Car(String a, String b){
            ……
        }
    }
    
  • 初始化对象的格式:

    类型 变量名称 = new 构造器();

    Car c= new Car();

  • 注意事项:

    • 任何类被定义出来,默认就带了无参构造器,写不写都有
    • 一旦定义了有参构造器,无参构造器就没有了,此时必须自己写一个同名的无参构造器

this关键字

  • 作用:出现在成员方法中&构造器中,代表当前对象的地址,用于访问当前对象的成员变量,成员方法

  • this出现在有参构造器中的用法:

    image.png
  • this出现在成员方法中的用法:


    image.png

封装

  • 定义:隐藏实现细节,暴露出合适的访问方式。(合理隐藏,合理暴露)

  • 实现步骤:

    1. 一般对成员变量使用private(私有)关键字修饰进行隐藏,private修饰后该成员变量就只能在当前类中访问

    2. 提供public修饰的公开getter(),setter()方法暴露其取值和赋值

      image.png
  • 封装的好处:

    • 加强了程序的安全性
    • 适当的封装可以提升开发效率,同时让程序易于维护

标准JavaBean

  • 可以理解成为实体类,其对象可以用于在程序中封装数据
  • 标准JavaBean需要满足的条件:
    • 成员变量使用private修饰
    • 为每一个成员变量书写对应的setXxx()/getXxx()方法
    • 必须提供一个无参构造器

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

区别 成员变量 局部变量
类中位置不同 类中,方法外 常见于方法之中
初始化值不同 有默认初始化值 没有默认值,使用之前必须初始化
内存位置不同 堆内存(因为成员变量属于对象) 栈内存
生命周期不同 随着对象的创建而存在,随着对象的消失而消失 随着方法的调用而存在,随着方法的运行结束而消失
作用域 在所属的大括号中

面向对象综合案例(JavaBean)

购物车

  • ShoppingCart

    package com.java.test;
    
    import java.util.Scanner;
    
    /**
     * 面向对象编程训练,购物车模块模拟
     */
    public class ShoppingCart {
        public static void main(String[] args) {
            //1.定义商品类,用于后期创建商品对象
            //2.定义购物车对象,使用一个数组对象表示
            Goods[] shopCart = new Goods[100];  //装商品对象,因此类型就是Goods
            //3.搭建操作架构
            MENU:
            while (true) {
                System.out.println();
                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 cmd = sc.next();
                switch (cmd) {
                    case "add":
                        addGoods(shopCart, sc);
                        break;
                    case "query":
                        queryGoods(shopCart);
                        break;
                    case "update":
                        updateGoods(shopCart, sc);
                        break;
                    case "pay":
                        pay(shopCart);
                        break;
                    default:
                        System.out.println("查无此功能!");
                }
                if (cmd.equals("pay")) {
                    break MENU;
                }
            }
        }
    
    
        /**
         * 所有功能均未开发输入纠错机制,测试数据请合法输入
         */
        private static void pay(Goods[] shopCart) {
            queryGoods(shopCart);
            double money = 0;
            for (int i = 0; i < shopCart.length; i++) {
                Goods g = shopCart[i];
                if (g != null) {
                    money += (g.getPrice() + g.getBuyNumber());
                } else {
                    break;
                }
            }
            System.out.println("订单总金额:" + money + "\t\t单位:元");
    
        }
    
        private static void updateGoods(Goods[] shopCart, Scanner sc) {
            while (true) {
                //让用户输入要修改购买数量的商品的id进行操作
                System.out.println("请您输入您要修改的商品的id:");
                int id = sc.nextInt();
                Goods g = getGoodsById(id, shopCart);
                if (g == null) {
                    //没有该商品
                    System.out.println("您的购物车不存在商品拥有此id,请重新输入");
                } else {
                    //存在该商品对象,下一步进行修改
                    System.out.println("请您输入商品" + g.getName() + "的最新购买数量:");
                    int buyNumber = sc.nextInt();
                    g.setBuyNumber(buyNumber);
                    System.out.println("修改完成!");
                    queryGoods(shopCart);
                    break;
                }
            }
        }
    
        public static Goods getGoodsById(int id, Goods[] shopCart) {
            for (int i = 0; i < shopCart.length; i++) {
                Goods g = shopCart[i];
                if (g != null) {
                    //判断所得id是否为目标id
                    if (g.getId() == id) {
                        return g;
                    }
                } else {
                    return null;    //找完了全部存在的商品都没有找到目标id
                }
            }
            return null;    //找完了100(数组的长度)个商品都没有找到目标id
        }
    
        private static void queryGoods(Goods[] shopCart) {
            System.out.println("+======================查询购物车信息如下======================");
            System.out.println("编号\t\t\t名称\t\t\t\t\t\t\t价格\t\t\t购买数量");
            for (int i = 0; i < shopCart.length; i++) {
                Goods g = shopCart[i];
                if (g != null) {// 展示这个商品对象
                    System.out.println(g.getId() + "\t\t\t" + g.getName() + "\t\t\t\t\t\t\t" + g.getPrice() + "\t\t\t" + g.getBuyNumber());
                } else {// 遍历结束
                    break;
                }
            }
            System.out.println("===========================================================");
        }
    
        private static void addGoods(Goods[] shopCart, Scanner sc) {
            // 可以将扫描器当作参数传进方法,方法内部就不用再额外建立扫描器
            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();
    
            // 将购买的商品的信息封装成一个商品对象
            Goods g = new Goods();
            g.setId(id);
            g.setName(name);
            g.setBuyNumber(buyNumber);
            g.setPrice(price);
    
            // 把商品对象添加到购物车数组
            for (int i = 0; i < shopCart.length; i++) {
                if (shopCart[i] == null) {
                    // 说明此位置没有元素存入,把我们新买的商品添加到此处即可
                    shopCart[i] = g;    //存放的是地址
                    break;  //结束,因为商品已经存入,不需要再寻找位置了
                }
                System.out.println("添加商品:" + g.getName() + "添加到购物车完成");
            }
        }
    }
    
  • Goods

    package com.java.test;
    
    public class Goods {
        private int id;
        private String name;
        private double price;
        private int buyNumber;
    
        public Goods() {
        }
    
        public Goods(int id, String name, double price, int buyNumber) {
            this.id = id;
            this.name = name;
            this.price = price;
            this.buyNumber = buyNumber;
        }
    
        public int getId() {
            return id;
        }
    
        public void setId(int id) {
            this.id = id;
        }
    
        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 int getBuyNumber() {
            return buyNumber;
        }
    
        public void setBuyNumber(int buyNumber) {
            this.buyNumber = buyNumber;
        }
    }
    
    

相关文章

  • 9.面向对象基础之构造器,封装,JavaBean,内存图,thi

    面向对象基础 面向对象三大基本特征:封装,继承,多态image.png 设计对象并使用 设计类,创建对象并使用 类...

  • 从基础代码深入js面向对象

    认识面向对象 1、面向对象中的概念: 一切事物皆对象 对象具有封装和继承特性 信息隐藏 基本面向对象 函数构造器构...

  • 面向对象编程

    面向对象编程 一、面向对象和面向过程 二、类和对象 三、内存图 四、构造方法 五、关键字 六、面向对象的三大特征 ...

  • Python基础语法——面向对象(下)

    面向对象三大思想:封装、继承、多态。 可参考一些优质文章: 关于面向对象的相关理解解释: 面向对象基础 装饰器、类...

  • 那些年出现的作业

    Java面向对象之类的练习之模拟计算器 demo Java面向对象之类的练习之ArrayBox封装 demo

  • JS构造器

    什么是构造器(Constructor)?在经典面向对象编程语言中,构造器是一种内存中已分配给该对象的情况下,用于初...

  • 001--Spring关于JavaBean创建

    话题1.在配置文件中的JavaBean如何被创建 话题2.构造对象实例,创建JavaBean 话题3.构造器方法,...

  • 面向对象(五)-面向对象三大特性之继承

    面向对象的三大特性 封装 继承 多态 1.封装 之前学习的构造函数与set、get访问器函数都是在进行封装。我们在...

  • 一、JavaScript 构造器模式

    构造器模式 在面向对象编程中,构造器是一个当新建对象的内存被分配后,用来初始化该对象的一个特殊函数。在JavaSc...

  • 面试必问

    方法重载 :不属于多态方法重写 :属于多态构造器: 构造器名称跟类名一样面向对象思想的三大特点:多态、封装、继...

网友评论

      本文标题:9.面向对象基础之构造器,封装,JavaBean,内存图,thi

      本文链接:https://www.haomeiwen.com/subject/uniicrtx.html