Hướng dẫn abstract base class c++ - lớp cơ sở trừu tượng C++

Chuyển đến nội phân

Trình Duyệt nào Không CNn Đan Hỗ trợ nữa.

Hãy nâng cấp lênn microsoft ed

Các lớp trừu tượng và niêm phong và các thành viên lớp (Hướng dẫn lập trình C#)

• Bài viết
• 27/10/2021
• 2 Phú

Trong bài viết nào

Từ khóa trừu tượng cho phép bạn tạo các lớp và thành viên lớp không đầy đủ và phải được thực hiện trong một lớp dẫn xuất.

Từ khóa niêm phong cho phép bạn ngăn chặn sự kế thừa của một lớp hoặc một số thành viên nhất định được đánh dấu ảo trước đây.

Các lớp học trừu tượng và các thành viên lớp học

Các lớp có thể được khai báo là trừu tượng bằng cách đặt từ khóa abstract trước định nghĩa lớp. Ví dụ:

public abstract class A
{
    // Class members here.
}

Một lớp trừu tượng không thể được khởi tạo. Mục đích của một lớp trừu tượng là cung cấp một định nghĩa chung về một lớp cơ sở mà nhiều lớp dẫn xuất có thể chia sẻ. Ví dụ, thư viện lớp có thể xác định một lớp trừu tượng được sử dụng làm tham số cho nhiều chức năng của nó và yêu cầu các lập trình viên sử dụng thư viện đó để cung cấp triển khai lớp của riêng họ bằng cách tạo một lớp dẫn xuất.

Các lớp trừu tượng cũng có thể xác định các phương pháp trừu tượng. Điều này được thực hiện bằng cách thêm từ khóa abstract trước loại trả về của phương thức. Ví dụ:

public abstract class A
{
    public abstract void DoWork(int i);
}

Các phương thức trừu tượng không có việc thực hiện, vì vậy định nghĩa phương thức được theo sau bởi một dấu chấm phẩy thay vì một khối phương thức bình thường. Các lớp dẫn xuất của lớp trừu tượng phải thực hiện tất cả các phương thức trừu tượng. Khi một lớp trừu tượng kế thừa một phương thức ảo từ một lớp cơ sở, lớp trừu tượng có thể ghi đè phương thức ảo bằng một phương thức trừu tượng. Ví dụ:

// compile with: -target:library
public class D
{
    public virtual void DoWork(int i)
    {
        // Original implementation.
    }
}

public abstract class E : D
{
    public abstract override void DoWork(int i);
}

public class F : E
{
    public override void DoWork(int i)
    {
        // New implementation.
    }
}

Nếu một phương thức

public abstract class A
{
    public abstract void DoWork(int i);
}

1 được khai báo abstract, nó vẫn là ảo cho bất kỳ lớp nào kế thừa từ lớp trừu tượng. Một lớp kế thừa một phương thức trừu tượng không thể truy cập vào việc triển khai ban đầu của phương thức, trong ví dụ trước,

public abstract class A
{
    public abstract void DoWork(int i);
}

3 trên lớp F không thể gọi

public abstract class A
{
    public abstract void DoWork(int i);
}

3 trên lớp D. Theo cách này, một lớp trừu tượng có thể buộc các lớp có nguồn gốc để cung cấp các phương thức mới .

Các lớp được niêm phong và các thành viên trong lớp

Các lớp có thể được khai báo là niêm phong bằng cách đặt từ khóa

public abstract class A
{
    public abstract void DoWork(int i);
}

5 trước định nghĩa lớp. Ví dụ:

public sealed class D
{
    // Class members here.
}

Một lớp niêm phong không thể được sử dụng như một lớp cơ sở. Vì lý do này, nó cũng không thể là một lớp trừu tượng. Các lớp niêm phong ngăn chặn đạo hàm. Bởi vì chúng không bao giờ có thể được sử dụng như một lớp cơ sở, một số tối ưu hóa thời gian chạy có thể khiến việc gọi các thành viên lớp niêm phong nhanh hơn một chút.

Một phương thức, người lập chỉ mục, thuộc tính hoặc sự kiện, trên một lớp dẫn xuất đang ghi đè một thành viên ảo của lớp cơ sở có thể tuyên bố thành viên đó là niêm phong. Điều này phủ nhận khía cạnh ảo của thành viên cho bất kỳ lớp nào có nguồn gốc. Điều này được thực hiện bằng cách đặt từ khóa

public abstract class A
{
    public abstract void DoWork(int i);
}

5 trước từ khóa ghi đè trong khai báo thành viên lớp. Ví dụ:

public class D : C
{
    public sealed override void DoWork() { }
}

Xem thêm

• Hướng dẫn lập trình C#
• Hệ thống loại C#
• Các lớp học trừu tượng và niêm phong và các thành viên trong lớp
• Đặc tính
• Phản HồI
• Gửi và xem ý kiến ​​ph

Phản HồI

Gửi và xem ý kiến ​​ph

Chuyển đến nội dung chính

Trình duyệt này không còn được hỗ trợ nữa.

Hãy nâng cấp lên Microsoft Edge để tận dụng các tính năng mới nhất, bản cập nhật bảo mật và hỗ trợ kỹ thuật.

How to define abstract properties (C# Programming Guide)

• Bài viết
• 10/27/2021
• 2 phút để đọc

Trong bài viết này

The following example shows how to define abstract properties. An abstract property declaration does not provide an implementation of the property accessors -- it declares that the class supports properties, but leaves the accessor implementation to derived classes. The following example demonstrates how to implement the abstract properties inherited from a base class.

This sample consists of three files, each of which is compiled individually and its resulting assembly is referenced by the next compilation:

• abstractshape.cs: the

  public abstract class A
  {
      public abstract void DoWork(int i);
  }
  

  7 class that contains an abstract

  public abstract class A
  {
      public abstract void DoWork(int i);
  }
  

  8 property.

• shapes.cs: The subclasses of the

  public abstract class A
  {
      public abstract void DoWork(int i);
  }
  

  7 class.

• shapetest.cs: A test program to display the areas of some

  public abstract class A
  {
      public abstract void DoWork(int i);
  }
  

  7-derived objects.

To compile the example, use the following command:

// compile with: -target:library
public class D
{
    public virtual void DoWork(int i)
    {
        // Original implementation.
    }
}

public abstract class E : D
{
    public abstract override void DoWork(int i);
}

public class F : E
{
    public override void DoWork(int i)
    {
        // New implementation.
    }
}

1

This will create the executable file shapetest.exe.

Examples

This file declares the

public abstract class A
{
    public abstract void DoWork(int i);
}

7 class that contains the

public abstract class A
{
    public abstract void DoWork(int i);
}

8 property of the type

// compile with: -target:library
public class D
{
    public virtual void DoWork(int i)
    {
        // Original implementation.
    }
}

public abstract class E : D
{
    public abstract override void DoWork(int i);
}

public class F : E
{
    public override void DoWork(int i)
    {
        // New implementation.
    }
}

4.

// compile with: csc -target:library abstractshape.cs
public abstract class Shape
{
    private string name;

    public Shape(string s)
    {
        // calling the set accessor of the Id property.
        Id = s;
    }

    public string Id
    {
        get
        {
            return name;
        }

        set
        {
            name = value;
        }
    }

    // Area is a read-only property - only a get accessor is needed:
    public abstract double Area
    {
        get;
    }

    public override string ToString()
    {
        return $"{Id} Area = {Area:F2}";
    }
}

• Modifiers on the property are placed on the property declaration itself. For example:

  public abstract double Area  
  

• When declaring an abstract property (such as

  public abstract class A
  {
      public abstract void DoWork(int i);
  }
  

  8 in this example), you simply indicate what property accessors are available, but do not implement them. In this example, only a get accessor is available, so the property is read-only.

The following code shows three subclasses of

public abstract class A
{
    public abstract void DoWork(int i);
}

7 and how they override the

public abstract class A
{
    public abstract void DoWork(int i);
}

8 property to provide their own implementation.

// compile with: csc -target:library -reference:abstractshape.dll shapes.cs
public class Square : Shape
{
    private int side;

    public Square(int side, string id)
        : base(id)
    {
        this.side = side;
    }

    public override double Area
    {
        get
        {
            // Given the side, return the area of a square:
            return side * side;
        }
    }
}

public class Circle : Shape
{
    private int radius;

    public Circle(int radius, string id)
        : base(id)
    {
        this.radius = radius;
    }

    public override double Area
    {
        get
        {
            // Given the radius, return the area of a circle:
            return radius * radius * System.Math.PI;
        }
    }
}

public class Rectangle : Shape
{
    private int width;
    private int height;

    public Rectangle(int width, int height, string id)
        : base(id)
    {
        this.width = width;
        this.height = height;
    }

    public override double Area
    {
        get
        {
            // Given the width and height, return the area of a rectangle:
            return width * height;
        }
    }
}

The following code shows a test program that creates a number of

public abstract class A
{
    public abstract void DoWork(int i);
}

7-derived objects and prints out their areas.

// compile with: csc -reference:abstractshape.dll;shapes.dll shapetest.cs
class TestClass
{
    static void Main()
    {
        Shape[] shapes =
        {
            new Square(5, "Square #1"),
            new Circle(3, "Circle #1"),
            new Rectangle( 4, 5, "Rectangle #1")
        };

        System.Console.WriteLine("Shapes Collection");
        foreach (Shape s in shapes)
        {
            System.Console.WriteLine(s);
        }
    }
}
/* Output:
    Shapes Collection
    Square #1 Area = 25.00
    Circle #1 Area = 28.27
    Rectangle #1 Area = 20.00
*/

See also

• C# Programming Guide
• The C# type system
• Abstract and Sealed Classes and Class Members
• Properties

Phản hồi

Gửi và xem ý kiến phản hồi dành cho