Fecha y hora actual: Sábado 24 Ago 2019 04:47
Índice del Foro

Foros de programación informática, diseño gráfico y Web

En esta comunidad intentaremos dar soporte de programación a todos los niveles, desde principiantes a profesionales de la informática, desarrollo de programas, programación web y mucho más.

Lección 68: Teoría de objetos en Java

Responder al Tema

Índice del Foro > Programación en general > Lección 68: Teoría de objetos en Java

Autor Mensaje
Kyshuo Ayame
Moderador Global


Registrado: 07 Ene 2011
Mensajes: 1043

Mensaje Publicado: Sábado 25 Ago 2012 17:30

Título del mensaje: Lección 68: Teoría de objetos en Java

Responder citando

Antes de continuar aprendiendo aspectos del lenguaje en sí, tenemos que formalizar aquel pantallazo que di en Modula acerca de la Teoría de Objetos, viendo aspectos un poco más profundos que, una vez comprendidos, nos permitirán asimilar todo lo que se viene.

No será posible, si no se manejan los aspectos que veremos a continuación, crear una aplicación con interfaz gráfica de usuario ni con conexión a bases de datos. Tampoco será posible crear sistemas de porte mediano (aunque solo queramos implementar un motor lógico). Así pues, veamos de la forma más sencilla posible, qué es esto de la teoría de objetos y qué herramientas nos da Java para trabajar con ella. Algo ya traemos de Modula y lo hemos adaptado a Java, pero se queda realmente corto. Vallamos entonces a ello:


Definición de Objeto:

Esta definición no será distinta de la que ya deberían saber, así pues tiene que sonarles familiar que un objeto es una entidad (“cosa” por ahora) que “vive” en memoria, que tiene una identidad propia y única, que puede contener datos permitiéndonos acceder a ellos y manipularlos.
Formalmente entonces, un objeto es una entidad de memoria que tiene identidad, estado y comportamiento.

Estos tres aspectos tienen su propia definición cada uno, pero antes de ir a ella, veamos una definición sencilla de lo que es una clase en Java.


Definición de Clase:

Una clase describe un conjunto de objetos. ¿Por qué conjunto? Porque pueden existir muchos objetos de una misma clase o bien, no existir ninguno. Los objetos son creados a imagen y semejanza de su clase, la cual está codificada en Java tal como ya lo hemos visto. De este modo, una clase describe en realidad a una clase de objetos, de ahí su nombre.
Por convención, los nombres de las clases siempre comienzan con mayúscula, de este modo “persona” no es un buen nombre para una clase, por eso nosotros usamos el nombre “Persona”. Si se fijan en las clases que ya tenemos propias de Java todas comienzan con mayúscula.


Relación entre clase y objeto:

Un objeto es un “caso” concreto de una clase, creado en memoria. Dicho de forma correcta, y es la forma que usaré de ahora en más, un objeto es una instancia de una clase. Así, cuando yo hablaba de “crear” un objeto en realidad debía haber hablado de instanciar un objeto.
Entonces, la clase es lo que nosotros codificamos en lenguaje Java para definir cómo serán las instancias de esa clase y un objeto es la entidad que se crea en memoria tomando como “plantilla” o “plano” la clase correspondiente. Noten que la clase es codificada en lo que se conoce como Tiempo de diseño (design-time) y los objetos son creados y existen en Tiempo de ejecución (run-time); de este modo el concepto de clase y el concepto de objeto nunca conviven en un mismo tiempo.

Todas las instancias de una misma clase son realmente objetos del mismo tipo porque claramente se parecen porque tienen los mismos atributos (no los mismos valores) y definen el mismo comportamiento (ya veremos mejor estos puntos).

Inicialmente, en nuestra clase Persona habíamos definido dos atributos: nombre y apellido. De esa manera la clase define que todas las instancias de ella tendrán esos atributos, teniendo en cuenta que para cada instancia los atributos son propios. ¿Qué quiero decir? Que si al correr el programa tenemos 85 instancias de la clase Persona, cada instancia tendrá su propio nombre y su propio apellido y de ninguna manera lo que pasa en un objeto interfiere con el otro. Si yo cambio el valor del atributo nombre para uno de los objetos, los demás seguirán intactos y ni se enterarán del cambio que ha sufrido el objeto en cuestión. Esto ustedes deberían arrastrarlo desde Modula.

Lo que acabo de explicar implica que los atributos declarados tal como lo hemos hecho hasta ahora son atributos de instancia (lo desarrollaré luego), porque cada instancia tiene los suyos propios. Así, mientras la clase es una sola y define su tipo de objetos, podemos tener 85 objetos de esa clase y por tanto tendremos en memoria 85 variables nombre y 85 variables apellido, una por cada instancia; donde además, dichas variables son encapsuladas dentro de la instancia a la que pertenecen; esto es lo que permite al programa diferenciar qué atributo pertenece a qué objeto.


Identidad de un objeto:

Para una clase no hablamos de identidad ya que esta está explícitamente dada por el nombre que le hemos puesto a la clase a la hora de definirla, así, la clase Persona es justamente identificada por ese nombre. Ahora bien, para los objetos, dado que pueden ser muchos de una misma clase (en efecto eso es lo que sucede) se hace necesario para el sistema identificar a cada uno de los objetos existentes por separado. De este modo la identidad de un objeto es única (al igual que la de una clase).

Como hablamos ya en Modula, la identidad de un objeto entonces es la dirección de memoria en donde está alojado, es decir, el contenido del puntero que lo apunta. Nada tiene que ver la referencia que nosotros hemos asignado para llegar al objeto. Por ejemplo:

Código:
  1. Persona p= new Persona();
  2. Persona q;
  3.  
  4. q=p;



Allí hemos instanciado un objeto de tipo Persona referenciándolo con la variable p. Luego tenemos otra referencia de tipo Persona llamada q y a esta le asignamos el mismo valor de p.

La instancia de la clase Persona que hemos creado, es decir el nuevo objeto ¿tiene dos identidades? Pues NO. ¿Cómo que no si yo puedo acceder al objeto tanto con p como con q? Pues si, eso es porque dichas variables conocen la identidad del objeto creado y por tanto ambas variables “miran” hacia él (son alias). Si yo cambio el valor de estas variables el objeto seguirá estando en el mismo lugar de memoria y por tanto su identidad no habrá cambiado. Así pues, las referencias no hacen más que decirnos donde está un objeto y por tanto estas no son su identidad.

Otro punto importante al respecto de la identidad, enfatizando aún más que esta está dada únicamente por la dirección de memoria que ocupa el objeto, es que si dos objetos tienen los mismos valores en sus atributos (el mismo estado) no son el mismo objeto. Por ejemplo si yo tengo dos objetos de tipo Persona donde ambos tienen como nombre Kyshuo y como apellido Ayame, no son el mismo objeto. Eso ustedes ya deberían manejarlo muy bien. Veamos un ejemplo:

Código:
  1. Persona p= new Persona(“Kushuo”,”Ayame”);
  2. Persona q= new Persona(“Kyshuo”,”Ayame”);
  3.  
  4. if (q==p)
  5. System.out.println(“Son la misma persona!!!);
  6. else
  7. System.out.println(“No son la misma persona.”);


¿Qué saldrá en la consola con ese trozo de código? ¿Son la misma persona? Pues NO, en la condición del if lo que estamos comparando son referencias a objetos, es decir, variables que contienen direcciones de memoria, por tanto esa condición será TRUE si ambas direcciones son iguales, es decir si p y q son alias a un mismo objeto, y FALSE en caso contrario.

De este modo, si nosotros queremos saber si son la misma persona deberíamos comparar el estado de ambos objetos, es decir, sus atributos uno a uno, y para eso deberíamos definirnos una operación que lo haga.


Atributos de un objeto:

Los atributos de un objeto son las variables que definen su estado, es decir, los datos que puede contener el objeto. En Java específicamente, los atributos son las variables que declaramos en la clase que define un tipo de objetos. Por ejemplo, la clase Persona tenía dos variables de tipo String: nombre y apellido. Esas variables eran dos atributos. Como ya dije, cada instancia de la clase Persona tendrá su propia variable nombre y su propia variable apellido.

En Modula los atributos correspondían a los campos del registro (RECORD) que especificaba el tipo de datos que crearíamos. Esto ustedes ya lo tienen claro, y si no es así, repasen lo que vimos en Modula respecto a la teoría de objetos.


Estado de un objeto:

Como ya dije, el estado de un objeto está dado por los valores de sus atributos en un momento dado, es decir, es el conjunto de valores de los atributos del objeto en un instante de tiempo. Por ejemplo, en el momento actual el estado de un objeto de tipo Persona es: Kyshuo Ayame; pero más tarde podría ser Pepe Peposo porque hemos cambiado el valor de sus atributos.


Comportamiento de un objeto:

El comportamiento de un objeto está dado por el conjunto de operaciones que el objeto puede ejecutar. Estas operaciones están definidas en la clase que define al tipo de objetos y generalmente tienen como cometido el poder obtener el estado actual de un objeto para consultarlo y/o para modificarlo. Las operaciones también pueden realizar acciones sobre otros objetos. Si ustedes vuelven a la clase Persona y miran todas las operaciones que definimos tienen ahí todo lo que una instancia de esa clase puede hacer, es decir, como puede comportarse.

En Java, las operaciones que hemos declarado hasta el momento son operaciones de instancia. ¿Qué significa eso? Al igual que con los atributos, cada instancia de una clase tendrá su propio conjunto de operaciones encapsulado dentro de sí misma. De este modo, si en la clase Persona yo defino una operación llamada obtenerNombrePersona(), cada instancia de esa clase tendrá una copia de esa operación para sí misma, y de este modo al hacer una invocación a la operación mediante una referencia, por ejemplo

Código:
  1. p.obtenerNombrePersona();


el sistema sabe que debe invocar a la operación obtenerNombrePersona que está en el objeto apuntado por p. Esto es algo totalmente nuevo porque en Modula no lo había explicado ya que su funcionamiento era un tanto diferente y en aquel entonces no tenía mucho sentido. Ahora se volverá importante saberlo. Lo desarrollaré más luego, pero por ahora ustedes deben saber que cada instancia tiene entonces sus propios atributos y sus propias operaciones, tomando siempre como base para crearse en memoria la clase que nosotros especificamos en Java.

------------------------------------------------------------------------------------


Operación y método, una diferencia fundamental:

Un concepto nuevo que surge ahora con Java es el concepto de método. Si ustedes leen otra bibliografía de Java puede que encuentren esta palabra en vez de procedimiento o función, o incluso como sustituto de operación, por ejemplo al hablar del método main. Lo cierto es que en Java operación es una cosa y método es otra bien diferente. Como habrán notado, yo jamás hablé del método main sino que hablé del procedimiento main.

Bien, en Java le llamamos operación SOLO a la firma de un procedimiento o una función. Es decir que, lo que nosotros escribíamos en el DEF de Modula eran operaciones, más formalmente dicho, especificaciones de operaciones. Llamamos método al código fuente que implementa a una operación, es decir, lo que está entre las llaves {}. Esto implica que en Módula escribíamos los métodos en el archivo MOD; ya desde aquel lenguaje había una diferencia entre estos conceptos, más allá de que no se utilizaban las mismas palabras para definirlos.

En los archivos DEF nosotros especificábamos el comportamiento de los objetos que crearíamos, es decir el QUE podrían hacer esos objetos. En los archivos MOD implementábamos el comportamiento de los objetos, es decir, el COMO harían los objetos las operaciones especificadas.

Entonces:

  • Operación es QUE hacer.
  • Método es COMO hacer.


Dado que en Java todo se escribe en un mismo archivo, hace falta tener en mente esta separación que luego se volverá crucial porque con el polimorfismo para un mismo QUE podremos definir distintos COMO, es decir, para una misma operación podremos implementar distintos métodos.

Como hemos venido programando hasta ahora, es decir creando atributos y operaciones de instancia, si no existe ningún objeto de una clase no existen por tanto ningún atributo ni ningún método. Siendo más claros, si yo no creo ningún objeto de tipo Persona no existirá ninguna variable nombre, ninguna variable apellido ni ningún método para la operación obtenerNombrePersona. Los atributos y métodos de instancia son justamente instanciados para cada nuevo objeto, es decir que cada vez que usamos un constructor, Java pide memoria para alojar los atributos definidos en la clase y los métodos para las operaciones también allí definidas. De este modo cada objeto tiene sus propios atributos y sus propios métodos encapsulados dentro de sí. Es por este motivo que se accede a los atributos y métodos públicos a través de una referencia a un objeto, porque dichos miembros existen porque existe el objeto y son propios de él. Cada objeto tendrá sus atributos y sus métodos instanciados y encapsulados.

-------------------------------------------------------------------------------------


Modificador static:

¿Recuerdan que en el último proyecto propuesto en Modula teníamos un problema con el formato para las fechas? Por si no lo recuerdan el tema era este: surgía la necesidad de que todos los objetos de tipo Fecha “vieran” a una misma variable formato que indicaba el formato en que debía ser impresa la fecha. De este modo, dicha variable no podía ser definida como atributo de los objetos Fecha porque sino cada fecha tendría su propio valor de formato, y eso era justamente lo que no queríamos porque necesitábamos un único valor de formato para TODOS los objetos de tipo Fecha existentes en el sistema. Esto debía ser válido incluso para los nuevos objetos que se crearan, es decir que la modificación del valor de la variable formato debía ser independiente de los objetos de tipo Fecha que existieran en el sistema, incluso si no existía ninguno. En Modula esto había sido solucionado definiendo dicha variable en el archivo DEF.

Ahora bien, en Java no tenemos archivo DEF. Para tener un ejemplo concreto, quiero que la clase Persona me de la posibilidad de saber cuántas instancias de ella existen en un momento dado, incluso quiero ser capaz de saber si no existe ninguna instancia de la clase Persona. ¿Cómo hago?

La primera idea sería agregar a la clase Persona una variable de tipo int llamada cantdiadPersonas que sume 1 cada vez que se instancie un nuevo objeto de la clase. Esto obviamente que está mal por muchas cosas:

  • Si no existen instancias de la clase Persona no tengo cómo acceder a una variable que es un atributo de instancia porque justamente no existe.
  • Cada vez que creo una nueva Persona en el sistema aumento 1 al valor de la variable cantidadPersonas, pero cada objeto tiene su propia copia de dicha variable, por tanto cada objeto de tipo Persona tendrá siempre el mismo valor y no se llevará una cuenta justamente porque cada instancia no tiene forma de saber cuantos objetos de su mismo tipo existen hasta ahora.
  • Al eliminar objetos de memoria no tenemos como indicar a los demás objetos que eso ha sucedido.


Muchos de ustedes seguramente dirán: “Es mucho más sencillo tener una variable externa a la que yo le sumo 1 cada vez que creo un nuevo objeto Persona y le resto 1 cuando lo elimino.

Claramente esto soluciona el problema, pero no sirve porque la solución la tiene que programar el usuario de la clase Persona, es decir, la clase Persona no da ningún tipo de ayuda ni solución al problema, de este modo, si yo se la paso a alguien para que la use en sus programas será esa persona quién tenga que programarse su propia solución al problema de las cantidades. Lo que yo quiero es que la solución sea un servicio de la propia clase Persona así como logramos en Modula que el módulo Fecha diera solución por sí mismo al problema del formato.

Existe un tipo de variables que no depende de la existencia de objetos de una clase sino que existen ya al momento de ejecutar el programa. Estas variables son llamadas atributos de clase justamente porque existen por la propia existencia de la clase en que son declaradas. Además, no se crea una copia de esta variable para cada objeto que exista de esa clase, sino que hay una única variable existente y TODOS los objetos ven a la misma variable (valga la redundancia).

Veamos un simple ejemplo de esto agregando entonces una variable a la clase Persona que me indique cuantas instancias de esa clase existen. Para que una variable sea de clase y no de instancia debemos usar el modificador static, sí, al fin vemos para qué sirve esta palabra reservada.

Código:
  1. public static int cantidadPersonas= 0;


Es importante que static (estático en inglés) no significa que la variable no varía, es decir, no estamos declarando una constante. Ya saben que las constantes se declaran con la palabra final. Estático significa para nosotros “Existe siempre”.

Teniendo entonces esa variable en nuestra clase Persona ¿cómo hacemos que cada vez que se cree un objeto de esa clase la variable aumente en 1? Pues si han entendido todo hasta ahora, deben tener bien claro que cada vez que se instancie un objeto Persona se hará por medio de un constructor, por tanto agregamos el incremento de la variable en nuestro constructor, quedando este así:

Código:
  1. public Persona(String nombre, String apellido, int edad, int
  2. documento,double sueldoPorHora, double horasTrabajadas){
  3. this.nombre= nombre;
  4. this.apellido= apellido;
  5. this.edad= edad;
  6. this.documento= documento;
  7. this.sueldoPorHora= sueldoPorHora;
  8. this.horasTrabajadas= horasTrabajadas;
  9.  
  10. Persona.cantPersonas++;
  11. }


Presten atención a la importancia de haber declarado la variable ya inicializándola en 0. Esto se debe a que en principio no existe ningún objeto de tipo Persona en el sistema.

Como pueden ver en vez de usar la referencia this para acceder a la variable estática usamos el nombre de la clase. Esto es porque this hace referencia al objeto actual y justamente la variable cantidadPersonas no depende de ningún objeto porque no pertenece a ninguno, pertenece a la clase.

¿Cómo accedo a la variable cantidadPersonas fuera de la clase Persona? Si ustedes intentan acceder a esta variable como si fuera cualquier otro atributo NetBeans no les hará problema pero les subrayará en amarillo la línea en que hayan escrito esa instrucción:

Código:
  1. p1.cantidadPersonas


El error Acceso a campo estático cantidadPersonas indica justamente que estamos accediendo a algo estático mediante la referencia a un objeto. Justamente lo estático no pertenece a ningún objeto y aunque cualquier objeto de la clase puede verlo no es lo más correcto. ¿Por qué? Porque si lo declaramos estático es justamente porque no queremos acceder a eso a través de objetos de la clase, sino que queremos que sea independiente. La forma correcta de hacerlo es, en vez de la referencia a un objeto, a través de la referencia a la clase:

Código:
  1. Persona.cantdiadPersonas


Así, si yo escribo en la clase principal que teníamos (DatosPersonas) estas líneas ¿qué sale en consola?

Código:
  1. public class DatosPersonas {
  2. public static void main(String[] args){
  3. Persona p1= new Persona("Kyshuo","Ayame",23,12345678,80,30);
  4. Persona p2= new Persona("Kyshuo","Ayame",23,12345678,80,30);
  5. Persona p3= new Persona("Kyshuo","Ayame",23,12345678,80,30);
  6. Persona p4= new Persona("Kyshuo","Ayame",23,12345678,80,30);
  7. System.out.println(Persona.cantidadPersonas);
  8. }
  9. }


Entonces, para acceder a atributos estáticos lo hago a través de la clase y no a través de una referencia a un objeto. La variable cantidadPersonas existe una única vez en el sistema independientemente de la cantidad de instancias de la clase Persona que existan en memoria. Esto resultará interesante para muchas cosas.

Ahora bien, nosotros hemos declarado a esta variable como pública, esto implica que yo puedo hacer en nuestra clase principal algo como esto:

Código:
  1. Persona.cantidadPersonas= 25;


Claramente si hacemos esto habremos modificado el valor de nuestra variable y por tanto ya no nos servirá para lo que fue pensada. Lo correcto sería declararla como privada:

Código:
  1. private static int cantidadPersonas= 0;


Dado esto necesitamos una operación que nos retorne el valor actual de cantidadPersonas. Declaremos entonces una operación que nos devuelva el valor de esta variable:

Código:
  1. public int obtenerCantidadPersonas(){
  2. return Persona.cantidadPersonas;
  3. }


Si ustedes escriben eso en NetBeans no tendrán problema ninguno, el programa compilará y funcionará bien. El tema es que esa es una operación de instancia, es decir, es una función tal como las que ya conocemos, y por tanto para usarla necesitamos hacerlo a través de un objeto de la clase Persona. ¿De qué me sirve tener una variable estática para la cual necesito una operación de instancia cuando quiero obtener su valor? Si la operación depende de la existencia de instancias de la clase no me sirve para nada que la variable sea estática porque para poder tener su valor necesitaré siempre que exista al menos un objeto de tipo Persona.

¿Qué puedo hacer? Pues declaremos a la operación como estática ¿no?

Código:
  1. public static int obtenerCantidadPersonas(){
  2. return Persona.cantidadPersonas;
  3. }


El declarar a una operación como estática implica lo mismo que declarar una variable como estática, o sea:

  • La operación existirá en memoria al iniciar el programa.
  • La operación depende de la clase y no de la existencia de instancias de la misma.
  • La operación entonces es independiente de los objetos de su clase.
  • La operación se invoca a través de la referencia a la clase a la que pertenece y no a través de un objeto de ella.

Entonces, desde la clase principal yo puedo hacer:

Código:
  1. System.out.println(Persona.obtenerCantidadPersonas());


En Modula podíamos llegar a decir que todas las operaciones declaradas en un DEF eran estáticas justamente porque existían a partir del módulo en que eran declaradas y no dependían de la existencia de objetos de ese módulo para ser invocadas. Asimismo, como la mayoría requería parámetros del tipo de objetos del módulo teníamos que tener al menos un objeto creado para hacer la invocación. La diferencia radica en que en Java las operaciones de instancia se encapsulan dentro del objeto al que pertenecen y las de clase no. En Modula esto no era así, las operaciones no se encapsulaban en el objeto porque dicho objeto lo definíamos nosotros mismos mediante un registro con un puntero hacia él.


Declaración correcta de constantes:

Ahora que conocemos el modificador static y qué significa, pensemos un poquito en algo: Imaginen que dentro de la clase persona yo me declaro una constante así:

Código:
  1. public final int MAX_EDAD_PERSONA= 85;


Como constante que es su valor nunca cambiará. Sin embargo, así como está declarada es una constante de instancia, o mejor dicho, una variable final de instancia; esto significa que cada objeto de la clase Persona tendrá su propia copia de esta constante. De este modo si tengo 198 instancias de Persona tengo 198 constantes MAX_EDAD_PERSONA en memoria. ¿Tiene sentido tener copias de un mismo valor constante en memoria? ¿No sería mejor tener una única copia de este valor y que todos los objetos puedan verla?

De este modo, la forma correcta de declarar constantes es así:

Código:
  1. public static final int MAX_EDAD_PERSONAS= 85;


Con esto logramos que la constante sea de clase y por tanto exista una sola vez en el sistema independientemente de las instancias de la clase que podamos llegar a crear. Con esto estamos ahorrando muchos recursos del sistema.

Si ustedes buscan información en Internet al respecto de las constantes verán que siempre son declaradas como estáticas, incluso veremos muchas de ellas en las clases propias de Java cuando avancemos un poco más.

NOTA:

Cambiando un poquito de tema, ahora que sabemos bastante sobre objetos, analicemos entonces bien por arriba la declaración del procedimiento main sin mirar sus argumentos.

Código:
  1. public static void main


  • El procedimiento se ha declarado como público para que pueda ser accedido desde fuera de la clase principal. ¿Quién tendrá que acceder desde fuera? Pues la máquina virtual de Java para poder ejecutar el programa.
  • El procedimiento se ha declarado como estático justamente porque la máquina virtual tiene que poder invocarlo aún sin la existencia de instancias de nuestro programa.
  • El tipo de retorno es void porque justamente es un procedimiento.
  • El nombre simplemente es main porque en inglés significa principal.


Espero que vean que no tenía forma de explicar todo esto sin ver todos los temas dados hasta ahora. Por eso Java al principio choca mucho, ya hay orientación a objetos pura y dura desde la declaración del procedimiento principal de nuestro programa.

El argumento de este método lo explicaré en breve.

-------------------------------------------------------------------------------------


Ejercicios:

A continuación les dejo dos ejercicios que aplican toda la teoría que he dado. Los primeros corresponden a preguntas estrictamente teóricas, si ustedes son capaces de responderlas es porque han entendido todo, en caso contrario, repasen lo que haga falta hasta que logren responderlas. No son ejercicios ideados por mí sino que corresponden a cursos reales de Java.

Ejercicio 1

Parte a)

Expliquen en sus propias palabras qué es una referencia. Escriban un ejemplo.

Parte b)
Expliquen en sus propias palabras cuál es la diferencia entre declarar una referencia e instanciar un objeto. Escriban un ejemplo de ambas cosas.

Parte c)
¿Las clases son tipos de datos? ¿Por qué?

Parte d)
Expliquen en sus propias palabras qué significa que una referencia sea un “alias” de otra referencia. Escriban un ejemplo.

Parte e)
Expliquen en sus propias palabras qué es un atributo de instancia. ¿Si creamos 100 objetos de cierta clase que contiene el atributo de instancia “x”, cuántas variables “x” habrán? Justifiquen su respuesta.

Parte f)
Expliquen en sus propias palabras qué es un constructor y qué tipos de constructores existen.



Ejercicio 2

Parte a)

Agregar una clase Vehiculo como la siguiente en un proyecto Java.

Código:
  1. public class Vehiculo {
  2. public String marca;
  3. public int anio;
  4.  
  5. public Vehiculo(){
  6. marca = "ninguna";
  7. anio = 0;
  8. }
  9.  
  10. public Vehiculo(String pMarca, int pAnio) {
  11. marca = pMarca;
  12. anio = pAnio;
  13. }
  14.  
  15. public String datosVehiculo() {
  16. return "Marca: " + marca + " Año: " + anio;
  17. }
  18. }


Parte b)
En el método main escribir el código para los siguientes pasos:
  • Declarar una variable “v” de tipo Vehiculo que represente una referencia (apuntador) a objetos de la clase Vehiculo. Recordar que sólo con declarar la variable NO estamos creando el objeto, sólo su referencia.
  • Crear un nuevo objeto de la clase Vehiculo apuntado por la referencia “v” llamando al constructor por defecto.
  • Mostrar en consola los datos del vehiculo recién creado.
  • Ejecuten el programa
    • Pedir al usuario que ingrese una marca y guardar esa marca en el objeto recién creado.
    • Pedir al usuario que ingrese un año (distinto a 2007) y guardar ese año en el objeto recién creado.

  • Mostrar en consola los datos del vehiculo.
  • Ejecuten el programa
    • Con esos datos (la marca y año ingresados por el usuario) creen otro objeto Vehiculo pero esta vez utilizando el constructor que reciba esos datos como parámetro. La referencia a este nuevo vehiculo será la variable “v2”.
    • Mostrar en consola los datos del segundo vehiculo. Notar que ambos vehículos (“v” y “v2”) tienen los mismos datos.

  • Ejecuten el programa
    • Codifiquen un IF preguntando si (v==v2). En caso afirmativo, se debe desplegar en consola el mensaje “Paso 9: v es igual a v2” y en otro caso (else) se debe desplegar en consola el mensaje “Paso 9: v es distinto a v2”.

  • Ejecuten el programa y expliquen lo que sucedió
    • Asignar “v2” a “v” de la siguiente forma: v = v2;
    • Codifique un IF preguntando si (v==v2). En caso afirmativo, se debe desplegar en consola el mensaje “Paso 11: v es igual a v2” y en otro caso (else) se debe desplegar en consola el mensaje “Paso 11: v es distinto a v2”.

  • Ejecuten el programa y expliquen lo que sucedió
    • Colocar el valor 2007 como año del segundo vehículo (utilizando la referencia “v2”).
    • Mostrar en consola los datos del segundo vehiculo. Comprobar que el año de este vehículo efectivamente haya cambiado para 2007.

  • Ejecuten el programa
    • Mostrar en consola los datos del primer vehículo (utilizando la referencia “v”).

  • Ejecuten el programa y expliquen lo que sucedió
    • Colocar la referencia “v” en null de la siguiente manera: v = null;
    • Mostrar en consola los datos del primer vehículo (utilizando la referencia “v”)

  • Ejecuten el programa y expliquen lo que sucedió


--------------------------------------------------------------

Hasta la próxima lección.

Volver arriba
Ver perfil del usuario Enviar mensaje privado
pirdy
Usuario Inquieto


Registrado: 11 Feb 2010
Mensajes: 137

Mensaje Publicado: Lunes 27 Ago 2012 12:45

Título del mensaje: Re: Lección 68: Teoría de objetos en Java

Responder citando

Bien profe, muy bien.

Este trabajo nunca se podra agradecer tanto. Saludos.

Volver arriba
Ver perfil del usuario Enviar mensaje privado
xRoki
Usuario Inquieto


Registrado: 22 Ago 2013
Mensajes: 71

Mensaje Publicado: Domingo 10 Nov 2013 20:45

Título del mensaje: Re: Lección 68: Teoría de objetos en Java

Responder citando

GRACIASSSSSS PROFEE!!!


ejercicio 2:

paso 9 dio else que v no es igual a v2 , eso ya lo explicaste es por que son distintos objetos que tienen los mismos atributos.

paso 11 dio que son iguales ya que al haber echo que v2 sea igual que v ... v2 directamente se vuelve aliado de v.

luegoo al colocar 2007 en el v2 .. es lo mismo que haberlo colocado en v ya que son aliados y sus atributos cambian.

si al volver v null y tratar de mostrar atributos.. no sucede ya que v es nullo.

Volver arriba
Ver perfil del usuario Enviar mensaje privado
sr floyd
Usuario Activo


Registrado: 05 Sep 2011
Mensajes: 196

Mensaje Publicado: Miércoles 25 Dic 2013 10:47

Título del mensaje: Re: Lección 68: Teoría de objetos en Java

Responder citando

Incalculable el valor de una leccion como esta!! La leere` varias veces, mil gracias Kishuo!

Volver arriba
Ver perfil del usuario Enviar mensaje privado MSN Messenger
sr floyd
Usuario Activo


Registrado: 05 Sep 2011
Mensajes: 196

Mensaje Publicado: Domingo 05 Ene 2014 04:36

Título del mensaje: Lección 68: Teoría de objetos en Java

Responder citando

Hola Kyshuo, tengo una preguntita, si las variables publicas que pertenecen a una clase son atributos de sus instancias ¿qué son los enumerados para los objetos de una clase donde estén declarados?
Gracias compañero!

Volver arriba
Ver perfil del usuario Enviar mensaje privado MSN Messenger
Kyshuo Ayame
Moderador Global


Registrado: 07 Ene 2011
Mensajes: 1043

Mensaje Publicado: Domingo 05 Ene 2014 14:02

Título del mensaje: Lección 68: Teoría de objetos en Java

Responder citando

Los enumerados en realidad son también objetos. La forma en que se declaran (la cual yo no detallé a fondo) es una forma especial de declarar una clase interna, por tanto, en realidad cuando declaramos un enumerado estamos definiendo una clase interna y luego objetos de ella.

Volver arriba
Ver perfil del usuario Enviar mensaje privado
jonga



Registrado: 27 Mar 2014
Mensajes: 8

Mensaje Publicado: Viernes 11 Abr 2014 15:09

Título del mensaje: Lección 68: Teoría de objetos en Java

Responder citando

¡Gran lección! Me ha quedado mucho más claro como funcionan las referencias en Java.

Volver arriba
Ver perfil del usuario Enviar mensaje privado
Responder al Tema
Mostrar mensajes anteriores:   
Ir a:  
Todas las horas están en GMT + 2 Horas

Temas relacionados

Tema Autor Foros Respuestas Publicado
El foro no contiene ningún mensaje nuevo

¿Cómo instalar correctamente JDK (Java Develope...

Alfonso Lara Temas generales 2 Martes 07 May 2019 22:09 Ver último mensaje
El foro no contiene ningún mensaje nuevo

Ayuda con TestNG Parametrico en java netbeans

baltigo Java 0 Sábado 30 Jun 2018 01:37 Ver último mensaje
El foro no contiene ningún mensaje nuevo

Publicar Aplicación web JAVA en tomcat

Irvin Java Web 1 Viernes 13 Oct 2017 17:54 Ver último mensaje
El foro no contiene ningún mensaje nuevo

Imagen referencial De creación de jtable en apl...

Jensel S.G Java 6 Miércoles 13 Sep 2017 20:06 Ver último mensaje
El tema está bloqueado: no pueden editarse ni agregar mensajes.

EMPLEO ANALISTA PROGRAMADOR/A BACK-END JAVA EE

GRUPOARESTORA Bolsa de trabajo 0 Viernes 23 Jun 2017 14:33 Ver último mensaje
Panel de Control
No puede crear mensajes, No puede responder temas, No puede editar sus mensajes, No puede borrar sus mensajes, No puede votar en encuestas,