- 静态多态
- 函数重载
- 运算符重载
- 动态多态
- abstract 和 virtual的区别
- 定义与用途:
- 成员实现:
- 继承与重写:
- 与接口的区别:
- 使用抽象类的好处主要体现在以下几个方面:
- 代码重用:
- 设计灵活性:
- 接口定义:
- 类型安全:
- 易于扩展和维护:
- 符合面向对象的设计原则:
- 综上所述,
- 派生类中调用基类成员
- 通过base关键字调用:
- 直接调用:
- 通过构造函数:
- 在C#中,new关键字有多个用途
- 对象实例化:
- 隐藏基类成员:
- 约束:
- 运算符重载:
- 初始化数组:
- 随对象一起初始化字段:
- 例子
静态多态
在编译时,函数和对象的连接机制被称为早期绑定,也被称为静态绑定。C#
提供了两种技术来实现静态多态性。分别为:
函数重载
同名不同参
运算符重载
动态多态
C#
允许您使用关键字 abstract
创建抽象类,用于提供接口的部分类的实现。当一个派生类继承自该抽象类时,实现即完成。抽象类包含抽象方法,抽象方法可被派生类实现。派生类具有更专业的功能。
请注意,下面是有关抽象类的一些规则:
您不能创建一个抽象类的实例。
您不能在一个抽象类外部声明一个抽象方法。
通过在类定义前面放置关键字 sealed
,可以将类声明为密封类。当一个类被声明为 sealed
时,它不能被继承。抽象类不能被声明为 sealed
。
总之,
类前声明abstruct
就可以写出一个抽象类
当有一个定义在类中的函数需要在继承类中实现时,可以使用虚方法。
虚方法是使用关键字 virtual 声明的。
虚方法可以在不同的继承类中有不同的实现。
对虚方法的调用是在运行时发生的。
动态多态性是通过 抽象类 和 虚方法 实现的。
在C#(以及其他一些面向对象的编程语言中),override
是一个关键字,用于指示一个方法在派生类中覆盖了基类中的同名方法。这意味着,当你使用派生类的对象并调用这个方法时,将执行派生类中的版本,而不是基类中的版本。
要使用override
关键字,必须满足以下条件:
基类中存在一个虚方法(virtual)或抽象方法(abstract):基类中必须有一个具有相同签名(即相同的名称、参数列表和返回类型)的虚方法或抽象方法。
派生类继承自基类:包含override
方法的类必须是从包含被覆盖方法的类继承而来的。
方法签名匹配:派生类中的方法必须与基类中被覆盖的方法具有相同的签名。
访问修饰符不能比基类方法更严格:派生类中方法的访问修饰符(如public
、protected
或internal
)不能比基类中被覆盖的方法更严格。例如,如果基类中的方法是public
的,那么派生类中的覆盖方法也必须是public
的。
using System;
namespace PolymorphismApplication
{
class Shape
{
protected int width, height;
public Shape( int a=0, int b=0)
{
width = a;
height = b;
}
public virtual int area()
{
Console.WriteLine("父类的面积:");
return 0;
}
}
class Rectangle: Shape
{
public Rectangle( int a=0, int b=0): base(a, b)
{
}
public override int area ()
{
Console.WriteLine("Rectangle 类的面积:");
return (width * height);
}
}
class Triangle: Shape
{
public Triangle(int a = 0, int b = 0): base(a, b)
{
}
public override int area()
{
Console.WriteLine("Triangle 类的面积:");
return (width * height / 2);
}
}
class Caller
{
public void CallArea(Shape sh)
{
int a;
a = sh.area();
Console.WriteLine("面积: {0}", a);
}
}
class Tester
{
static void Main(string[] args)
{
Caller c = new Caller();
Rectangle r = new Rectangle(10, 7);
Triangle t = new Triangle(10, 5);
c.CallArea(r);
c.CallArea(t);
Console.ReadKey();
}
}
}
abstract 和 virtual的区别
在C#
中,abstract
和virtual
是两个用于类和成员修饰的关键字,它们各自有着特定的用途和区别。
定义与用途:
abstract
关键字用于定义抽象类和抽象成员(包括方法、属性、索引器、事件)。抽象类是一种特殊的类,不能被实例化,只能被其他类继承。抽象成员在抽象类中没有具体的实现,必须在派生类中提供实现。
virtual
关键字用于定义虚方法、虚属性、虚索引器或虚事件。虚成员可以在派生类中被重写(override
)。这意味着派生类可以提供该成员的不同实现。
成员实现:
abstract
修饰的方法或属性不能有实现,它们只是声明了一个约定,具体的实现必须在派生类中完成。
virtual
修饰的方法或属性必须有方法实现(哪怕只有一对大括号)。派生类可以选择是否重写虚成员。
继承与重写:
如果一个类包含抽象方法,那么这个类必须被声明为抽象类。抽象方法必须在任何非抽象派生类中被重写。
虚方法可以被任何继承它的类重写,但不是必须的。如果派生类没有重写虚方法,那么将使用基类中的实现。
与接口的区别:
抽象类是对对象的抽象,可以包含抽象方法和非抽象方法,是对一组具有共同特征的对象的抽象。它不能被实例化,但可以通过继承来创建具体的对象。
接口是一种行为规范,只包含抽象方法和事件的声明,不包含任何实现。任何实现接口的类都必须提供接口中所有方法的实现。
总的来说,abstract
和virtual
在C#
中都是用于实现多态性的重要机制,但它们在定义、实现、继承与重写方面有着明显的区别。abstract
更强调强制派生类提供实现,而virtual
则提供了一种可选的重写机制。
使用抽象类的好处主要体现在以下几个方面:
代码重用:
抽象类允许我们定义一组通用的方法和属性,这些方法和属性可以被多个派生类共享。通过继承抽象类,派生类可以自动获得这些通用方法和属性的实现,从而避免了在每个派生类中重复编写相同的代码。
设计灵活性:
抽象类为设计提供了更大的灵活性。通过将某些方法或属性声明为抽象成员(即没有具体实现的方法或属性),我们可以强制派生类提供这些成员的具体实现。这有助于确保派生类遵循一定的接口或协议,从而实现更加一致和可预测的行为。
接口定义:
抽象类可以作为接口的一种实现方式。与纯接口相比,抽象类可以包含部分实现,使得某些通用的功能可以在抽象类中实现,而派生类只需关注特定于它们自己的实现。
类型安全:
通过抽象类,我们可以限制哪些类可以作为派生类。只有实现了抽象类中所有抽象成员的类才能被实例化。这有助于确保类型安全,防止不正确的类继承和使用。
易于扩展和维护:
当需要添加新的功能或修改现有功能时,我们只需在抽象类中进行相应的更改,所有继承该抽象类的派生类都将自动获得这些更改。这大大简化了代码的扩展和维护过程。
符合面向对象的设计原则:
使用抽象类有助于遵循面向对象的设计原则,如开闭原则(对扩展开放,对修改封闭)和里氏替换原则(子类必须能够替换其基类)。这些原则有助于构建更加健壮、可维护和可扩展的软件系统。
综上所述,
使用抽象类可以提高代码的重用性、设计灵活性、类型安全性以及易于扩展和维护性,同时也有助于遵循面向对象的设计原则。
派生类中调用基类成员
在派生类中调用基类成员的方法取决于成员的类型(字段、属性、方法)以及成员的访问修饰符。以下是几种常见的方式来在派生类中调用基类成员:
通过base关键字调用:
当派生类需要访问或调用被覆盖(override
)的基类方法或属性时,可以使用base
关键字来引用基类中的成员。
base
关键字用于访问基类的构造函数、字段、属性、方法等。
public class BaseClass
{
public void BaseMethod()
{
Console.WriteLine("This is the base method.");
}
}
public class DerivedClass : BaseClass
{
public new void BaseMethod() // 注意这里使用了new关键字来隐藏基类方法
{
base.BaseMethod(); // 调用基类中被覆盖的方法
Console.WriteLine("This is the derived method.");
}
}
直接调用:
如果派生类没有覆盖基类的成员,那么可以直接调用这些成员,而无需使用base
关键字。
public class DerivedClass : BaseClass
{
public void CallBaseMethod()
{
BaseMethod(); // 直接调用基类方法
}
}
通过构造函数:
在派生类的构造函数中,可以使用base
关键字来调用基类的构造函数。
public class BaseClass
{
public BaseClass()
{
Console.WriteLine("BaseClass constructor called.");
}
}
public class DerivedClass : BaseClass
{
public DerivedClass() : base() // 调用基类的构造函数
{
Console.WriteLine("DerivedClass constructor called.");
}
}
请注意,如果基类成员是私有的(private
),那么派生类无法直接访问它们。私有成员只能在定义它们的类内部被访问。如果基类成员是受保护的(protected
),则派生类可以直接访问这些成员。如果基类成员是公共的(public
)或受保护的,那么派生类可以像访问任何其他公共或受保护成员一样访问它们。
此外,当派生类使用new关键字隐藏基类中的成员时,虽然派生类成员和基类成员具有相同的名称,但它们实际上是两个不同的成员。在这种情况下,如果需要调用基类中被隐藏的成员,就必须使用base
关键字。
在C#中,new关键字有多个用途
它们在不同上下文中具有不同的意义。以下是new
关键字在C#
中的一些主要用途:
对象实例化:
最常见的用法是创建对象实例。例如:
MyClass myObject = new MyClass();
这里,new MyClass()
用于调用MyClass
的构造函数并创建该类的一个新实例。
隐藏基类成员:
当在派生类中定义与基类成员同名的成员时,可以使用new关键字来显式地表示派生类成员隐藏了基类成员。这样做通常是为了避免基类成员的意外调用。
class Base
{
public void MyMethod() { /* ... */ }
}
class Derived : Base
{
public new void MyMethod() { /* ... */ }
}
在这个例子中,Derived
类中的MyMethod
隐藏了Base
类中的MyMethod
。
约束:
在泛型类、接口或方法的定义中,new()
约束用于指定类型参数必须具有无参数的公共构造函数。
public class MyClass<T> where T : new()
{
public T CreateInstance()
{
return new T();
}
}
这里,new()
约束确保T类型有一个无参数的构造函数,因此可以在CreateInstance
方法中创建它的实例。
运算符重载:
new
运算符也可以被重载以用于自定义类型。这通常与资源管理和释放相关,尤其是在实现IDisposable
接口时。但是,直接重载new
运算符并不常见,因为C#
提供了更具体的语法来管理资源(如using
语句)。
初始化数组:
new
用于创建数组实例,并可以初始化数组元素。
int[] myArray = new int[5] { 1, 2, 3, 4, 5 };
这里,new int[5]
创建一个包含5
个整数的数组,并通过花括号中的值进行初始化。
随对象一起初始化字段:
在对象实例化时,可以使用对象初始化器语法与new
一起初始化对象的字段或属性。
var person = new Person
{
Name = "Alice",
Age = 30
};
这里,new Person
创建了一个Person
对象,并使用对象初始化器语法设置了Name
和Age
属性。
请注意,new
关键字的具体行为取决于它在哪里以及如何被使用。在使用new
时,应确保你了解其当前上下文中的确切意义,以避免潜在的错误或混淆。
例子
using System;
class TODO {
static void Main() {
Console.Write("Hello C#!\n");
Tools tools = new Tools();
int ans = tools.add(1, 2);
Console.WriteLine(ans);
Cars chaos = new Cars();
Console.WriteLine("this thing is {0}.", chaos.SayName());
chaos.x = 1;
chaos.y = 2;
chaos.z = 3;
Console.WriteLine(chaos.Area());
}
}
class Tools {
public int add(int x, int y) { return x + y; }
public int add(int x, int y, int z) { return x + y + z; }
}
abstract class Boxs {
public int x;
public int y;
public int z;
public int Area() {
return x * y * x;
}
abstract public string SayName();
virtual public void SayHello() { System.Console.Write("Hello!\n"); }
private int total;
}
class Cars: Boxs {
public override string SayName() { return "CAR"; }
public override void SayHello() {
base.SayHello();
}
public new int Area() {
return x + y + z;
}
}