Einführung in Variablen in C #
In C # ist eine Variable ein Name, den wir dem Speicherort geben, und jede Variable hat einen angegebenen Typ, der den Wertetyp angibt, der in einer Variablen gespeichert werden kann. Alle Variablen sollten deklariert werden, bevor sie verwendet werden. Jede Variable hat einen bestimmten Typ, der die Größe und den Bereich der Variablen bestimmt. Um eine Operation mit Variablen ausführen zu können, müssen Sie unbedingt eine Variable mit einem bestimmten Datentyp definieren, um den Datentyp anzugeben, den die Variable in unserer Anwendung enthalten kann. Lassen Sie uns ein paar grundlegende Dinge über Variablen sehen,
- Variablen sind nichts anderes als ein Name, der dem Datenwert gegeben wird.
- Variablen können den Wert bestimmter Datentypen enthalten, z. B. int, string, float usw.
- Deklaration und Initialisierung von Variablen erfolgen in separaten Anweisungen.
- Variablen können durch mehrere durch Komma getrennte Variablen sowie ein- und mehrzeilig bis zum Ende des Semikolons definiert werden.
- Werte müssen einer Variablen zugewiesen werden, bevor wir sie verwenden. Andernfalls wird ein Fehler beim Kompilieren angezeigt.
- Der Wert einer Variablen kann bis zur Programmverfügbarkeit jederzeit geändert werden.
Wie deklariere ich Variablen in C #?
Es gibt einige Regeln, um C # -Variablen zu deklarieren:
- Wir müssen einen Variablennamen mit der Kombination von Zahlen, Buchstaben und Unterstrichen definieren.
- Jeder Variablenname sollte mit Buchstaben oder Unterstrichen beginnen.
- Zwischen dem Variablennamen darf kein Leerzeichen stehen.
- Variablennamen sollten keine reservierten Schlüsselwörter wie int, char, float usw. enthalten.
Die Syntax für die Variablendefinition in C #
;
=value;
=value;
Hier die ist ein Datentyp, in dem die Variable die Datentypen Integer, Sting, Float usw. enthalten kann . ist der Name einer Variablen, die den Wert in unserer Anwendung enthält, und weist der Variablen einen bestimmten Wert zu und schließlich wird verwendet, um die Zugriffsberechtigung für die Variable zu erteilen. Dies sind einige geeignete Methoden, um die Variablennamen in der Programmiersprache c # zu beschreiben.
int name;
float value;
char _firstname;
Sie können eine Variable zum Zeitpunkt der Definition auch wie folgt initialisieren:
int value = 100;
Wie initialisiere ich Variablen in C #?
Um einer Variablen, die als Initialisierung bezeichnet wird, einen Wert zuzuweisen, können Variablen mit einem Gleichheitszeichen durch den konstanten Ausdruck initialisiert werden. Variablen können auch bei ihrer Deklaration initialisiert werden.
Syntax :
= value;
Oder
variable_name = value;
Beispielsweise,
int value1=5, value2= 7;
double pi= 3.1416;
char name='Rock';
Variablentypen in C # mit Beispielen
Es gibt verschiedene Arten von Variablen, z
- Lokale Variablen
- Instanzvariablen oder nicht statische Variablen
- Statische Variablen oder Klassenvariablen
- Konstante Variablen
- Schreibgeschützte Variablen
1. Lokale Variablen
Eine lokale Variable, die in einer Methode, einem Block oder einem Konstruktor definiert ist. Sobald die Variable deklariert ist, existieren diese Variablen nur innerhalb des Blocks und wir können nur innerhalb des Blocks auf diese Variablen zugreifen. Die Variable wird erstellt, wenn die Funktion aufgerufen oder der Block eingegeben wird. Sie wird nach dem Vorhandensein aus dem Block oder während der Rückkehr des Aufrufs von der Funktion einmal abgebrochen.
Im Beispielprogramm ist die Variable "customer_age" eine lokale Variable für die Funktion GetAge (). Der Compiler generiert einen Fehler, sobald wir die Variable customer_age außerhalb der Funktion GetAge () anwenden.
Beispielprogramm - Lokale Variablen
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();
)
)
Ausgabe:
Alter des Kunden: 28
2. Instanzvariablen oder nicht statische Variablen
Instanzvariablen werden als nicht statische Variablen bezeichnet. Die Instanzvariablen werden in einer Klasse deklariert, jedoch außerhalb einer Methode, eines Blocks oder eines Konstruktors. Diese Variablen werden erstellt, sobald das Objekt einer Klasse erstellt wurde, und es wird zerstört, wenn das Objekt zerstört wird. Zum Beispiel Variablen können wir die Zugriffsspezifizierer verwenden.
Im Programm sind die Instanzvariablen markEnglish und markMaths. Wir können mehrere Objekte erstellen. Jedes der Objekte verfügt über eine Kopie der Instanzvariablen.
Beispielprogramm - Instanzvariablen
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);
)
)
Ausgabe:
Markierungen, die vom ersten Objekt erhalten wurden:
90
80
93
Markierungen, die vom zweiten Objekt erhalten wurden:
95
70
90
3. Statische Variablen oder Klassenvariablen
Eine statische Variable wird zu Beginn der Programmausführung erstellt und am Ende der Ausführung zerstört. Statische Variablen werden auch als Klassenvariablen bezeichnet. Für den Zugriff auf statische Variablen muss kein Objekt der Klasse erstellt werden. wir können einfach auf die Variable zugreifen als,
Class_name.variable_name;
Eine statische Variable wird mit dem Schlüsselwort static innerhalb einer Klasse oder außerhalb einer Methode oder eines Konstruktors deklariert.
Beispielprogramm - Statische Variable
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);
)
)
Ausgabe:
Smiths Gehalt: 100000
4. Konstantenvariablen
Konstante Variablen ähneln den einmal initialisierten statischen Variablen und dem einmaligen Lebenszyklus einer Klasse. Sie benötigen die Instanz der Klasse nicht zum Initialisieren oder Zugreifen. Die Konstantenvariable wird mit dem Schlüsselwort 'const' deklariert. Diese Variablen können nach ihrer Deklaration nicht mehr geändert werden und sollten nur zum Zeitpunkt des Deklarationsteils initialisiert werden.
Beispielprogramm - Konstante Variable
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);
)
)
Ausgabe:
Wert von x: 25
Wert von y: 35
Wert von max: 75
5. Schreibgeschützte Variablen
Eine schreibgeschützte Variable wird mit dem Schlüsselwort ' read-only ' deklariert und diese Variablen können nicht wie konstante Variablen geändert werden. Die konstante Variable ist ein unveränderlicher Wert für die gesamte Klasse, während schreibgeschützt ein permanenter Wert für eine bestimmte Instanz einer Klasse ist. Es besteht kein Zwang, eine schreibgeschützte Variable bei der Zeitdeklaration zu initialisieren. Sie kann im Konstruktor initialisiert werden. Der für die Variable festgelegte Standardwert ist 0.
Beispielprogramm - schreibgeschützt
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);
)
)
Ausgabe:
Wert von max: 75
Wert von x: 0
Fazit
Schließlich wissen Sie, wie Sie mit Variablen Daten auf unterschiedliche Weise speichern können. In diesem Artikel haben wir gelernt, wie Variablen deklariert und initialisiert werden und wie sie verwendet werden. Ich hoffe, dieser Artikel hätte Ihnen beim Arbeitsprozess von Variablen geholfen.
Empfohlene Artikel
Dies ist eine Anleitung zu Variablen in C #. Hier diskutieren wir, was Variablen in C # sind, wie wir Variablen deklarieren, wie wir Variablen initialisieren und schließlich welche unterschiedlichen Variablentypen in C # mit ihren Beispielen existieren. Sie können sich auch die folgenden Artikel ansehen, um mehr zu erfahren -
- Wie funktioniert Copy Constructor in C #?
- C # String Funktionen mit Beispielen
- Wie deklariere ich Variablen in PHP?
- Verschiedene C # -Funktionen
- Variablen in JavaScript