oop java introduction object oriented programming java
Aquest vídeo tutorial introduirà conceptes OOP (Object Oriented Programming) a Java, com ara Objecte, Classe, Herència, Polimorfisme, Abstracció, Encapsulació, etc.:
A la programació de programari, tenim diversos tipus de llenguatges de programació. Les llengües més importants entre elles tenen un caràcter procedimental o orientat a objectes.
En els llenguatges de programació de procediments, els problemes més grans es divideixen en petits problemes solucionables. Aquests petits problemes es converteixen en procediments o funcions. D'aquesta manera, el llenguatge de programació procedimental posa l'accent en les funcions més que en les dades. Per tant, els llenguatges de procediment han descuidat completament les dades i, per tant, no garanteixen la seguretat de les dades.
Aquest problema el va tenir cura el llenguatge de programació orientat a objectes. La programació orientada a objectes és una forma de dissenyar i programar programes mitjançant la manipulació d’objectes i els objectes són la part principal de la programació.
Descobriu tota la nostra sèrie de tutorials de Java per a principiants aquí .
Què aprendreu:
Videotutorials sobre conceptes OOPS
Concepte OOPS a Java: primera part:
Aprofundiment del concepte OOPS a Java - Part 2:
Els llenguatges de programació orientats a objectes emfatitzen les dades més que les funcions. La programació orientada a objectes (OOP) gira al voltant d’objectes, és a dir, una entitat en temps real.
Aquest objecte agrupa les dades i els mètodes que operen en aquestes dades en una sola unitat. D'aquesta manera, les dades es protegeixen del món exterior tenint els mètodes a l'interior de l'objecte. A POO, els objectes es comuniquen entre ells mitjançant missatges.
Qualsevol idioma OOP admet les funcions següents:
- Classes
- Encapsulació
- Abstracció
- Herència
- Polimorfisme
Totes aquestes funcions garanteixen la seguretat de les dades i, alhora, també podem escriure aplicacions robustes. Smalltalk, C ++, Java, etc. són alguns dels llenguatges de programació orientats a objectes.
En aquest tutorial, parlarem dels conceptes bàsics de l'OOP pel que fa al llenguatge Java.
Programació orientada a objectes (OOP) a Java
Java és l’habilitat de programació més buscada actualment. A Java, tot es basa en l'objecte. Java té una classe arrel anomenada Object de la qual es deriva tota la funcionalitat de Java. Així, en aquest tutorial, parlarem de les principals característiques de l'OOP relacionades amb Java.
Lectura recomanada => Preguntes i respostes de l’entrevista OOP
Aquí analitzarem com Java admet les següents funcions OOP.
- Objecte i classe
- Classe
- Herència
- Polimorfisme
- Abstracció
- Encapsulació
Analitzem detalladament cadascun d’aquests conceptes Java OOP.
Objecte i classe
Una classe es pot definir com un prototipus de disseny o un pla. A partir d’aquests plànols es creen objectes. Bàsicament defineix un tipus comú que consisteix en propietats i mètodes que operen en aquestes propietats per a aquest tipus comú. A continuació, definim les instàncies d’aquesta classe anomenades objectes.
Una classe té molts components tal com es mostra a la figura següent.
Un objecte representa una entitat de la vida real. A Java, un objecte és una instància d'una classe. Per tant, una classe que és un pla es pot utilitzar per crear molts objectes. Aquests objectes solen comunicar-se entre ells passant missatges entre ells mitjançant mètodes.
Vídeo tutorial: classes i objectes
Un objecte sol tenir:
- Un estat: Les propietats o atributs d’un objecte en un moment concret.
- Comportament: Els mètodes representen el comportament d’un objecte. Els mètodes també defineixen com es comuniquen els objectes.
- Identitat: Identifica l'objecte donant-li un nom únic.
Per exemple, si tenim una classe PetAnimals.
A continuació, podem definir un objecte d'aquesta classe de la següent manera:
PetAnimals porc = PetAnimals nou.
Aquí la identitat de l'objecte és un porc.
A continuació es mostra un programa que demostra classe i objecte.
//student class class Student{ int roll_No; String student_name; } class Main{ public static void main(String args[]){ //Create objects of class Student Student student1=new Student(); Student student2=new Student(); //Initialize Student class objects student1.roll_No=101; student1.student_name='Lisa'; student2.roll_No=102; student2.student_name='Dan'; //Print object data System.out.println('Student 1 Details: ' + student1.roll_No+' '+student1.student_name); System.out.println('Student 2 Details: ' + student2.roll_No+' '+student2.student_name); } }
Sortida
A la classe anterior, hem definit una classe Student amb dues propietats roll_No i student_name. Després, en el mètode principal, declarem dos objectes de classe, és a dir, student1 i student2. Tingueu en compte que aquests objectes es creen mitjançant un operador nou. Un cop creats els objectes, assignem dades a les propietats de l’objecte.
Finalment, imprimim el contingut de l’objecte amb l’operador ‘.’ (Punt).
Aprendrem més sobre classes i objectes en els nostres temes específics de tutories de POO.
Herència
L'herència és una de les característiques més importants de l'OOP. Mitjançant l’herència, Java promou la reutilització del codi.
Llavors, què és una herència a Java?
L’herència és un mecanisme de Java en el qual una classe pot heretar les propietats d’una altra classe. Les propietats que es poden heretar inclouen membres de dades i mètodes de la classe.
La classe que hereta les propietats d’una altra classe s’anomena subclassa. La classe heretada es coneix com a classe “súper” a Java.
En heretar la classe, la subclasse no només hereta les propietats, sinó que també reutilitza el codi, ja que el programador no ha de tornar a escriure el codi quan el pot heretar directament mitjançant l'herència.
A Java, l’herència s’aconsegueix utilitzant la paraula clau “extends”. Aquesta paraula clau estén s'utilitza en la definició de la classe i va seguida del nom de la classe que s'ha d'heretar.
Per exemple,si hi ha dues classes, A i B, i A l'hereta B, llavors aquesta herència s'escriu en Java com:
class B extends A { …… }
Com ja s'ha esmentat, aquí A és la superclasse o classe base o classe pare. B és una subclasse, classe derivada o classe secundària.
L'herència es divideix en els tipus següents.
Java admet herència única, multinivell i jeràrquica.
Tingueu en compte que Java no admet herències múltiples. Java tampoc no admet l’herència híbrida, que és una combinació d’herències jeràrquiques múltiples.
A continuació es mostra un exemple de programa d’herència única a Java.
//base class class Employee{ float salary=50000; } //derived class class Developer extends Employee{ int bonus=20000; } class Main{ public static void main(String args[]){ //declare Developer class object and access properties of base and derived class Developer p=new Developer(); System.out.println('Inheritance in Java'); System.out.println('Developer salary: '+p.salary); System.out.println('Bonus declared for Developer: '+p.bonus); System.out.println('Developer Total Earnings: ' + (p.salary + p.bonus)); } }
Sortida
Al programa anterior, tenim un empleat de classe base. Tenim un altre desenvolupador de classe que hereta de la classe Employee. En el mètode principal, podem veure que declarant un objecte de la classe Developer podem accedir no només a les propietats de la classe Developer sinó també de la classe Employee, ja que és heretat per la classe Developer.
Polimorfisme
El polimorfisme és una altra característica important de l'OOP. El polimorfisme és la capacitat del llenguatge de permetre que objectes o entitats assumeixin múltiples formes. Per exemple, un mètode que té diverses implementacions és polimòrfic a Java.
El polimorfisme és de dos tipus a Java:
- Sobrecàrrega o polimorfisme de temps de compilació: En el polimorfisme en temps de compilació, la crida al mètode polimòrfic o sobrecarregat es resol en el moment de la compilació.
- Polimorfisme d’execució o d’execució: En polimorfisme en temps d'execució, la crida a un mètode anul·lat al programa Java es resol en temps d'execució.
Discutirem detalladament el polimorfisme en els nostres tutorials posteriors.
A continuació es mostra un exemple de polimorfisme en temps de compilació a Java en què tenim un mètode add que està sobrecarregat per realitzar addicions amb diferents tipus d'operands.
class Numbers_Sum { //add method : takes two int parameters public int add(int val1, int val2) { return (val1 + val2); } // overloaded add : takes three int parameters public int add(int val1, int val2, int val3) { return (val1 + val2 + val3); } //overloaded add: takes two double parameters public double add(double val1, double val2) { return (val1 + val2); } } class Main{ public static void main(String args[]) { //create an object of Numbers_Sum class and call overloaded functions Numbers_Sum numsum = new Numbers_Sum(); System.out.println('Polymorphism in Java'); System.out.println('add(int, int): ' + numsum.add(15, 18)); System.out.println('add(int, int, int): ' + numsum.add(5, 10, 20)); System.out.println('add(double,double): ' + numsum.add(5.5, 15.5)); } }
Sortida
En aquest programa, tenim tres mètodes sobrecarregats anomenats add. El primer mètode pren dos paràmetres int, el següent mètode pren tres paràmetres int i el tercer mètode pren dos paràmetres dobles. Depenent del nombre de paràmetres, la trucada del mètode es resol en temps de compilació i es fa la trucada adequada.
Abstracció
Mitjançant l’abstracció de dades, només exposem les parts essencials de l’aplicació accessibles a l’usuari. Per exemple, si tenim un cotxe, no ens preocupen els components interns del vehicle, sinó que només el considerem com un tot.
Mitjançant un mecanisme d’abstracció de dades, només identificem els detalls necessaris i ignorem els detalls irrellevants. Java utilitza classes i interfícies abstractes per aconseguir l'abstracció. Les interfícies són 100% abstractes, ja que només tenen prototips de mètodes i no la seva definició.
L'exemple següent mostra una classe abstracta i el seu ús.
// Abstract class declaration abstract class PetAnimal { // Abstract method: should be defined in derived class public abstract void animalSound(); // non-abstract method public void print() { System.out.println('This method is example of abstraction'); } } // Derived class class Dog extends PetAnimal { //abstract method defined here public void animalSound() { System.out.println('The doggy barks'); } } class Main { public static void main(String[] args) { Dog doggy = new Dog(); // Instantiate derived class and call methods doggy.animalSound(); doggy.print(); } }
Sortida
Al programa anterior, tenim una classe abstracta PetAnimals. En això, tenim un mètode abstracte 'animalSound'. A continuació, creem una classe Dog i heretem la classe PetAnimals. A la classe Dog, substituïm el mètode animalSound.
com inicialitzar una llista a Java
Encapsulació
L’encapsulament és amagar dades o protegir-les. En la programació, aconseguim l’encapsulació embolicant dades i mètodes que operen en aquestes dades en una sola unitat.
Video Tutorial: Encapsulació i polimorfisme a Java
Una classe es pot veure com una unitat d’encapsulació, és a dir, tenim membres de dades i mètodes que operen en aquests membres de dades agrupats en una sola unitat.
Es pot aconseguir una encapsulació adequada fent privats els membres de les dades i fent públics els mètodes que operen sobre aquestes dades, de manera que les dades estiguin completament protegides de les entitats externes.
El programa Java següent mostra el concepte d’encapsulació.
class Customer_Account { //private data of class private long customer_accountNo; private String customer_name,customer_email; private float customer_salary; //public getter/setter methods to access private data public long getAcc_no() { return customer_accountNo; } public void setAcc_no(long acc_no) { this.customer_accountNo = acc_no; } public String getName() { return customer_name; } public void setName(String name) { this.customer_name = name; } public String getEmail() { return customer_email; } public void setEmail(String email) { this.customer_email = email; } public float getSalary() { return customer_salary; } public void setSalary(float salary) { this.customer_salary = salary; } } public class Main { public static void main(String[] args) { //create an object of customer_Account class Customer_Account acc=new Customer_Account(); //use setter methods to set values acc.setAcc_no(123458765432L); acc.setName('SoftwareTestingHelp'); acc.setEmail('sth@sth.com'); acc.setSalary(65000f); //use getter methods to read values System.out.println('Customer Account Number: ' + acc.getAcc_no()); System.out.println('Customer Account Details:'); System.out.println(' Customer Name: '+acc.getName()+'
'+ ' Customer Email: ' + acc.getEmail()+'
' + ' Customer Salary: ' +acc.getSalary()); } }
Sortida
Al programa anterior, tenim una classe Customer_Account.
En aquesta classe, tenim membres de dades que són tots privats. A continuació, per a cada camp privat, proporcionem mètodes getter i setter per llegir i establir valors respectivament. Aquests getters i seters són públics. D'aquesta manera protegim els camps de dades en no permetre'ls cap accés directament des de fora de la classe.
Només s’hi pot accedir a través de getters i seters. Això demostra l’encapsulació que hem descrit anteriorment.
Preguntes freqüents
P # 1) Què s'entén per programació orientada a objectes?
Resposta: La programació orientada a objectes (OOP) és un paradigma de programari que gira al voltant de les dades. A POO, es posa èmfasi en les dades i, per tant, els problemes s’expressen en termes d’objectes que són entitats que consisteixen en dades o camps i mètodes que operen en aquests camps de dades.
En fer-ho, s’apliquen diverses característiques distintives de la POO com l’herència, el polimorfisme, l’abstracció i l’encapsulació per garantir la seguretat de les dades, la seva reutilització, etc.
Q # 2) Quins són els 4 principis bàsics de l'OOP?
Resposta:La programació orientada a objectes (OOP) té quatre principis bàsics:
- Herència
- Polimorfisme
- Abstracció
- Encapsulació
També s’anomenen quatre pilars d’OOP.
P # 3) Per què es diu Java orientat a objectes?
Resposta: Java té un objecte de classe arrel del qual derivem totes les altres característiques de Java. Així, sense classe i objecte, no podem tenir un programa Java. Per tant, Java s’anomena llenguatge OOP.
Q # 4) Java és purament orientat a objectes?
Resposta: No, Java no és un llenguatge pur orientat a objectes. Com que Java també proporciona tipus de dades primitius com int, char, float, double, long, etc., no està classificat com a llenguatge OOP pur.
Q # 5) Quina diferència hi ha entre C ++ i Java?
Resposta: Tant C ++ com Java són llenguatges orientats a objectes i admeten funcions OOP. Però C ++ és un llenguatge compilat. Java, en canvi, es compila, així com un llenguatge interpretat.
L'intèrpret de Java executa el codi de bytes en temps d'execució i genera una sortida que el fa independent de la plataforma. C ++, però, depèn de la plataforma.
Més informació sobre el concepte OOPS
Classe
La classe és un pla / prototipus d’un objecte del món real i modelitza l’estat i el comportament d’aquest objecte del món real.
Declaració de classe
class MyClass { // field, constructor, and // method declarations }
Class room(){ //room should have dimension. Dimension is attribute. //in the room, we are going keep things. Keeping is the function we are going to do. Keepthings (); this is a method in java. }
Objecte
Els objectes de programari són com objectes de la vida real amb estat i comportament. L'estat s'emmagatzemarà com a camp i exposarà el seu comportament com a mètodes.
Aquí l'habitació és com un disseny general. Dins d’aquesta habitació, heu de dissenyar una sala d’estar, una cuina, un dormitori.
Class CookingRoom(){ Dimension is attribute. //here we should have method to keep cooking things. Keepthings(){ This method is same like room class keep things method. but it should have some more features to hold cooking items. } cooking(); }
Class LivingRoom(){ Dimension is attribute. //here we should have method to keep Living Room things. Keepthings(){ This method is same like room class keep things method. but it should have some more features to hold living room items(like tv etc). } watching tv(); }
Aquí el mètode 'Keepthings ()' hauria de fer les funcionalitats bàsiques necessàries per a l'habitació i hauria de tenir una especificació addicional segons els requisits de la classe de 'sala d'estar' i 'sala de cuina'. Per tant, les dues classes haurien d’heretar els mètodes de la classe “sala”.
Herència
El comportament (mètodes) i l’estat d’una classe heretada a l’altra classe s’anomenen herència. Els mètodes i l’estat s’hereten de la classe pare a la classe fill.
Tan,
Class CookingRoom extends Room{ }
Class LivingRoom extends Room{ }
Polimorfisme
En biologia, el polimorfisme es refereix a les espècies que poden tenir moltes formes diferents.
Amb el mateix concepte en la programació orientada a objectes, la classe fill pot heretar els seus mètodes de classe pare, també pot afegir característiques úniques a aquest comportament. El polimorfisme es pot aconseguir mitjançant la sobrecàrrega o la substitució del mètode.
Sobrecàrrega
public class OverloadDemo { public int add( int a,int b) { int rs=a+b; return rs; } public int add( int a,int b,int c) { int rs=a+b+c; return rs; } public static void main(String[] args) { OverloadDemo ov=new OverloadDemo(); System.out.println(ov.add(23,56,45)); System.out.println(ov.add(23,56)); } }
Sobresortint
public class Bicycle { int wheels=2; String seat; public void riding() { System.out.println('bicycle is used for riding'); } }
public class RoadBicycle extends Bicycle{ public void riding() { System.out.println('RoadBicycle is used for road riding'); } }
public class TestBicycle { public static void main(String[] args) { Bicycle b=new RoadBicycle(); b.riding(); } }
SORTIDA: Aquí el mètode de classe infantil substitueix el mètode de classe pare.
Súper paraula clau
La paraula clau super és una variable de referència que s'utilitza per referir-se a l'objecte de classe pare immediat. Amb la paraula clau super, podeu referir-vos al mètode o variables de la classe pare o al constructor.
Aquesta paraula clau
Aquesta paraula clau s’utilitza per referir-se a l’objecte de classe actual. Mitjançant aquesta paraula clau, podeu accedir a la variable d’instància de classe actual o al mètode de classe actual. Això es pot passar com a argument a la crida al mètode.
public class DemoThisKeyword { private int accno; private int balance; public void setvalues(int accno,int balance) { this.accno=accno; this.balance=balance; } public int showdata() { System.out.println(accno); System.out.println(balance); return balance; } public static void main(String[] args) { // TODO Auto-generated method stub DemoThisKeyword obj =new DemoThisKeyword(); obj.setvalues(11, 100); obj.showdata(); System.out.println(obj.showdata()); } }
constructor
Els constructors Java són com mètodes que s’anomenaran quan es crea l’objecte per a la classe. El constructor hauria de tenir el mateix nom que la classe.
Class Myclass{ Myclass(); Method1() { } }
Mentre creava un objecte per a la classe, Myclass myobj = new Myclass ();
Es cridarà el mètode constructor. El compilador Java crea automàticament el constructor per a totes les classes per defecte.
public class ConstructorExampleProgram { int employee_age; String employee_name; int employee_salary; //Default constructor ConstructorExampleProgram(){ this.employee_name=Bob'; this.employee_age=30; this.employee_salary=7000; } //Parameterized constructor ConstructorExampleProgram(String n,int a,int b){ this.employee_name=n; this.employee_age=a; this.employee_salary=b; } public static void main(String args[]){ ConstructorExampleProgram obj1 = new ConstructorExampleProgram(); ConstructorExampleProgram obj2 = new ConstructorExampleProgram('clare', 56,7500); System.out.println(obj1.employee_name+' '+obj1.employee_age+' '+obj1.employee_salary); System.out.println(obj2.employee_name+' '+obj2.employee_age+' '+obj2.employee_salary); } }
Regles a seguir per al constructor:
- El constructor hauria de tenir el mateix nom que el nom de la classe.
- El constructor no hauria de tenir una declaració de retorn.
Punts a destacar:
- A la programació orientada a objectes, els objectes són la part principal de la programació.
- Els conceptes de PO són objecte, classe, herència, polimorfisme, constructor.
- Súper paraula clau que s'utilitza per fer referència als membres de la classe pare i això La paraula clau s'utilitza per referir-se a un objecte de classe actual.
- Els constructors són com mètodes que s’anomenaran quan es crea l’objecte per a la classe.
Conclusió
Aquest tutorial va tractar els conceptes bàsics de funcions importants orientades a objectes compatibles amb Java. Aquest és només un tutorial introductori sobre OOPS a Java. Tractarem tots els temes en detall als nostres tutorials posteriors. Java admet quatre pilars de POO, és a dir, polimorfisme, herència, abstracció i encapsulació.
A part d’aquestes funcions, Java també admet les altres funcions i construccions de POO com la contenció, l’agregació, la transmissió de missatges, etc., que es parlaran en els nostres propers tutorials.
Lectura recomanada
- Tutorial JAVA per a principiants: més de 100 tutorials pràctics de vídeo Java
- Què és l'abstracció a Java: apreneu amb exemples
- Què és l’herència a Java: tutorial amb exemples
- Què és el polimorfisme a Java: tutorial amb exemples
- Encapsulació a Java: tutorial complet amb exemples
- Tipus d’herència a Java: herència múltiple contra Vs
- Conceptes OOPS en C #: Tutorial de conceptes de programació orientada a objectes
- Programació orientada a objectes en C ++