本文详细介绍了面向对象编程的基础概念，包括什么是面向对象、如何设计类和对象、对象内存图的解析以及封装的重要性。通过实例展示了类的定义、对象的创建以及内存分配，强调了成员变量和局部变量的区别。此外，还讨论了构造器的作用、this关键字的用法以及标准JavaBean的规范。内容深入浅出，适合Java初学者理解面向对象编程的核心思想。
前言
- 该文章为Java自学笔记面向对象基础部分
- 学习视频为https://www.bilibili.com/video/av250694651
目录
1.什么是面向对象？
面向对象介绍：
- 并不是一个技术，而是一种编程指导思想。
- 把现实世界的具体事物全部看成一个一个的对象来解决问题。
为什么要用面向对象编程：
- 生活中我们解决问题就是按照对象化的方式进行的。如果程序也能够按照生活的中的方式来解决问题，那么程序就更符合人类的思维习惯，代码看起来会更易理解、更简单。
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存在自动垃圾回收器，会定期进行清理。
4.面向对象变成训练：模拟购物车模块
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("编号\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\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.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+"添加到购物车完成！！");
}
}
5.构造器
学构造器的目的：
- 真正知道对象具体是通过调用什么代码完成的。
- 能够掌握为对象属性赋值的其他写法。
构造器的作用：用于初始化一个类的对象，并返回对象的地址。
构造器的分类：
- 无参数构造器（默认存在的）：初始化的对象时，成员变量的数据均采用默认值。
- 有参数构造器：在初始化对象的时候，同时可以为对象进行赋值。
构造器定义格式：
修饰符 类名(形参列表){
...
}
public class Car {
...
// 无参数构造器，若没有写有参构造器，这个可以不写
public Car(){
...
}
// 有参数构造器，这里写了有参构造器，上面的无参构造器就必须写了
public Car(String n, String b){
...
}
}
注意：
- 任何类定义出来，默认就自带了无参数构造器，写不写都有。
- 一旦定义了有参数构造器，无参数构造器就没有了，此时就需要自己写一个无参数构造器了。
6.this关键字
作用：出现在成员方法、构造器中代表当前对象的地址，用于访问当前对象的成员变量、成员方法。
this出现在有参数构造器中的用法：
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
}
}
this出现在成员方法中的用法:
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
}
7.封装
面向对象的三大特征：封装，继承，多态。
什么是封装： 隐藏实现细节，暴露出合适的访问方式。（合理隐藏、合理暴露）
为什么要用封装：
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()。
- 必须提供一个无参构造器。
9.使用标准JavaBean改造面向对象实例
//改造前
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可以通过快捷键直接生成
10.补充知识：成员变量、局部变量区别
| 区别 | 成员变量 | 局部变量 |
|---|---|---|
| 类中位置不同 | 类中，方法外 | 常见于方法中 |
| 初始化值不同 | 有默认初始化值 | 没有，使用之前需要完成赋值 |
| 内存位置不同 | 堆内存 | 栈内存 |
| 生命周期不同 | 随着对象的创建而存在，随着对象的消失而消失 | 随着方法的调用而存在，随着方法的运行结束而消失 |
| 作用域 | 不好描述，随着对象存在 | 在所属的大括号中 |
面向对象基础部分完结
297
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
