¿Qué son las clases, las referencias y los objetos?

He estado progtwigndo Java por 2 años, y aparentemente he encontrado un problema donde no podía entender y diferenciar clase, referencia y un objeto nuevamente (no entiendo por qué me olvido de estos conceptos).

Lleguemos al problema, que es que no estoy seguro si una clase o referencia son las mismas, aunque ya tengo una idea de qué es objeto.

¿Alguien puede diferenciar de una manera agradable, comprensible y completa cuáles son las clases, las referencias y el objeto?

Todo lo que sé es que la clase es más como una plantilla para un objeto (anteproyecto de una casa donde la clase es el plano y la casa es un objeto).

Si te gustan las metáforas de vivienda:

  • una clase es como el anteproyecto de una casa. Usando este modelo, puedes construir tantas casas como quieras.
  • cada casa que construyes (o instancia, en OO lingo) es un objeto , también conocido como instancia .
  • cada casa también tiene una dirección, por supuesto. Si quieres decirle a alguien dónde está la casa, les das una tarjeta con la dirección escrita en ella. Esa tarjeta es la referencia del objeto.
  • Si desea visitar la casa, mire la dirección escrita en la tarjeta. Esto se llama desreferenciación .

Puedes copiar esa referencia tanto como quieras, pero solo hay una casa: solo estás copiando la tarjeta que tiene la dirección, no la casa en sí. Los métodos de Java siempre pasan por valor, pero el valor puede ser una referencia de objeto. Entonces, si tengo:

Foo myFoo = new Foo(); // 1 callBar(myFoo); // 2 myFoo.doSomething() // 4 void callBar(Foo foo) { foo = new Foo(); // 3 } 

Entonces veamos qué está pasando.

  1. Varias cosas están sucediendo en la línea 1. new Foo() le dice a la JVM que construya una nueva casa usando el modelo Foo . La JVM lo hace y devuelve una referencia a la casa. A continuación, copie esta referencia a myFoo . Esto es básicamente como pedirle a un contratista que te construya una casa. Él lo hace, luego te dice la dirección de la casa; escribes esta dirección abajo.
  2. En la línea 2, le das esta dirección a otro método, callBar . Pasemos a ese método a continuación.
  3. Aquí, tenemos una referencia Foo foo . Java es pass-by-value, por lo que el foo en callBar es una copia de la referencia myFoo . Piense que es como darle a callBar su propia tarjeta con la dirección de la casa. ¿Qué hace callBar con esta tarjeta? Pide que se construya una nueva casa, y luego usa la tarjeta que le diste para escribir la dirección de esa nueva casa. Tenga en cuenta que callBar ahora no puede llegar a la primera casa (la que construimos en la línea 1), pero esa casa no se modifica por el hecho de que una tarjeta que solía tener su dirección en ella, ahora tiene la dirección de otra casa en ella .
  4. Volviendo al primer método, desreferenciamos myFoo para llamar un método ( doSomething() ). Esto es como mirar la tarjeta, ir a la casa cuya dirección está en la tarjeta y luego hacer algo en esa casa. Tenga en cuenta que nuestra tarjeta con la dirección de callBar no se modifica con el método de callBar . Recuerde, le proporcionamos a callBar una copia de nuestra referencia.

Toda la secuencia sería algo así como:

  1. Pídale a JVM que construya una casa. Sí, y nos da la dirección. myFoo esta dirección a una tarjeta llamada myFoo .
  2. Invocamos a callBar . Antes de hacerlo, copiamos la dirección escrita en myfoo a una nueva tarjeta, que le damos a callBar . Llama a esa tarjeta foo .
  3. callBar le pregunta a la JVM por otra casa. Lo crea y devuelve la dirección de la nueva casa. callBar copia esta dirección en la tarjeta que le dimos.
  4. Volviendo al primer método, miramos nuestra tarjeta original, sin cambios; ir a la casa cuya dirección está en nuestra tarjeta; y haz algo allí.

Cuando codifica, construye un

Instancia (ocurrencia, copia)

de un

Objeto

de un dicho

Clase

y mantener un

referencia

a ella, para que pueda llamar a sus métodos.

Además, algunos conceptos básicos de OOP : Clases , Objeto , Instancia y Referencia .

En el libro “Pensando en Java” de Bruce Eckel se ha descrito perfectamente:

“Se puede imaginar un televisor (el objeto) y un control remoto (la referencia). Mientras mantenga esta referencia, tiene una conexión con el televisor, pero cuando alguien dice” Cambiar el canal “o” Inferior ” el volumen, “lo que estás manipulando es la referencia, que a su vez modifica el objeto. Si deseas moverte por la habitación y aún controlar el televisor, tomas el control remoto / referencia contigo, no con el televisor.

Además, el control remoto puede funcionar por sí mismo, sin televisión. Es decir, solo porque tenga una referencia no significa necesariamente que haya un objeto conectado a ella. Entonces, si desea mantener una palabra o frase, crea una referencia de cadena:

 String s; 

Pero aquí ha creado solo la referencia, no un objeto. Si decidió enviar un mensaje a s en este punto, obtendrá un error porque s no está conectado a nada (no hay televisión). Una práctica más segura, entonces, es siempre inicializar una referencia cuando la creas:

 String s = "asdf"; 

Sin embargo, esto utiliza una función especial de Java: las cadenas se pueden inicializar con el texto entre comillas. Normalmente, debe usar un tipo más general de inicialización para objetos.

Cuando crea una referencia, desea conectarla con un nuevo objeto. Lo haces, en general, con el nuevo operador. La palabra clave new dice: “Hazme uno nuevo de estos objetos”. Así que en el ejemplo anterior, puedes decir:

 String s = new String("asdf"); 

Esto no solo significa “Hacerme una cadena nueva”, sino que también brinda información sobre cómo crear la cadena al proporcionar una cadena de caracteres inicial. Por supuesto, Java viene con una gran cantidad de tipos listos, además de String. Lo que es más importante es que puedes crear tus propios tipos. De hecho, la creación de nuevos tipos es la actividad fundamental en la progtwigción de Java “.

Supongamos que escribe allí dos líneas de código:

 Engine app1 = new Engine(); //LINE 1 Engine app2 = app1; //LINE 2 

En la línea 1, Engine es una clase , básicamente es un blueprint.

new Engine () es la instancia que se crea en el montón.

Usted está refiriendo esa instancia usando app1 y app2 en su código.

Entonces, app1 y app2 son las referencias .

Cuando creas un objeto, lo que sucede detrás de la escena es que una parte de la memoria está reservada para contener ese objeto. Esto podría estar en cualquier parte del gran paisaje de la gran memoria; depende del sistema operativo y del comstackdor, y realmente no tienes control ni conocimiento de dónde termina.

Pregúntate, entonces, ¿cómo usas ese objeto si no sabes dónde está en la memoria? ¿Cómo se puede leer un valor si no se sabe dónde se almacena ese valor? Esto es lo que las referencias hacen por ti. Son una forma de mantenerse en contacto con el objeto. Es una pequeña cadena unida al globo que es una referencia.

Utiliza la referencia para decir “¡Quiero tocar este objeto ahora!”, O “¡Quiero leer un valor de este objeto!”.

La clase es una plantilla, tienes razón. Es un poco de conocimiento sobre la estructura de datos. Object es esa instancia de estructura en la memoria. La referencia es una dirección de memoria de esa instancia.

Si por Object quieres decir el identificador java, entonces Object es la clase básica para todas las clases complejas de Java.

Object es la representación en tiempo de ejecución de la definición de Class . Y el nombre con el que usa el objeto se llama reference (ya que hace referencia a la ubicación real del objeto en la memoria)

ejemplo

 MyClass ref = new MyClass(); 

Aquí, MyClass es (contiene) la definición de clase .

new MyClass () crea un objeto para esta clase (hecho solo durante la ejecución, por lo tanto, representa el tiempo de ejecución)

ref es el nombre que usa para trabajar en el objeto de la clase, es la referencia .

========= Clase y Objeto ===========

Clase => ex: Persona (Más como imaginación)

Object => ex: John, Mike (persona real)

=========== Referencia ============

ex:

Televisión tv1; – (La televisión es una clase, tv1 es un control remoto sin televisión)

Televisión tv2 = nueva Televisión (); – (Ahora el control remoto tv2 tiene un televisor)

tv1 = tv2; – (Ahora tv1 y tv2 pueden controlar la misma televisión)

Televisión tv3 = nueva Televisión (); – (tv3 es un nuevo control remoto con nueva televisión)

Clase: se usa para definir una entidad de la vida real en un entorno de progtwigción.

Cualquier entidad de la vida real que tenga al menos una property y un behaviour correspondiente se puede considerar como una clase. Tomemos un ejemplo de un automóvil , es tener un accelerator propiedad que ayuda al automóvil a moverse y controlar su velocidad. El comportamiento correspondiente es la acceleration , que es directamente proporcional al empuje aplicado al acelerador.

 class Car { private String tier; private String tierFriction; private double weight; private double gasFedToEngine; } 

La clase anterior muestra algunas propiedades de un automóvil, del que depende su aceleración. Comportamiento ( method in the class ) siempre depende de la (s) propiedad (es) ( global attribute(s) of the class ). Ahora, si desea más detalles, puede definir Tier como otra entidad, entonces la definición se verá como

 class Tier { private String tierMaterial; private String tierFriction; private double weight; private double tierDiameter; } class Car { private Tier tier; // getting all properties of Tier here itself private double weight; private double gasFedToEngine; } 

Objeto: se usa para definir varios sabores de una entidad y para realizar manipulaciones de datos en ellos por separado.

Ahora hemos definido una entidad para nuestro progtwig, digamos que estamos teniendo una sala de exposición de autos usados, que tiene automóviles de diferentes compañías. Entonces cada automóvil se convierte en un object de nuestra entidad. Los objetos pueden ser Audi, Nissan, Ferrari, etc. Por eso, después de abrir la sala de exposiciones, le agregamos autos como este

 static List showroomCars = new ArrayList(); public boolean addCarToShowroom() { Car carNissan = new Car(); // always creates a new objects and allocates some memory in heap carNissan.setName("Nissan"); carNissan.setColor(RED); carNissan.setWeight(300); showroomCars.add(carNissan); Car carAudi = new Car(); carAudi.setName("Audi"); carAudi.setColor(BLACK); carAudi.setWeight(270); showroomCars.add(carAudi); } 

Entonces ahora se agregan dos autos nuevos al Showroom, uno de Nissan y otro de Audi, cada uno con sus propios valores de atributos específicos.

Class solo da definición, la manipulación se hace en Object , para hacer la manipulación en cualquier clase, se debe crear un objeto. Cada vez que se crea un objeto para una clase, todas sus variables no satónicas (instancia) se cargarán en la memoria con sus respectivos valores predeterminados.

Referencia: se usa para abordar un objeto

Cuando decimos Car carAudi = new Car(); definimos un nuevo objeto para Car y se asigna una ubicación de memoria para ese objeto. La variable de referencia carAudi contiene la dirección de memoria de ese objeto. El usuario nunca accede directamente al objeto ni su ubicación de memoria. Ahí es donde la variable de referencia tiene importancia, almacena el formato hexadecimal de la ubicación de la memoria. Si queremos hacer modificaciones en un objeto lo hacemos con la ayuda de la referencia no directamente.

Un objeto puede tener cualquier cantidad de referencia, pero una referencia puede apuntar solo a un objeto a la vez.

 class Car { void test() { Car car1 = new Car(); // (1) Car car2 = new Car(); // (2) car2 = car1; /** Says that car2 should point to where car1 points, so now both points to first object of Car But for this car2 has to loose its current object-(2), making it an Abandoned object (An object with no active reference from the stack). **/ } }