---

 
 

1. 面向过程和面向对象的初步认识

---

C语言是面向过程，关注的是过程，分析出求解问题的步骤，通过函数调用逐步解决问题。


我们关心的是这几个步骤。

而C++是基于面向对象的，关注的是对象，将一件事情拆分成不同的对象，靠对象之间的交互完成。

这里总共有四个对象：人、衣服、洗衣粉、洗衣机
整个洗衣服的过程：人将衣服放进洗衣机、倒入洗衣粉、启动洗衣机，洗衣机就会完成洗衣过程并甩干。
整个过程主要是：人、衣服、洗衣粉、洗衣机四个对象之间交互完成的，人不需要关心洗衣机具体是如何清洗衣服并如何甩干的。

 
 

2. 类的引入

---

C语言结构体中只能定义变量，在C++中，结构体内不仅可以定义变量，也可以定义函数。比如：我们用C语言方式实现的栈，结构体中只能定义变量；现在以C++方式实现，会发现struct中也可以定义函数。

以下是C++实现栈的过程。

typedef int DataType;
struct Stack
{
    void Init(size_t capacity)
    {
        _array = (DataType*)malloc(sizeof(DataType) * capacity);
        if (nullptr == _array)
        {
            perror("malloc申请空间失败");
            return;
        }
        _capacity = capacity;
        _size = 0;
    }
    void Push(const DataType& data)
    {
        // 扩容
        _array[_size] = data;
        ++_size;
    }
    DataType Top()
    {
        return _array[_size - 1];
    }
    void Destroy()
    {
        if (_array)
        {
            free(_array);
            _array = nullptr;
            _capacity = 0;
            _size = 0;
        }
    }
    DataType* _array;
    size_t _capacity;
    size_t _size;
};
int main()
{
    Stack s;
    s.Init(10);
    s.Push(1);
    s.Push(2);
    s.Push(3);
    cout << s.Top() << endl;
    s.Destroy();
    return 0;
}

上面结构体的定义，在C++中更喜欢用class来代替。

 
 

3. 类的定义

---

class className
{
	// 类体：由成员函数和成员变量组成
};  // 一定要注意后面的分号

class为定义类的关键字，ClassName为类的名字，{}中为类的主体，注意: 类定义结束时后面分号不能省略。

类体中内容称为类的成员：类中的变量称为类的属性或成员变量; 类中的函数称为类的方法或者成员函数。

类的两种定义方式：

1. 声明和定义全部放在类体中，需注意：成员函数如果在类中定义，编译器可能会将其当成内联函数处理。
   
2. 类声明放在.h文件中，成员函数定义放在.cpp文件中，注意：成员函数名前需要加类名::
   

一般情况下，更期望采用第二种方式。但是如果函数体内的代码量如果少的话，还是建议直接写在类里面，因为这样可以被当做内联函数处理。

成员变量命名规则的建议：

// 我们看看这个函数，是不是很僵硬？
class Date
{
public:
	void Init(int year)
	{
		// 这里的year到底是成员变量，还是函数形参？
		year = year;
	}
private:
	int year;
};
// 所以一般都建议这样
class Date
{
public:
	void Init(int year)
	{
		_year = year;
	}
private:
	int _year;
};
// 或者这样
class Date
{
public:
	void Init(int year)
	{
		mYear = year;
	}
private:
	int mYear;
};
// 其他方式也可以的，主要看公司要求。一般都是加个前缀或者后缀标识区分就行。

 
 

4. 类的访问限定符及封装

---

4.1 访问限定符

C++实现封装的方式：用类将对象的属性与方法结合在一块，让对象更加完善，通过访问权限选择性的将其接口提供给外部的用户使用。

【访问限定符说明】

1. public修饰的成员在类外可以直接被访问
2. protected和private修饰的成员在类外不能直接被访问(此处protected和private是类似的)
3. 访问权限作用域从该访问限定符出现的位置开始直到下一个访问限定符出现时为止
4. 如果后面没有访问限定符，作用域就到 } 即类结束。
5. class的默认访问权限为private，struct为public(因为struct要兼容C)

注意⚠️： 访问限定符只在编译时有用，当数据映射到内存后，没有任何访问限定符上的区别

来看一道面试题：

问题：C++中struct和class的区别是什么？
 
 
解答：C++需要兼容C语言，所以C++中struct可以当成结构体使用。另外C++中struct还可以用来定义类。和class定义类是一样的，区别是struct定义的类默认访问权限是public，class定义的类默认访问权限是private。 注意：在继承和模板参数列表位置，struct和class也有区别，后序在相应的章节里介绍。

 

4.2 封装

面向对象的三大特性：封装、继承、多态。

来看一道面试题：

在类和对象阶段，主要研究类的封装特性，那什么是封装呢？
 
 
封装：将数据和操作数据的方法进行有机结合，隐藏对象的属性和实现细节，仅对外公开接口来和对象进行交互。
 
封装本质上是一种管理，让用户更方便使用类。比如：对于电脑这样一个复杂的设备，提供给用户的就只有开关机键、通过键盘输入，显示器，USB插孔等，让用户和计算机进行交互，完成日常事务。但实际上电脑真正工作的却是CPU、显卡、内存等一些硬件元件。

对于计算机使用者而言，不用关心内部核心部件，比如主板上线路是如何布局的，CPU内部是如何设计的等，用户只需要知道，怎么开机、怎么通过键盘和鼠标与计算机进行交互即可。因此计算机厂商在出厂时，在外部套上壳子，将内部实现细节隐藏起来，仅仅对外提供开关机、鼠标以及键盘插孔等，让用户可以与计算机进行交互即可。
 
在C++语言中实现封装，可以通过类将数据以及操作数据的方法进行有机结合，通过访问权限来隐藏对象内部实现细节，控制哪些方法可以在类外部直接被使用。

 
 

5. 类的作用域

---

类定义了一个新的作用域，类的所有成员都在类的作用域中。在类体外定义成员时，需要使用 ::作用域操作符指明成员属于哪个类域。

class Person
{
public:
	void PrintPersonInfo();
private:
	char _name[20];
	char _gender[3];
	int _age;
};
// 这里需要指定PrintPersonInfo是属于Person这个类域
void Person::PrintPersonInfo()
{
	cout << _name << " " << _gender << " " << _age << endl;
}

 
 

6. 类的实例化

---

用类类型创建对象的过程，称为类的实例化

1. 类是对对象进行描述的，是一个模型一样的东西，限定了类有哪些成员，定义出一个类并没有分配实际的内存空间来存储它；比如：入学时填写的学生信息表，表格就可以看成是一个类，来描述具体学生信息。
   类就像谜语一样，对谜底来进行描述，谜底就是谜语的一个实例。
   谜语：“年纪不大，胡子一把，主人来了，就喊妈妈” 谜底：山羊
2. 一个类可以实例化出多个对象，实例化出的对象 占用实际的物理空间，存储类成员变量

int main()
{
	Person._age = 100;   // 编译失败：error C2059: 语法错误:“.”
	return 0;
}
// Person类是没有空间的，只有Person类实例化出的对象才有具体的年龄。

3. 做个比方。类实例化出对象就像现实中使用建筑设计图建造出房子，类就像是设计图，只设计出需要什么东西，但是并没有实体的建筑存在，同样类也只是一个设计，实例化出的对象才能实际存储数据，占用物理空间
   

 
 

7. 类对象模型

---

7.1 如何计算类对象的大小

class A
{
public:
	void PrintA()
	{
		cout << _a << endl;
	}
private:
	char _a;
};

问题：类中既可以有成员变量，又可以有成员函数，那么一个类的对象中包含了什么？如何计算一个类的大小？

 

7.2 类对象的存储方式猜测

• 对象中包含类的各个成员
  
  缺陷：每个对象中成员变量是不同的，但是调用同一份函数，如果按照此种方式存储，当一个类创建多个对象时，每个对象中都会保存一份代码，相同代码保存多次，浪费空间。那么如何解决呢？

• 代码只保存一份，在对象中保存存放代码的地址
  

• 只保存成员变量，成员函数存放在公共的代码段

问题：对于上述三种存储方式，那计算机到底是按照那种方式来存储的？

我们再通过对下面的不同对象分别获取大小来分析看下

// 类中既有成员变量，又有成员函数
class A1 {
public:
	void f1() {}
private:
	int _a;
};
// 类中仅有成员函数
class A2 {
public:
	void f2() {}
};
// 类中什么都没有---空类
class A3
{};

 

7.3 结构体内存对齐规则

这里的对齐规则其实和C语言中结构体的内存对齐规则差不多，所以在这里就简单讲一下，感兴趣的可以看看这篇文章：《自定义类型：结构体，枚举，联合》的第一小节

1. 第一个成员在与结构体偏移量为0的地址处。
2. 其他成员变量要对齐到某个数字（对齐数）的整数倍的地址处。注意：对齐数 = 编译器默认的一个对齐数 与 该成员大小的较小值。VS中默认的对齐数为8
3. 结构体总大小为：最大对齐数（所有变量类型最大者与默认对齐参数取最小）的整数倍。
4. 如果嵌套了结构体的情况，嵌套的结构体对齐到自己的最大对齐数的整数倍处，结构体的整体大小就是所有最大对齐数（含嵌套结构体的对齐数）的整数倍。

 
 

8. this指针

---

8.1 this指针的引出

我们先来定义一个日期类 Date

class Date
{
public:
	void Init(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	void Print()
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}
private:
	int _year;    // 年
	int _month;   // 月
	int _day;     // 日
};
int main()
{
	Date d1, d2;
	d1.Init(2022, 1, 11);
	d2.Init(2022, 1, 12);
	d1.Print();
	d2.Print();
	return 0;
}

对于上述类，有这样的一个问题：

Date类中有 Init 与 Print 两个成员函数，函数体中没有关于不同对象的区分，那当d1调用 Init 函数时，该函数是如何知道应该设置d1对象，而不是设置d2对象呢？

C++中通过引入this指针解决该问题，即：C++编译器给每个“非静态的成员函数“增加了一个隐藏的指针参数，让该指针指向当前对象(函数运行时调用该函数的对象)，在函数体中所有“成员变量”的操作，都是通过该指针去访问。只不过所有的操作对用户是透明的，即用户不需要来传递，编译器自动完成。

 

8.2 this指针的特性

1. this指针的类型：类类型 * const，即成员函数中，不能给this指针赋值。
2. 只能在“成员函数”的内部使用
3. this指针本质上是“成员函数”的形参，当对象调用成员函数时，将对象地址作为实参传递给this形参。所以对象中不存储this指针。
4. this指针是“成员函数”第一个隐含的指针形参，一般情况由编译器通过ecx寄存器自动传递，不需要用户传递

下面我们来看几道面试题：

1. this指针存在哪里？
   解答：存在栈里，因为它是一个隐含的参数
    
2. this指针可以为空吗？
   解答：不可以，如果this指针为空的话，我们在成员函数里面访问类的成员时，就相当于对空指针进行了解引用操作

// 1.下面程序编译运行结果是？ A、编译报错 B、运行崩溃 C、正常运行
class A
{
public:
	void Print()
	{
		cout << "Print()" << endl;
	}
private:
	int _a;
};
int main()
{
	A* p = nullptr;
	p->Print();
	return 0;
}

//答案:C  原因是这里虽然p是空指针,但我们进行p->Print(),这样的操作并不是空指针进行解引用操作，而是去调用A类的成员函数，因为成员函数里面并没有对类的成员进行访问


// 2.下面程序编译运行结果是？ A、编译报错 B、运行崩溃 C、正常运行
class A
{
public:
	void PrintA()
	{
		cout << _a << endl;
	}
private:
	int _a;
};
int main()
{
	A* p = nullptr;
	p->PrintA();
	return 0;
}

//答案:B 原因是我们去调用成员函数时,我们在成员函数里面对类的成员进行了访问,所以这里就涉及了对空指针的解引用操作

 
 

9. const成员函数

---

将const修饰的“成员函数”称之为const成员函数，const修饰类成员函数，实际修饰该成员函数隐含的this指针，表明在该成员函数中不能对类的任何成员进行修改。

我们来思考下面这几个问题：

1. const对象可以调用非const成员函数吗？
   答：不可以，这里涉及了权限放大的问题：加上const修饰的对象，对它的成员只能读不能写，非const成员函数对类的成员是可读可写的。所以是不可以的。
    
2. 非const对象可以调用const成员函数吗？
   答：可以，这里涉及了权限缩小的问题：非const成员函数对类的成员是可读可写的，加上const修饰的对象，对它的成员只能读不能写。我们对非const对象想读或者想写都是可以的。
    
3. const成员函数内可以调用其它的非const成员函数吗？
   答：不可以，原因是权限只能缩小不能放大，这里属于权限放大。
    
4. 非const成员函数内可以调用其它的const成员函数吗？
   答：可以，原因是权限只能缩小不能放大，这里属于权限缩小。

 
 

10. 类的默认成员函数

---

因为这里涉及到的内容比较多，所以我单独整理成了一篇博客：《类的默认成员函数》，里面包含了：

1. 构造函数
2. 析构函数
3. 拷贝构造函数
4. 赋值运算符重载
5. 取地址及const取地址操作符运算符重载

讲的还是比较详细的，大家可以去看看，如果对上面这些默认成员函数有所了解的话，可以接着往下看。

 
 

11. static成员

---

11.1 static成员的概念

声明为static的类成员称为类的静态变量，用static修饰的成员变量，称之为静态成员变量；用static修饰的成员函数，称之为静态成员函数。静态成员变量一定要在类外进行初始化。

面试题：实现一个类，就算程序中创建出了多少个类的对象。

class A
{
public:
	A() 
	{ 
		++_scount; 
	}
	A(const A& t) 
	{ 
		++_scount;
	}
	~A()
	{
		--_scount; 
	}
	static int GetACount() 
	{ 
		return _scount; 
	}
private:
	//static int _scount = 0;// 不能在这里初始化,因为在这里给的是一个缺省值,缺省值是给构造函数的初始化列表的,初始化列表是初始化某一个对象,而加static的成员不属于某一个对象
	static int _scount; 
};
int A::_scount = 0;
void TestA()
{
	cout << A::GetACount() << endl;
	A a1, a2;
	A a3(a1);
	cout << A::GetACount() << endl;
}

 

11.2 static成员特性

1. 静态成员函数和静态成员变量本质就是受限制的全局变量和全局函数，是专属于这个类，受类域和访问限定符的限制
2. 静态成员为所有类对象所共享，不属于某个具体的对象，存放在静态区
3. 静态成员变量必须在类外定义，定义时不添加static关键字，类中只是声明
4. 类静态成员即可用 类名::静态成员 或者 对象.静态成员 来访问
5. 静态成员函数没有隐藏的this指针，不能访问任何非静态成员
6. 静态成员也是类的成员，受public、protected、private 访问限定符的限制

【问题】

1. 静态成员函数可以调用非静态成员函数吗？
   答：不可以，静态成员函数没有this指针，也不能访问非静态成员变量。
    
2. 非静态成员函数可以调用类的静态成员函数吗？
   答：可以，静态成员函数和静态成员变量本质就是受限制的全局变量和全局函数，只不过受类域和访问限定符的限制。

 

11.3 编译器的一个特殊处理

我们在上面讲过，静态成员变量是在类里面声明，类外面定义的，原因是在声明处给的是一个缺省值,缺省值是给构造函数的初始化列表的,初始化列表是初始化某一个对象,而加static的成员不属于某一个对象。

但是编译器在这个地方会做这样的处理：

这里可以这样写，应该是后面的人打的一个补丁吧，可能认为这样写会更方便，我用g++也测试了一下，也是支持这样的语法的。不过值得注意的是，只有整型可以这样写，其他类型都不行！！！

这个语法跟前面我们讲的也有点冲突，但它确实存在，我们在这里就认为是一个特殊处理吧。
不过这样我们也就可以写这样的代码了：

 
 

12. 友元

---

友元提供了一种突破封装的方式，有时提供了便利。但是友元会增加耦合度，破坏了封装，所以友元不宜多用。

友元分为：友元函数和友元类

 

12.1 友元函数

问题：现在尝试去重载operator << ，然后发现没办法将operator << 重载成成员函数。因为cout的输出流对象和隐含的this指针在抢占第一个参数的位置。this指针默认是第一个参数也就是左操作数了。但是实际使用中cout需要是第一个形参对象，才能正常使用。所以要将operator << 重载成全局函数。但又会导致类外没办法访问成员，此时就需要友元来解决。operator >> 同理。

class Date
{
public:
	Date(int year, int month, int day)
		: _year(year)
		, _month(month)
		, _day(day)
	{}
	// d1 << cout; -> d1.operator<<(&d1, cout); 不符合常规调用
// 因为成员函数第一个参数一定是隐藏的this，所以d1必须放在<<的左侧
	ostream& operator<<(ostream& _cout)
	{
		_cout << _year << "-" << _month << "-" << _day << endl;
		return _cout;
	}
private:
	int _year;
	int _month;
	int _day;
};

友元函数可以直接访问类的私有成员，它是定义在类外部的普通函数，不属于任何类，但需要在类的内部声明，声明时需要加friend关键字。

class A
{
public:
	A(int a)
		:_a(a)
	{}
private:
	int _a;
	const static int _b = 0;
	int _arr[_b];
};


class Date
{
	friend ostream& operator<<(ostream& _cout, const Date& d);
	friend istream& operator>>(istream& _cin, Date& d);
public:
	Date(int year = 1900, int month = 1, int day = 1)
		: _year(year)
		, _month(month)
		, _day(day)
	{}
private:
	int _year;
	int _month;
	int _day;
};
ostream& operator<<(ostream& _cout, const Date& d)
{
	_cout << d._year << "-" << d._month << "-" << d._day;
	return _cout;
}
istream& operator>>(istream& _cin, Date& d)
{
	_cin >> d._year;
	_cin >> d._month;
	_cin >> d._day;
	return _cin;
}
int main()
{
	Date d;
	cin >> d;
	cout << d << endl;
	return 0;
}

说明：

• 友元函数可访问类的私有和保护成员，但不是类的成员函数
• 友元函数不能用像成员函数修饰this指针那样加const修饰
• 友元函数可以在类定义的任何地方声明，不受类访问限定符限制
• 一个函数可以是多个类的友元函数
• 友元函数的调用与普通函数的调用原理相同

 

12.2 友元类

友元类的所有成员函数都可以是另一个类的友元函数，都可以访问另一个类中的非公有成员。

• 友元关系是单向的，不具有交换性。
  比如上述Time类和Date类，在Time类中声明Date类为其友元类，那么可以在Date类中直接访问Time类的私有成员变量，但想在Time类中访问Date类中私有的成员变量则不行。
• 友元关系不能传递
  如果C是B的友元， B是A的友元，则不能说明C时A的友元。
• 友元关系不能继承，在后面章节详细介绍。

class Time
{
	friend class Date; // 声明日期类为时间类的友元类，则在日期类中就直接访问Time类中的私有成员变量
public:
	Time(int hour = 0, int minute = 0, int second = 0)
		: _hour(hour)
		, _minute(minute)
		, _second(second)
	{}

private:
	int _hour;
	int _minute;
	int _second;
};
class Date
{
public:
	Date(int year = 1900, int month = 1, int day = 1)
		: _year(year)
		, _month(month)
		, _day(day)
	{}

	void SetTimeOfDate(int hour, int minute, int second)
	{
		// 直接访问时间类私有的成员变量
		_t._hour = hour;
		_t._minute = minute;
		_t._second = second;
	}

private:
	int _year;
	int _month;
	int _day;
	Time _t;
};

 
 

13. 内部类

概念：如果一个类定义在另一个类的内部，这个内部类就叫做内部类。内部类是一个独立的类，它不属于外部类（内部类本质还是全局类，只是被外部类封装了一下。），更不能通过外部类的对象去访问内部类的成员。外部类对内部类没有任何优越的访问权限。

注意：内部类就是外部类的友元类，参见友元类的定义，内部类可以通过外部类的对象参数来访问外部类中的所有成员。但是外部类不是内部类的友元。

特性：

1. 内部类可以定义在外部类的public、protected、private都是可以的。
2. 注意内部类可以直接访问外部类中的static成员，不需要外部类的对象/类名。
3. sizeof(外部类)=外部类，和内部类没有任何关系。

class A
{
private:
 static int k;
 int h;
public:
// B就是一个普通类,只是受A的类域和访问限定符限制
 class B // B天生就是A的友元:B可以访问A的私有,A不能访问B的私有
 {
 public:
 void foo(const A& a)
 {
 cout << k << endl;//OK
 cout << a.h << endl;//OK
 }
 };
};
int A::k = 1;
int main()
{
    A::B b;
    b.foo(A());
    
    return 0;
}

我们来看一道有意思的题：OJ链接

我们在这里通过C++的语法就能直接过了：

class Solution {
    // 内部类
    class Sum
    {
    public:
        Sum()
        {
            _ret += _i;
            ++_i;
        }
    };
    // Sum是Solution的友元
public:
    int Sum_Solution(int n) {
        Sum arr[n];

        return _ret;
    }
private:
    static int _i;
    static int _ret;
};

int Solution:: _i = 1;
int Solution:: _ret = 0;

 
 

14. 匿名对象

class A
{
public:
	A(int a = 0)
		:_a(a)
	{
		cout << "A(int a)" << endl;
	}
	~A()
	{
		cout << "~A()" << endl;
	}
private:
	int _a;
};
class Solution {
public:
	int Sum_Solution(int n) {
		//...
		return n;
	}
};
int main()
{
	A aa1;
	// 不能这么定义对象，因为编译器无法识别下面是一个函数声明，还是对象定义
	//A aa1();
	// 但是我们可以这么定义匿名对象，匿名对象的特点不用取名字，
	// 但是他的生命周期只有这一行，我们可以看到下一行他就会自动调用析构函数
	A();
	A aa2(2);
	// 匿名对象在这样场景下就很好用，当然还有一些其他使用场景，这个我们以后遇到了再说
	Solution().Sum_Solution(10);
	return 0;
}

 
 

15. 拷贝对象时的一些编译器优化

看这节之前，我介意先看一下这篇文章：《类的默认成员函数》，这里才能看得通透一点

在传参和传返回值的过程中，一般编译器会做一些优化，减少对象的拷贝，这个在一些场景下还是非常有用的。

class A
{
public:
	A(int a = 0)
		:_a(a)
	{
		cout << "A(int a)" << endl;
	}
	A(const A& aa)
		:_a(aa._a)
	{
		cout << "A(const A& aa)" << endl;
	}
	A& operator=(const A& aa)
	{
		cout << "A& operator=(const A& aa)" << endl;
		if (this != &aa)
		{
			_a = aa._a;
		}
		return *this;
	}
	~A()
	{
		cout << "~A()" << endl;
	}
private:
	int _a;
};


void f1(A aa)
{}


A f2()
{
	A aa;
	return aa;
}
int main()
{
	// 传值传参
	A aa1;
	f1(aa1);
	cout << endl;
	// 传值返回
	f2();
	cout << endl;
	// 隐式类型，连续构造+拷贝构造->优化为直接构造
	f1(1);
	// 一个表达式中，连续构造+拷贝构造->优化为一个构造
	f1(A(2));
	cout << endl;
	// 一个表达式中，连续拷贝构造+拷贝构造->优化一个拷贝构造
	A aa2 = f2();
	cout << endl;
	// 一个表达式中，连续拷贝构造+赋值重载->无法优化
	aa1 = f2();
	cout << endl;
	return 0;
}

总结：

1. 接收返回值对象，尽量用拷贝构造的方式接收，不要赋值接收
2. 函数中返回对象时，尽量返回匿名对象

16. 再次理解类和对象

---

现实生活中的实体计算机并不认识，计算机只认识二进制格式的数据。如果想要让计算机认识现实生活中的实体，用户必须通过某种面向对象的语言，对实体进行描述，然后通过编写程序，创建对象后计算机才可以认识。比如想要让计算机认识洗衣机，就需要：

1. 用户先要对现实中洗衣机实体进行抽象-- - 即在人为思想层面对洗衣机进行认识，洗衣机有什么属性，有那些功能，即对洗衣机进行抽象认知的一个过程
2. 经过1之后，在人的头脑中已经对洗衣机有了一个清醒的认识，只不过此时计算机还不清楚，想要让计算机识别人想象中的洗衣机，就需要人通过某种面相对象的语言(比如：C++、Java、Python等)将洗衣机用类来进行描述，并输入到计算机中
3. 经过2之后，在计算机中就有了一个洗衣机类，但是洗衣机类只是站在计算机的角度对洗衣机对象进行描述的，通过洗衣机类，可以实例化出一个个具体的洗衣机对象，此时计算机才能洗衣机是什么东西。
4. 用户就可以借助计算机中洗衣机对象，来模拟现实中的洗衣机实体了。

在类和对象阶段，大家一定要体会到，类是对某一类实体(对象)来进行描述的，描述该对象具有那些属性，那些方法，描述完成后就形成了一种新的自定义类型，才用该自定义类型就可以实例化具体的对象。