Menu

Java OOP: Introduzione alla programmazione orientata agli oggetti in Java

  • Principale
  • Altro
  • Java OOP: Introduzione alla programmazione orientata agli oggetti in Java

oop java introduction object oriented programming java

Prova Il Nostro Strumento Per Eliminare I Problemi

Questo video tutorial introdurrà concetti OOP (Object Oriented Programming) in Java come Object, Class, Inheritance, Polymorphism, Abstraction, Encapsulation, ecc:

Nella programmazione software, abbiamo vari tipi di linguaggi di programmazione. Le principali lingue tra loro sono di natura procedurale o orientata agli oggetti.

Nei linguaggi di programmazione procedurale, i problemi più grandi sono suddivisi in piccoli problemi risolvibili. Questi piccoli problemi vengono convertiti in procedure o funzioni. In questo modo il linguaggio di programmazione procedurale enfatizza le funzioni piuttosto che i dati. Pertanto i linguaggi procedurali hanno completamente trascurato i dati e quindi non garantiscono affatto la sicurezza dei dati.

Questo problema è stato risolto dal linguaggio di programmazione orientato agli oggetti. La programmazione orientata agli oggetti è un modo di progettare e programmare software manipolando oggetti e gli oggetti sono la parte principale della programmazione.

Scopri la nostra intera serie di tutorial Java per principianti Qui .

Concetto OOPS in Java

Cosa imparerai:

Esercitazioni video sui concetti di OOPS

Concetto OOPS in Java - Parte 1:

Uno sguardo approfondito al concetto di OOPS in Java - Parte 2:

I linguaggi di programmazione orientati agli oggetti enfatizzano i dati più che le funzioni. La programmazione orientata agli oggetti (OOP) ruota attorno agli oggetti, ovvero un'entità in tempo reale.

Questo oggetto raggruppa i dati ei metodi che operano su questi dati in un'unica unità. In questo modo, i dati sono protetti dal mondo esterno avendo i metodi all'interno dell'oggetto. In OOP, gli oggetti comunicano tra loro tramite messaggi.

Qualsiasi linguaggio OOP supporta le seguenti funzionalità:

  • Classi
  • Incapsulamento
  • Astrazione
  • Eredità
  • Polimorfismo

Tutte queste caratteristiche assicurano che i dati siano protetti e allo stesso tempo possiamo anche scrivere applicazioni robuste. Smalltalk, C ++, Java, ecc sono alcuni dei linguaggi di programmazione orientati agli oggetti.

In questo tutorial, discuteremo le basi dell'OOP riguardanti il ​​linguaggio Java.

Programmazione orientata agli oggetti (OOP) in Java

Java è attualmente l'abilità di programmazione più ricercata. In Java, tutto è basato sull'oggetto. Java ha una classe radice chiamata Object da cui deriva l'intera funzionalità di Java. Pertanto, in questo tutorial, discuteremo le caratteristiche principali di OOP relative a Java.

Lettura consigliata => Domande e risposte per l'intervista OOP

Qui discuteremo di come Java supporta le seguenti funzionalità OOP.

  • Oggetto e classe
  • Classe
  • Eredità
  • Polimorfismo
  • Astrazione
  • Incapsulamento

Discutiamo in dettaglio ciascuno di questi concetti Java OOP.

Oggetto e classe

Una classe può essere definita come un prototipo di progetto o un progetto. Gli oggetti vengono creati da questi progetti. Definisce essenzialmente un tipo comune costituito da proprietà e metodi che operano su queste proprietà per questo tipo comune. Quindi definiamo le istanze di questa classe chiamate oggetti.

Una classe ha molti componenti come mostrato nella figura seguente.

Oggetto e classe - Componenti

Un oggetto rappresenta un'entità della vita reale. In Java, un oggetto è un'istanza di una classe. Quindi una classe che è un progetto può essere utilizzata per creare molti oggetti. Questi oggetti spesso comunicano tra loro scambiandosi messaggi tramite metodi.

Tutorial video: classi e oggetti

Un oggetto in genere ha:

  1. Uno stato: Le proprietà o gli attributi di un oggetto in un determinato momento.
  2. Comportamento: I metodi rappresentano il comportamento di un oggetto. I metodi definiscono anche come comunicano gli oggetti.
  3. Identità: Identifica l'oggetto assegnandogli un nome univoco.

Per esempio, se abbiamo una classe PetAnimals.

Quindi possiamo definire un oggetto di questa classe come segue:

PetAnimals pig = nuovi PetAnimals.

Qui l'identità dell'oggetto è un maiale.

Di seguito è riportato un programma che mostra la classe e l'oggetto.

//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); } }

Produzione

output - Oggetto e classe

Nella classe precedente, abbiamo definito una classe Student con due proprietà roll_No e student_name. Quindi, nel metodo principale, dichiariamo due oggetti di classe, ovvero student1 e student2. Notare che questi oggetti vengono creati utilizzando un nuovo operatore. Una volta creati gli oggetti, assegniamo i dati a entrambe le proprietà dell'oggetto.

Infine, stampiamo il contenuto dell'oggetto utilizzando l'operatore '.' (Punto).

Impareremo di più sulle classi e sugli oggetti nei nostri argomenti specifici dei tutorial OOP.

Eredità

L'ereditarietà è una delle caratteristiche più importanti dell'OOP. Attraverso l'ereditarietà, Java promuove la riusabilità del codice.

Allora cos'è un'eredità in Java?

L'ereditarietà è un meccanismo in Java in cui una classe può ereditare le proprietà di un'altra classe. Le proprietà che possono essere ereditate includono membri di dati e metodi della classe.

La classe che eredita le proprietà di un'altra classe è chiamata sottoclasse. La classe ereditata è conosciuta come la classe 'super' in Java.

Ereditando la classe, la sottoclasse non solo eredita le proprietà, ma riutilizza anche il codice poiché il programmatore non ha bisogno di scrivere nuovamente il codice quando può ereditarlo direttamente usando l'ereditarietà.

In Java, l'ereditarietà si ottiene utilizzando la parola chiave 'extends'. Questa parola chiave extends viene utilizzata nella definizione della classe ed è seguita dal nome della classe che deve essere ereditata.

Per esempio,se ci sono due classi, A e B, e A deve essere ereditata da B, questa eredità viene scritta in Java come:

class B extends A { …… }

Come già accennato, qui A è la superclasse o classe base o classe genitore. B è una sottoclasse, una classe derivata o una classe figlia.

L'ereditarietà è ulteriormente suddivisa nei seguenti tipi.

Ereditarietà - Tipi

Java supporta l'ereditarietà singola, multilivello e gerarchica.

Notare che Java non supporta più eredità. Java inoltre non supporta l'ereditarietà ibrida che è una combinazione di eredità multiple e gerarchiche.

Di seguito è riportato un programma di esempio di Single Inheritance in 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)); } }

Produzione

output - Ereditarietà in Java

Nel programma precedente, abbiamo una classe base Employee. Abbiamo un'altra classe Developer che eredita dalla classe Employee. Nel metodo principale, possiamo vedere che dichiarando un oggetto della classe Developer possiamo accedere non solo alle proprietà della classe Developer ma anche della classe Employee in quanto ereditata dalla classe Developer.

Polimorfismo

Il polimorfismo è un'altra caratteristica importante dell'OOP. Il polimorfismo è la capacità del linguaggio di consentire a oggetti o entità di assumere forme multiple. Per esempio, un metodo che ha varie implementazioni è polimorfico in Java.

Il polimorfismo è di due tipi in Java:

  • Sovraccarico o polimorfismo in fase di compilazione: Nel polimorfismo in fase di compilazione, la chiamata al metodo polimorfico o sovraccarico viene risolta in fase di compilazione.
  • Sostituzione o polimorfismo di runtime: Nel polimorfismo runtime, la chiamata a un metodo sovrascritto nel programma Java viene risolta in fase di runtime.

Discuteremo in dettaglio il polimorfismo nei nostri tutorial successivi.

Di seguito è riportato un esempio di polimorfismo in fase di compilazione in Java in cui abbiamo il metodo add che viene sovraccaricato per eseguire l'addizione con diversi tipi di operandi.

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)); } }

Produzione

uscita 3

In questo programma, abbiamo tre metodi sovraccaricati denominati add. Il primo metodo accetta due parametri int, il metodo successivo accetta tre parametri int e il terzo metodo accetta due parametri doppi. A seconda del numero di parametri, la chiamata al metodo viene risolta in fase di compilazione e viene eseguita la chiamata appropriata.

Astrazione

Utilizzando l'astrazione dei dati, esponiamo solo le parti essenziali dell'applicazione che sono rese accessibili all'utente. Per esempio, se abbiamo un'auto, non ci preoccupiamo dei componenti interni dell'auto, piuttosto consideriamo solo l'auto nel suo insieme.

Utilizzando un meccanismo di astrazione dei dati, identifichiamo solo i dettagli necessari e ignoriamo i dettagli irrilevanti. Java utilizza classi e interfacce astratte per ottenere l'astrazione. Le interfacce sono astratte al 100% in quanto hanno solo prototipi di metodo e non la loro definizione.

L'esempio seguente mostra una classe astratta e il suo utilizzo.

// 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(); } }

Produzione

output - Astrazione in Java

Nel programma sopra, abbiamo una classe astratta PetAnimals. In questo, abbiamo un metodo astratto 'animalSound'. Quindi creiamo una classe Dog ed ereditiamo la classe PetAnimals. Nella classe Dog, sovrascriviamo il metodo animalSound.

ordinamento rapido pseudocodice c ++

Incapsulamento

L'incapsulamento nasconde o protegge i dati. Nella programmazione, otteniamo l'incapsulamento avvolgendo dati e metodi che operano su tali dati in una singola unità.

Tutorial video: incapsulamento e polimorfismo in Java

Una classe può essere vista come un'unità di incapsulamento, ovvero abbiamo membri di dati e metodi che operano su questi membri di dati come raggruppati in una singola unità.

Un corretto incapsulamento può essere ottenuto rendendo privati ​​i membri dei dati e avendo i metodi che operano su questi dati come pubblici in modo che i dati siano completamente protetti dalle entità esterne.

Il seguente programma Java mostra il concetto di incapsulamento.

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()); } }

Produzione

output - Incapsulamento in Java

Nel programma precedente, abbiamo una classe Customer_Account.

In questa classe, abbiamo membri di dati che sono tutti privati. Quindi, per ogni campo privato, forniamo metodi getter e setter per leggere e impostare rispettivamente i valori. Questi getter e setter sono pubblici. In questo modo proteggiamo i campi dati non consentendo loro alcun accesso direttamente dall'esterno della classe.

È possibile accedervi solo tramite getter e setter. Questo dimostra l'incapsulamento che abbiamo descritto sopra.

Domande frequenti

D # 1) Cosa si intende per programmazione orientata agli oggetti?

Risposta: La programmazione orientata agli oggetti (OOP) è un paradigma software che ruota attorno ai dati. In OOP, l'accento è posto sui dati e quindi i problemi sono espressi in termini di oggetti che sono entità costituite da dati o campi e metodi che operano su questi campi di dati.

In questo modo, vengono applicate diverse caratteristiche distintive di OOP come ereditarietà, polimorfismo, astrazione e incapsulamento per garantire la sicurezza dei dati, la riusabilità, ecc.

D # 2) Quali sono i 4 principi di base dell'OOP?

Risposta:La programmazione orientata agli oggetti (OOP) ha quattro principi di base:

  • Eredità
  • Polimorfismo
  • Astrazione
  • Incapsulamento

Sono anche chiamati quattro pilastri dell'OOP.

D # 3) Perché Java si chiama Object-Oriented?

Risposta: Java ha un oggetto di classe radice da cui deriviamo tutte le altre funzionalità di Java. Quindi senza classe e oggetto, non possiamo avere un programma Java. Quindi Java è chiamato linguaggio OOP.

D # 4) Java è puramente orientato agli oggetti?

Risposta: No, Java non è un puro linguaggio orientato agli oggetti. Poiché Java fornisce anche tipi di dati primitivi come int, char, float, double, long, ecc., Non è classificato come linguaggio OOP puro.

D # 5) Qual è la differenza tra C ++ e Java?

Risposta: Sia C ++ che Java sono linguaggi orientati agli oggetti e supportano le funzionalità OOP. Ma C ++ è un linguaggio compilato. Java d'altra parte è compilato come un linguaggio interpretato.

L'interprete Java esegue il codice byte in fase di runtime e genera un output che lo rende indipendente dalla piattaforma. C ++ tuttavia dipende dalla piattaforma.

Maggiori informazioni sul concetto OOPS

Classe

La classe è un progetto / prototipo di un oggetto del mondo reale e modella lo stato e il comportamento di tale oggetto del mondo reale.

Dichiarazione di 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. }

Dichiarazione di classe

Oggetto

Gli oggetti software sono come oggetti della vita reale con stato e comportamento. Lo stato verrà memorizzato come un campo ed esporrà il suo comportamento come metodi.

Qui la stanza è come il design generale. All'interno di questa stanza, dovresti progettare un soggiorno, una cucina, una camera da letto.

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(); }

Qui il metodo 'Keepthings ()' dovrebbe svolgere le funzionalità di base richieste per la stanza e dovrebbe avere specifiche aggiuntive in base ai requisiti della classe 'soggiorno' e della classe 'cucina'. Quindi le due classi dovrebbero ereditare i metodi nella classe 'room'.

oggetto

Eredità

Il comportamento (metodi) e lo stato di una classe ereditata dall'altra sono chiamati ereditarietà. I metodi e lo stato vengono ereditati dalla classe padre alla classe figlia.

Così,

Class CookingRoom extends Room{ } Class LivingRoom extends Room{ }

Polimorfismo

In biologia, il polimorfismo si riferisce alle spezie che possono avere molte forme diverse.

Con lo stesso concetto nella programmazione orientata agli oggetti, la classe figlia può ereditare i metodi della sua classe genitore, inoltre può aggiungere caratteristiche uniche a quel comportamento. Il polimorfismo può essere ottenuto mediante il sovraccarico o l'override del metodo.

Sovraccarico

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)); } }

ovrloading

Overriding

public class Bicycle { int wheels=2; String seat; public void riding() { System.out.println('bicycle is used for riding'); } }

overriding1

public class RoadBicycle extends Bicycle{ public void riding() { System.out.println('RoadBicycle is used for road riding'); } }

overriding2

public class TestBicycle { public static void main(String() args) { Bicycle b=new RoadBicycle(); b.riding(); } }

classe testbicycle

PRODUZIONE: Qui il metodo della classe figlia sovrascrive il metodo della classe genitore.

output-override

Super parola chiave

La parola chiave Super è una variabile di riferimento utilizzata per fare riferimento all'oggetto della classe genitore immediato. Con la parola chiave super, puoi fare riferimento al metodo o alle variabili della classe genitore o al costruttore.

Questa parola chiave

Questa parola chiave viene utilizzata per fare riferimento all'oggetto classe corrente. Utilizzando questa parola chiave, è possibile accedere alla variabile di istanza della classe corrente o al metodo di classe corrente. Questo può essere passato come argomento nella chiamata al metodo.

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()); } }

questa parola chiave

Costruttore

I costruttori Java sono come i metodi che verranno chiamati quando l'oggetto viene creato per la classe. Il costruttore dovrebbe avere lo stesso nome della classe.

Class Myclass{ Myclass(); Method1() { } }

costruttore

Durante la creazione di un oggetto per la classe, Myclass myobj = new Myclass ();

Verrà chiamato il metodo del costruttore. Il costruttore viene creato automaticamente dal compilatore Java per tutte le classi per impostazione predefinita.

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); } }

Programma di esempio del costruttore

Regole da seguire per il costruttore:

  • Il costruttore dovrebbe avere lo stesso nome del nome della classe.
  • Il costruttore non dovrebbe avere un'istruzione return.

Punti da notare:

  • Nella programmazione orientata agli oggetti, gli oggetti sono la parte principale della programmazione.
  • I concetti OOP sono oggetto, classe, ereditarietà, polimorfismo, costruttore.
  • Super parola chiave utilizzata per fare riferimento ai membri della classe genitore e Questo la parola chiave viene utilizzata per fare riferimento a un oggetto classe corrente.
  • I costruttori sono come metodi che verranno chiamati quando l'oggetto viene creato per la classe.

Conclusione

Questo tutorial ha trattato le basi di importanti funzionalità orientate agli oggetti supportate da Java. Questo è solo un tutorial introduttivo su OOPS in Java. Tratteremo tutti gli argomenti in dettaglio nei nostri successivi tutorial. Java supporta quattro pilastri dell'OOP, ovvero polimorfismo, ereditarietà, astrazione e incapsulamento.

Oltre a queste funzionalità, Java supporta anche le altre funzionalità e costrutti OOP come il contenimento, l'aggregazione, il passaggio di messaggi, ecc. Che verranno discussi nei nostri prossimi tutorial.

Lettura consigliata

^