类
类修饰符 class 类名
{
}
- public:是类的修饰符,下面介绍常使用的几个类修饰符
- new:仅允许在嵌套类声明时使用,表明类中隐藏了由基类中继承而来的、与基类中同名的成员。
- public:不限制对该类的访问。
- protected:只能从其所在类和所在类的子类(派生类)进行访问。
- internal:只有其所在类才能访问。
- private:只有.Net中的应用程序或库才能访问。
- abstract:抽象类,不允许建立类的实例。
- sealed:密封类,不允许被继承。
构造函数和析构函数
构造函数和析构函数是类中比较特殊的两种成员函数,主要用来对对象进行初始化和回收对象资源。一般来说,对象的生命周期从构造函数开始,以析构函数结束。
简明来说就是当我实例化了一个ProgramClass类,他在第一时间就会执行构造函数,当我用完了ProgramClass类,他会自动执行析构函数。
析构函数
不能在结构中定义析构函数。只能对类使用析构函数。
一个类只能有一个析构函数。
无法继承或重载析构函数。
无法调用析构函数。它们是被自动调用的。
析构函数既没有修饰符,也没有参数。
析构函数一般都是在程序结束时才执行
类代码:
class ProgramClass
{
public ProgramClass()//构造函数,
{
Console.WriteLine("构造函数");
}
public void Shownum()
{
Console.WriteLine("这是Shownum函数");
}
~ProgramClass()//析构函数
{
Console.WriteLine("析构函数");
}
}
主函数代码:
static void Main(string[] args)
{
/*测试构造函数和析构函数*/
ProgramClass pc = new ProgramClass();
pc.Shownum();
}
输出:
构造函数
这是Shownum函数
析构函数
类的面向对象特性
主要内容在上一篇(面向对象OOP的三个基本特征)
类的封装
class Myclass //创建一个类
{
private int x = 0;//创建私有变量x
private int y = 0;//创建私有变量y
public int X//属性
{
get
{
return x;
}
set
{
x = value;
}
}
public int Y
{
get
{
return y;
}
set
{
y = value;
}
}
public int Add()
{
return x + y;
}
}
主函数:
/*类的封装*/
Myclass mc = new Myclass();//实例化对象
mc.X = 6;
mc.Y = 7;
Console.WriteLine("x+y={0}", mc.Add());
类的多态
-
在类的继承中,C#允许在基类与派生类中声明具有同名的方法,而且同名的方法可以有不同的代码,也就是说在基类与派生类的相同功能中可以有不同的实现方法,从而为解决同一问题提供多种途径。
-
多态性就是指在程序运行时,执行的虽然是一个调用方法的语句,却可以根据派生类对象的类型的不同完成方法不同的具体实现。
在C#中可以通过多种途径实现多态性:
- 虚方法:将父类的方法标记为虚方法,使用关键字virtual,此方法在子类中可以重写(使用关键字override)
2.== 抽象类与抽象方法==:如果我们不需要使用父类创建对象,它的存在只是为供子类继承。可以将父类写成抽象(关键字abstract)类,将父类的方法写成抽象方法,子类中的方法仍用关键字override重写。
3.接口实现:
我们选择使用虚方法实现多态还是抽象方类抽象方法实现多态,取决于我们是否需要使用基类实例化的对象。
-
抽象类:不需要使用基类实例化的对象
-
虚方法:需要使用基类实例化的对象
举例:
-
现有Clerk(基类),ProjectManager(继承类),此时需要使用虚方法来实现多态,因为我们需要使用Clerk创建的对象,这些对象是普通员工对象 职员(Clerk)需要有工作计划,经理(ProjectManager)也需要有工作计划
-
现有Drink类作为基类,Milk,Tea类继承Drink,我们需要使用的是Milk和Tea创建对象,无需Drink创建对象,此时将Drink写成抽象类
茶(Tea)可以饥渴,牛奶(Milk)也可以解渴————此时抽象出一个饮料(Drink)类作为基类
采用虚拟方法代码如下:
class Clerk
{
public virtual void WorkPlan() // 此处采用virtual方法
{
Console.WriteLine("我是职员,我需要有工作计划");
}
}
class ProjectManager:Clerk // 继承于Clerk
{
public override void WorkPlan() // 用override进行重写
{
Console.WriteLine("我是经理,我也需要有工作计划");
}
}
class Program
{
static void Main(string[] args)
{
Clerk myClerk = new Clerk();
ProjectManager myPM = new ProjectManager();
Clerk[] clerk = { myClerk, myPM };
foreach (Clerk outclerk in clerk)
outclerk.WorkPlan();
Console.ReadKey();
}
}
采用抽象方法代码如下:
abstract class Drink
{
public abstract void drink(); // 使用抽象化方法时,不能有方法体
}
class Milk:Drink
{
public override void drink()
{
Console.WriteLine("我是牛奶,我可以解渴");
}
}
class Tea:Drink
{
public override void drink()
{
Console.WriteLine("我是茶,我可以解渴");
}
}
class Program
{
static void Main(string[] args)
{
Drink myMilk = new Milk(); // 此处注意抽象类Drink是不能进行实例化的
Drink myTea = new Tea();
Drink[] drink = { myMilk, myTea };
foreach (Drink outDrink in drink)
outDrink.drink();
Console.ReadKey();
}
}
我的多态程序
类:
class Myclass
{
private int x = 0;
private int y = 0;
public int X
{
get
{
return x;
}
set
{
x = value;
}
}
public int Y
{
get
{
return y;
}
set
{
y = value;
}
}
public virtual int Add()
//定义一个virtual类型的方法,以便在子类(派生类)中重写该方法
{
return X + Y;
}
}
class MyClass2 : Myclass
{
public override int Add()//重写求和方法
{
//int x = 5;
//int y = 7;
return X+ Y;
}
}
主函数:
/*类的多态*/
MyClass2 mc2 = new MyClass2();
//使用子类(派生类)MyClass2的对象实例化基类Myclass的对象
Myclass mc1=(Myclass)mc2;
mc1.X = 3;
mc1.Y = 5;
Console.WriteLine(mc2.Add());
Console.WriteLine(mc1.Add());
注意
1.virtual修饰符不能与private、static、abstract或者override修饰符同时使用。
2.override修饰符不能与new、static或者virtual修饰符同时使用,并且重写方法只能用于重写基类中的虚方法。
3.C#中,继承、虚方法和重写方法组合在一起才能实现多态性。