Inleiding tot variabelen in C #
In C # is een variabele een naam die we aan de geheugenlocatie geven en elke variabele heeft een opgegeven type dat het type waarden aangeeft dat in een variabele kan worden opgeslagen. Alle variabelen moeten worden aangegeven voordat ze in gebruik zijn; elke variabele heeft een specifiek type dat de grootte en het bereik van variabelen bepaalt. Om een bewerking op variabelen uit te voeren, is het essentieel om een variabele met een bepaald gegevenstype te definiëren om het type gegevens op te geven dat de variabele in onze applicatie kan bevatten. Laten we een paar basiszaken over variabelen bekijken,
- Variabelen zijn niets anders dan een naam die wordt gegeven aan de gegevenswaarde.
- Variabelen kunnen de waarde van bepaalde gegevenstypen bevatten, bijvoorbeeld int, string, float, enzovoort.
- Verklaring en initialisatie van variabelen staan in afzonderlijke verklaringen.
- Variabelen kunnen worden gedefinieerd door meerdere gescheiden door een komma en ook in enkele en meerdere regels tot het einde van de puntkomma.
- Waarden moeten worden toegewezen aan een variabele voordat we er gebruik van maken; anders wordt een compilatie-fout weergegeven.
- De waarde van een variabele kan op elk moment worden gewijzigd tot de toegankelijkheid van het programma.
Hoe variabelen in C # te declareren?
Er zijn enkele regels om C # variabelen aan te geven:
- We moeten een variabelenaam definiëren met de combinatie van cijfers, alfabetten en onderstrepingstekens.
- Elke variabelenaam moet beginnen met alfabetten of onderstrepingstekens.
- Er mag geen witruimte worden toegestaan tussen de naam van de variabele.
- Variabelenamen mogen geen gereserveerde zoekwoorden bevatten zoals int, char, float, enzovoort.
De syntaxis voor variabele definitie in C #
;
=value;
=value;
Hier de is een type gegevens waarin de variabele de typen kan bevatten die een geheel getal zijn, Sting, float, enzovoort . is de naam van een variabele die de waarde in onze applicatie bevat en is het toewijzen van een specifieke waarde aan de variabele en ten slotte wordt gebruikt om toegangsrechten te geven voor de variabele. Dit zijn enkele geschikte methoden om de variabelenamen in de programmeertaal c # te beschrijven.
int name;
float value;
char _firstname;
U kunt een variabele op het moment van definitie ook als volgt initialiseren,
int value = 100;
Hoe variabelen in C # te initialiseren?
Om een waarde toe te wijzen aan een variabele die initialisatie wordt genoemd, kunnen variabelen worden geïnitialiseerd met een gelijkteken door de constante uitdrukking, variabelen kunnen ook worden geïnitialiseerd bij hun declaratie.
Syntaxis :
= value;
Of
variable_name = value;
Bijvoorbeeld,
int value1=5, value2= 7;
double pi= 3.1416;
char name='Rock';
Typen variabelen in C # met voorbeelden
Er zijn verschillende soorten variabelen, zoals
- Lokale variabelen
- Instantievariabelen of niet-statische variabelen
- Statische variabelen of klassenvariabelen
- Constante variabelen
- Alleen-lezen variabelen
1. Lokale variabelen
Een lokale variabele gedefinieerd binnen een methode of blok of constructor. Als de variabele eenmaal is gedeclareerd, bestaan die variabelen alleen binnen het blok en hebben we alleen toegang tot deze variabelen binnen het blok. De variabele wordt gemaakt wanneer de functie wordt aangeroepen of het blok wordt ingevoerd en deze wordt eenmaal afgebroken nadat deze uit het blok bestaat of terwijl de oproep uit de functie terugkeert.
In het voorbeeldprogramma is de variabele "customer_age" een lokale variabele voor de functie GetAge (). De compiler genereert een fout zodra we de variabele customer_age buiten de functie GetAge () toepassen.
Voorbeeldprogramma - lokale variabelen
using System;
class CustomerEntry
(
Public void GetAge()
(
int customer_age=0; // local variable
customer_age= customer_age+28;
Console. WriteLine("Customer Age: "+ customer_age);
)
public static void Main(String() args)
(
CustomerEntry _customerObj=new CustomerEntry();
_customerObj.GetAge();
)
)
Output:
Klant leeftijd: 28
2. Instantievariabelen of niet-statische variabelen
Instantievariabelen worden de niet-statische variabelen genoemd; de instantievariabelen worden in een klasse gedeclareerd maar buiten elke methode, blok of constructor gedeclareerd. Deze variabelen worden gemaakt zodra het object van een klasse is gemaakt en deze wordt vernietigd wanneer het object wordt vernietigd. Voor variabelen kunnen we bijvoorbeeld de toegangsspecificaties gebruiken.
In het programma zijn de instantievariabelen markEnglish, markMaths. We kunnen meerdere objecten maken, elk van de objecten heeft een kopie van een instantievariabele.
Voorbeeldprogramma - instantievariabelen
using System;
class StudentMarks (
// instance variables
int markEnglish;
int markMaths;
int markPhysics;
public static void Main(String() args) // Main Method
(
StudentMarks obj1 = new StudentMarks (); //Object creation 1
obj1. markEnglish = 90;
obj1. markMaths = 80;
obj1. markPhysics = 93;
StudentMarks obj2 = new StudentMarks (); //Object creation 1
obj2. markEnglish = 95;
obj2. markMaths = 70;
obj2. markPhysics = 90;
Console.WriteLine("Marks Obtained from first object:");
Console.WriteLine(obj1. markEnglish);
Console.WriteLine(obj1. markMaths);
Console.WriteLine(obj1. markPhysics);
Console.WriteLine("Marks obtained from second object:");
Console.WriteLine(obj2. markEnglish);
Console.WriteLine(obj2. markMaths);
Console.WriteLine(obj2. markPhysics);
)
)
Output:
Cijfers verkregen van het eerste object:
90
80
93
Cijfers verkregen van het tweede object:
95
70
90
3. Statische variabelen of klassenvariabelen
Een statische variabele wordt aan het begin van de uitvoering van het programma gemaakt en vernietigt aan het einde van de uitvoering. Statische variabelen worden ook wel klassenvariabelen genoemd. Voor toegang tot statische variabelen is het niet nodig om een object van de klasse te maken; we hebben eenvoudig toegang tot de variabele als,
Class_name.variable_name;
Een statische variabele wordt gedeclareerd met het trefwoord statisch binnen een klasse of buiten een methode of constructor.
Voorbeeldprogramma - statische variabele
using System;
class Employee
(
static double empSalary;
static StringempName="Smith";
public static void main(String() args)
(
Employee.empSalary=100000; // accessing the static variable
Console. WriteLine(Employee.empName+ "'s Salary:" + Employee.empSalary);
)
)
Output:
Smith's salaris: 100000
4. Constantenvariabelen
Constante variabelen zijn vergelijkbaar met de statische variabelen, eenmaal geïnitialiseerd en de eenmalige levenscyclus van een klasse en er is geen instantie van de klasse nodig voor initialisatie of toegang. De constante variabele wordt gedeclareerd met behulp van het sleutelwoord 'const'. Deze variabelen kunnen niet meer worden gewijzigd nadat ze zijn gedeclareerd en moeten alleen worden geïnitialiseerd op het moment van het declaratiegedeelte.
Voorbeeldprogramma - constante variabele
Using System;
Class Program_A
(
int x= 25; // instance variable
static int y= 35; // static variable
const float maxValue =75; // constant variable
public static void main()
(
Program_A classObject= new Program_A(); // object creation
Console.WriteLine("Value of x : " + classObject.x);
Console.WriteLine("Value of y : " + Program_A.y);
Console.WriteLine("Value of max " " + Program_A. maxValue);
)
)
Output:
Waarde van x: 25
Waarde van y: 35
Waarde van max: 75
5. Alleen-lezen variabelen
Een alleen-lezen variabele wordt gedeclareerd met behulp van het trefwoord ' alleen-lezen ' en die variabelen kunnen niet worden gewijzigd zoals constante variabelen. De constante variabele is een onveranderlijke waarde voor de hele klasse, terwijl alleen-lezen een permanente waarde is voor een specifieke instantie van een klasse. Er is geen verplichting om een alleen-lezen variabele te initialiseren bij de tijdaangifte, deze kan worden geïnitialiseerd onder constructor. De standaardwaarde die is ingesteld op de variabele is 0.
Voorbeeldprogramma - alleen-lezen
using System;
class Program_B
(
const float maxValue =75; // constant variable
readonly int x; // read-only variable
public static void main()
(
Program_B classObject= new Program_B(); // object creation
Console.WriteLine("Value of max: " + Program_A. maxValue);
Console.WriteLine("Value of x : " + classObject.x);
)
)
Output:
Waarde van max: 75
Waarde van x: 0
Conclusie
Eindelijk, u weet hoe variabelen u in staat stellen gegevens op verschillende manieren op te slaan. In dit artikel hebben we geleerd hoe variabelen te declareren en te initialiseren en hoe we er gebruik van kunnen maken. Ik hoop dat dit artikel je zou hebben geholpen met het werkproces van variabelen.
Aanbevolen artikelen
Dit is een gids voor variabelen in C #. Hier bespreken we wat variabelen zijn in C #, hoe declareren we variabelen, hoe initialiseren we variabelen en tot slot wat zijn verschillende soorten variabelen in C # met zijn voorbeelden. U kunt ook de volgende artikelen bekijken voor meer informatie -
- Hoe werkt Copy Constructor in C #?
- C # String Functies met voorbeelden
- Hoe variabelen in PHP te declareren?
- Verschillende C # -functies
- Variabelen in JavaScript