C#-klasse en object

In deze tutorial leer je aan de hand van voorbeelden over het concept van klassen en objecten in C#.

C# is een objectgeoriënteerd programma. Bij objectgeoriënteerd programmeren (OOP) lossen we complexe problemen op door ze in objecten te verdelen.

Om met objecten te werken, moeten we de volgende activiteiten uitvoeren:

• maak een klas
• maak objecten uit de klas

C#-klasse

Voordat we over objecten leren, moeten we de werking van klassen begrijpen. Klasse is de blauwdruk voor het object.

We kunnen de klas zien als een schets (prototype) van een huis . Hierin staan ​​alle details over de vloeren, deuren, ramen etc. Op basis van deze omschrijvingen kunnen wij een huis bouwen. Huis is het object.

Zoals veel huizen kunnen worden gemaakt van de schets, kunnen we veel objecten van een klasse maken.

Maak een klas in C#

We gebruiken het class-sleutelwoord om een ​​object te maken. Bijvoorbeeld,

class ClassName {

}

Hier hebben we een klasse gemaakt met de naam ClassName . Een klas kan

• velden - variabelen om gegevens op te slaan
• methoden - functies om specifieke taken uit te voeren

Laten we een voorbeeld bekijken,

class Dog {
 
  //field
  string breed;
 
  //method
  public void bark() {

  }
 
}

In het bovenstaande voorbeeld,

• Hond - klasnaam
• ras - veld
• schors() - methode

Opmerking :In C# worden velden en methoden binnen een klasse leden van een klasse genoemd.

C#-objecten

Een object is een instantie van een klasse. Stel, we hebben een klasse Hond . Bulldog, Duitse herder, Mopshond zijn objecten van de klas.

Een object van een klasse maken

In C# maken we als volgt een object van de klasse.

ClassName obj = new ClassName();

Hier hebben we de new . gebruikt trefwoord om een ​​object van de klasse te maken. En, obj is de naam van het object. Laten we nu een object maken van de Hond klasse.

Dog bullDog = new Dog();

Nu, de bullDog object heeft toegang tot de velden en methoden van de Hond klasse.

Toegang tot klasleden met behulp van Object

We gebruiken de naam van objecten samen met de . operator om toegang te krijgen tot leden van een klasse. Bijvoorbeeld,

using System;

namespace ClassObject {

  class Dog {
    string breed;

    public void bark() {
      Console.WriteLine("Bark Bark !!");
      
    }

    static void Main(string[] args) {

      // create Dog object 
      Dog bullDog = new Dog();

      // access breed of the Dog 
      bullDog.breed = "Bull Dog";
      Console.WriteLine(bullDog.breed);

      // access method of the Dog
      bullDog.bark();   

      Console.ReadLine();
     
    }
  }
}

Uitvoer

Bull Dog
Bark Bark !!

In het bovenstaande programma hebben we een object gemaakt met de naam bullDog van de Hond klas. Merk op dat we de objectnaam en de . . hebben gebruikt (puntoperator) om toegang te krijgen tot het ras veld

// access breed of the Dog
bullDog.breed = "Bull Dog";

en de blaf() methode

// access method of the Dog
bullDog.bark();

Meerdere objecten van een klasse maken

We kunnen meerdere objecten van dezelfde klasse maken. Bijvoorbeeld,

using System;

namespace ClassObject {

  class Employee {

    string department;

    static void Main(string[] args) {

      // create Employee object 
      Employee sheeran = new Employee();

      // set department for sheeran
      sheeran.department = "Development";
      Console.WriteLine("Sheeran: " + sheeran.department);

      // create second object of Employee
      Employee taylor = new Employee();

      // set department for taylor
      taylor.department = "Content Writing";
      Console.WriteLine("Taylor: " + taylor.department);

      Console.ReadLine();
    }
  }
}

Uitvoer

Sheeran: Development
Taylor: Content Writing

In het bovenstaande voorbeeld hebben we twee objecten gemaakt:sheeran en taylor van de Medewerker klasse.

Hier kun je zien dat beide objecten hun eigen versie hebben van de afdeling veld met verschillende waarden.

Objecten maken in een andere klasse

In C# kunnen we ook een object van een klasse in een andere klasse maken. Bijvoorbeeld,

Bijvoorbeeld,

using System;

namespace ClassObject {

  class Employee {
    public string name;

    public void work(string work) {
      Console.WriteLine("Work: " + work);
      
    }
  }

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

      // create Employee object 
      Employee e1= new Employee();

      Console.WriteLine("Employee 1");

      // set name of the Employee 
      e1.name="Gloria";
      Console.WriteLine("Name: " + e1.name);

      //call method of the Employee
      e1.work("Coding"); 

      Console.ReadLine();
     
    }
  }
}

Uitvoer

Employee 1
Name: Gloria
Work: Coding

In het bovenstaande voorbeeld hebben we twee klassen:Werknemer en EmployeeDrive . Hier maken we een object e1 van de Medewerker klasse in de EmployeeDrive klasse.

We hebben de e1 . gebruikt bezwaar om toegang te krijgen tot de leden van de Werknemer les van EmployeeDrive . Dit is mogelijk omdat de leden in de Medewerker klasse zijn public .

Hier, public is een toegangsspecificatie die betekent dat de klasleden toegankelijk zijn vanuit andere klassen. Ga voor meer informatie naar C# Access Modifiers.

Waarom objecten en klassen?

Objecten en klassen helpen ons een groot project op te delen in kleinere deelproblemen.

Stel dat je een spel wilt maken met honderden vijanden en elk van hen heeft velden zoals gezondheid , munitie , en methoden zoals shoot() en run() .

Met OOP kunnen we een enkele Vijand . maken klasse met verplichte velden en methoden. Vervolgens kunnen we er meerdere vijandelijke objecten van maken.

Elk van de vijandelijke objecten heeft zijn eigen versie van gezondheid en munitie velden. En ze kunnen de algemene shoot() . gebruiken en run() methoden.

In plaats van aan projecten te denken in termen van variabelen en methoden, kunnen we ze nu zien in termen van objecten.

Dit helpt de complexiteit te beheren en onze code herbruikbaar te maken.