Menú

Conceptes de C #: constructor, destructor, classe estàtica, Struct & Enum

  • Principal
  • Altres
  • Conceptes de C #: constructor, destructor, classe estàtica, Struct & Enum

c concepts constructor

Proveu El Nostre Instrument Per Eliminar Problemes

Aquest tutorial explica alguns dels conceptes importants de la programació en C # com ara Constructor, Destructors, Static Class, Structs and Enums:

En un dels nostres tutorials anteriors sobre Objectes i classes, vam aprendre què són una classe i un objecte.

Un objecte és similar a un objecte del món real i una classe és una col·lecció lògica d’objectes similars. És un dels tipus més fonamentals presents a C #. En aquest tutorial, aprofundirem en els altres conceptes relacionats amb C #.

=> Exploreu aquí la sèrie completa de formació C #

C # Constructor i altres conceptes

En aquest tutorial, coneixerem alguns aspectes importants de les classes i com podem utilitzar-los als nostres programes. Intentarem crear programes C # senzills basats en els conceptes que hem après en els nostres tutorials anteriors.

Què aprendreu:

Què és un constructor a C #?

El constructor és un tipus de mètode especial en llenguatge de programació C # que es crida o s’invoca automàticament quan es crea un objecte de la classe donada.

La seva funció principal és inicialitzar els membres de dades de l'objecte recentment creat. Una de les característiques més distintives del constructor és el seu nom. Té el mateix nom que la classe.

Els constructors són bàsicament de dos tipus:

  1. Per defecte
  2. Parametrat

C # Constructor per defecte

Com el seu nom indica, el constructor per defecte és el constructor bàsic d'una classe. No té cap argument i s'invoca directament en el moment de la creació d'objectes.

public class Program { public Program(){ Console.WriteLine('Constructor has been invoked'); } public static void Main(string() args) { Program p = new Program(); } }

La sortida del programa següent serà:

S'ha invocat el constructor

Explicació

Hem definit un constructor 'Programa' dins de la classe 'Programa'. Ara, quan inicialitzem la classe dins del mètode principal, el constructor s’invoca automàticament.

Per tant, qualsevol fragment de codi que hàgim guardat dins del constructor serà invocat. Aquí hem imprès un missatge 'S'ha invocat el constructor' dins dels claus del constructor, de manera que quan inicialitzem la classe, el constructor s'inicialitzarà per defecte i el missatge s'imprimirà com a sortida.

Constructor parametritzat

Com el seu nom indica, els constructors parametritzats són el constructor amb paràmetres. Aquests constructors s’utilitzen per passar diferents valors als objectes.

public class Details { public Details(int a, int b){ int c = a+b; Console.WriteLine('The sum is: '+ c); } } public class Program { public static void Main(string() args) { Details d = new Details(2, 3); } }

La sortida del programa següent serà:

etl test de preguntes i respostes d'entrevistes per a pdf amb experiència

La suma és: 5

Explicació

En el nostre exemple anterior amb el constructor per defecte, tenim el nostre mètode principal a la mateixa classe. En aquest exemple, estem tenint el mètode principal en una classe diferent.

Tenim una classe anomenada 'Detalls' que conté un constructor parametritzat que accepta dos valors enters. Dins del constructor, estem imprimint la suma dels nombres enters. Tenim una altra classe anomenada 'Programa' que conté el nostre mètode principal. Dins del mètode principal, hem inicialitzat la classe 'Detalls'.

Com s'ha explicat anteriorment, quan s'inicialitza una classe, els seus constructors es criden automàticament. Així, en aquest cas, s'ha invocat el nostre mètode constructor 'Detalls' i quan passem el paràmetre durant la inicialització, imprimeix la sortida.

Destructors en C #

Els destructors són tot el contrari que els constructors. És un mètode especial de la classe que s'invoca quan un objecte de classe surt fora de l'abast. Semblant a un constructor, un nom de destructor també és exactament el mateix que el nom de la classe, però amb un prefix de '~' (titlla).

El destructor no accepta cap paràmetre ni retorna cap valor. Destructor destrueix els objectes de la classe, de manera que s'utilitza principalment per alliberar memòria després d'executar el programa. Una altra cosa important a destacar sobre el destructor és que ni es pot sobrecarregar ni heretar.

Exemple de destructors:

public class Program { public Program(){ Console.WriteLine('Constructor has been invoked'); } ~Program(){ Console.WriteLine('Destructor has been invoked'); } public static void Main(string() args) { Program p = new Program(); } }

La sortida del programa següent serà:

S'ha invocat el constructor
S'ha invocat Destructor

Explicació

Hem utilitzat el mateix exemple que per aprendre constructor. Acabem d'afegir un destructor a la classe del programa (~ Programa). Quan inicialitzem l'objecte de la classe, s'invoca el constructor i es crea l'objecte de la classe. Això imprimeix la frase 'Constructor ha estat invocat' a la consola.

Quan l'execució s'ha completat i l'objecte de classe surt fora de l'abast, el programa avança cap al destructor. Aleshores s’invoca el destructor, que al seu torn destrueix l’objecte. Aquí hem imprès un missatge dins del destructor, que s’imprimeix a la consola després d’invocar-lo.

Membres estàtics en una classe

Els membres de la classe es poden declarar estàtics mitjançant la paraula clau estàtica. Quan un objecte es declara estàtic, independentment del nombre d'objectes creats, només hi haurà una còpia de l'objecte estàtic.

Ser estàtic implica que hi haurà una única instància del membre que existirà per a una classe determinada. Vol dir que es pot invocar el valor de la funció estàtica o variables dins de la classe sense crear-ne un objecte.

Les variables estàtiques s’utilitzen per declarar constants ja que els seus valors es poden obtenir directament invocant la classe en lloc de crear-ne una instància.

Exemple:

public class Details { public static void stat(){ Console.WriteLine('Static method invoked'); } } public class Program { public static void Main(string() args) { Details.stat(); } }

La sortida del programa següent serà:

Mètode estàtic invocat

Explicació

A l'exemple anterior, hem creat una classe 'Detalls' que conté un mètode estàtic 'stat'. Tenim una altra classe 'Programa' que conté el mètode principal. En els nostres temes anteriors, vam veure com podem inicialitzar una classe per accedir als mètodes. Però, com hem comentat, es pot accedir als membres estàtics de la classe amb la inicialització d'objectes de classe.

Per tant, en el mètode principal, acabem d’invocar el mètode utilitzant la classe directament sense crear cap objecte. La sortida del programa va executar el codi escrit dins del mètode estàtic. En aquest cas, hem imprès un missatge a la consola.

Classe estàtica en C #

Una classe estàtica és similar a una classe normal a C #. La classe estàtica només pot tenir membres estàtics i no es pot crear una instància. S’utilitza una classe estàtica per assegurar-se que la classe no s’instancia. Es declara una classe estàtica mitjançant la paraula clau static abans de la classe de paraules clau durant la declaració.

Exemple:

public static class Details { public static void multiply(int a, int b){ int c = a*b; Console.WriteLine('Multiplication result is: '+c); } } public class Program { public static void Main(string() args) { Details.multiply(2,8); } }

La sortida del programa següent serà:

El resultat de la multiplicació és: 16

Explicació

A l'exemple anterior, hem creat una classe estàtica 'Detalls' i dins de la classe estàtica hem creat un altre mètode estàtic 'multiplicar'. Dins del mètode, tenim alguns fragments de codi que volem executar. També tenim un altre 'Programa' de classe amb el mètode principal.

Dins del mètode principal, hem invocat el mètode de multiplicació present dins de la classe estàtica. Si mireu el nostre mètode principal, veureu que no hem inicialitzat ni creat cap objecte per a la classe estàtica, sinó que hem invocat directament la classe des del mètode principal.

Per tant, quan invocem directament el mètode de multiplicació mitjançant el nom de la classe i proporcionant paràmetres, executa el codi i imprimeix la sortida.

Estructures en C #

L’entitat de tipus de valor a C # s’anomena estructura. Ajuda l'usuari a emmagatzemar dades relacionades de diversos tipus de dades diferents en una sola variable. Com s'ha dit, una estructura és una entitat de tipus de valor que conté camps, mètodes, constructors, operadors, esdeveniments, etc. Es declara una estructura mitjançant la paraula clau 'struct'.

Característiques de Structs:

com fer una matriu de cadena java
  • Pot incloure constants, mètodes, propietats, índex, operadors, constructors, etc.
  • No pot tenir cap constructor per defecte.
  • Pot implementar una interfície però no pot heretar amb altres estructures o classes.
  • Cal inicialitzar les estructures mitjançant l’ús d’una paraula clau nova.

Diferència entre Struct i Class

Struct i Class poden semblar-se similars d’alguna manera, però tenen diverses diferències.

Les diferències inclouen:

  • Una estructura és un tipus de valor mentre que una classe és un tipus de referència.
  • Es necessita la nova paraula clau per inicialitzar les estructures.
  • Els Structs només poden tenir constructors parametritzats i, d'altra banda, una classe pot tenir constructors parametritzats i per defecte.

Struct: Definició

Es pot definir una estructura mitjançant la paraula clau struct. Una estructura pot definir un nou tipus de dades amb diversos membres diferents per al programa.

Una estructura es pot inicialitzar d'una manera similar a la d'una inicialització d'objectes, és a dir, mitjançant la nova paraula clau. Com que una estructura és una entitat de tipus de valor, és més ràpida d'operar que un objecte de classe. Sempre que sigui necessari emmagatzemar dades, hem d’utilitzar una estructura. D'altra banda, si necessiteu transferir dades, és recomanable utilitzar classe que una estructura.

Exemple:

public struct Cuboid { public int length; public int width; public int height; } public class Program { public static void Main(string() args) { Cuboid cb = new Cuboid(); cb.length = 10; cb.width = 20; cb.height = 30; Console.WriteLine('The volume of cuboid is: {0}', (cb.length*cb.width*cb.height)); } }

La sortida del programa següent serà:

El volum del cuboide és: 6000

Explicació

A l'exemple anterior, hem definit un cuboide estructural dins del qual hem emmagatzemat tipus de dades per a la longitud, amplada i alçada del cuboide. Tenim un altre programa de classe on tenim el nostre mètode principal.

Al mètode principal, inicialitzem l’estructura “Cuboid” mitjançant la nova paraula clau. Després hem utilitzat l'objecte per trucar i assignar valors als tipus de dades emmagatzemats a l'estructura. Després hem realitzat una operació a les variables de l’estructura i hem imprès el resultat a la consola.

Per tant, si voleu utilitzar qualsevol propietat, esdeveniment o mètode, l’estructura s’ha d’inicialitzar mitjançant la nova paraula clau o, en cas contrari, us produirà un error de compilació.

Enumeracions en C #

Enum és un conjunt de constants enteres i similar a una estructura també és una entitat de tipus de valor. S'utilitza principalment per declarar una llista d'enters mitjançant la paraula clau 'enum' dins d'un espai de noms, una classe o fins i tot una estructura. En enum, proporcionem un nom a cadascuna de les constants enteres, de manera que les podem referir utilitzant els seus respectius noms.

Enum pot tenir un nombre fix de constants. Ajuda a millorar la seguretat i també es pot recórrer.

Característiques d'Enum

  • Enum millora la llegibilitat i la mantenibilitat del codi proporcionant noms significatius a les constants.
  • Enum no es pot utilitzar amb les constants de tipus cadena.
  • Enum pot incloure constants com int, long, short, byte, etc.
  • Per defecte, el valor de les constants enum comença amb zero

Declarar una enumera

A continuació es mostra la sintaxi per declarar enum.

enum { list of integer constants };

Totes les constants enum tenen valors predeterminats. El valor comença a 0 i avança un per un.

Exemple:

public enum Cuboid{ length, width, height } public class Program { public static void Main(string() args) { int l = (int)Cuboid.length; int w = (int)Cuboid.width; int h = (int)Cuboid.height; Console.WriteLine('The length is :{0}”, l); Console.WriteLine('The width is :{0}”, w); Console.WriteLine('The height is :{0}”, h); } }

La sortida del programa següent serà:

La longitud és: 0
L'amplada és: 1
L'alçada és: 2

Explicació

Vam treballar amb un exemple similar que vam aprendre durant l’estruct. En aquest exemple, hem creat un enum anomenat Cuboid. Aquesta enumera conté tres membres, és a dir, longitud, amplada i alçada.

Tenim un altre programa de classe dins del qual tenim el nostre mètode principal. S'ha utilitzat un repartiment explícit per convertir variables de tipus enum en tipus enter, a continuació, hem emmagatzemat els seus valors en diferents variables dins del mètode principal i les hem imprès a la consola.

Per defecte, el valor del primer enum serà zero, el segon en tindrà 1 i així successivament. Per tant, quan vam imprimir els valors vam rebre la sortida esmentada.

Canvi del valor de l’enumeració

Enum també permet als usuaris canviar l'índex inicial inicial dels membres. Un cop hàgiu canviat l'índex inicial de la variable, els membres següents tindran els seus valors actualitzats en la seqüència incremental.

Assignem un valor al primer membre de l’enum que hem definit en el nostre exemple anterior i vegem què passa:

public enum Cuboid { length = 10, width, height } public class Program { public static void Main(string() args) { int l = (int)Cuboid.length; int w = (int)Cuboid.width; int h = (int)Cuboid.height; Console.WriteLine('The length is :{0}”, l); Console.WriteLine('The width is :{0}”, w); Console.WriteLine('The height is :{0}”, h); } }

La sortida del programa següent serà:

La longitud és de: 10
L'amplada és: 11
L'alçada és: 12

Explicació

Quan assignem el primer membre de l'enum amb un valor, tots els membres posteriors de l'enum s'assignaran amb l'increment d'aquest valor. Com hem definit, el primer valor és 10, el valor posterior es converteix en 11 i el següent es converteix en 12.

L'usuari pot assignar qualsevol valor segons la seva elecció i tots els membres de l'enum s'assignaran automàticament amb l'increment dels valors definits per l'usuari.

Propietats en C #

Les propietats de C # són bàsicament el membre anomenat de la interfície, les classes i l’estructura. Les propietats són una extensió de les variables membres / mètode de struct o classe. S'utilitzen per llegir, escriure o canviar el valor dels camps privats.

S'accedeix a les propietats igual que els camps. Tenen accessoris que es poden utilitzar per obtenir, configurar i calcular els valors. També podem posar lògica mentre configurem valors a les propietats. També es pot utilitzar amb la classe privada que restringeix l'accés des de fora, però, al mateix temps, permet a l'usuari utilitzar propietats per obtenir o establir valors.

Què són els accessors?

Els accessors de propietats constitueixen les declaracions que es poden utilitzar per llegir, escriure o calcular una propietat determinada. La declaració de propietat pot contenir get, set o tots dos.

Exemple:

public class Cube { private int side; //Declare a Side property of type integer public int Side{ get{ return side; } set{ side = value; } } } public class Program { public static void Main(string() args) { Cube cb = new Cube(); cb.Side = 5; Console.WriteLine('The volume of cube is :{0}', (cb.Side * cb.Side* cb.Side)); } }

Quan el fragment de codi anterior es compila i s’executa correctament, s’observa la següent sortida.

El volum del cub és: 125

Explicació

A l'exemple anterior, tenim una classe 'Cub' dins de la qual hem declarat una propietat 'Side' del tipus enter. Després d'això, obtenim i establim la propietat on hem retornat i proporcionem el valor al costat variable.

l'algorisme de dijkstra java mitjançant la cua de prioritat

Tenim una altra classe 'Programa' amb el mètode principal dins del qual hem inicialitzat la classe Cube i proporcionat el valor de la propietat Side, i després hem imprès el resultat calculat a la consola.

Conclusió

En aquest tutorial, hem après sobre les funcions membres de la classe. Una funció membre pot operar sobre qualsevol objecte de la classe on estigui present. També vam aprendre sobre constructors i destructors.

Els constructors s’inicialitzen automàticament en el moment de la creació d’objectes de classe, mentre que els destructors destrueixen la classe i s’utilitzen principalment per eliminar l’assignació de memòria després de finalitzar l’execució. Els constructors poden ser de dos tipus, és a dir, predeterminats i parametritzats.

El destructor no accepta cap paràmetre ni retorna cap valor. Tant Constructor com Destructors tenen noms que són exactament el mateix que el nom de la classe. També vam aprendre sobre les variables estàtiques i la classe estàtica i sobre com es pot accedir sense utilitzar cap instància de classe. Vam saber que una classe estàtica només pot tenir membres estàtics.

També vam parlar d’estructures o estructures. Els Structs són entitats de tipus valor i s’han d’inicialitzar per accedir-hi.

També es va discutir la quantitat i les propietats de C #. Enum és un conjunt de constants enters anomenats. De manera similar a l’estructura, també és una entitat de tipus valor. L’enum tindrà els seus membres i cada membre tindrà el seu propi valor per defecte.

Al final, vam discutir les propietats, que són una extensió de les variables membres / mètode de struct o classe. S'utilitzen per obtenir, establir o canviar el valor dels camps privats.

=> Vegeu la nostra sèrie completa d’entrenaments C # aquí

Lectura recomanada

^