Come suggerisce il nome, il concetto di programmazione orientata agli oggetti o Java OOP si riferisce a linguaggi che utilizzano oggetti nella programmazione, utilizzano gli oggetti come fonte primaria per implementare ciò che deve accadere nel codice. Gli oggetti vengono visti dallo spettatore o dall'utente, eseguendo le attività assegnate.

La programmazione orientata agli oggetti mira a implementare entità del mondo reale come ereditarietà, occultamento, polimorfismo, ecc. Nella programmazione. Lo scopo principale dell'OOP è quello di collegare insieme i dati e le funzioni che operano su di essi in modo che nessun'altra parte del codice possa accedere a questi dati tranne quella funzione.

Discutiamo i prerequisiti perfezionando i concetti di dichiarazione di metodo e passaggio di messaggi. A partire dalla dichiarazione del metodo, è composto da sei componenti:

• Modificatore di accesso : Definisce il tipo di accesso del metodo, ovvero da dove è possibile accedervi nella tua applicazione. In Java esistono 4 tipi di specificatori di accesso:
  
  • pubblico: Accessibile in tutte le classi dell'applicazione.
  • protetto: Accessibile all'interno del pacchetto in cui è definito e nel suo sottoclassi (incluse le sottoclassi dichiarate all'esterno del pacchetto) .
  • privato: Accessibile solo all'interno della classe in cui è definito.
  • default (dichiarato/definito senza utilizzare alcun modificatore): Accessibile all'interno della stessa classe e pacchetto all'interno del quale è definita la relativa classe.
• Il tipo di reso : il tipo di dati del valore restituito dal metodo o void se non restituisce un valore.
• Nome del metodo : Le regole per i nomi dei campi si applicano anche ai nomi dei metodi, ma la convenzione è leggermente diversa.
• Elenco dei parametri : elenco separato da virgole dei parametri di input definiti, preceduti dal tipo di dati, tra parentesi racchiuse. Se non sono presenti parametri, è necessario utilizzare parentesi vuote ().
• Elenco delle eccezioni : le eccezioni che si prevede vengano generate dal metodo. È possibile specificare queste eccezioni.
• Corpo del metodo : è il blocco di codice, racchiuso tra parentesi graffe, che è necessario eseguire per eseguire le operazioni previste.

Passaggio del messaggio : Gli oggetti comunicano tra loro inviandosi e ricevendo informazioni. Un messaggio per un oggetto è una richiesta di esecuzione di una procedura e pertanto invocherà una funzione nell'oggetto ricevente che genera i risultati desiderati. Lo scambio di messaggi implica specificare il nome dell'oggetto, il nome della funzione e le informazioni da inviare.

Maestro OOP in Java Scrivi codice Java più pulito, più modulare e riutilizzabile costruendo le basi della programmazione orientata agli oggetti con il corso interattivo Impara di Educative Programmazione orientata agli oggetti in Java . Iscriviti su Educative.io con il codice GEEKS10 per risparmiare il 10% sul tuo abbonamento.

Ora che abbiamo coperto i prerequisiti di base, passeremo ai 4 pilastri degli OOP che sono i seguenti. Ma iniziamo conoscendo le diverse caratteristiche di un linguaggio di programmazione orientato agli oggetti.

I concetti OOPS sono i seguenti:

1. Classe
2. Oggetto
3. Metodo E passaggio del metodo
4. Pilastri delle OOP
   • Astrazione
   • Incapsulamento
   • Eredità
   • Polimorfismo
     • Polimorfismo in fase di compilazione
     • Polimorfismo di esecuzione

protocollo internet smtp

UN classe è un progetto o prototipo definito dall'utente da cui vengono creati gli oggetti. Rappresenta l'insieme di proprietà o metodi comuni a tutti gli oggetti di un tipo. Utilizzando le classi, puoi creare più oggetti con lo stesso comportamento invece di scrivere il codice più volte. Ciò include le classi per oggetti che si verificano più di una volta nel codice. In generale, le dichiarazioni di classe possono includere questi componenti nell'ordine:

1. Modificatori : Una classe può essere pubblica o avere accesso predefinito (fare riferimento a Questo per dettagli).
2. Nome della classe: Per convenzione il nome della classe dovrebbe iniziare con la lettera iniziale maiuscola.
3. Superclasse (se presente): Il nome del genitore della classe (superclasse), se presente, preceduto dalla parola chiave extends. Una classe può estendere (sottoclasse) solo un genitore.
4. Interfacce (se presenti): Un elenco separato da virgole delle interfacce implementate dalla classe, se presenti, precedute dalla parola chiave implements. Una classe può implementare più di un'interfaccia.
5. Corpo: Il corpo della classe è racchiuso tra parentesi graffe, { }.

Un oggetto è un'unità base della programmazione orientata agli oggetti che rappresenta entità della vita reale. Un tipico programma Java crea molti oggetti che, come sai, interagiscono invocando metodi. Gli oggetti sono ciò che esegue il tuo codice, sono la parte del tuo codice visibile al visualizzatore/utente. Un oggetto è costituito principalmente da:

1. Stato : È rappresentato dagli attributi di un oggetto. Riflette anche le proprietà di un oggetto.
2. Comportamento : È rappresentato dai metodi di un oggetto. Riflette anche la risposta di un oggetto ad altri oggetti.
3. Identità : è un nome univoco dato a un oggetto che gli consente di interagire con altri oggetti.
4. Metodo : Un metodo è una raccolta di istruzioni che eseguono alcune attività specifiche e restituiscono il risultato al chiamante. Un metodo può eseguire alcune attività specifiche senza restituire nulla. I metodi ce lo permettono riutilizzo il codice senza riscriverlo, motivo per cui vengono considerati risparmiatori di tempo . In Java, ogni metodo deve far parte di una classe, che è diversa dai linguaggi come C , C++ , E Pitone .

classe e oggetti un semplice programma Java:

public class GFG {    static String Employee_name;  static float Employee_salary;  static void set(String n, float p) {  Employee_name = n;  Employee_salary = p;  }  static void get() {  System.out.println('Employee name is: ' +Employee_name );  System.out.println('Employee CTC is: ' + Employee_salary);  }  public static void main(String args[]) {  GFG.set('Rathod Avinash', 10000.0f);  GFG.get();  } }>

Employee name is: Rathod Avinash Employee CTC is: 10000.0>

Parliamo ora dei 4 pilastri delle OOP:

Pilastro 1: Astrazione

Dati Astrazione è la proprietà in virtù della quale vengono visualizzati all'utente solo i dettagli essenziali. Le unità banali o non essenziali non vengono visualizzate all'utente. Esempio: un'auto è vista come un'auto piuttosto che come i suoi singoli componenti.
L'astrazione dei dati può anche essere definita come il processo di identificazione solo delle caratteristiche richieste di un oggetto, ignorando i dettagli irrilevanti. Le proprietà e i comportamenti di un oggetto lo differenziano da altri oggetti di tipo simile e aiutano anche a classificare/raggruppare l'oggetto.

Considera un esempio di vita reale di un uomo che guida un'auto. L'uomo sa solo che premendo l'acceleratore la velocità dell'auto aumenterà o che frenando l'auto si fermerà, ma non sa come premendo l'acceleratore la velocità effettivamente aumenti. Non conosce il meccanismo interno dell'auto o l'implementazione degli acceleratori, dei freni, ecc. nell'auto. Ecco cos'è l'astrazione.

In Java, l'astrazione è ottenuta da interfacce E classi astratte . Possiamo raggiungere il 100% di astrazione utilizzando le interfacce.

scheda SIM inserita ma nessun servizio Android

Il metodo astratto contiene solo la dichiarazione del metodo ma non l'implementazione.

Dimostrazione della classe Abstract

//abstract class abstract class GFG{  //abstract methods declaration  abstract void add();  abstract void mul();  abstract void div(); }>

Pilastro 2: Incapsulamento

È definito come il raggruppamento dei dati in una singola unità. È il meccanismo che lega insieme il codice e i dati che manipola. Un altro modo di pensare all'incapsulamento è che si tratta di uno scudo protettivo che impedisce l'accesso ai dati da parte del codice esterno a questo scudo.

• Tecnicamente, dentro incapsulamento , le variabili o i dati in una classe sono nascosti a qualsiasi altra classe ed è possibile accedervi solo tramite qualsiasi funzione membro della classe in cui sono dichiarati.
• Nell'incapsulamento, i dati in una classe sono nascosti alle altre classi, il che è simile a what dati nascosti fa. Pertanto, i termini incapsulamento e occultamento dei dati sono usati in modo intercambiabile.
• L'incapsulamento può essere ottenuto dichiarando tutte le variabili in una classe come private e scrivendo metodi pubblici nella classe per impostare e ottenere i valori delle variabili.

Dimostrazione di incapsulamento:

//Encapsulation using private modifier  //Employee class contains private data called employee id and employee name class Employee {  private int empid;  private String ename; }>

Pilastro 3: Eredità

Eredità è un pilastro importante dell'OOP (Object Oriented Programming). È il meccanismo in Java mediante il quale una classe può ereditare le funzionalità (campi e metodi) di un'altra classe. Stiamo ottenendo l'ereditarietà utilizzando si estende parola chiave. L'ereditarietà è anche conosciuta come è un relazione.

Parliamo di alcune importanti terminologie usate di frequente:

• Superclasse: La classe le cui caratteristiche vengono ereditate è nota come superclasse (nota anche come classe base o classe genitore).
• Sottoclasse: La classe che eredita l'altra classe è nota come sottoclasse (nota anche come classe derivata o estesa o classe figlia). La sottoclasse può aggiungere i propri campi e metodi oltre ai campi e ai metodi della superclasse.
• Riutilizzabilità: L'ereditarietà supporta il concetto di riusabilità, ovvero quando vogliamo creare una nuova classe ed esiste già una classe che include parte del codice che desideriamo, possiamo derivare la nostra nuova classe dalla classe esistente. In questo modo riutilizziamo i campi e i metodi della classe esistente.

Dimostrazione di ereditarietà:

I comandi Linux creano la cartella

//base class or parent class or super class class A{  //parent class methods  void method1(){}  void method2(){} } //derived class or child class or base class class B extends A{ //Inherits parent class methods  //child class methods  void method3(){}  void method4(){} }>

Pilastro 4: Polimorfismo

Si riferisce alla capacità dei linguaggi di programmazione orientati agli oggetti di distinguere in modo efficiente tra entità con lo stesso nome. Ciò viene fatto da Java con l'aiuto della firma e della dichiarazione di queste entità. Si chiama la capacità di apparire in molte forme polimorfismo .

Per esempio.

sleep(1000) //millis sleep(1000,2000) //millis,nanos>

Nota: Il polimorfismo in Java è principalmente di 2 tipi:

1. Sovraccarico
2. Preponderante

Esempio

// Java program to Demonstrate Polymorphism // This class will contain // 3 methods with same name, // yet the program will // compile & run successfully public class Sum {  // Overloaded sum().  // This sum takes two int parameters  public int sum(int x, int y)  {  return (x + y);  }  // Overloaded sum().  // This sum takes three int parameters  public int sum(int x, int y, int z)  {  return (x + y + z);  }  // Overloaded sum().  // This sum takes two double parameters  public double sum(double x, double y)  {  return (x + y);  }  // Driver code  public static void main(String args[])  {  Sum s = new Sum();  System.out.println(s.sum(10, 20));  System.out.println(s.sum(10, 20, 30));  System.out.println(s.sum(10.5, 20.5));  } }>

30 60 31.0>

Conclusione

Il concetto di programmazione orientata agli oggetti (OOP) in Java è un modo potente per organizzare e scrivere codice. Utilizza idee chiave come classi, oggetti, ereditarietà, polimorfismo, incapsulamento e astrazione per creare codice flessibile e riutilizzabile. Utilizzando il concetto Java OOP, i programmatori possono creare applicazioni complesse in modo più efficiente, rendendo il codice più facile da gestire, comprendere e modificare. Nel complesso, i concetti OOP di Java aiutano a creare soluzioni software robuste e scalabili.

Concetto di programmazione orientata agli oggetti (OOP) in Java - Domande frequenti

Qual è il concetto di OOP in Java?

L'OOP (Object-Oriented Programming) è un paradigma di programmazione basato sul concetto di oggetti, che possono contenere dati sotto forma di campi (attributi o proprietà) e codice sotto forma di procedure (metodi o funzioni). In Java, i concetti di OOP includono incapsulamento, ereditarietà, polimorfismo e astrazione.

Perché gli OOP sono importanti in Java?

Gli OOP aiutano a organizzare e strutturare il codice in un modo più gestibile, semplificando la manutenzione e la scalabilità delle applicazioni Java. Promuove inoltre la riusabilità, la modularità e la flessibilità del codice, portando a uno sviluppo software efficiente e robusto.

Quali sono i principi fondamentali degli OOP in Java?

I principi fondamentali degli OOP in Java sono l'incapsulamento, l'ereditarietà, il polimorfismo e l'astrazione. L'incapsulamento garantisce che lo stato interno di un oggetto sia nascosto e sia possibile accedervi solo tramite metodi pubblici. L'ereditarietà consente a una classe di ereditare proprietà e comportamento da un'altra. Il polimorfismo consente agli oggetti di essere trattati come istanze della loro classe genitore. L'astrazione si concentra sul nascondere i dettagli dell'implementazione e mostrare solo le informazioni necessarie al mondo esterno.

Come viene implementato l'OOP in Java?

In Java, gli OOP vengono implementati tramite classi e oggetti. Una classe funge da modello per la creazione di oggetti, che sono istanze di quella classe. Ogni oggetto ha il proprio insieme di attributi (variabili) e metodi (funzioni). Seguendo i concetti di OOP come incapsulamento, ereditarietà, polimorfismo e astrazione, gli sviluppatori Java possono progettare codice ben strutturato e gestibile.

Quali sono i vantaggi dell'utilizzo degli OOP in Java?

Alcuni vantaggi dell'utilizzo degli OOP in Java includono la riusabilità del codice, la modularità, la flessibilità, la scalabilità e una manutenzione più semplice. Gli OOP consentono agli sviluppatori di modellare entità del mondo reale come oggetti, portando a un codice più intuitivo e organizzato. Supporta inoltre funzionalità come ereditarietà e polimorfismo, che migliorano l'estensibilità e la leggibilità delle applicazioni Java.

Puoi fornire un esempio di implementazione del concetto OOP in Java?

Sicuro! Un esempio di implementazione del concetto OOP in Java è la creazione di una classe 'Car' con attributi come 'make', 'model' e 'year', insieme a metodi come 'start()', 'accelerate()' e 'stop'. ()'. Istanziando oggetti dalla classe 'Car' e chiamando i suoi metodi, possiamo simulare il comportamento di diverse istanze di auto in modo strutturato e orientato agli oggetti.