类的层次结构有两种基本的构造方式 自顶向下 自底向上
基类的保护成员是指允许派生类的方法代码访问，而不是指通过派生类的对象访问
如果基类中的字段通过公有且可读写的属性进行了封装，那么建议将字段定义为私有的，这样包括其派生类在内的所有其他类型都必须通过属性进行访问
隐藏基类成员
如果派生类中定义了与基类相同的成员，默认情况下基类的成员在派生类中会被隐藏，即派生类成员覆盖了基类成员 用new来修饰提高代码可读性
base 关键字，当派生类隐藏了基类成员时，base关键字就能发挥作用：直接写出的成员名表示派生类的成员，增加了base引用的成员表示被隐藏的基类成员
用base声明创建对象时调用的基类重载构造函数
虚拟方法和重载方法
using System.Collections.Generic;
using System.Linq;
using System.Text; namespace ConsoleApplication1
{
class Program
{
static void Main()
{
foreach (Automobile a in GetAutos())
{
a.Speak();
Console.WriteLine("{0}行驶1000公里需要{1}小时", a.Name, a.Run());
}
//Console.ReadLine();
}
static Automobile[] GetAutos()
{
Automobile[] autos = new Automobile[];
autos[] = new Bus("客车", );
autos[] = new Truck("东风卡车", );
autos[] = new Truck("黄河卡车", );
autos[] = new Automobile("汽车", , );
return autos;
}
} public class Automobile
{
private string name;
public string Name
{
get { return name; }
} private float speed;
public float Speed
{
get { return speed; }
} private float weight;
public float Weight
{
get { return weight; }
set { weight = value; }
} public Automobile(string name, float speed, float weight)
{
this.name = name;
this.speed = speed;
this.weight = weight;
} public virtual float Run(float distance)//虚拟方法
{
return distance / speed;
} public virtual void Speak()
{
Console.WriteLine("汽车鸣笛……");
}
}
public class Bus : Automobile
{
private int passangers;
public int Passangers
{
get { return passangers; }
set { passangers = value; }
}
public Bus(string name, int passangers)
: base(name, , )
{
this.passangers = passangers;
}
public override void Speak()
{
Console.WriteLine("嘀……嘀……");
}
} public class Truck : Automobile
{
private float load;
public float Load
{
get { return load; }
set { load = value; }
}
public Truck(string name, int load)
: base(name, , )
{
this.load = load;
}
public override float Run(float distance)//重载方法
{
return ( + load / Weight / ) * base.Run(distance);
}
public override void Speak()//重载方法
{
Console.WriteLine("叭……叭……");
}
} }
抽象类和抽象方法（抽象类不能直接用new创建对象，但可以与派生类的实例相关联）
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text; namespace ConsoleApplication1
{
class Program
{
static void Main()
{
Vehicle v1 = new Train();
v1.Speak();
Console.WriteLine("行驶1000公里需{0}小时", v1.Run());
v1 = new Truck(, );
v1.Speak();
Console.WriteLine("行驶1000公里需{0}小时", v1.Run());
Console.ReadLine();
}
} public abstract class Vehicle
{
private float speed;
public float Speed
{
get { return speed; }
} public virtual float Run(float distance)
{
return distance / speed;
} public abstract void Speak();//抽象方法：无执行代码 public Vehicle(float speed)
{
this.speed = speed;
}
} public class Train : Vehicle
{
public Train()
: base()
{ } public override void Speak()
{
Console.WriteLine("呜……");
}
} public abstract class Automobile:Vehicle
{
public Automobile(float speed):base(speed)
{ } public override abstract void Speak();//重载+抽象
} public class Truck : Automobile
{
private float weight;
public float Weight
{
get { return weight; }
} private float load;
public float Load
{
get { return load; }
} public Truck(int weight, int load)
: base()
{
this.weight = weight;
this.load = load;
} public override float Run(float distance)
{
return ( + load / Weight / )* base.Run(distance);
} public override void Speak()
{
Console.WriteLine("叭……叭……");
}
}
}
密封类和密封方法
一些类型不允许或是不需要再有派生类型 sealed 密封类是对类继承的截止 密封方法是对类继承中方法重载的截止
sing System;
using System.Collections.Generic;
using System.Linq;
using System.Text; namespace ConsoleApplication1
{
class Program
{
static void Main()
{
Student s1=new Student(,"王小红");
Console.WriteLine(s1);
Student s2=new Graduate(,"王晓红","张大伟");
Console.WriteLine(s2);
Console.WriteLine(s1.Equals(s2));
Console.ReadLine();
}
} public class Student
{
private string name;
public string Name
{
get { return name; }
} private int id;
public int ID
{
get { return id; }
} public Student(int id, string name)
{
this.id = id;
this.name = name;
} public override string ToString()
{
return string.Format("学号{0}，姓名{1}", id, name);
} public sealed override bool Equals(object obj)
{
if (obj is Student && ((Student)obj).id == this.id)
return true;
else
return false;
}
} public class Graduate : Student
{
private string supervisor;
public string Supervisor
{
get { return supervisor; }
set { supervisor = value; }
} public Graduate(int id, string name, string supervisor)
: base(id, name)
{
this.supervisor = supervisor;
} public override string ToString()
{
return base.ToString() + ",导师：" + supervisor;
}
}
}