Differenza tra object e istanza

So che questo tipo di domanda è stata posta in precedenza , ma sento ancora che la risposta è troppo ambigua per me (e, per estensione, alcuni / più principianti) da cogliere.

Ho cercato di insegnare a me stesso concetti di programmazione più ampi rispetto all’ODP procedurale e di base. Capisco i concetti concreti di OOP (tu fai una class che ha dati (membri) e funzioni (metodi) e quindi istanzia la class in fase di esecuzione per fare effettivamente cose, quel genere di cose).

Penso di avere un controllo su cosa sia una class (una specie di progetto di progetto per un’istanza da creare a sua somiglianza al momento della compilazione ). Ma se è così, cos’è un object? So anche che nei linguaggi basati su prototipi, questo può mandare ancora più in su le cose, ma forse questo è il motivo per cui nella mia mente deve esserci una chiara distinzione tra object ed istanza.

Oltre a ciò, lotto con i concetti di “object” e “istanza”. Molte risorse che ho letto (comprese le risposte in SO) dicono che sono in gran parte le stesse e che la differenza è nella semantica. Altre persone dicono che c’è una vera differenza concettuale tra i due.

Gli esperti qui in SO possono aiutare un principiante ad avere quel momento “aha” per andare avanti nel mondo di OOP?

Grazie ancora.

Nota: questo non è compito a casa, non vado a scuola, tuttavia, penso che sarebbe di aiuto alle persone che stanno cercando aiuto per i compiti.

Un progetto per un progetto di casa è come una descrizione di class. Tutte le case costruite da quel progetto sono oggetti di quella class. Una data casa è un’istanza.

La verità è che la programmazione orientata agli oggetti crea spesso confusione creando una disconnessione tra il lato filosofico dello sviluppo e il reale funzionamento meccanico del computer. Proverò a contrastare i due per te:

Il concetto base di OOP è questo: Classe >> Oggetto >> Istanza.

La class = la stampa blu. L’object è una cosa reale costruita in base alla “stampa blu” (come la casa). Un’istanza è una copia virtuale (ma non una copia reale) dell’object.

La spiegazione più tecnica di una “istanza” è che si tratta di un “riferimento di memoria” o di una variabile di riferimento. Ciò significa che una “istanza” è una variabile in memoria che ha solo un indirizzo di memoria di un object in essa contenuto. L’object a cui si rivolge è lo stesso object di cui si dice che l’istanza è “un’istanza di”. Se hai molte istanze di un object, in realtà hai solo molte variabili in diversi punti della memoria che hanno tutti lo stesso indirizzo di memoria esatto – che sono tutti gli indirizzi dello stesso object esatto. Non puoi mai ‘cambiare’ un’istanza, sebbene sembri ansible nel tuo codice. Quello che fai davvero quando cambi ‘un’istanza, cambi direttamente l’object originale. Dal punto di vista elettronico, il processore passa attraverso un punto aggiuntivo in memoria (la variabile / istanza di riferimento) prima che cambi i dati dell’object originale.

Il processo è: processore >> posizione di memoria dell’istanza >> posizione di memoria dell’object originale.

Nota che non importa quale istanza usi: il risultato finale sarà sempre lo stesso. TUTTE le istanze continueranno a mantenere le stesse informazioni esatte nelle loro posizioni di memoria – l’indirizzo di memoria dell’object – e solo l’object cambierà.

La relazione tra class e object è un po ‘più confusa, sebbene filosoficamente sia la più facile da capire (stampa blu >> casa). Se l’object è un dato reale che si trova da qualche parte nella memoria, cos’è la ‘class’? Si scopre che meccanicamente l’object è una copia esatta della class. Quindi la class è solo un’altra variabile da qualche altra parte in memoria che contiene la stessa informazione esatta che l’object fa. Nota la differenza tra le relazioni:

L’object è una copia della class. L’istanza è una variabile che contiene l’indirizzo di memoria dell’object.

Puoi anche avere più oggetti della stessa class e quindi più istanze di ciascuno di questi oggetti. In questi casi, l’insieme di istanze di ciascun object ha valore equivalente, ma le istanze tra gli oggetti non lo sono. Per esempio:

Consentire alla class A di class A di lasciare Object1, Object2 e Object3.

// Oggetto1 ha lo stesso valore esatto di object2 e object3, ma si trova in diversi punti della memoria.

da Object1 >> let obj1_Instance1, obj1_Instace2, obj1_Instance3

// tutte queste istanze hanno anche un valore equivalente e in posti diversi nella memoria. I loro valori = Object1.MemoryAddress.

eccetera.

Le cose diventano più complicate quando inizi a introdurre i tipi. Ecco un esempio utilizzando i tipi da C #:

// presume la class Persona esiste Persona john = new Person ();

In realtà, questo codice è più facile da analizzare se lo suddividi in due parti:

Person john; john = new Person(); 

Nel linguaggio tecnico, la prima riga ‘dichiara una variabile di tipo Persona. Ma cosa significa ?? La spiegazione generale è che ora ho una variabile vuota che può contenere solo un object Person. Ma aspetta un minuto – è una variabile vuota! Non c’è nulla in quella posizione di memoria delle variabili. Si scopre che i “tipi” sono meccanicamente privi di significato. I tipi sono stati originariamente inventati come un modo per gestire i dati e nient’altro. Anche quando si dichiarano tipi primitivi come int, str, chr (senza inizializzarlo), non accade nulla all’interno del computer. Questo strano aspetto sintattico della programmazione è parte del modo in cui le persone hanno l’idea che le classi siano il progetto di oggetti. Gli OOP sono diventati ancora più confusi con i tipi con tipi di delegati, gestori di eventi, ecc. Vorrei provare a non concentrarmi troppo su di loro e ricordare che sono tutti un termine improprio. Nulla cambia con la variabile fino a quando non diventa un object o è impostato su un indirizzo di memoria di un object.

Anche la seconda riga è un po ‘confusa perché fa due cose contemporaneamente:

Il lato destro “nuova Persona ()” viene valutato per primo. Crea una nuova copia della class Person, cioè crea un nuovo object.

Il lato sinistro “john =”, viene quindi valutato successivamente. Trasforma john in una variabile di riferimento dandogli l’indirizzo di memoria dell’object che è stato appena creato sul lato destro della stessa linea.

Se vuoi diventare un buon sviluppatore, è importante capire che nessun ambiente informatico funziona mai basato su ideali filosofici. I computer non sono nemmeno logici: sono in realtà solo una grande raccolta di cavi che vengono incollati insieme usando circuiti booleani di base (principalmente NAND e OR).

La parola Class deriva dalla classificazione ( una categoria in cui qualcosa è messo ), ora abbiamo tutti sentito che una class è come un progetto, ma cosa significa esattamente? Significa che la Classe contiene una Descrizione di una particolare Categoria, ( Vorrei mostrare la differenza tra Classe, Oggetto e Istanza con l’esempio usando Java e chiederei ai lettori di visualizzarla come una Storia mentre la leggi, e se tu non ho familiarità con java non importa ) Quindi iniziamo con make Category chiamato HumanBeing , quindi il programma Java lo esprimerà come segue

 class HumanBeing{ /*We will slowly build this category*/ } 

Ora quali attributi ha un Essere Umano in Nome , Età , Altezza , Peso per ora limitiamoci a questi quattro attributi, aggiungiamolo alla nostra Categoria

 class HumanBeing{ private String Name; private int Age; private float Height; private float Weight; /*We still need to add methods*/ } 

Ora ogni categoria ha un comportamento, ad esempio la categoria Cane ha un comportamento di abbaiare, recuperare, rotolare ecc …, Analogamente la nostra categoria HumanBeing può anche avere un certo comportamento, ad esempio quando chiediamo al nostro HumanBeing qual è il tuo nome / età / peso / altezza? Dovrebbe darci il suo nome / età / peso / altezza, quindi in java lo facciamo come segue

 class HumanBeing{ private String Name; private int Age; private float Height; private float Weight; public HumanBeing(String Name,int Age,float Height,float Weight){ this.Name = Name; this.Age = Age; this.Height = Height; this.Weight = Weight; } public String getName(){ return this.Name; } public int getAge(){ return this.age; } public float getHeight(){ return this.Height; } public float getWeight(){ return this.Weight; } } 

Ora abbiamo aggiunto un comportamento alla nostra categoria HumanBeing , quindi possiamo chiederne il nome, l’età, l’altezza, il peso ma da chi chiederete questi dettagli, perché la class HumanBeing è solo una categoria, è un progetto per esempio un Architetto fa un progetto su un foglio dell’edificio che vuole build, ora non possiamo continuare a vivere nel progetto (la sua descrizione dell’edificio ) possiamo solo vivere nell’edificio una volta costruito Quindi qui dobbiamo fare un essere umano dalla nostra categoria che abbiamo descritto sopra, quindi come lo facciamo in Java

 class Birth{ public static void main(String [] args){ HumanBeing firstHuman = new HumanBeing("Adam",25,6.2,90); } } 

Ora nell’esempio sopra abbiamo creato il nostro primo essere umano con il nome di peso in base all’età, quindi cosa sta succedendo esattamente nel codice sopra? . Stiamo istanziando la nostra categoria HumanBeing cioè viene creato un object della nostra class

Nota: Object e Instance non sono sinonimi In alcuni casi sembra che Object e Instance siano sinonimi ma non lo sono, darò entrambi i casi

Caso 1: object e istanza sembra essere sinonimi
Lasciatemi elaborare un po ‘, quando diciamo HumanBeing firstHuman = new HumanBeing("Adam",25,6.2,90); Un object della nostra categoria viene creato sulla memoria heap e ad esso viene assegnato un indirizzo e firstHuman contiene un riferimento a tale indirizzo, ora questo object è un object di HumanBeing e anche un’istanza di HumanBeing . Qui sembra che gli Oggetti e l’Istanza siano sinonimi, mi ripeterò di non essere sinonimi

Riprendici la nostra storia, abbiamo creato il nostro primo Umano, ora possiamo chiedere il suo nome, età, altezza, peso, questo è come lo facciamo in Java

 class Birth{ public static void main(String [] args){ HumanBeing firstHuman = new HumanBeing("Adam",25,6.2,90); System.out.println(firstHuman.getName()); System.out.println(firstHuman.getAge()); ... ... } } 

quindi abbiamo il primo essere umano e lasciamo spostare la piuma dando al nostro primo essere umano una qualifica, facciamolo un dottore, quindi abbiamo bisogno di una categoria chiamata dottore e diamo qualche comportamento al nostro dottore, quindi in java facciamo come segue

 class Doctor extends HumanBeing{ public Doctor(String Name,int Age,float Height,float Weight){ super(Name,Age,Height,Weight); } public void doOperation(){ /* Do some Operation*/ } public void doConsultation(){ /* Do so Consultation*/ } } 

Qui abbiamo usato il concetto di ereditarietà che sta portando una certa riusabilità nel codice, ogni dottore sarà sempre un essere umano prima, quindi un medico avrà nome, età, peso, altezza che sarà ereditato da HumanBeing invece di scriverlo di nuovo, nota che abbiamo appena scritto una descrizione di un dottore che non abbiamo ancora creato, quindi creiamo un Dottore nella nostra class Birth

 class Birth{ public static void main(String [] args){ Doctor firstDoctor = new Doctor("Strange",40,6,80); ....... ....... /*Assume some method calls , use of behaviour*/ ....... ....... } } 

Caso 2: object e istanza non sono sinonimi
Nel codice precedente possiamo visualizzare che stiamo istanziando la nostra categoria Dottore e portandola in vita, cioè stiamo semplicemente creando un object della categoria Dottore , Come sappiamo già che l’ Oggetto è creato su Heap Memory e firstDoctor detiene un riferimento a firstDoctor su il mucchio;

Questo particolare object firstDoctor è il seguente (nota: firstDoctor contiene un riferimento all’object, non è l’object stesso)

  1. firstDoctor è un object di class Doctor And An Instance of A class Doctor
  2. firstDoctor non è un object di class HumanBeing ma class HumanBeing di class HumanBeing

Quindi un object particolare può essere un’istanza per una particolare class, ma non è necessario che sia un object di quella determinata class

Conclusione:

Si dice che un object è un’istanza di una particolare categoria se soddisfa tutte le caratteristiche di quella particolare categoria

L’esempio del mondo reale sarà il seguente, siamo nati prima come esseri umani, quindi immaginateci come oggetti umani, ora quando cresciamo assumiamo responsabilità e impariamo nuove abilità e interpretiamo ruoli diversi nell’esempio di vita Figlio, fratello, figlia, padre , madre ora Che cosa siamo in realtà? Possiamo dire che siamo oggetti di umani, ma istanze di fratello, figlia, …, ecc

Spero che aiuti

Grazie

inserisci la descrizione dell'immagine qui

Gli oggetti sono cose in memoria mentre le istanze sono cose che fanno riferimento a loro. Nella foto sopra:

  • std (istanza) -> Oggetto studente (a destra)
  • std1 (istanza) -> Oggetto studente (a sinistra)
  • std2 (istanza) -> Oggetto studente (a sinistra)
  • std3 (istanza) -> nessun object (null)

Un object è un’istanza di una class (per le lingue basate sulla class).

Penso che questa sia la spiegazione più semplice che possa venire in mente.

Una class definisce un object. Puoi andare ancora oltre in molte lingue e dire che un’interfaccia definisce attributi e metodi comuni tra gli oggetti.

Un object è qualcosa che può rappresentare qualcosa nel mondo reale. Quando vuoi che l’object rappresenti effettivamente qualcosa nel mondo reale, quell’object deve essere istanziato. Instantiation significa che devi definire le caratteristiche (attributi) di questo specifico object, di solito attraverso un costruttore.

Una volta definite queste caratteristiche, ora hai un’istanza di un object.

Mi auguro questo chiarisca tutto.

Penso che sia importante sottolineare che ci sono generalmente due cose. Il progetto e le copie. Le persone tendono a nominare queste cose diverse; classi, oggetti, istanze sono solo alcuni dei nomi che le persone usano per loro. L’importante è che ci sia il progetto e le copie di esso – indipendentemente dai nomi per loro. Se hai già la comprensione di questi due, evita semplicemente le altre cose che ti stanno confondendo.

Immagino che la migliore risposta sia già stata data via.

Le classi sono progetti e gli oggetti sono edifici o esempi di quel progetto hanno fatto il trucco anche per me.

A volte, mi piacerebbe pensare che le classi siano template (come in MS Word), mentre gli oggetti sono i documenti che usano il template.

“Una class descrive un insieme di oggetti chiamati istanze.” – Xerox Learning Research Group, “The Smalltalk-80 System”, Byte Magazine, Volume 06 Numero 08, p39, 1981.

Cos’è un object?

Un object è un’istanza di una class. L’object può essere compreso al meglio trovando esempi reali intorno a te. La tua scrivania, il tuo laptop, la tua auto sono tutti esempi di un object reale.

L’object del mondo reale condivide due caratteristiche, tutte hanno uno stato e un comportamento. Gli esseri umani sono anche un buon esempio di object, noi umani abbiamo stato / attributi – nome, altezza, peso e comportamento – camminare, correre, parlare, dormire, codice: P.

Cos’è una class?

Una class è un modello o un modello che descrive i dettagli di un object. Questi dettagli sono vale a dire

Attributi nome / operazioni / metodi dello stato

 class Car { int speed = 0; int gear = 1; void changeGear(int newGear) { gear = newGear; } void speedUp(int increment) { speed = speed + increment; } void applyBrakes(int decrement) { speed = speed - decrement; } } 

Considera l’esempio precedente, la speed e l’ gear dei campi rappresenteranno lo stato dell’object e i metodi changeGear , speedUp e applyBrakes definiscono il comportamento dell’object Car con il mondo esterno.

Riferimenti:

  • Cos’è un object?
  • Cos’è una class?

Consente di confrontare le mele con le mele. Sappiamo tutti cos’è una mela. Cosa sembra. Che sapore ha Questa è una class. È la definizione di una cosa. È ciò che sappiamo di una cosa.

Ora vai a cercare una mela. Questa è un’istanza. Possiamo vederlo. Possiamo assaggiarlo. Possiamo fare cose con esso. È quello che abbiamo.

Classe = Ciò che sappiamo di qualcosa. Una definizione

Object / Instance = Qualcosa che si adatta alla definizione con cui possiamo avere e con cui possiamo fare le cose.

In alcuni casi, il termine “object” può essere utilizzato per descrivere un’istanza, ma in altri casi viene utilizzato per descrivere un riferimento a un’istanza. Il termine “istanza” si riferisce solo all’istanza reale.

Ad esempio, un elenco può essere descritto come una raccolta di oggetti, ma ciò che effettivamente contiene sono riferimenti a istanze di oggetti.

Mi è sempre piaciuta l’idea che equivale alla definizione di una class come quella di un “Tipo di dati astratti” . Cioè, quando hai definito una class stai definendo un nuovo tipo di “qualcosa”, la sua rappresentazione del tipo di dati, in termini di primitive e di altri “qualcosa”, e il suo comportamento in termini di funzioni e / o metodi. (Ci scusiamo per la generalità e il formalismo)

Ogni volta che definisci una class, apri una nuova possibilità per definire determinate quadro con le sue proprietà e il suo comportamento, quando istanziati e / o crei un particolare object al di fuori di esso stai materializzando effettivamente questa possibilità.

A volte i termini object e istanze sono intercambiabili. Alcuni puristi di OOP sosterranno che tutto è un object, non mi lamenterò, ma nel mondo reale dell’OOP, noi sviluppatori usiamo due concetti:

  1. Classe: esempio di tipo di dati astratto da cui è ansible ricavare altri oggetti ADT e creare oggetti.
  2. Oggetti: chiamate anche istanze, rappresentano esempi particolari delle strutture dati e delle funzioni rappresentate da un dato tipo di dati astratti.

La programmazione orientata agli oggetti è una metafora del sistema che ti aiuta a organizzare le conoscenze che il tuo programma deve gestire, in modo da facilitare lo sviluppo del tuo programma. Quando scegli di programmare usando OOP, raccogli i tuoi OOP-Googles e decidi che vedrai il problema del mondo reale come molti oggetti che collaborano tra loro, inviando messaggi. Invece di vedere un Tizio alla guida di un’auto, vedi un ragazzo che invia un messaggio all’automobile indicando ciò che vuole che l’auto faccia. L’auto è un grosso object e risponderà a questo messaggio inviando un messaggio al suo motore o alla sua ruota per essere in grado di rispondere correttamente a ciò che il Driver gli ha detto di fare nel messaggio, ecc …

Dopo aver creato la tua metafora del sistema e stai vedendo tutta la realtà come oggetti che inviano messaggi, decidi di mettere tutte le cose che vedi che sono rilevanti per il tuo dominio problematico nel PC. Lì si nota che ci sono molti tipi che guidano diverse carte, ed è insensato programmare il comportamento di ognuno di loro separatamente perché si comportano tutti allo stesso modo … Quindi puoi dire due cose:

  • Tutti i ragazzi si comportano nello stesso modo, quindi creerò una class chiamata Driver che specificherà chi sono i driver del mondo che si comportano, perché si comportano tutti allo stesso modo. (E stai usando OOP di class)
  • O potresti dire Hey! Il secondo Driver si comporta allo stesso modo del primo Driver, ma a lui piace andare un po ‘più veloce. E il terzo Driver si comporta allo stesso modo del primo Driver, ma a lui piace zigzagare quando guida. (E tu usi l’OOP basato sul prototipo).

Quindi inizi a inserire nel computer le informazioni su come si comportano tutti i driver (o su come si comportano i primi, e su come la seconda e la terza differiscono da quella), e dopo un po ‘hai il tuo programma, e usi il codice per crea tre driver che sono il modello che stai usando in quel PC per refeer ai driver che hai visto nel mondo reale. Quei 3 driver che hai creato all’interno del PC sono istanze del prototipo (in realtà il primo è il prototipo, il primo potrebbe essere il prototipo stesso a seconda di come modellare le cose) o la class che hai creato. La differenza tra istanza e object è che l’object è la metafora che usi nel mondo reale. Scegli di vedere il ragazzo e l’auto come oggetti (sarebbe scorretto dire che li vedi come istanze) collaborando tra loro. E poi lo usi come ispirazione per creare il tuo codice. L’istanza esiste solo nel tuo programma, dopo aver creato il prototipo o la class. Gli “oggetti” esistono al di fuori del PC perché è la mapping che usi per unire il mondo reale con il programma. Unisce il ragazzo con l’istanza del driver che hai creato nel PC. Quindi l’object e l’istanza sono estremamente correlati, ma non sono esattamente uguali (un’istanza è una “gamba” di un object nel programma e l’altra “gamba” è nel mondo reale).

Estendere uno degli esempi precedenti in questa discussione …

Considera uno scenario: è necessario che 5 case vengano costruite in un quartiere per scopi residenziali. Tutte e 5 le case condividono un’architettura di costruzione comune. L’architettura della costruzione è una class . House è un object . Ogni casa con persone che vi soggiornano è un’istanza .

Oggetto: quando creiamo un object, qualche memoria è occupata da quell’object Ex: Test t = new Test (); // ecco un object della class Test

Istanza: quando dichiariamo l’istanza, la memoria separata non è occupata da quell’istanza Ex: Test t; // ecco l’istanza della class Test

Dì semplicemente che l’object è una sola dichiarazione che non assegna memoria. e istanza è un object di una class che alloca la memoria.

Per me c’è una piccola differenza tra un object e un’istanza

Piace :

class1 obj;

qui, obj è un’istanza di class1 che occupa la memoria dello stack

class1 obj = new class1 ();

in questo caso obj è un object della class 1 e occupa la memoria heap