面向对象基础_动物运动会.cpp

设计模式：工厂模式、单例模式的基本实现

对象:
1. 一切事物皆为对象, 即所有的东西都是对象, 对象就是可以看到、感觉到、听到、触摸到、尝到或闻到的东西。
2. 对象是一个自包含的实体，用一组可识别的特性和行为来标识。

面向对象编程：
Object-Oriented Programming。是针对对象来编程的开发方式


动物运动会：






1. 实现一声猫叫：
int main()
{
	cout << "喵" << endl;
}



2. 想让猫多叫几声：
void Shout()
{
	cout << "喵" << endl;
}
int main()
{
	Shout();
}

缺点：
	好比，居委会的公用电视放在你家，而别人都没有，于是街坊邻居大都来你家看电视。

类：
	就是具有相同属性和功能的对象的抽象的集合。
注意：
	1. 类名称首字母应该大写。多个单词则各个首字母大写。
	2. 对外公开的方法需要用"public"修饰符。



3. 使用类实现猫叫：
class Cat
{
public:
	void Shout()
	{
		cout << "喵" << endl;
	}
};
int main()
{
/*
	// C++中静态创建对象
	Cat cat;
	cat.Shout();
*/
	// C++中动态创建对象
	Cat *cat = new Cat;
	cat->Shout();
	delete cat;
}

Cat 实例化后，就等同于生了一只小猫cat, 此时就可以让小猫cat->Shout()了。

实例：
	就是一个真实的对象。例如：我们都是'人'，而你我其实就是'人'类的实例。
实例化：
	就是创建对象的过程。(动态使用 new 来创建)	



4. 构造函数
class Cat
{
	string name;
public:
	Cat(string name)
	{
		this->name = name;
	}
	void Shout()
	{
		cout << "我的名字叫" << name << " 喵" << endl;
	}
};
int main()
{
	// 在客户端要生成小猫时，就必须要给小猫起名字
	Cat *cat = new Cat("咪咪");
	cat->Shout();
	delete cat;
}

需求：
	希望出生的小猫有个名字，比如叫"咪咪"，当咪咪叫的时候，最好能说 "我的名字叫咪咪，喵" —— 考虑使用构造函数

缺点：
	就目前的代码，当生下一个小猫时，必须给它起名字，如果没有想好名字，则不能创建对象。如果真的不需要起名字也可生出小猫来，可以使用下面的"函数重载"

构造函数：
	1. 又叫构造方法，其实就是对类进行初始化。构造函数与类名同名，无返回值，也不需要 void，在 new 是调用。
	2. 所有类都有构造函数，如果你不编写，则系统默认生成空的构造函数，如你有定义的构造函数，那么默认的构造函数就会失效。



5. 函数(方法)重载
class Cat
{
private:
	string name;
public:
	Cat()
	{
		name = "无名";
	}
	Cat(string name)
	{
		this->name = name;
	}
	void Shout()
	{
		cout << "我的名字叫" << name << " 喵" << endl;
	}
};
int main()
{
	// 不会报错，猫叫时会是"我的名字叫无名 喵"
	Cat *cat = new Cat;
	cat->Shout();
	delete cat;
}

函数重载：
	1. 两个方法的方法名必须相同，但参数类型或个数必须要有所不同，否则重载就没有意义了。
	2. 函数重载可在不改变原方法的基础上，新添加功能。(函数重载提供了函数可扩展的能力)



6. 属性操作

需求：
	小猫叫的次数太少，希望是我让它叫几声，它就叫几声?

分析：
	叫几声并不是必须要实例化的时候就声明的，我们可以在之后规定它叫几声。	

class Cat
{
	string name;
	int shoutNum;
public:
	Cat()
	{
		name = "无名";

		// 初始叫声为3
		shoutNum = 3;
	}
	Cat(string name)
	{
		this->name = name;

		// 初始叫声为3
		shoutNum = 3;
	}
	void setShoutNum(int shoutNum)
	{
		if(shoutNum <= 10)
		{
			this->shoutNum = shoutNum;
		}
		else
		{
			// 最多叫 10 声
			this->shoutNum = 10;
		}
	}
	int getShoutNum()
	{
		return shoutNum;
	}
	void Shout()
	{
		string result = "";

		for(int i=0; i<shoutNum; i++)
		{
			result += " 喵";
		}
		cout << "我的名字叫" << name << result << endl;
	}
};
int main()
{
	Cat *cat = new Cat("mimi");
	cat->setShoutNum(5);
	cat->Shout();
	delete cat;
}
public 和 private 的区别：
	1. public 表示它所修饰的类成员可以允许其它任何类来访问。
	2. private 表示只允许同一类中的成员访问，其它类包括它本身的子类无法访问。如果没有修饰符，默认是 private
	3. 通常属性都是 private ，即私有成员；方法都是 public ，即公有方法。
	4. 举例：
		类: 我们的房子，更多的是不透明的墙。
		private 成员: 房子内的东西。
		public 成员： 门和窗子，可以控制。
		如果全部都声明为 public , 相当于我们的房子是全透明的，或做了不设防的门窗。

	
命名方式：
	1. 属性名一般首字母小写或前加'_'；方法名一般首字母大写

get和set方法：
	1. 属性有两个方法 get 和 set。 
	2. get 返回与声明的属性相同的数据类型，表示的意思是调用时可以得到内部字段的值、引用或指针
	3. set 一般带一个参数，其作用是调用时为内部的属性赋值。


7. 封装:
	1. 每个对象都包含它能进行操作所需要的所有信息, 这个特性称为封装, 因此对象不必依赖其它对象来完成自己的操作. 这样方法和属性包装在类中,通过类的实例来实现.

	2. 封装的好处:
		1). 良好的封装能够减少耦合. (类定义和客户端的其它程序是分开的)
		2). 类内部的实现可以自由地修改.
		3). 类具有清晰的对外接口

添加Dog类:
class Dog
{
	string name;
	int shoutNum;
public:
	Dog()
	{
		name = "无名";

		// 初始叫声为3
		shoutNum = 3;
	}
	Dog(string name)
	{
		this->name = name;

		// 初始叫声为3
		shoutNum = 3;
	}
	void setShoutNum(int shoutNum)
	{
		if(shoutNum <= 10)
		{
			this->shoutNum = shoutNum;
		}
		else
		{
			// 最多叫 10 声
			this->shoutNum = 10;
		}
	}
	int getShoutNum()
	{
		return shoutNum;
	}
	void Shout()
	{
		string result = "";

		for(int i=0; i<shoutNum; i++)
		{
			result += " 汪";
		}
		cout << "我的名字叫" << name << result << endl;
	}
};


8. 继承:
	
	1. 猫和狗都是动物，更准确说它们都是哺乳动物。
	2. 哺乳动物：胎生、哺乳、恒温
	3. 猫和狗与哺乳动物是继承关系

继承说明：
	1. 对象的继承是一种 'is-a' 的关系，如果两个对象A和B，可以描述为 'B是A'，则表明B可以继承A。
	例如：
		'猫是哺乳动物'，说明猫与哺乳动物之间是继承与被继承的关系。
	2. 实际上，继承者还可以理解为是对被继承者的特殊化，因为它除了具备被继承者的特性外，还具备自己独有的个性。
	例如：
		猫有可以抓老鼠，爬树等'哺乳动物'对象则不具备的属性。
	因此：在继承关系中，继承者可以完全替代被继承者，反之则不成立。
	例如：
		'哺乳动物是猫'：有些莫名其妙。
	3. 继承定义了类如何相互关联，共享特性。继承的工作方式是：定义父类和子类，其中子类继承父类的所有特性。子类不但继承了父类的所有特性，还可以定义新的特性。

	4. 学好继承记住三句话：
		1). 子类拥有父类所有的属性和功能。
		2). 子类具有自己的属性和功能。
		3). 子类还可以以自己的方式实现父类的功能(方法重写)
	
	5. protected 表示继承时子类可以对基类有完全访问权。

	6. 子类从它的父类中继承的成员有：属性、方法。
		注意：对于父类的构造函数只能被调用，不能被继承。

	7. 继承的缺点是：
		1). 父类变，子类不得不变。
		2). 继承会破坏包装，父类实现细节暴露给子类，增大了两个类的耦合性(可以理解为'藕断丝连')。
			继承显然是一种类与类之间强耦合的关系。
	
	8.	当两个类之间具备'is-a'的关系时，就可以考虑用继承。表示一个类是两一个类的特殊种类。
		当两个类之间是'has-a'的关系时，表示某个角色具有某一项责任，此时不适合继承。
		例如：
			人有两只手，手不能继承人；
			飞机场有飞机，飞机不能继承飞机场。


//动物类：
class Animal
{
protected:
	string name;
	int shoutNum;
public:
	Animal()
	{
		name = "无名";
		shoutNum = 3;
	}
	Animal(string name)
	{
		this->name = name;
		shoutNum = 3;
	}
	void setShoutNum(int shoutNum)
	{
		if(shoutNum <= 10)
		{
			this->shoutNum = shoutNum;
		}
		else
		{
			this->shoutNum = 10;
		}
	}