OOP: Constructor - Destructor - Overloading [C#]

A. Constructor

Được gọi là hàm tạo, có hai loại hàm tạo :
- Hàm tạo không có tham số
- Hàm tạo có tham số truyền vào.
Khi bạn sử dụng hàm tạo, nó sẽ tạo các giá trị cho các trường thuộc tính của đối tượng mới được triển khai.

 public class Bird
    {
        //Field
        protected string name;
        protected float weight;
        protected string color;

        public Bird()
        {
            this.Name = "Bird ABCDF";
            this.Weight = 20;
            this.Color = "Green";
        }
        public Bird(string name, float weight, string color)
        {
            this.Name = name;
            this.Weight = weight;
            this.Color = color;
        }
..................
...................
....................

Vậy ta dùng những hàm tạo này như thế nào ? Chúng ta qua hàm Main để test thử nhé.

class Program
    {
        static void Main(string[] args)
        {

            // Default
            var Bird1 = new Bird();
            Bird1.Name = "Bird ABC";
            Bird1.Weight = 10;
            Bird1.Color = "Red";
            Bird1.printInfo();

            // Using constructor with parameter
            var Bird2 = new Bird("Bird ABCD", 15, "Blue");
            Bird2.printInfo();

           // using constructor without parameter.
            var Bird3 = new Bird();
            Bird3.printInfo();

            Console.ReadLine();

        }
    }

Có thể thấy với Constructor rỗng tùy bạn nhập giá trị. Nếu sử dụng Constructor với tham số quy định, bạn phải đáp ứng đúng và đủ cho nó.

Như vậy !

Hàm tạo là một hàm đặc biệt cho phép ta thực thi chương trình ngay khi khởi động đối tượng mới. Lưu ý là một Constructor có tên trùng với tên class và không có giá trị trả lại kiểu : void, string, int , float . . . . Và luôn cho phép điều khiển truy xuất Public.
Ở bài sau chúng ta sẽ tìm hiểu từ khóa điều khiển truy xuất là gì !

B. Destructor

Được gọi là hàm hủy, trong ví dụ dưới bạn cần thêm lệnh cho hàm hủy.

class Bird
{
    ~Bird()  // destructor
    {
        // cleanup statements...
    }
}

Sau khi ta khai báo hàm hủy này, nó sẽ được tự động gọi trên các class cở sở của đối tượng. Và nó sẽ gọi ngầm lệnh như sau.

protected override void Finalize()
{
    try
    {
        // Cleanup statements...
    }
    finally
    {
        base.Finalize();
    }
}

 

Lưu ý !

- Hàm hủy được tự động gọi khi kết thúc chương trình để giải phóng tài nguyên không được kiểm soát.

- Trong thực tế ta rất ít khi cần sử dụng hàm này, vì chỉ sử dụng nếu có tài nguyên không thể kiểm soát. Và thường liên quan đến hệ thống,tập tin, kết nối mạng . . .

- Không nên tạo một hàm hủy RỖNG. Nếu vậy nó vẫn tự gọi Finalize () và điều đó làm giảm hiệu suất khi không có tác dụng gì.

- Không thể định nghĩa hàm này trong một struct mà chỉ sử dụng ở class. Một class chỉ tạo được một hàm hủy mà thôi.

- Hàm hủy không có tham số truyền vào.

C. Overloading Method

- Hay còn được gọi là nạp chồng phương thức. Có thể hiểu đơn giản là ta có thể triển khai 2 hay nhiều phương thức (method) mà nó trùng tên trong cùng một class.

using System;

namespace TestClassOOP
{

    class People
    {

        void methodOverloading()
        {
            Console.WriteLine("Hello !");
        }

        void methodOverloading(string world)
        {
            Console.WriteLine(world);
        }

        int methodOverloading(int a)
        {
            return a;
        }

        float methodOverloading(int a, int b)
        {
            return a * b;
        }
    }
}

Ta thử gọi những hàm này để dùng xem sao nhé:



Lúc này bạn sẽ tháy có 4 lựa chọn cho bạn, tương ứng với 4 hàm mà bạn đã tạo ở trên.

Chúng ta có thể dễ dàng phân biệt các hàm dựa vào tham số truyền vào của chúng.

- Khi bạn sử dụng Overloading thì không được phép tạo cùng lúc 2 hàm mà tham số truyền vào là giống nhau, xét về mặt vị trí. Hai hàm có tham số đầu vào rỗng cũng là có cùng tham số và không hợp lệ. Nếu giống nhau mà khác vị trí thì hợp lệ. Ở đây ta không xét type của nó (void, string, int, float ...). Hai hàm float và string cùng trùng tham số và vị trí đều không hợp lệ.

Như vậy !

Ở C# khi sử dụng các hàm trùng tên trong một lớp thì đó chính là Overloading. Ưu điểm của cách dùng này giúp bạn giảm thiểu đặt tên cho các phương thức chung hình thức mà vẫn biết được mình cần dùng gì

abstract public  class People
    {
        abstract public void methodOverloading();

        abstract public void methodOverloading(string world);

        abstract public int methodOverloading(int a);

        abstract public float methodOverloading(int a, int b);
    }

Bạn có thể dùng nó cho lớp cha để cho các lớp con kế thừa hoặc dùng với abstract để lớp con triển khai đều được. Và chúng ta sẽ đi tiếp hiểu trong bài sau . . . ;))
Nguồn: Tự Học IT Online - http://tuhocit.net