0% encontró este documento útil (0 votos)
99 vistas6 páginas

Introducción a la POO en Java

El documento describe los primeros pasos de un estudiante en la implementación de clases y objetos en Java. El estudiante crea una clase Posición con atributos x e y que representan las coordenadas, y métodos para modificar, consultar, incrementar y decrementar dichos atributos. Solicita ayuda para completar el constructor de copia. En los comentarios, otros usuarios proveen sugerencias para mejorar el código y resolver la duda sobre el constructor de copia.

Cargado por

Gabo Coca
Derechos de autor
© All Rights Reserved
Nos tomamos en serio los derechos de los contenidos. Si sospechas que se trata de tu contenido, reclámalo aquí.
Formatos disponibles
Descarga como PDF, TXT o lee en línea desde Scribd
0% encontró este documento útil (0 votos)
99 vistas6 páginas

Introducción a la POO en Java

El documento describe los primeros pasos de un estudiante en la implementación de clases y objetos en Java. El estudiante crea una clase Posición con atributos x e y que representan las coordenadas, y métodos para modificar, consultar, incrementar y decrementar dichos atributos. Solicita ayuda para completar el constructor de copia. En los comentarios, otros usuarios proveen sugerencias para mejorar el código y resolver la duda sobre el constructor de copia.

Cargado por

Gabo Coca
Derechos de autor
© All Rights Reserved
Nos tomamos en serio los derechos de los contenidos. Si sospechas que se trata de tu contenido, reclámalo aquí.
Formatos disponibles
Descarga como PDF, TXT o lee en línea desde Scribd

Ejercicios básicos | Diario de un Aprendiz de Java [Link]

23rd May 2005 Ejercicios básicos


Buscando por la red he encontrado unos ejercicios propuestos de clases
y objetos [[Link]
/[Link]<br ></a>] , y he empezado a hacerlos. Son parte de la
asignatura de Programación Orientada a Objetos de la Universidad de
Murcia. Podeis encontrar su página web en este enlace [[Link]
/~bmoros/] . En la parte teórica de la asignatura se trabaja con los
lenguajes orientados a objetos Eiffel, C++ y Java, pero las prácticas se
entregan solo en este último, Java.

El enunciado de lo primero que he hecho dice asi :

1.- Implementar la clase Posicion que represente un punto


(x,y) en el eje de las coordenadas. Cada posición viene
definida por dos valores enteros x e y. Las operaciones
disponibles son:

· Constructor por defecto, se corresponde con la


posición (0,0).
· Constructor al que se le pasa como parámetro los
valores inciales de las coordenadas X e Y.
· Constructor de copia.
· Métodos para modificación y consulta (set/get) de los
atributos de la clase.
· Métodos para incrementar y decrementar los valores
de cada una de las coordenadas de la posición (incX,
incY, decX, decY).
· Un método para establecer los valores de las
coordenadas (setXY).

Y siguiendo este enunciado, he escrito este codigo

class Posicion {
  int x, y;

/*Constructor por defecto*/


  Posicion() {
   this.x = 0;
   this.y = 0;
  }

1 de 6 12/07/18 20:23
Ejercicios básicos | Diario de un Aprendiz de Java [Link]

/*Constructor al que se le pasa como parámetro los


valores
iniciales de las coordenadas X e Y.*/
  Posicion(int x, int y) {
   this.x = x;
   this.y = y;
  }

/*Métodos para modificación y consulta*/


  void setX(int x) {
   this.x = x;
  }

  void setY(int y) {
   this.y = y;
  }

  int getX() {
  return x;
  }

  int getY() {
   return y;
  }

/* Métodos para incrementar y decrementar los


atributos*/
  void incX() {
   x++;
  }

  void incY() {
   y++;
  }

  void decX() {
   x--;
  }

  void decY() {
   y--;
  }

/*Método para establecer los valores de las

2 de 6 12/07/18 20:23
Ejercicios básicos | Diario de un Aprendiz de Java [Link]

coordenadas*/
  void setXY(int x, int y) {
   this.x = x;
   this.y = y;
  }
}

Como veis, lo único que me falta es el constructor de copia, pero es algo


que no he hecho nunca y aún desconozco. Queda en la lista de cosas
TO-LEARN (pero en la lista que realmente se va siguiendo, no el otra en
la que dejas los temas imposibles .. xD).
¡Aprovecho para pedir rectificaciones y/o ayudas en el codigo, se
agradece mucho si alguien lo revisa! ¡Saludos!

Posted 23rd May 2005 by servo

6 View comments

Hada 3:11 AM
Hola!
He estado mirando tu código y parece correcto, lo único que el
último método, no estoy segura de lo que te pide porque si te das
cuenta, es idéntico al de modificar...
En cuanto al constructor de copia, se utilizan para inicializar un
objeto con otro objeto de la misma clase.
Ejemplo:

public class Coordenadas


{
int x,y;
public Coordenadas(const Coordenadas c)
{
x=c.x;
y=c.y
}

};

Espero haberte ayudado algo...


Saludos!! ;)
Reply

3 de 6 12/07/18 20:23
Ejercicios básicos | Diario de un Aprendiz de Java [Link]

Frank 1:03 PM
Hola,
El método de copia me imagino que es aquel constructor en el que
haces referencia a otro constructor, por ejemplo:

Posicion() {
this(0, 0);
}

esto da el mismo resultado de lo que habías colocado inicializando


en cero, pero es una forma más elegante. Saludos y suerte con
este maravilloso lenguaje.
Reply

kbza 1:32 PM
El constructor por copia es exactamente lo que planteo Hada.
Dicho constructor recibe como parametro otro objeto de la misma
clase y copia los atributos de este, tal cual mostro Hada.

Saludos.
Reply

yack dexsar castillo barrazueta 7:43 PM


esta chevere...pero me encantaria saber mucho mas...porfa
podriame enviarme a mi blog.
Reply

Kevin Espinoza 9:23 AM


Hola amigo esta muy interesante tu blog yo recien inicio java
desde 0, ahora recién estoy en la lectura mira tengo un ejemplo:

import [Link].*;
public class sibasico
{
public static void main (String args[])throws IOException
{

InputStreamReader teclado = new InputStreamReader ([Link]);


BufferedReader flujo = new BufferedReader (teclado);
String cadena;

int a,b;

4 de 6 12/07/18 20:23
Ejercicios básicos | Diario de un Aprendiz de Java [Link]

char c;
c='\0';
a=b=0;

[Link]("Ingrese primer numero: ");


cadena=[Link]();
a=[Link](cadena);
[Link]("Ingrese segundo numero: ");
cadena=[Link]();
b=[Link](cadena);
[Link]("Elegir su tipo de operacion: ");
cadena=[Link]();
c=[Link](cadena);
switch (c)
{
case '+':
{

[Link]("HOLA");
}
default:
{
[Link]("ERROR: ");

}
}

Lo que tengo problemas es con la variable char de "c", porque


quiero ingresar con variable +, -, * para que calcule la operacion
correspondiente, pero no sé como asignar al caracter c.
he probado con:
c=[Link](cadena);

pero me bota error por favor si alguien me ayuda =)


Reply

CARLOS 1:06 AM
para un costructor de copia lo unico que tienes que hacer es
instanciar como parametro el mismo contructor de la clase que

5 de 6 12/07/18 20:23
Ejercicios básicos | Diario de un Aprendiz de Java [Link]

estas creando, que en tu caso seria Posicion


Posicion(Posicion p)
{
this.x = p.x;
this.y = p.y;
}
Reply

Enter your comment...

Comment as: Gabriel Cortez (Google) Sign out

Publish Preview Notify me

6 de 6 12/07/18 20:23

Common questions

Con tecnología de IA

A copy constructor enables the creation of a new object as a copy of an existing object by taking another object of the same class as a parameter and replicating its attribute values. This is particularly useful for creating duplicates of complex objects with their current state .

Without a copy constructor, replicating an object's state involves manual copying of each attribute separately, increasing susceptibility to errors and omission. This absence complicates tasks like implementing undo features or maintaining object versions, as each attribute must be explicitly handled across all duplications, leading to code redundancy and decreased maintainability .

Comments serve to explain logic, clarify function use, and outline expected behavior, which aids in identifying incongruities during debugging. They provide context without requiring deep code dives; therefore, accurate and comprehensive commenting can streamline error checking and maintain coherent code understanding, especially in collaborative settings .

Challenges include runtime errors when parsing or casting characters incorrectly, leading to logical errors or program crashes. Specifically, using methods that misalign with the intended operation type can cause unexpected behavior, such as incorrect operation comparisons or defaulting to error responses when dealing with special characters like '+', '-' or '*' .

Constructor overloading offers flexible options for object instantiation, allowing different initial setups while maintaining code simplicity. However, it can introduce complexity in managing and understanding the multiple pathways an object can be initialized, potentially leading to maintenance challenges or unexpected behavior if not well-documented .

The relationship between these methods lies in their functionality of altering the state of object attributes. While the method for setting coordinates directly assigns new values to both x and y attributes, methods for modifying coordinates increment or decrement the current values. They serve complementary roles in managing attribute states .

The 'Posicion' class must implement operations including a default constructor that initializes the position to (0,0), a constructor that sets custom initial coordinates, a copy constructor, getter and setter methods for both coordinates, methods to increment and decrement both coordinates, and a method to set both coordinates simultaneously .

'This' keyword is crucial in distinguishing instance variables from method parameters or local variables that share the same name, enhancing clarity and preventing conflicts. It aids in defining the scope of variables, ensuring the intended object attributes are used and modified throughout class methods .

Input streams allow dynamic user interaction through real-time data entry, extending functionality beyond static inputs. They enable programs to perform operations based on variable user data, facilitating applications like calculators or interactive queries. However, careful management of input streams is necessary to avoid errors and ensure smooth runtime performance .

Using explicit constructors offers clear and precise control over object initialization, allowing for specific input values which tailor towards unique object creation needs. In contrast, default constructors provide a baseline state which can simplify repeated common initializations, but might lack the specificity for particular requirements. The choice depends on the balance between simplicity and the need for customization .

También podría gustarte