您的位置:时时app平台注册网站 > 编程知识 > C#中Abstract 、Virtual和Override的施用【时时app平台注

C#中Abstract 、Virtual和Override的施用【时时app平台注

2019-11-28 03:04

public int x;

this.x = x;

public virtual void Pay() { 

}

public abstract void CalculatePay();

x ;

public int x;

public override double Area()

x = 110, y = 150

1) 抽象方法是隐式的虚方法。

sc.y = 150;

{

}

2) 只允许在抽象类中使用抽象方法声明。

{

Console.WriteLine(p.Y);

}

 

结构是隐式密封的;因此它们不能被继承。

public abstract int Y { get; }

//只读封装
public class Department
{
private string department;
public Department(string str)//有参构造函数
{
department = str;
}
public string DepartmentName
{
get { return this.department; }
}

protected double y;

将收到错误信息:

newperson p = new newperson();

class MainClass

protected int y = 200;

密封类在声明中使用sealed 修饰符,这样就可以防止该类被其它类继承。如果试图将一个密封类作为其它类的基类,C#将提示出错。理所当然,密封类不能同时又是抽象类,因为抽象总是希望被继承的。

return 2 * PI * x * x 2 * PI * x * y;

// cs_sealed_keyword.cs

}

static void Main()

base 是子类中引用父类,用于在派生类中访问重写的基类成员。
this 是当前类,引用自己,用于访问本类的成员,当然也包括继承而来公有和保护成员。

{

public Sphere(double r) : base(r,0) { }

public abstract class Employee {

{

{

 

class MyDerivedC: MyClass {} // Error

get { return y 100; }

C#提出了一个密封类(sealed class)的概念,帮助开发人员来解决这一问题。

Sphere sphere = new Sphere(10);

SealedClass sc = new SealedClass();

public abstract class parent

public int y;

{

//2:只写封装
public class SetPart
{
private string setpart;
public string Setpartname
{
set
{
setpart = value;
Console.WriteLine("the Setpartname is:{0}",setpart);
Console.Read();
}
}
}
public class Tester
{
static void Main(string[] args)
{
SetPart s=new SetPart();
s.Setpartname= "my name";

}

示例

1) 抽象类不能实例化。

以下代码展示了一个密封类和一个密封成员。在这个例子中,HourlyEmployee类不能被进一步地细化。此外,HourlyEmployee.Pay方法不能被重写。

return PI * x * x;

}

3.override 方法提供从基类继承的成员的新实现。由 override 声明重写的方法称为重写基方法。重写的基方法必须与 override 方法具有相同的签名。不能重写非虚方法或静态方法。重写的基方法必须是 virtual、abstract 或 override 的。 override 声明不能更改 virtual 方法的可访问性。 override 方法和 virtual 方法必须具有相同的访问级别修饰符。重写属性声明必须指定与继承属性完全相同的访问修饰符、类型和名称,并且被重写的属性必须是 virtual、abstract 或 override 的。

sealed 修饰符可以应用于类、实例方法和属性。密封类不能被继承。密封方法会重写基类中的方法,但其本身不能在任何派生类中进一步重写。当应用于方法或属性时,sealed 修饰符必须始终与 override 一起使用。

Console.WriteLine(base.Area());

sealed class SealedClass

3)注意:
a).在静态成员中使用base和this都是不允许的。原因是,base和this访问的都是类的实例,也就是对象,而静态成员只能由类来访问,不能由对象来访问。
b).base是为了实现多态而设计的。
c).使用this或base关键字只能指定一个构造函数,也就是说不可同时将this和base作用在一个构造函数上。
d).除了base,访问基类成员的另外一种方式是:显示的类型转换来实现。只是该方法不能为静态方法。

sealed修饰符也可以应用在实例方法、属性、事件和索引器上,但是不能应用于静态成员。密封成员可以存在于密封或非密封类中。一个密封成员必须对虚成员或隐含虚成员进行重写,如抽象成员。但是,密封成员自己是不能被重写的,因为它是密封的。sealed修饰符必须与override修饰符结合使用。虽然密封成员不能被重写,但是一个在基类中的密封成员可以用new修饰符在派生类中进行隐藏。重要的是,CLR可以对密封成员进行优化。

}

Console.WriteLine()内部要写pm.DepartmentName而不写department呢????

}

sealed class SealedClass

}

密封类正好与抽象类相反。抽象类型必须被继承,不能为一个抽象类型创建一个实例。相反地,密封类型不能被继承,它是具体的。密封类不能被派生类型细化,它是类层次结构中的终结节点。

y ;

'MyDerivedC' cannot inherit from sealed class 'MyClass'.

public class Dimensions

sealed(参考)

Console.WriteLine(p.X);

Console.WriteLine("x = {0}, y = {1}", sc.x, sc.y);

Console.ReadKey();

密封类:
密封类是类的一种,用sealed修饰,不能用作基类。它也不能抽象类。密封类主要用于防止派生。

5) 在方法或属性声明中使用 abstract 修饰符以指示方法或属性不包含实现。


Console.WriteLine(p.Y);

在类声明中使用 sealed 修饰符可防止继承此类,例如:

public virtual double Area()

public sealed override void Pay() {

    CalculatePay();

}

public override void CalculatePay() {

}

public override int Y

{

get { return x 100; }

}

Console.ReadKey();

    }
}//问题:这个测试函数部分是怎样的执行过程啊?语句s.Setpartname= "my name"就是给属性赋值吧?为什么会执行了  Console.WriteLine()?而且内部为什么不写s.Setpartname而写setpart呢?

(1)抽象类具有以下特性:

public sealed class HourlyEmployee: Employee {

}

using System;

}

}

static void Main(string[] args)

封装函数:

}

public int y;

}

将密封类用作基类或将 abstract 修饰符与密封类一起使用是错误的。

}

输出

public override double Area()

sc.x = 110;

1)base作用:用于从派生类中访问基类的成员,调用基类上已被其他方法重写的方法。指定创建派生类实例时应调用的基类构造函数。

}

2. virtual关键字用于修饰方法、属性、索引器或事件声明,并使它们可以在派生类中被重写。虚拟成员的实现可由派生类中的重写成员更改。调用虚方法时,将为重写成员检查该对象的运行时类型。将调用大部分派生类中的该重写成员,如果没有派生类重写该成员,则它可能是原始成员。默认情况下,方法是非虚拟的。不能重写非虚方法。virtual 修饰符不能与 static、abstract, private 或 override 修饰符一起使用。和抽象方法的相同点是都用了override关键字进行重写方法,不同点是抽象方法必须存在于抽象类中,而子类必须重写,除非子类也是抽象的。

在前面的示例中,如果试图通过使用下面的语句从密封类继承:

Console.WriteLine(p.X);

}
public class Tester
{
    static void Main(string[] args)
    {
        Department pm = new Department("myName");
        Console.WriteLine("pm.DepartmentName is:{0}", pm.DepartmentName);
        Console.Read();

    }问题:调用有参构造函数时应该是把字符串"naName"赋值给了私有字段department了吧?那为什么

public abstract int X { get; }

{

注:从静态方法中使用 base 关键字是错误的。
2)区别:

{

{

  1. abstract 修饰符指示所修饰的内容缺少实现或未完全实现。 abstract 修饰符可用于类、方法、属性、索引器和事件。在类声明中使用abstract修饰符以指示某个类只能是其他类的基类。标记为抽象或包含在抽象类中的成员必须通过从抽象类派生的类来实现。

(3)在抽象方法声明中使用 static 或 virtual 修饰符是错误的。除了在声明和调用语法上不同外,抽象属性的行为与抽象方法一样。在静态属性上使用abstract修饰符是错误的。在派生类中,通过包括使用 override 修饰符的属性声明,可以重写抽象的继承属性。

C#中Abstract 、Virtual和Override的施用【时时app平台注册网站】。}

4) 从抽象类派生的非抽象类必须包括继承的所有抽象方法和抽象访问器的实际实现。

Cylinder cylinder = new Cylinder(10, 10);

public Dimensions() { }

public override int X

public Dimensions(double x, double y)

protected int x=100;

(2)抽象方法具有以下特性:

}

public Circle(double r) : base(r,0) { }

3) 不能用 sealed 修饰符修饰抽象类,因为这两个修饰符的含义是相反的。采用 sealed 修饰符的类无法继承,而 abstract 修饰符要求对类进行继承。

{

}

public override double Area()

}

p.function();

public Cylinder(double r, double h) : base(r, h) { }

3) 因为抽象方法声明不提供实际的实现,所以没有方法体;方法声明只是以一个分号结束,并且在签名后没有大括号 ({ })。

}

2) 抽象类可以包含抽象方法和抽象访问器。

Console.WriteLine(P.Area());

return x * y;

{

public override void function()

Dimensions P = new Circle(5.0);

}

{

static void Main(string[] args)

public class Circle : Dimensions

 

{

{

{

Console.WriteLine(sphere.Area());

public class Cylinder : Dimensions

{

{

public class newperson : parent

Console.WriteLine(cylinder.Area());

this.y = y;

{

public const double PI = Math.PI;

public abstract void function();

return 4 * PI * x * x;

4. base和this的区别

{

public class Sphere : Dimensions

protected double x;

本文由时时app平台注册网站发布于编程知识,转载请注明出处:C#中Abstract 、Virtual和Override的施用【时时app平台注

关键词: