java 类和对象基础（上）
1. 初识面向对象
1.1 什么是面向对象
面向对象是解决问题的一种思想，主要依靠对象之间的交互完成一件事情。
在面向对象的世界里，一切皆为对象。Java是一门纯面向对象的语言(Object Oriented Program，简称OOP)。所以，java 与 C语言 有着很大的不同。
用面向对象的思想来涉及程序，更符合人们对事物的认知，对于大型程序的设计、扩展以及维护都非常友好。
1.2 面向对象 和 面向过程 的区别
我们先举个洗衣服的例子：
这是传统洗衣服的过程：
从上面的图片我们可以知道：洗衣服可以分成很多个步骤。比较注重洗衣服的过程，哪怕缺少了一步，衣服都会洗不干净，无法完成洗衣服这件事。
这就是面向过程的思想。 按照该种方式来写代码，将来扩展或者维护起来会比较麻烦。
这是现代洗衣服的过程：
从上面图片我们可以知道：我们把洗衣服这件事分成了四个对象之间相互协调完成。
四个对象：人，衣服，洗衣机，洗衣粉。
洗衣服这件事的过程：人把衣服放进洗衣机，导入洗衣粉或者洗衣液，开启洗衣机，洗衣机自动完成工作。
这个过程，我们不去关心洗衣机是如何工作的，不去关心洗衣服的过程，只是靠这四个对象之间的交互，协调工作，完成洗衣服这件事。
这就是面向对象的思想
总结：面向过程 和 面向对象 是两种不同的解决问题的思想，两者并没有好坏之分，都有其专门的应用场景。
2. 类的定义和使用
2.1 简单认识 类
类是用来对一个实体(对象)来进行描述的，主要描述该实体(对象)具有哪些属性(外观尺寸等)，哪些功能(用来干啥)，描述完成后计算机就可以识别了。
比如：电脑（computer），可以把它看成一个类别，去描述一台具体的电脑。
属性：品牌，型号，CPU，GPU(显卡)，屏幕分辨率，重量，外观尺寸，颜色…
功能：编辑文档，观看视频，看网课，玩游戏，发消息…
2.2 定义(创建) 类
// 创建类
class ClassName{
// 字段(属性) 或者 成员变量
...
// 行为 或者 成员方法
...
}
上述代码的一些解释：
class：java 里面的关键字，用来创建一个类。
ClassName: 这是类名，根据自己的需要，来自定义类名。
成员变量：用来描述这个类的属性。定义在类里面，在方法的外面。
成语方法：用来描述这个类具有的功能。
2.3 类 的具体写法展示
2.3.1 定义一个电脑(Computer)类
public class Computer {
public String brand; //品牌
public String model; //型号
public String CPU; //处理器
public String GPU; // 显卡
public double weight; // 重量
public String color; // 颜色
public int price; // 价格
public void PlayGame() {
System.out.println("玩游戏。");
}
public void WatchMovie() {
System.out.println("看电影。");
}
public void Work() {
System.out.println("用来工作。");
}
}
2.3.2 定义一个狗(Dog)类
public class Dog {
public String name;
public int age;
public void eat() {
System.out.println(" 正在吃饭..");
}
}
2.3.3 定义一个洗衣机(WashMachine)类
class WashMachine{
public String brand; // 品牌
public String type; // 型号
public double weight; // 重量
public double length; // 长
public double width; // 宽
public double height; // 高
public String color; // 颜色
public void washClothes(){ // 洗衣服
System.out.println("洗衣功能");
}
public void dryClothes(){ // 脱水
System.out.println("脱水功能");
}
public void setTime(){ // 定时
System.out.println("定时功能");
}
}
注意事项
- 类名注意采用大驼峰定义
- 目前，成员前，均写 public ，具体原因，后面介绍。
- 目前，成员均不为 static 修饰，具体原因，后面介绍。
- 在开发工作中，一般是一个java文件，一个类，这样更加方便管理代码。
- main方法所在的类一般要使用public修饰
- public修饰的类必须要和文件名相同，所以，不要轻易修改类名。
抛出问题：现在，我已经知道了什么是类，类是如何定义的了，那么，如何使用类呢？
答：类的实例化！！！！！！
2.4 类的实例化（类的使用）
2.4.1什么是实例化，如何实例化？
上面的介绍中，我们定义的一个类，而定义出来的这个类，相当于是一种新的类型。
就像 C语言的 结构体一样，而在java里，我们把这种自定义的类，成为 引用类型。
java里面，有两种类型，一种是基本数据类型，另一种则是引用类型。
基本数据类型： 如 char(字符型)，int(整形)，double(浮点型)…
引用类型：如 String(字符串类型)，Array[ ] (数组)…
有了这些自定义的类型之后，就可以使用这些类来定义实例(或者称为对象)。
用类类型创建对象的过程，称为类的实例化，在java中采用new关键字，配合类名来实例化对象。
比如：
public class Test {
public static void main(String[] args) {
Computer computer = new Computer(); //实例化了一个 Computer 对象。
}
}
上面代码的解释：
new Computer()：这就是新创建的对象，这个对象里面有着成员变量以及成员方法。
computer：这叫做 引用 ，也可以成为 引用变量，里面存放着实例化的对象的地址。
那么，计算机是如何储存这样的数据呢？ 可以看一下下面这张图。
2.4.2 访问对象的 成员变量和成员方法
通过对象的引用，可以访问对象的成员变量，成员方法。
访问方式：引用变量.成员变量（成员方法）
如：
public class Test {
public static void main(String[] args) {
Computer computer = new Computer(); //实例化了一个 Computer 对象。
// 通过对象的引用，调用成员变量，给 成员变量 赋值。
computer.brand = "联想";
computer.model = "拯救者Y7000";
computer.CPU = "i7-13650HX";
computer.GPU = "RTX4060";
computer.color = "黑色";
computer.price = 6799;
//通过对象的引用，调用成员变量，成员方法，输出信息
System.out.println("品牌： "+computer.brand);
System.out.println("型号： "+computer.model);
System.out.println("处理器： "+computer.CPU);
System.out.println("显卡： "+computer.GPU);
System.out.println("颜色： "+computer.color);
System.out.println("价格： "+computer.price);
computer.PlayGame();
}
}
结果输出如下：
2.5 成员变量的初始值
2.5.1 成员变量 和 局部变量的不同
| 局部变量 | 成员变量 | |
|---|---|---|
| 1.作用范围 | 当前代码块 | 整个类内 |
| 2.生命周期 | 代码块结束时结束 | 与对象相同 |
| 3.初始值 | 必须显式地定义并且初始化，否则无法使用 | 有默认值，可以直接使用 |
| 4.权限 | 只局限于定义它的代码块内 | 根据不同的访问修饰限定符 |
2.5.2 成员变量的默认值
- 引用类型：默认为 null ，如：String
- 基本数据类型：默认为 0 ，如 int，double
- 布尔类型：默认为 false
2.6 类和对象的说明
- 类只是一个模型一样的东西，用来对一个实体进行描述，限定了类有哪些成员.
- 类是一种自定义的类型，可以用来定义变量.
- 一个类可以实例化出多个对象，实例化出的对象 占用实际的物理空间，存储类成员变量
- 做个比方。类实例化出对象就像现实中使用建筑设计图建造出房子，类就像是设计图，只设计出需要什么东西，但是并没有实体的建筑存在，同样类也只是一个设计，实例化出的对象才能实际存储数据，占用物理空间。
3.this 引用
3.1 为什么会有 this 引用
先看一个日期类的例子：
public class Date {
public int year;
public int month;
public int day;
public void setDay(int y, int m, int d){
year = y;
month = m;
day = d;
}
public void printDate(){
System.out.println(year + "/" + month + "/" + day);
}
public static void main(String[] args) {
// 构造三个日期类型的对象 d1 d2 d3
Date d1 = new Date();
Date d2 = new Date();
Date d3 = new Date();
// 对d1，d2，d3的日期设置
d1.setDay(2020,9,15);
d2.setDay(2020,9,16);
d3.setDay(2020,9,17);
// 打印日期中的内容
d1.printDate();
d2.printDate();
d3.printDate();
}
}
以上代码定义了一个日期类，然后main方法中创建了三个对象，并通过Date类中的成员方法对对象进行设置和打印，代码整体逻辑非常简单，没有任何问题。
但是，我们仔细思考之后，会发现有两个问题：
1.形参名不小心与成员变量名相同：
public void setDay(int year, int month, int day){
year = year;
month = month;
day = day;
}
这样的代码会发生什么呢？
我们可以发现：三个参数并没有被赋值。都是默认值。
为什么会是这样的呢？
答：当函数的形参变量（局部变量） 与 成员变量的名字相同时，编译器会把这三个变量（year，month，day）看作为 局部变量 ，根据局部变量优先原则， 局部变量自己给自己赋值，出了函数，局部变量就被销毁了成员变量。 所以，成员变量没有被赋值,当你打印成员变量时，他们是 默认值:0。
那么，如何解决这个问题呢？ --> 使用 this 即可。
public void setDay(int year, int month, int day){
this.year = year;
this.month = month;
this.day = day;
}
2.当多个对象，同时调用了 同一个方法，他们是怎么区分是那个对象的呢？
如以下代码：
public class Test {
public static void main(String[] args) {
Date date1 = new Date();
Date date2 = new Date();
Date date3 = new Date();
date1.setDay(2008,8,8);
date2.setDay(2009,9,9);
date3.setDay(2010,10,10);
}
}
提出问题：这么多对象，同时调用了同一个setDay()方法，在这个方法内，是怎么区分是哪个对象调用setDay()方法中的year，month，day？
答：靠的就是 this 。
以上两个问题，都是靠 this 来解决的，那么 this 到底是 神马玩意？
3.2 什么是this
this代表当前对象的引用，在成员方法中所有成员变量的操作，都是通过this引用去访问。只不过所有的操作对用户是透明的，即用户不需要来传递，编译器自动完成。
3.2.1 什么是当前对象，如何判断当前对象？
答：谁调用了该方法，谁就是当前对象，而 this 就代表当前对象的引用
如图所示：
3.2.2 this 是怎么传递的
其实，就是隐藏的第一个参数！
public void setDay(Date this,int year, int month, int day){
this.year = year;
this.month = month;
this.day = day;
}
从代码中我们可以看到，哪怕你加了Date this，代码也不会报错。
3.3 this的注意事项 和 用法
3.3.1注意事项：
- 不能在 静态方法 中使用
- 只能在 非静态方法 当中使用
什么是静态方法，非静态方法，后面会介绍的。
3.3.2 习惯使用this：
有人会问：我可不可以不写 this 啊？因为有些代码，不写 this 输出结果也不会发生改变，如下面两段代码：
public void printDate(){
System.out.println(this.year + "-" + this.month + "-" + this.day);
}
public void printDate(){
System.out.println(year + "/" + month + "/" + day);
}
当对象的引用调用这两段代码时，会发现，他们的输出结果是一样的，那就会有人说，this是不是就可以不写了？
答：虽然结果是一样的，但是，还是要 习惯使用this 。因为使用 this ，能保证我们的代码不会出现因为缺少this而没有出现我们想要的结果。（如上面的setDay()方法。）
3.3.3 this的用法：
- 可以通过 this 访问 当前对象的成员变量。
- 可以通过 this 访问 当前对象的成员方法。
- 可以通过 this 访问 当前对象的其他构造方法。
这里提到了一个全新的名词，构造方法，那什么是构造方法呢？
答：用于对象的成员变量的初始化。
4.对象的构造及初始化
4.1 如何给对象的成员变量进行初始化
再来看看上面提到的日期类：
public class Date {
public int year;
public int month;
public int day;
public void setDay(int y, int m, int d){
this.year = y;
this.month = m;
this.day = d;
}
public void printDate(){
System.out.println(this.year + "-" + this.month + "-" + this.day);
}
public static void main(String[] args) {
// 构造三个日期类型的对象 d1 d2 d3
Date d1 = new Date();
Date d2 = new Date();
Date d3 = new Date();
// 对d1，d2，d3的日期设置
d1.setDay(2020,9,15);
d2.setDay(2020,9,16);
d3.setDay(2020,9,17);
// 打印日期中的内容
d1.printDate();
d2.printDate();
d3.printDate();
}
}
我们可以看到，我们是调用了类内的成员方法setDay()来给成员变量进行初始化的，但是，如果每次实例化一个对象，都要调用setDay()方法，是不是太麻烦了，有什么方法可以更加快捷的给对象的成员变量进行一个初始化呢？
解决办法：使用构造方法给对象进行初始化。
4.2 构造方法
4.2.1 构造方法的概念
构造方法是一个特殊的成员方法，名字必须与类名相同，在创建对象时，由编译器自动调用，并且在整个对象的生命周期内只调用一次。
如上面日期类的构造方法 ：
public Date(int year, int month, int day){
this.year = year;
this.month = month;
this.day = day;
System.out.println("Date(int,int,int)方法被调用了");
}
4.2.2 构造方法的作用
构造方法的作用：给对象中的成员进行初始化，但并不负责给对象开辟空间。
那么，构造方法是什么时候被调用的呢？
看下图：
一个对象的生成，有两步很重要：
- 为对象分配内存空间。
- 调用合适的构造方法。（说明：构造方法可以不止一个，可以写多个，这叫 构造方法的重载。）
4.2.3 构造方法的特性
- 名字必须与类名相同
- 没有返回值类型，设置为void也不行
- 创建对象时由编译器自动调用，并且在对象的生命周期内只调用一次(相当于人的出生，每个人只能出生一次)
- 构造方法可以重载(用户根据自己的需求提供不同参数的构造方法)
public class Date {
public int year;
public int month;
public int day;
// 无参构造方法
public Date(){
this.year = 1900;
this.month = 1;
this.day = 1;
System.out.println("调用了不带参数的构造方法");
}
// 带有三个参数的构造方法
public Date(int year, int month, int day) {
this.year = year;
this.month = month;
this.day = day;
System.out.println("调用了带有三个参数的构造方法");
}
public void printDate(){
System.out.println(this.year + "-" + this.month + "-" + this.day);
}
public static void main(String[] args) {
Date d = new Date();
d.printDate();
}
}
- 如果用户没有显式定义任何的构造方法，编译器会生成一份默认的构造方法，生成的默认构造方法一定是无参的。
public class Date {
public int year;
public int month;
public int day;
public void printDate(){
System.out.println(this.year + "-" + this.month + "-" + this.day);
}
public static void main(String[] args) {
Date d = new Date();
d.printDate();
}
}
上述Date类中，没有定义任何构造方法，编译器会默认生成一个不带参数的构造方法。
如下：
public Date() {
}
注意：如果你已经定义了自己的构造方法，那么编译器就不会再给你提供默认的构造方法。
- 在构造方法中，使用 this 来调用类内其他的构造方法。（对应了上面介绍的this的用法第三点）
class Date {
public int year;
public int month;
public int day;
public void setDay(int year, int month, int day){
this.year = year;
this.month = month;
this.day = day;
}
public Date(int year, int month, int day) {
this.year = year;
this.month = month;
this.day = day;
System.out.println("调用了带有三个参数的构造方法。");
}
public Date() {
this(2008,8,8); //通过this调用带有三个参数的构造方法。
System.out.println("调用了无参数的构造方法。");
}
public void print() {
System.out.println(this.year +" 年 "+ this.month+" 月 "+ this.day+" 日");
}
}
public class Test {
public static void main(String[] args) {
Date date = new Date(2008,8,8);
Date date1 = new Date();
}
}
注意的点：
6.1. this 必须放在构造方法的第一行语句。
public Date() {
this(2008,8,8); //通过this调用带有三个参数的构造方法。
System.out.println("调用了无参数的构造方法。");
}
6.2. 不可以形成 环。（会直接报错）
- 绝大多数情况下使用public来修饰，特殊场景下会被private修饰(后序讲单例模式时会遇到)
4.3 默认初始化
我们之前提到过，成员变量 和 局部变量 之间的一点区别是：局部变量必须要初始化，不然无法使用，而成员变量会有默认值。
在 2.5.2 可详细查看 默认值。
4.4 就地初始化
在成员变量定义的时候，直接初始化。
public class Date {
//就地初始化
public int year = 1900;
public int month = 1;
public int day = 1;
public Date(){
}
public Date(int year, int month, int day) {
}
public static void main(String[] args) {
Date d1 = new Date(2021,6,9);
Date d2 = new Date();
}
}
5.总结
这篇文章，我们总共需要知道并掌握几点即可：
1. 会定义类 和 创建对象
2. 会访问对象当中的成员变量 和 成员方法
3. 明白 this 是干嘛的
4. 明白 构造方法是干嘛的
希望这篇文章能帮到屏幕前的你，如果文章有表达错误，或者有不同意见的，欢迎评论区指出，谢谢。
扫一扫
1309
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
