9.1 继承的概念
继承：
基类（父类）
派生类（子类）
派生类中自动拥有了父类的定义的变量和函数，每个派生类也可以成为其他新派生类的父类；
9.2 由父类派生子类
1.继承的语法：
eg
class Animal //(1)定义父类
{
public double weight;
private double temperature;
public Animal()
{
weight = 0;
temperature = 0;
}
public void eat()
{
Console.WriteLine("eat");
}
public void breathe()
{
Console.WriteLine("breathe");
}
public void sleep()
{
Console.WriteLine("sleep");
}
}
class Mammal:Animal //（2）定义子类：继承于父类
{
private string skins;
public Mammal()
{
skins = "皮";
}
public string Skins
{
set { skins = value; }
get { return skins; }
}
public void run()
{
Console.WriteLine("run");
}
public void scukle()
{
Console.WriteLine("scukle");
}
}
class Program
{
static void Main(string[] args)
{
Mammal best = new Mammal();
Console.WriteLine(best.weight); // （3）使用继承于父类中的属性
Console.WriteLine(best.Skins); // 使用新添加的属性
best.eat(); //使用继承于父类中方法
best.run();//使用子类添加的方法
Console.ReadKey();
}
}
9.3 protected 成员
父类中的private修饰成员，只能在类自己内部使用，不能再子类中使用；解决这个问题有两种方法：
（1）此时使用protected 修饰，protected 成员不能被类外部使用，但是在子类总使用（如果将成员修饰符换成public，但是这样会让类失去封装性）；
（2）定义一个public的属性实现；
private成员：只有本类内能使用（本类的对象都不能使用）
class Animal
{
private double weight;
}
class dog:Animal
{
void print()
{
weight=30; //error,无法访问
}
}
class Program
{
static void Main(string[] args)
{
Animal a = new Animal();
a.weight = 30; //error,无法访问
}
}
}
protected 成员：只有本类（废话）和子类中能使用
class Animal
{
protected double weight;
}
class dog:Animal
{
void print()
{
weight=30; //protected 成员，子类可以访问
}
}
class Program
{
static void Main(string[] args)
{
Animal a = new Animal();
a.weight = 30; //protected 成员，外部无法访问
}
}
}
9.4 虚函数与重写
（1）虚函数就是用vortual修饰的函数，一般在基类上设计虚函数，在派生类中重写（Override）；
class Animal
{
private double temperature; //(1)虚函数
public virtual void eat()
{
Console.WriteLine("eat");
}
}
class dog : Animal
{
private double temperature;
public override void eat() //重写虚函数
{
Console.WriteLine("dog eat");
}
}
class Program
{
static void Main(string[] args)
{
dog g = new dog();
g.eat();
Console.ReadKey();
}
}
（2）重新（override）与重载：
重载：是指在同一个类中，有多个函数名相同，但是参数类型/个数不同的多个函数；重载发生在同一个类中；（系统根据调用的 实参数个数和类型自动匹配对应重载的函数）
重写：是指子类中定义了和父类同名的函数，并改写这个方法；重写发生在继承关系中；（系统根据对象的实际类型调用对应函数，如果对象是父类对象，就调用父类中方法，如果是是子类对象，则调用子类对象）
9.5 函数的隐藏
派生类可以使用new 关键修饰函数，从而隐藏基类中的同名函数；
class Animal
{
public void eat()
{
Console.WriteLine("eat");
}
}
class dog : Animal
{
public new void eat() //new 关键字
{
Console.WriteLine("dog eat");
}
}
class Program
{
static void Main(string[] args)
{
dog g = new dog();
g.eat();
Animal a = new Animal();
a.eat();
Console.ReadKey();
}
}
6.6 Base关键字
利用关键字base，可以在子类中（只能在子类中）调用父类的重写的后者隐藏方法；
class Animal
{
public void eat()
{
Console.WriteLine("eat");
}
}
class dog : Animal
{
public new void eat()
{
base.eat(); //base关键字
}
}
6.7抽象类和抽象函数
（1）抽象类：就是用就是用Abstrct修饰的类
（a）抽象类不能实例化；
（b）抽象类和抽象函数，抽象属性没有什么必然关系，抽象类内部可以是抽象方法，也可以是一般法方法，或者都有都可以（但是有抽象方法的类一定是抽象类）；
（c）如果一个非抽象类继承抽闲类，这个子类，必须要实现(用重新)抽象父类中所有抽象方法，否则，这个类就必须还是抽闲函数；
public abstract class Animal
{
private void eat()
{
Console.WriteLine("");
}
public abstract void run();
public abstract void sleep();
}
public class dog : Animal //错误，子类没有重写完父类所有抽象方法，这个类必须还是抽象函数
{
public override void run(){}
//
}
（2）抽象函数：就是用就是用Abstrct修饰的函数（）
（a）抽闲函数是一种特殊的虚函数，必须在抽闲类中定义；有抽象方法的类一定是抽象类；
（b）抽闲函数定义时候只能有函数签名，不能有任何执方法体（包含{}都不能有）；
public abstract class Animal
{
private void eat()
{
Console.WriteLine("");
}
public abstract void run(){}; //错误，抽象方法不能有任何方法体
public abstract void sleep();
}
（C）抽象方法，抽象属性必须为public，否则编译出错；
abstract class Animal
{
private void eat()
{
Console.WriteLine("eat");
}
abstract void run(); //错误抽象成员不能为私有的，只能为public
public abstract void sleep();
}
（3）抽闲属性：
（a）也可以定义抽象属性：抽象属性也不能有任何实现代码（{}都不能有）
abstract class Animal
{
abstract public int Age
{
set; //不能有属性也不能有具体实现，（{}都不能有）
get;
}
}
（b）同样的，抽闲属性，也必须在继承类全部中用overridi，重写，否则这个类也必须为抽象类；
abstract class Animal
{
string name;
abstract public int Age //抽象属性
{
set;
get;
}
}
class dog : Animal
{
public override int Age //重写属性
{
set { }
get { return 3; }
}
}
（4）小结：
（1）含有抽象方法或者抽象属性（字段不能为抽象的）的类必须是抽象类；
（2）抽象成员必须为public的；抽象成员不能有任何的实现体（包含{}）
（3）如果一个实体继承抽象类，那么子类必须实现所有的抽象方法和属性，否则这个类必须还是抽象累；
（4）抽象类不能直接实例化，抽象方法/属性不能直接使用，必须在子类中用overridie重写；