文章目录

• 1. 设计对象并使用
• • 1.1 设计类，创建对象并使用
  • 1.2 定义类的几个补充注意事项
• 2. 对象内存图
• 3. 面向对象编程训练:模拟购物车
• 4. 构造器
• 5. this关键字
• 6. 封装
• • 封装思想概述
  • 如何更好地封装
• 7. 标准 JavaBean
• 8. 补充知识：成员变量、局部变量区别
• 9. 面向对象编程(oop) 综合案例

1. 设计对象并使用

1.1 设计类，创建对象并使用

• 类： 是相同事物共同特征的描述（设计图）

• 对象： 是类的具体实例（万物皆对象）

• 如何设计类？
  public class 类名{
          ~~~~~~~        1.成员变量（代表属性，一般是名词）
          ~~~~~~~        2.成员方法（代表行为，一般是动词）
          ~~~~~~~        3.构造器
          ~~~~~~~        4.代码块
          ~~~~~~~        5.内部类
  }

• 如何创建对象？
  类名 对象名 = new 类名()

• 访问对象信息
  对象.成员变量;
对象.成员方法(...)

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

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

2. 对象内存图

1. 对象放在那个位置？
   堆内存
2. Car c = new Car()，c变量名中存储的是什么？
   存储的是对象在堆内存中的地址
3. 成员变量（namw、price）的数据放在哪里，存于哪个位置？
   对象中，存在于堆内存中

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

3. 面向对象编程训练:模拟购物车

public class Goods {    int id;    String name;    double price;    int buyNumber;}

import java.util.Scanner;public class ShopCarTest {    public static void main(String[] args) { boolean flag = true; //1.定义商品类 //2.定义购物车对象 Goods[] shopCar = new Goods[100]; //3.搭建操作架构 while (flag) {     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,sc);      flag = false;      break;  default:      System.out.println("没有该功能!");     } }    } //商品添加到购物车    private static void addGoods(Goods[] shopCar,Scanner sc) { //录入用户输入的商品信息 System.out.println("请输入商品的编号:"); int id = sc.nextInt(); System.out.println("请输入商品的名称:"); String name = sc.next(); System.out.println("请输入商品的价格:"); double price = sc.nextDouble(); System.out.println("请输入商品的数量:"); int buyNumber = sc.nextInt(); Goods g = new Goods(); g.id = id; g.name = name; g.price = price; g.buyNumber = buyNumber; for (int i = 0; i < shopCar.length; i++) {     if(shopCar[i] == null){  shopCar[i] = g;  break;     } } System.out.println("商品" + g.name + "已添加到购物车");    } //查询购物车信息    private static void queryGoods(Goods[] shopCar) { System.out.println("=====查询购物车信息如下====="); System.out.println("编号\t\t名称\t\t\t\t价格\t\t\t购买数量"); 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" + g.price + "\t\t" +g.buyNumber);     }else {  break;     } }    } //修改购买商品的数量    private static void updateGoods(Goods[] shopCar,Scanner sc) { 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;   //找完100种商品都没有id一样的商品    } //求总金额    private static void payGoods(Goods[] shopCar,Scanner sc) { queryGoods(shopCar); double money = 0; 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);    }}

4. 构造器

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

格式：修饰符 类名(形参列表){.....}

调用构造器得到对象的格式：类 变量名称 = new 构造器

分类和作用：

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

注意事项：

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

public class Car {    String name;    double price;    public void start(){ System.out.println(name + "启动了");    }    public void run(){ System.out.println("价格是:" + price + "的" + name + "跑的很快");    }    //无参数构造器    public Car(){ System.out.println("这是无参数构造器!");    }    //有参数构造器   (暂无this关键字)    public Car(String n,double p){ System.out.println("这是有参数构造器!"); name = n; price = p;    }}

public class Test1 {    public static void main(String[] args) { //创建汽车对象 Car c1 = new Car(); c1.name = "宝马"; c1.price = 38.9; System.out.println(c1.name); System.out.println(c1.price); c1.start(); c1.run(); System.out.println("==============="); Car c2 = new Car("奔驰",41.7); System.out.println(c2.name); System.out.println(c2.price); c2.start(); c2.run();    }}

5. this关键字

• 可以出现在构造器、方法中
• 代表当前对象的地址
• 可以用于指定当前对象的成员变量、成员方法

public class Car {    String name;    double price;    public Car(){ System.out.println("这是无参数构造器中的this: " + this);    }    public void run(){ System.out.println("方法中的this: " + this);    }    //this出现在有参数构造器中的用法    public Car(String name,double price){ this.name = name; this.price = price;    }    //this出现在成员方法中的用法    public void goWith(String name){ System.out.println(this.name +"正在和"+ name + "一起比赛!");    }}

public class Test1 {    public static void main(String[] args) { Car c = new Car(); c.run(); System.out.println(c); System.out.println("-------------"); Car c0 = new Car("奔驰",39.8); System.out.println(c0.name); System.out.println(c0.price); System.out.println("-------------"); c0.goWith("宝马");    }}//这是无参数构造器中的this: Car@6cd8737//方法中的this: Car@6cd8737//Car@6cd8737.//-------------//奔驰//39.8//-------------//奔驰正在和宝马一起比赛!

6. 封装

封装思想概述

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

如何更好地封装

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

7. 标准 JavaBean

JavaBean 也可以称为实体类（例如学生类，老师类，票类）——创建对象 + 封装数据

书写要求：

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

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

9. 面向对象编程(oop) 综合案例

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

public class TestMovie {    public static void main(String[] args) { //定义一个电影类型的数组,存储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 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()); }    }}