Bevezetés a C # változóiban
A C #-ban egy változó egy név, amelyet a memóriahelynek adunk, és minden változónak van egy meghatározott típusa, amely meghatározza az érték típusát, amelyet a változóban tárolhatunk. Az összes változót használat előtt be kell jelenteni; minden változónak van egy meghatározott típusa, amely meghatározza a változók méretét és tartományát. A változókkal végzett bármilyen művelet elvégzéséhez elengedhetetlen egy adott adattípusú változó meghatározása, hogy meghatározható legyen az adattípus, amelyet a változó az alkalmazásunkban tárolhat. Nézzünk néhány alapvető dolgot a változókról,
- A változók nem más, mint az adatok értékének megadott név.
- A változók tartalmazhatják az egyes adattípusok, például az int, a karakterlánc, az úszó stb. Értékét.
- A változók deklarálása és inicializálása külön nyilatkozatokban található.
- A változókat vesszővel elválasztva többször is meghatározhatjuk, és az sem pontosvessző végéig is egyszeres és többsoros lehet.
- Az értékeket hozzá kell rendelni egy változóhoz, mielőtt felhasználnánk; egyébként fordítási idő hibát fog mutatni.
- A változó értéke bármikor megváltoztatható, amíg a program nem elérhető.
Hogyan deklarálhatjuk a változókat a C # -ben?
Van néhány szabály a C # változó deklarálására:
- Meg kell határoznunk egy változó nevet a számok, ábécé és aláhúzás kombinációjával.
- Minden változó nevének betűkkel vagy aláhúzással kell kezdődnie.
- A változó neve között nem szabad semmilyen helyet hagyni.
- A változónevek nem tartalmazhatnak olyan tartalék kulcsszavakat, mint az int, char, float és így tovább.
A C # változódefiníció szintaxisa
;
=value;
=value;
Itt a egy olyan típusú adat, amelyben a változó megtarthatja azokat a típusokat, amelyek egészek, Sting, float és így tovább . a változó neve, amely értéket tart az alkalmazásban és egy adott értéket rendel a változónak és végül a változó hozzáférési engedélyének megadására szolgál. Néhány alkalmas módszer a változónevek leírására c # programozási nyelven.
int name;
float value;
char _firstname;
A változót a meghatározáskor az alábbiak szerint is inicializálhatja:
int value = 100;
Hogyan inicializálhatjuk a változókat a C # -ben?
Az értékek hozzárendeléséhez az inicializálásnak nevezett változóhoz a változókat egyenlő jellel lehet inicializálni az állandó kifejezéssel, a változók inicializálhatók azok deklarálásakor is.
Szintaxis :
= value;
Vagy
variable_name = value;
Például,
int value1=5, value2= 7;
double pi= 3.1416;
char name='Rock';
A C # változóinak típusai példákkal
Többféle változó létezik, például
- Helyi változók
- Példányváltozók vagy nem statikus változók
- Statikus vagy osztályváltozók
- Állandó változók
- Csak olvasható változók
1. Helyi változók
Egy módszerben, blokkban vagy konstruktorban meghatározott helyi változó. Miután a változót deklarálták, ezek a változók csak a blokkon belül léteznek, és ezekre a változókra csak a blokkban férhetünk hozzá. A változó akkor jön létre, amikor a funkció meghívásra kerül vagy a blokk bekerül, és egyszer lebontják azt a blokkból való létezés után, vagy amíg a hívás visszatér a funkcióból.
A mintaprogramban az „customer_age” változó a GetAge () függvény helyi változója. A fordító hibát generál, mihelyt a kliens_változót a GetAge () függvényen kívül alkalmazzuk.
Mintaprogram - Helyi változók
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();
)
)
Kimenet:
Vevő életkora: 28
2. Példányváltozók vagy nem statikus változók
A példányváltozókat nem statikus változóknak nevezzük; a példányváltozókat osztályban deklarálják, de bármelyik módszer, blokk vagy konstruktoron kívül deklarálják. Ezeket a változókat egy osztály objektumának létrehozása után hozzák létre, és akkor pusztulnak el, amikor az objektum elpusztul. Például a változókat használhatjuk a hozzáférési jellemzőket.
A programban a példányváltozók a markEnglish, markMaths. Több objektumot is létrehozhatunk, mindegyik objektum példány változójával rendelkezik.
Mintaprogram - Példányváltozók
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);
)
)
Kimenet:
Az első tárgytól kapott jelek:
90
80
93
A második tárgytól kapott jelek:
95
70
90
3. Statikus vagy osztályváltozók
A program végrehajtásának elején létrejön egy statikus változó, amely a végrehajtás végén elpusztul. A statikus változókat osztályváltozóknak is nevezzük. A statikus változók eléréséhez nem kell létrehoznunk az objektumot; egyszerűen elérhetjük a változót,
Class_name.variable_name;
A statikus változót statikus kulcsszó használatával deklaráljuk egy osztályon belül, vagy bármilyen módszer vagy konstruktor kívül.
Mintaprogram - statikus változó
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);
)
)
Kimenet:
Smith fizetése: 100000
4. Állandó változók
Az állandó változók hasonlóak a statikus változókhoz, az inicializálás után és az osztály egyszeri életciklusához, és az inicializáláshoz vagy eléréshez nincs szükség az osztály példányára. Az állandó változót a 'const' kulcsszó használatával deklaráljuk, ezeket a változókat nem lehet megváltoztatni, ha azt deklaráltuk, és csak a deklarációs résznél kell inicializálni.
Mintaprogram - állandó változó
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);
)
)
Kimenet:
X értéke: 25
Y értéke: 35
Max. Érték: 75
5. Csak olvasható változók
A csak olvasható változókat a „ csak olvasható ” kulcsszó deklarálja, és ezeket a változókat nem lehet állandó változókként megváltoztatni. Az állandó változó az egész osztály változatlan értéke, míg a csak olvasható az osztály adott példányának állandó értéke. Nincs szükség írásvédett változó inicializálására az időbevallás során, inicializálható kivitelező alatt. A változóra beállított alapértelmezett érték 0.
Mintaprogram - csak olvasható
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);
)
)
Kimenet:
Max. Érték: 75
X értéke: 0
Következtetés
Végül megtudta, hogy a változók hogyan teszik lehetővé az adatok különböző módon történő tárolását. Ebben a cikkben megtudtuk, hogyan kell deklarálni és inicializálni a változókat, és hogyan lehet felhasználni azokat. Remélem, hogy ez a cikk segített volna a változók munkafolyamatában.
Ajánlott cikkek
Ez egy útmutató a C # változóinak. Itt tárgyaljuk, hogy mi a C # változó, hogyan deklaráljuk a változókat, hogyan inicializáljuk a változókat, és végül, mi a különféle típusú C típusú változók a példáival. A következő cikkeket is megnézheti további információkért -
- Hogyan működik a Copy Constructor a C # -ben?
- C # Karakterlánc funkciók példákkal
- Hogyan deklarálhatjuk a változókat a PHP-ben?
- Különböző C # funkciók
- Változók a JavaScript-ben