面向对象基础(勿进，自用）

类与实例

class 定义类的关键字
第一：类名称首字母大写，多个单词则各个首字母大写
第二：对外公开的方法需要用“public”修饰符。
实例化就是创建对象的过程，使用new关键字来创建。

构造方法

对类进行初始化，构造方法与类同名，无返回值，也不需要void，在new时候调用。

class Cat{
	pubic Cat(string name){
		this.name = name;
	}
	……
}

方法重载

方法重载提供了创建同名的多个方法的能力，但这些方法需使用不同的参数类型。

class Cat{
	pubic Cat(string name){
		this.name = name;
	}
	pubic Cat(){
		this.name = "";
	}
	……
}

方法重载时，两个方法必须方法名相同。但是参数类型或者个数必须要有所不同。好处是：在不改变原方法的基础上，新增功能。

属性与修饰符

属性有两个方法get和set。可以看作是可读和可写。

private int shotNum=3;
public int ShoutNum{
	get{
		return shoutNum;
	}
	set{
		if (value <= 10)
			shoutNum = value;
		else
			shoutNum = 10;
	}
}

cat.ShoutNum = 5;//给属性赋值

封装

每个对象都包含它能进行操作所需要的所有信息，这个特性称为封装，因此对象不必依赖其他对象来完成自己的操作。这样的方法和属性包装在类中，通过类的实例来实现。
封装的好处：
1、良好的封装能减少耦合。
2、类内部的实现可以自由地修改。
3、类具有清晰的对外接口。

继承

如果子类继承于父类，
第一：子类拥有父类非private的属性和功能；
第二：子类具有自己的属性和功能，即子类可以扩展父类没有的属性和功能；
第三：子类还可以以自己的方式实现父类的功能（方法重写）。

protected表示继承时子类可以对基类有完全访问权。用protected修饰的类成员，对子类公开，但不对其他类公开。

class Cat : Animal{
	public Cat() : base()
	{}
	public Cat(string name) : base(name)
	{}

class Dog : Animal{
	public Dog() : base()
	{}
	public Dog(string name) : base(name)
	{}

继承的优点：继承使得所有子类公共的部分都放在了父类，使得代码得到了共享，避免了重复；继承使得修改或扩展继承而来的实现都较为容易。
继承的缺点：父类变，子类不得不变。继承破坏包装，父类的实现细节暴露给子类。继承是一种类与类之间强耦合的关系。

多态

多态表示不同的对象可以执行相同的动作，但是要通过它们自己的实现代码来执行。
注意：第一，子类以父类的身份出现。第二，子类在工作时以自己的方式实现。第三，子类以父类的身份出现时，子类特有的属性和方法不可以使用。

怎么使用呢？
虚方法：为了使子类的实例完全接替来自父类的类成员，父类必须将该成员声明为虚拟的。返回类型之前添加virtual关键字。
方法重写：子类可以选择使用override关键字，将父类实现替换为它自己的实现，这就是方法重写Override。

class Animal{
	……
	//修饰符中添加了一个virtual，表示此方法是虚方法，可以被子类重写。
	public virtual string Shout(){
		return "";
	}
}

class Cat : Animal{
	public Cat() : base()
	{}
	public Cat(string name) : base(name)
	{}
	//添加了override，表示方法重写
	public override string Shout(){
		……
	}

Animal animal = new Cat();

Cat cat = new Cat();
Animal animal = cat;

重构

抽象类

class Animal{
	……
	protected virtual string getShoutSound(){
			return "";
	}
}

变成

abstract class Animal{
	……
	protected abstract string getShoutSound();
	//抽象方法没有方法体，直接加;
}

第一：抽象类不能实例化。
第二：抽象方法是必须被子类重写的方法。
第三：如果类中包含抽象方法，那么类就必须定义为抽象类。

接口

声明一IChange接口，此接口有一个方法ChangeThing

interface IChange{
	string ChangeThing(string thing);
}

class MechineCat: Cat, IChange{
	public MachineCat():base(){
	}
	public MachineCat(string name):base(name){
	}
	public string ChangeThing(string thing){
		return base.Shout() + "万能口袋" + thing;
	}
}

抽象类和接口的区别

抽象类可以给出一些成员的实现，接口却不包含成员的实现
抽象类的抽象成员可以被子类部分实现，接口的成员需要实现类完全实现
一个类只能继承一个抽象类，但可以实现多个接口。
注意：
第一：类是对对象的抽象，抽象类是对类的抽象；接口是对行为的抽象。
第二：如果行为跨越不同类的对象，可使用接口；对于一些相似的类对象，用继承抽象类。
第三：从设计角度讲，抽象类是从子类中发现了公共的东西，泛化出父类，然后子类继承父类，而接口是根本不知道子类的存在，方法如何实现还不确认，预先定义。

抽象类 自底而上抽象出来
接口 自顶向下设计出来

集合

泛型