【 塔 · 第 二 条 约 定 】
【 塔 · 第 二 条 约 定 】
一、c#整理private、protected、public、abstract等的异同
-
private：private是完全私有的，只有在类自己里面可以调用，在类的外部和子类都不能调用，子类也不能继承父类的private的属性和方法。
-
protected：虽然可以被外界看到，但外界不可以调用（相当于隐私），只有自己及自己的子类可以调用，其属性和方法都可以被他的子类继承和调用。
-
public：对任何类和成员都完全公开，无访问限制。
-
abstract：抽象类只能被继承而不能被实例化。抽象类被继承后，继承类仍然可以是抽象类，若子类是可定义对象的实体类，那么抽象类的所有成员变为实体成员。
- private 和protected：在同一类中可视为一样，但在继承中不同，private在子类中不可被访问，而protected可以。
- public与其他的不同：其成员可以跨程序集，而其他类型的不可。
- abstract类多用来定义类，与public连用
public abstract class Employee
{
protected string id;//受保护的类型，如同隐私只能由部分人知道，若为private类型，则不能被子类调用
public abstract string Id{get;set;}
public abstract int Add(int a,int b);
}
public class Employee1 : Employee//Employee1继承了Employee，Employee中所有方法属性都能被其调用
{
public override string Id
{
get
{
return id;
}
set
{
id = value;
}
}
public override int Add(int a,int b)
{
return a + b;
}
}
2、有关继承、多态等概念
- 继承：可让你重用代码，节省程序设计，在类之间建立一种关系，使子类的实例可以继承已有的父类的方法和属性，且可以加入新的特性或者修改已有的特性建立起类的新层次。现实中许多实体之间具有共同特性也存在内在差别，我们可以分块描述差别，让这些差别继承其共性。这就是继承。一个类从另一个类派生出来时，子类从父类那里继承特性。子类也可以作为其它类的父类。从一个父类派生出来的多层类形成了类的层次结构。
注意：C#中，子类只能继承一个父类。
using System ;
class Vehicle //定义交通工具(汽车)类
{
public int wheels ; //公有成员：轮子个数
protected float weight ; //保护成员：重量
public Vehicle( ){get;set;}
public Vehicle(int w,float g)
{
wheels = w ;
weight = g ;
}
public void Speak( )
{
Console.WriteLine( "交通工具的轮子个数是可以变化的! " ) ;
}
} ;
class Car:Vehicle //定义轿车类：从汽车类中继承,相当于is-a，汽车是轿车
{
private int passengers ; //私有成员：乘客数
public Car(int w , float g , int p) : base(w, g)//调用父类的方法
{
wheels = w ;
weight = g ;
passengers=p ;
}
}
Vehicle 作为父类，体现了"汽车"这个实体具有的公共性质：汽车都有轮子和重量。Car 类继承了Vehicle 的这些性质，并且添加了自身的特性：可以搭载乘客。
继承规则
- 继承是可传递的。如果B是C的父类，A是B的父类，那么C不仅继承了B中声明的成员，同样也继承了A中的成员。Object 类作为所有类的基类。
- 子类应当是对父类的扩展。子类可以添加新的成员，但不能除去已经继承的成员的定义。
- 构造函数和析构函数不能被继承。除此以外的其它成员，不论对它们定义了怎样的访问方式，都能被继承。父类中成员的访问方式 只能决定子类能否访问它们。
- 子类如果定义了与继承而来的成员同名的新成员，就可以覆盖已继承的成员。但这并不因为这派生类删除了这些成员，只是不能再访问这些成员。
- 类可以定义虚方法、虚属性以及虚索引指示器，它的子类能够重载这些成员，从而实现类可以展示出多态性。
- 派生类只能从一个类中继承，可以通过接口实现多重继承。
using System ;
public class ParentClass
{
public ParentClass( )
{
Console.WriteLine("父类构造函数。");
public void print( )
{
Console.WriteLine("I'm a Parent Class。") ;
}
}
}
public class ChildClass : ParentClass
{
public ChildClass( )
{
Console.WriteLine("子类构造函数。") ;
}
public static void Main( )
{
ChildClass child = new ChildClass( ) ;
child.print( ) ;
}
}
程序运行输出：父类构造函数。子类构造函数。I'm a Parent Class。
-
多态：
在运行时，可以通过指向父类的指针，来调用实现子类中的方法。可以把一组对象放到一个数组中，然后调用它们的方法，在这种场合下，多态性作用就体现出来了，这些对象不必是相同类型的对象。当然，如果它们都继承自某个类，你可以把这些子类，都放到一个数组中。如果这些对象都有同名方法，就可以调用每个对象的同名方法。 同一操作作用于不同的对象，可以有不同的解释，产生不同的执行结果，这就是多态性。
多态性通过子类重父类中的虚函数型方法来实现。在面向对象的系统中，多态性是一个非常重要的概念，它允许客户对一个对象进行操作，由对象来完成一系列的动作，具体实现哪个动作、如何实现由系统负责解释。
在C#中，多态性的定义是：同一操作作用于不同的类的实例，不同的类将进行不同的解释，最后产生不同的执行结果。
C#支持两种类型的多态性：
● 编译时的多态性 ：编译时的多态性是通过重载来实现的。对于非虚的成员来说，系统在编译时，根据传递的参数、返回的类型等信息决定实现何种操作。
● 运行时的多态性：运行时的多态性就是指直到系统运行时，才根据实际情况决定实现何种操作。C#中，运行时的多态性通过虚成员实现。
编译时的多态性为我们提供了运行速度快的特点，而运行时的多态性则带来了高度灵活和抽象的特点。
可以用不同的方式实现组件中的多态性：
- 接口多态性。
● 继承多态性。
● 通过抽象类实现的多态性。
using System ;
public class DrawingBase
{
public virtual void Draw( )
{
Console.WriteLine("I'm just a generic drawing object.") ;
}
}
public class Line : DrawingBase
{
public override void Draw( )
{
Console.WriteLine("I'm a Line.") ;
}
}
public class Circle : DrawingBase
{
public override void Draw( )
{
Console.WriteLine("I'm a Circle.") ;
}
}
public class Square : DrawingBase
{
public override void Draw( )
{
Console.WriteLine("I'm a Square.") ;
}
}
public class DrawDemo
{
public static int Main(string[] args)
{
DrawingBase [] dObj = new DrawingBase [4];
dObj[0] = new Line( ) ;
dObj[1] = new Circle( ) ;
dObj[2] = new Square( ) ;
dObj[3] = new DrawingBase( ) ;
foreach (DrawingBase drawObj in dObj)
drawObj.Draw( ) ;
return 0;
}
}
