Bagikan melalui

abstrak (Referensi C#)

Pengubah abstract menunjukkan bahwa hal yang dimodifikasi memiliki implementasi yang hilang atau tidak lengkap. Pengubah abstrak dapat digunakan dengan kelas, metode, properti, pengindeks, dan peristiwa. Gunakan pengubah abstract dalam deklarasi kelas untuk menunjukkan bahwa suatu kelas hanya dimaksudkan untuk menjadi kelas dasar bagi kelas lainnya, tidak dibuat dengan sendirinya. Anggota yang ditandai sebagai abstrak harus diimplementasikan oleh kelas non-abstrak yang berasal dari kelas abstrak.

Contoh 1

Dalam contoh ini, kelas Square harus menyediakan implementasi GetArea karena berasal dari Shape:

abstract class Shape
{
    public abstract int GetArea();
}

class Square : Shape
{
    private int _side;

    public Square(int n) => _side = n;

    // GetArea method is required to avoid a compile-time error.
    public override int GetArea() => _side * _side;

    static void Main()
    {
        var sq = new Square(12);
        Console.WriteLine($"Area of the square = {sq.GetArea()}");
    }
}
// Output: Area of the square = 144

Kelas abstrak memiliki fitur sebagai berikut:

  • Kelas abstrak tidak dapat diwakilkan.

  • Kelas abstrak dapat berisi metode dan pengakses abstrak.

  • Tidak dimungkinkan untuk memodifikasi kelas abstrak dengan pengubah disegel karena kedua pengubah memiliki arti yang berlawanan. Pengubah sealed mencegah kelas diwariskan dan pengubah abstract mengharuskan kelas untuk diwariskan.

  • Kelas non-abstrak yang berasal dari kelas abstrak harus mencakup implementasi aktual dari semua metode dan pengakses abstrak yang diwariskan.

Gunakan pengubah abstract dalam deklarasi metode atau properti untuk menunjukkan bahwa metode atau properti tersebut tidak berisi implementasi.

Metode abstrak memiliki fitur sebagai berikut:

  • Metode abstrak secara implisit merupakan metode virtual.

  • Deklarasi metode abstrak hanya diizinkan dalam kelas abstrak.

  • Karena deklarasi metode abstrak tidak memberikan implementasi aktual, maka tidak ada badan metode; deklarasi metode hanya berakhir dengan titik koma dan tidak ada kurung kurawal ({ }) setelah tanda tangan. Contohnya:

    public abstract void MyMethod();

    Implementasi disediakan oleh pengambilalihan metode, yang merupakan anggota kelas non-abstrak.

  • Merupakan sebuah kesalahan untuk menggunakan pengubah statis atau virtual dalam deklarasi metode abstrak.

Properti abstrak berperilaku seperti metode abstrak, kecuali untuk perbedaan sintaksis deklarasi dan pemanggilan.

  • Merupakan sebuah kesalahan untuk menggunakan pengubah abstract pada properti statik.

  • Properti abstrak yang diwariskan dapat diambil alih di kelas turunan dengan menyertakan deklarasi properti yang menggunakan pengubah ambil alih.

Untuk informasi selengkapnya tentang kelas abstrak, lihat Kelas Abstrak dan Tersegel serta Anggota Kelas.

Kelas abstrak harus menyediakan implementasi untuk semua anggota antarmuka.

Kelas abstrak yang mengimplementasikan antarmuka dapat memetakan metode antarmuka ke metode abstrak. Contohnya:

interface I
{
    void M();
}

abstract class C : I
{
    public abstract void M();
}

Contoh 2

Dalam contoh ini, kelas DerivedClass berasal dari kelas abstrak BaseClass. Kelas abstrak berisi metode abstrak, AbstractMethod, dan dua properti abstrak, X dan Y.

// Abstract class
abstract class BaseClass
{
    protected int _x = 100;
    protected int _y = 150;

    // Abstract method
    public abstract void AbstractMethod();

    // Abstract properties
    public abstract int X { get; }
    public abstract int Y { get; }
}

class DerivedClass : BaseClass
{
    public override void AbstractMethod()
    {
        _x++;
        _y++;
    }

    public override int X   // overriding property
    {
        get
        {
            return _x + 10;
        }
    }

    public override int Y   // overriding property
    {
        get
        {
            return _y + 10;
        }
    }

    static void Main()
    {
        var o = new DerivedClass();
        o.AbstractMethod();
        Console.WriteLine($"x = {o.X}, y = {o.Y}");
    }
}
// Output: x = 111, y = 161

Dalam contoh sebelumnya, jika Anda mencoba untuk mewakilkan kelas abstrak menggunakan pernyataan seperti ini:

BaseClass bc = new BaseClass();   // Error

Anda akan mendapatkan kesalahan yang menyatakan bahwa pengompilasi tidak dapat membuat instans dari kelas abstrak 'BaseClass'.

Meskipun demikian, dimungkinkan untuk menggunakan konstruktor kelas abstrak, seperti dalam contoh di bawah ini

Contoh 3

public abstract class Shape
{
    public string Color { get; set; }

    // Constructor of the abstract class
    protected Shape(string color)
    {
        Color = color;
        Console.WriteLine($"Created a shape with color {color}.");
    }

    // Abstract method that must be implemented by derived classes
    public abstract double CalculateArea();
}

public class Square : Shape
{
    public double Side { get; set; }

    // Constructor of the derived class calling the base class constructor
    public Square(string color, double side) : base(color)
    {
        Side = side;
    }

    public override double CalculateArea()
    {
        return Side * Side;
    }
}

public class Program
{
    public static void Main(string[] args)
     {
            Square square = new Square("red", 5);
            Console.WriteLine($"Area of the square: {square.CalculateArea()}");            
     }
}

Kelas Shape dinyatakan abstract, yang berarti tidak dapat diinstansiasi secara langsung. Sebaliknya, ini berfungsi sebagai cetak biru untuk kelas lain.

  • Meskipun Anda tidak dapat membuat objek dari kelas abstrak, objek tersebut masih dapat memiliki konstruktor. Konstruktor ini biasanya protected, yang berarti hanya dapat diakses dari kelas turunan. Dalam hal ini, konstruktor Shape mengambil parameter color dan menginisialisasi properti Color. Ini juga mencetak pesan ke konsol. Bagian public Square(string color, double side) : base(color) memanggil konstruktor kelas dasar (Shape) dan meneruskan argumen color ke dalamnya.
  • Di kelas Bentuk, konstruktor yang ditentukan mengambil warna sebagai parameter protected Shape(string color). Ini berarti tidak ada lagi konstruktor tanpa parameter default yang secara otomatis disediakan oleh C# sehingga kelas turunan harus menggunakan ekspresi : base(color) untuk memanggil konstruktor dasar. Mengatur nilai default ke warna protected Shape(string color="green") akan memungkinkan untuk menghilangkan ekspresi : base(color) di kelas turunan, masih konstruktor tersebut protected Shape(string color="green") akan dipanggil, mengatur warna menjadi hijau.

Spesifikasi Bahasa C#

Untuk informasi selengkapnya, lihat Spesifikasi Bahasa C#. Spesifikasi bahasa adalah sumber definitif untuk sintaks dan penggunaan C#.

Lihat juga