oops concepts c object oriented programming concept tutorial
Aquest tutorial explica els conceptes OOPS a C #. Podeu aprendre sobre principis de programació orientats a objectes com el polimorfisme, l’encapsulació, l’herència i l’abstracció:
La programació orientada a objectes és un model de programació que funciona sobre un principi que gira al voltant d’objectes en lloc d’acció o lògica. Permet als usuaris crear objectes en funció del requisit i després crear mètodes per operar sobre aquests objectes.
Treballar sobre aquests objectes per obtenir el resultat desitjat és l'objectiu de la programació orientada a objectes.
=> Exploreu tota la sèrie de tutorials de formació en C # aquí
Revisem alguns dels conceptes que vam aprendre als nostres tutorials anteriors.
Espai de noms
Un espai de noms a C # és una col·lecció de classes. Proporciona una estructura per mantenir un nom de classe separat d’un altre nom declarant-los en un espai de noms diferent. Perquè les classes amb el mateix nom no entrin en conflicte entre elles.
Classe
Una classe és un pla d’un tipus de dades. En realitat és una col·lecció d’objectes. Conté objectes i la definició de l'operació que cal fer en aquest objecte.
Objectes
Els objectes són les instàncies de la classe.
Als nostres tutorials anteriors, ja hem après sobre la classe i els objectes en detall.
Què aprendreu:
Conceptes OOPS en C #
La programació orientada a objectes ofereix diversos avantatges respecte als altres models de programació com:
- L’enfocament modular precís i clar dels programes ofereix una comprensió i un manteniment fàcils.
- Les classes i els objectes creats al projecte es poden utilitzar a tot el projecte.
- L’enfocament modular permet que existeixin diferents mòduls de manera independent, permetent així a diversos desenvolupadors treballar junts en diferents mòduls.
En aquest tutorial, ens centrarem més en altres conceptes bàsics OOPS principals:
- Encapsulació
- Polimorfisme
- Herència
- Abstracció
Encapsulació
L’encapsulació és un concepte de programació orientat a objectes que permet als programadors embolicar dades i fragments de codi dins d’un recinte. En utilitzar el programa d’encapsulació, podeu amagar els membres d’una classe d’una altra classe. És com encerclar un element lògic dins d’un paquet. Permet només informació rellevant disponible i visible a l'exterior i això només per a membres específics.
L’encapsulació s’implementa mitjançant especificadors d’accés. L'especificador d'accés s'utilitza per definir la visibilitat i l'accessibilitat del membre de la classe a C #.
C # conté els següents especificadors d'accés.
quina és la clau de seguretat de la xarxa en un encaminador
- Públic
- Privat
- Protegit
- Intern
Els especificadors d'accés defineixen la visibilitat de la classe i els seus valors. Permet fer visibles les dades d’una part concreta del codi i amagar-les d’una altra part. La visibilitat més utilitzada és la pública i la privada.
Vegem-los.
Públic: La paraula clau pública permet que els seus membres siguin visibles des de qualsevol lloc del projecte. Aquest especificador d'accés té la restricció de visibilitat mínima.
Privat: Els membres privats només poden accedir als membres de la mateixa classe. Això té una de les visibilitats més restringides
Protegit: L’accessibilitat protegida permet accedir al membre des de la classe i des d’una altra classe que hereta aquesta classe.
Intern: Internal proporciona accessibilitat des del projecte. Una altra accessibilitat interna similar és la interna protegida. Això permet el mateix que el intern i l'única diferència és que una classe fill pot heretar aquesta classe i arribar als seus membres fins i tot d'un altre projecte.
Polimorfisme
El polimorfisme deriva del diccionari grec, significa un amb moltes formes. Poly significa molts i Morph significa formes. Permet que la classe de C # tingui múltiples implementacions amb el mateix nom.
El polimorfisme es divideix bàsicament en dues parts:
- Polimorfisme en temps de compilació
- Polimorfisme en temps d'execució
# 1) Polimorfisme de temps estàtic o de compilació
El polimorfisme en temps de compilació també es coneix com polimorfisme estàtic. La sobrecàrrega de mètodes és una de les formes en què s’aconsegueix el polimorfisme en temps de compilació. Es coneix com polimorfisme en temps de compilació, ja que es pren el mètode de decisió en el moment de la compilació.
S’aconsegueix mantenint el nom del mètode igual però passant diferents conjunts de paràmetres. En la sobrecàrrega de mètodes, el sistema comprova primer el paràmetre utilitzat i, en funció del conjunt de paràmetres, decideix anomenar el mètode adequat.
Exemple:
class Program { void print(int i, int j) { Console.WriteLine('Printing int: {0}', (i+j) ); } void print(string a, string b) { Console.WriteLine('Printing String: ' , (a+b)); } static void Main(string[] args) { Program prog = new Program(); // Call print for sum of integers prog.print(5, 6); // Call to concatenate strings prog.print('Hello','World'); Console.ReadKey(); } }
A l'exemple anterior, hem anomenat el mateix mètode 'imprimir' dues vegades amb paràmetres diferents. Al principi, passem dos enters com a paràmetres, després hem passat dues cadenes com a paràmetres. Hi ha dos mètodes 'd'impressió' amb el mateix nom.
Quan passem un paràmetre amb el sistema sencer, buscarà el mètode anomenat 'imprimir' que accepta dos paràmetres enters i executarà això ignorant altres mètodes amb el mateix nom.
A la segona part, hem passat el paràmetre string. De nou, el sistema buscarà el mètode que accepta dos paràmetres de cadena. Per tant, en funció dels paràmetres passats, el primer mètode afegirà dos enters i el següent concatenarà dues cadenes.
# 2) Polimorfisme dinàmic o polimorfisme en temps d'execució
El polimorfisme en temps d'execució o polimorfisme dinàmic es produeix quan el nom del mètode i la signatura del mètode tenen el mateix nom i paràmetres. La substitució del mètode és un exemple de polimorfisme dinàmic. Permet a l'usuari crear una classe abstracta amb implementació parcial de la interfície.
La substitució del mètode s’aconsegueix mitjançant l’herència. Per aconseguir mètodes de substitució, tant la classe base com la classe derivada haurien de tenir el mateix nom i paràmetre. Durant el temps de compilació, el compilador no és capaç de reconèixer el mètode de substitució i, per tant, no genera cap error. La decisió d'executar un mètode es pren durant l'execució.
Exemple:
class Program { public void print() { Console.WriteLine('Printing from class Program'); } } class Execute : Program { public void print() { Console.WriteLine('Printing from class Execute'); } public static void Main(string[] args) { Execute exe = new Execute(); exe.print(); Console.ReadLine(); } }
Si executem el programa anterior obtindrem la següent sortida:
Printing from class Execute
Tot i que la classe Execute ha heretat tots els mètodes de la classe Programa, però quan anomenem el mètode print que és present a les dues classes, el mètode present a la classe fill substituirà el mètode de la classe pare.
El polimorfisme dinàmic s’utilitza per implementar l’abstracció. Permet a l'usuari crear una classe abstracta que s'utilitza per proporcionar una implementació d'una interfície quan és heretada per una classe derivada. La classe abstracta pot contenir noms / signatures dels mètodes i la classe derivada pot tenir una definició més especialitzada per al mètode.
Herència
L’herència és una part important del concepte OOPS. En herència, definim les classes pares i fills. La classe fill pot heretar tots els mètodes, objectes i propietats de la classe pare. Una classe infantil també pot tenir els seus propis mètodes i implementació específica.
La classe pare també es coneix com a classe base i la classe fill que hereta la classe base també es coneix com a classe derivada.
Exemple:
class Program { public void print() { Console.WriteLine('Printing from class Program'); } } class Execute : Program { public static void Main(string[] args) { Execute exe = new Execute(); exe.print(); Console.ReadLine(); } }
Aquí tenim una classe anomenada com a programa que té un mètode. Tenim una altra classe Execute que hereta la classe Programa. La classe Execute és la classe derivada i el programa de classe es coneix com a classe base.
Ara, en lloc de crear una instància d'objecte per al programa de classe, hem creat una instància d'objecte per a la classe Execute. Mitjançant aquesta instància podem accedir al mètode d’impressió des de la classe base.
Per tant, la sortida del codi anterior serà:
Printing from class Program
La classe derivada no només hereta mètodes, sinó que hereta gairebé tots els membres de la classe, com ara camps, propietats, etc., en funció de la visibilitat. L’herència a C # no permet l’ús de múltiples herències, és a dir, una classe no pot heretar de diverses classes diferents, però, una classe pot heretar d’una altra classe que pot heretar d’una classe diferent.
Abstracció
L’abstracció és un dels principis principals de la programació orientada a objectes. L’abstracció permet al programador mostrar només al món els detalls necessaris mentre amaga els altres. L’abstracció s’aconsegueix en C # mitjançant la classe i la interfície Abstract.
Es pot declarar una classe com a classe abstracta mitjançant la paraula clau 'Abstract'. La classe Abstract en C # sempre és la classe base de la jerarquia. El que els fa diferents de l’altra classe és que no es poden crear instàncies. Cal heretar una classe abstracta C #.
Exemple:
class Program { static void Main(string[] args) { Hyundai hyn = new Hyundai(); String descp = hyn.Describe(); Console.WriteLine(descp); Console.ReadKey(); } } abstract class Car { public void Describe() { return 'Description of the car'; } } class Hyundai : Car { }
El resultat següent és:
Description of the car
Si el compareu amb els nostres exemples anteriors durant l’herència o el polimorfisme dinàmic, trobareu les similituds. La diferència més reconeixible és l’ús de paraules clau abstractes abans de la classe Car. En cas que vulgueu anul·lar-ho o proporcionar la vostra pròpia implementació similar al que vam fer en polimorfisme dinàmic. A continuació, podeu aconseguir-ho seguint el següent.
class Program { static void Main(string[] args) { Hyundai hyn = new Hyundai(); String descp = hyn.Describe(); Console.WriteLine(descp); Console.ReadKey(); } } abstract class Car { public virtual string Describe() { return 'Description of the car'; } } class Hyundai : Car { public override string Describe() { return 'Description of the car is now Hyundai'; } }
Per tant, si executeu aquest codi ara, donarà la següent sortida:
Description of the car is now Hyundai
El mètode de classe derivada substitueix el mètode de classe base. D'aquesta manera, podeu crear una classe derivada diferent, com ara Ferrari, Porsche, BMW, etc. amb els seus propis mètodes d'implementació.
Si us fixeu bé, veureu que el nostre mètode de descripció a la classe abstracta no conté cap implementació.
Llavors, per què definim mètodes buits?
Això es deu al fet que una classe Abstract proporciona una signatura dels mètodes i fa que les subclasses siguin una obligació de crear una implementació per a tots aquests mètodes. Això permet compartir la classe base però, al mateix temps, també comprova la implementació del mètode de la classe derivada.
Interfície
A C #, la interfície és el pla d'una classe. La interfície és similar a una classe abstracta i s’utilitza per aconseguir un abstracció al cent per cent. Tots els mètodes descrits dins de la interfície són abstractes per defecte. No té cap cos de mètode i no es pot instanciar.
La interfície s'utilitza principalment per aconseguir una herència múltiple i una abstracció completa. Tota la signatura del mètode declarada dins de la interfície s'ha de proporcionar amb la implementació de la classe o l'estructura que la implementa.
Exemple:
class Program { static void Main(string[] args) { Hyundai hyn = new Hyundai(); String descp = hyn.Describe(); Console.WriteLine(descp); Console.ReadKey(); } } interface Car { string Describe(); } class Hyundai : Car { public string Describe() { return 'Description of the car is now Hyundai'; } }
La sortida del codi anterior serà:
Description of the car is now Hyundai
Aquí hem creat una interfície Car. Com que la interfície no pot tenir cap definició de mètode, acabem de proporcionar el nom del mètode i el tipus de retorn a la interfície. Després vam implementar la interfície Car a una altra classe Hyundai. A la classe implementada hem proporcionat la definició dels mètodes definits dins de la interfície.
Conclusió
En el concepte de programació orientada a objectes, cada part del programa es tracta com un objecte. Class és una col·lecció d'elements similars i un objecte és la instància de la classe.
L’encapsulació en C # permet a l’usuari establir la visibilitat de la classe i dels seus membres. El polimorfisme permet que els mètodes tinguin el mateix nom, però amb paràmetres diferents dins de la mateixa classe o amb el mateix paràmetre en una classe diferent.
L’herència és quan una classe fill que també es coneix com a classe derivada hereta totes les propietats, inclosos els mètodes, objectes, camps, etc. de la classe pare, que també es coneix com a classe base. L’abstracció permet al programa mostrar només la signatura mentre amaga els detalls de la implementació.
Programa consolidat
class Program { void print(int i, int j) { Console.WriteLine('Printing int: {0}', (i + j)); } void print(string a, string b) { Console.WriteLine('Printing String '+ a + b); } static void Main(string[] args) { Program prog = new Program(); // Call print for sum of integers prog.print(5, 6); // Call to concatenate strings prog.print('Hello', 'World'); Hyundai hyn = new Hyundai(); String descp = hyn.Describe(); Console.WriteLine(descp); Console.ReadKey(); } } abstract class Car { public virtual string Describe() { return 'Description of the car'; } } class Hyundai : Car { public override string Describe() { return 'Description of the car is now Hyundai'; } }
=> Exploreu tota la sèrie de tutorials de formació en C # aquí
Lectura recomanada
- OOP Java: Introducció a la programació orientada a objectes a Java
- Programació orientada a objectes en C ++
- Tutorial Unix Pipes: Pipes a la programació Unix
- Tutorial de Python DateTime amb exemples
- Dipòsit d'objectes a QTP: tutorial núm. 22
- Conceptes OOP de Python (classes, objectes i herència de Python)
- QTP Tutorial # 7 - Paradigma d’identificació d’objectes de QTP: com QTP identifica objectes de manera única?
- Apreneu els conceptes avançats de scripts SoapUI Groovy: tutorial SoapUI núm. 9