让我们进入面向对象的世界(一)

让我们进入面向对象的世界

---

开场白

大家好！，从今天开始我们就正式进入对象村了，这里遍地都是对象，我记得有人经常跟我说，来到对象村，就能找对象。
在进入面向对象之前，大家仔细的回忆一下，我们在学习C语言的时候，是不是执行的程序代码都是过程化的。但在面向对象里面，我们需要建立自己的对象类型，设立自己的对象类型，让开发变得很有趣，以及让对象变得更美好，相信我，一旦进入对象村，你就不想回头了。

一.面向对象概述

一如既往的我们来认识一下，对象村的枯燥规则
面向对象程序设计（简称 OOP) 是当今主流的程序设计范型， 它已经取代了 20 世纪 70
年代的“ 结构化” 过程化程序设计开发技术。Java 是完全面向对象的， 必须熟悉 OOP 才能
够编写 Java 程序。
面向对象的程序是由对象组成的， 每个对象包含对用户公开的特定功能部分和隐藏的实
现部分。程序中的很多对象来自标准库，还有一些是自定义的。究竟是自己构造对象， 还是
从外界购买对象完全取决于开发项目的预算和时间。但是， 从根本上说， 只要对象能够满足
要求，就不必关心其功能的具体实现过程。在 OOP 中， 不必关心对象的具体实现，只要能
够满足用户的需求即可。

看了这么一大坨东西，是不是很绝望，很懵逼，这对象村咋了，怎么这么多事，天天要求我这，天天要求我哪。

让我们引入一个简单的例子来说明
假设有一天你和你的朋友正在办公室工作，你的白痴老板给了一个任务给你们，要求你们谁先完成这个任务就可以得到奖金。
任务要求是:
画出正方形、三角形、圆形。当用户点击图形的时候图形需要顺时针旋转360度并根据不同的形状播放不同的音效文件。

我同事的想法如下：
他很从容的想到，这个程序要做什么，需要什么动作。他就着手开始设计程序了。

 rotate(shapeNum) {
 // 旋转360
 }
 playSound(shapeNum) {
 // ֱ查询播放哪个个文件
 //播放
 }
1
2
3
4
5
6
7

然后你脑瓜子一转，这不就是三个不同的事物和用户吗

这里圆形、正方形、三角形，难道不就是三个类吗？
于是你转身开始了设计：

//正方形
class Square(){
//动作
rotate(){}
//播放
playSouurd(){
}

}
1
2
3
4
5
6
7
8
9

//圆形
class Circle(){
//动作
rotate(){}
//播放
playSouurd(){
}
}
1
2
3
4
5
6
7
8

//三角形
class Triangle(){
//动作
rotate(){}
//播放
playSouurd(){
}

}
1
2
3
4
5
6
7
8
9

你这样看俩人的设计没啥区别，但这个时候，你的老板来考问你，我觉得图形不够用了，你必须给我在增加一个六边形，能做到吗？你们俩。当然此时此刻，你的朋友慌了。
他的设计思路如下

 rotate(shapeNum) {
 // 旋转360
 }
 playSound(shapeNum) {
 // ֱ查询播放哪个个文件
 //播放
 }
1
2
3
4
5
6
7

你会发现一旦加入新图形，他就要在playSound加入判断，如果是六边形的话，就做出相应的判断，然后执行相应的方法，但你想啊，此时此刻，你都已经写完了，如果又加新的东西进去，是不是变得非常麻烦了呢？

这时候你的设计思路就比较面向对象。
你直接甩出一个六边形类

class hexagon(){
//动作
rotate(){}
//播放
playSouurd(){
}
}
1
2
3
4
5
6
7

如果说到这里你还是没觉得过程化的没有什么不好的话，我们再来看，如果你的老板又说，你这个旋转六边形，必须按照指定的(x,y)坐标旋转。
此刻你的朋友又得把之前的代码重新写一遍

 rotate(shapeNum,xPt,YPt) {
 //如果不是旋转点
 	//计算旋转点
 	//然后旋转
 //否则
 	//以x 和 y定为旋转中心
 	//然后旋转即可
 }
 playSound(shapeNum) {
 // ֱ查询播放哪个个文件
 //播放
 }
1
2
3
4
5
6
7
8
9
10
11
12

而你只需要定义六边形的时候，改变它的方法即可，并不需要改变整体

int xPoint
int yPoint
rotate() {
 // 使用 x和 y
 // 执行旋转
 }
playSound() {
//播放 
 }
1
2
3
4
5
6
7
8
9

哈哈 ，相信到这里，你就已经理解了面向对象的便捷性了吧。
当然，到这里还没有结束，你的朋友开始与你争论了，他倔强的说，你这不也是过程化吗？你这每个物体都有重复的方法。没看出跟我有什么不同。

其实解释他的困惑很简单。
首先我们把这三种物体叫做类、另外我们之所有重复的代码，是因为我们还没有引入面向对象的继承特性。
我这里画个图，让大家简单理解一下面向对象的继承特性是怎么来的。

这里子类是完全可以继承父类的方法的，这就打消了说的重复代码的结果。

这时候又有人会问？那新生成的六边形方法跟父类的完全就不同，我们继承过来又有什么用呢？java当然都替我们考虑好了，当我们重用父类的方法的时候，子类可以进行重写。

说了这么一大堆，我们该怎么去调用这个类去执行这个方法呢？

“这就是面向对象的重点。当你要旋转某个三角形的时候，程序代码会调用该三角形对象的rotate()方法。调用的一方不需知道该对象如何执行这个动作。如果要加入新的对象，只要写出该对象类型的类就行，让新的对象维持自己的行为。

这就是你的设计思想的高明之处，奖金是你的了，哈哈。

二.认识对象和类

怎么说呢？这个问题该怎么解释呢？
简单一点理解吧！
类是用来对一个实体(对象)来进行描述的，主要描述该实体(对象)具有哪些属性(外观尺寸等)，哪些功能用来干啥)，描述完成后计算机就可以识别了。
当然我们要时刻记住一点，对象是靠类塑造出来的。也就是常说的，类的实例化就是对象。

2.1什么是类

首先说明哈，类不是对象，类是对象的蓝图，举个例子来说，现在有一个Dog类

class Dog{
	int size;
	string color;
	string name;
}
// 狗的属性
public void barks() {
System.out.println(name + ": 旺旺旺~~~");
}
// 狗的行为
public void wag() {
System.out.println(name + ": 摇尾巴~~~");
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14

它能创造出很多的对象，比如说泰迪狗、旺财狗、哈巴狗、香肠狗、种种，但根据类创建的对象。就是实例化变量。

2.2 什么是对象呢？

大家都知道通讯录吧，对象好比就是通讯录的每一笔数据，填入一笔新的数据，就如同创建了对象，然后吧，你就会对对象进行操作，比如查看、删除、增加等等。
但注意一点哈，这些对象都是相互独立的。

2.3 让我们来创建第一个对象

这里在开始创建对象之前，我们需要俩个类。一个是实例化对象的类，一个是测试该类的类，说起来有点绕口，大概就是，我会用main方法来，操作建立的对象。

class Dog{
	int size;
	string color;
	string name;
}
// 狗的属性
public void barks() {
System.out.println(name + ": 旺旺旺~~~");
}
// 狗的行为
public void wag() {
System.out.println(name + ": 摇尾巴~~~");
}
1
2
3
4
5
6
7
8
9
10
11
12
13

class Test(){
	 public static void main(String[] args) {
		//创建第一个对象
		Dog d =new Dog();//建立一个狗对象。
		d.size=40;//存取该对象的变量
		d.barks();//调用对象的方法
}
}
1
2
3
4
5
6
7
8

大家大概已经理解了，上面的过程吧，让我们来进入下一个回合。

2.3 让我们进一步了解，我们针对对象的操作，是怎样的

我们定义了创建对象之后，我们该怎么给对象的变量，传参的呢?大家想过没有？
当然这里java已经提供了一个构造方法。具体的用法如下：

public class PetDog {
   public String name;
   public String color;
	//无参数的构造方法
    public PetDog() {

    }
    //有参数的构造方法。
    public PetDog(String name, String color) {
        this.name = name;
        this.color = color;
    }
    public  void wangwang(){
        System.out.println(name+"汪汪叫");
    }
    public  void wag(){
        System.out.println(name+"摇尾巴");
    }
}

public class Main {
    //类的实例化
    //用类类型创建对象的过程，称为类的实例化，在java中采用new关键字，配合类名来实例化对象。
    public static void main(String[] args) {
        PetDog Dog=new PetDog();//创建对象的时候，我们就调用了，构造方法。
        Dog.name="旺财";
        Dog.color="红色";
        Dog.wag();
        Dog.wangwang();
	 	PetDog Dog2=new PetDog("哮天犬","白色");//调用有参的构造方法
	 	Dog2.wag();
        Dog2.wangwang();
	 
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

运行结构如下：

解释了，对象怎么实例化变量之后，相信你在上述的程序中，看到了一个this引用，这个东西，相信你应该也很好奇

 public PetDog(String n, String c) {
        name = n;
        color = c;
    }
}
1
2
3
4
5

你说我们也可以这样写呀，为什么要加this这个引用呢？
这里我用一个例子来解释你的疑惑。

public class Date {
public int year;
public int month;
public int day;
public  Date(int year, int month, int day){
year = year;
month = month;
day = day;
}
public void printDate(){
System.out.println(year + "/" + month + "/" + day);
}
public static void main(String[] args) {
// 构造三个日期类型的对象 d1 d2 d3
Date d1 = new Date(2022,10,30);
d1.printDate();


}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

执行结果如下：

这上面就说明了.形参名不小心与成员变量名相同，那么就是自己给自己赋值，当然输出的是空的，
。
加上this的引用就是为了指明变量代表的是当前对象，免得混淆。
这里再做个小总结：

1. this的类型：对应类类型引用，即哪个对象调用就是哪个对象的引用类型
2. this只能在"成员方法"中使用
3. 在"成员方法"中，this只能引用当前对象，不能再引用其他对象

相信你在我的介绍下，已经逐步的进入了对象村了，我会再接下的讲解中，带你逐步去了解面向对象的特性。