Introducción al lenguaje Java

Introducción al lenguaje Java
Tipo de entrega:
Fecha límite:
Lugar:
por grupos de prácticas
sesión de laboratorio
Atenea
Objetivos de la práctica:
• Escribir aplicaciones simples en Java
• Utilizar el entorno de desarrollo de Java (Eclipse)
• Utilizar los conceptos de Clase, Atributo, Constructor y Método en el código de una
aplicación Java
• Generar el programa principal en el código de una aplicación Java
• Identificar ámbito de una variables
• Utilizar conceptos de herencia.
• Utilizar conceptos de sobre escritura.
Estudio previo
Realiza el planteamiento de los ejercicios (como mínimo de los ejercicios obligatorios). El
planteamiento del problema significa describir y razonar clases (nombre), atributos (nombre y
tipo), métodos (nombre, parámetros que aceptan y resultado que devuelve). Tráelo a la
sesión de laboratorio en papel.
Resultados
Los resultados esperados de esta práctica es la carpeta del Workspace del Eclipse que
contiene los códigos de las aplicaciones.
Colección de problemas
Ejercicio 1 (constructores)
a) Crea una clase Libro que pueda ser utilizada para representar los libros que hay en una
biblioteca. Supón que cada libro tiene los siguientes atributos:
•
•
•
•
título
autor
año de publicación
editorial
b) Escribe un método main que cree dos objetos de la clase Libro y que muestre el valor de
los atributos de cada uno de ellos.
Ejercicio 2 (paso de parámetros)
Realiza un programa Java que reciba como argumento un valor de temperatura en grados
Celsius e imprima por pantalla su valor en grados Fahrenheit. La fórmula de conversión de
grados Celsius a grados Fahrenheit es: F = 9/5 * C + 32.
Ejercicio 3 (métodos, paso de parámetros)
Realiza un programa Java que calcule el cuadrado de una suma, el de una diferencia y que
muestre el mensaje siguiente exactamente:
El cuadrado de la suma de primerValor y segundoValor vale cuadradoSuma.
El cuadrado de la diferencia de primerValor y segundoValor vale cuadradoResta.
Eres un mossstruo".
Utiliza los números 3 y 2 para los cálculos.
Ejercicio 4 (ámbito variables)
a) Señala cual es el ámbito de las variables x y q
{
int x = 15;
{
int q = 34;
}
}
b) Crea una clase para probar el ámbito del código del apartado anterior y prueba a printar
por pantalla el valor de q desde su ámbito y fuera de éste. Haz lo mismo con la variable q.
Ejercicio 5 (constructores)
Queremos que la salida por consola de un programa en Java sea:
Un
Un
Un
Un
árbol de 4 metros
árbol tipo Roble
árbol genérico
Pino de 5 metros
Escribe el código en JAVA que falta para que la salida por consola del programa sea:
public class PruebaArboles
{
public static void main(String args[]) {
Arbol arbol1 = new Arbol(4);
Arbol arbol2 = new Arbol("Roble");
Arbol arbol3 = new Arbol();
Arbol arbol4 = new Arbol(5,"Pino");
}
}
Ejercicio 6 (métodos)
¿Cuál es el resultado del siguiente programa Ejercicio6.java?
public class Ejercicio6 {
public static void main(String [ ] args){
Clase1 obj1=new Clase1();
obj1.imprimir(24.3,5);
}
}
class Clase1 {
private double valor=9.8;
private int x=7;
public void imprimir(double valor, int x) {
System.out.print(valor+" "+this.x);
}
}
Ejercicio 7 (Strings)
Realiza este ejercicio primero sin ayuda del Eclipse y después comprueba tus resultados con
el Eclipse.
a) ¿Cuál es el valor de saluda_pepe ?
String saludo = "hola";
String nombre = "Pepe";
String saluda_pepe = "";
saluda_pepe = saludo + nombre;
b) ¿Cuál es el valor de saludo? ¿Es de tipo String o de tipo int?
String saludo = "hola";
int n = 5;
saludo = saludo + " " + n;
c) ¿Cuál es el valor de subsaludo?
String saludo = "hola";
String subsaludo = "";
subsaludo = saludo.substring(0,2);
d) ¿Cuál es la salida por consola de este programa? Razona la respuesta
public class Ejemplo5 {
public static void main(String[] args) {
String saludo = "Hola";
String saludo2 ="hola";
int n = 5;
System.out.println(saludo.substring(0,2));
System.out.println(saludo +" " + n);
System.out.println("saludo
==
saludo2
saludo.equals(saludo2));
}
}
"+
Ejercicio 8 (métodos)
¿Cuál es la salida de este programa? ¿Por qué? (Nota: Busca overflow en Java)
public class Overflow {
public static void main(String[] args) {
int gran = 0x7fffffff;
System.out.println("gran = " + gran);
int mas_grande = gran * 4;
System.out.println("mas_grande = " + mas_grande);
}
}
Ejercicio 9 (métodos)
Escribe un programa que disponga de una clase para representar las asignaturas del
cuatrimestre que estás cursando. Una asignatura tiene un nombre, un código numérico y el
cuatrimestre del que forma parte. Los valores iniciales han de proporcionarse en el
constructor. La clase ha de tener métodos para obtener los valores de los atributos. El
programa ha de construir un objeto con los siguientes valores: nombre “FSD”, código 2022,
cuatrimestre 2B. A continuación el programa ha de imprimir los valores del objeto por
pantalla.
Ejercicio 10 (métodos y constructores)
Define una clase que represente un punto en un espacio bidimensional. La clase debe
disponer de un constructor con las coordenadas del punto y métodos que devuelvan las
coordenadas.
Ejercicio 11 (métodos)
Escribe un programa que instancia (crea) cuatro puntos (objetos): el primero situado en el
origen, el segundo situado en (2,3), el tercero en (2, -1) y el cuarto como punto medio entre
el segundo y el tercero.
Ejercicio 12 (constructores)
Añade a la clase anterior un constructor sin parámetros que permita construir puntos en el
origen de coordenadas.
Ejercicio 13 (métodos)
Añade un método a la clase anterior que calcule la distancia a otro punto.
Ejercicio 14 (métodos)
Escribe un programa que cree un punto (5,3) e imprima la distancia del punto al origen de
coordenadas.
Ejercicio 15 (métodos)
Se desea calcular la distancia recorrida por un móvil. Se sabe que el móvil sigue movimientos
rectilíneos entre una serie de puntos. Se pide escribir un método que reciba una serie de
puntos y determine la distancia recorrida por el móvil. Para probar el método, escribe un
programa que calcule la distancia recorrida entre los puntos (0,0), (2,4), (4,5), (4,6), (3,4) y
(0,0) (vuelta al origen). Prueba también qué ocurre cuando se llama al método con un solo
punto.
Ejercicio 16 (métodos)
a) Explique todos los errores de las clases C.java y DemoC.java. Corrígelos.
public class C {
private int dato1 = 0;
private int dato2 = 0;
public int dato3 = 0;
public C(){
}
public void setDato1(int n){
dato1 = n;
}
public void getDato2(){
return dato2;
}
public void getDato3(){
return dato3;
}
private void setDato3(int n){
dato3=n;
}
}
public class DemoC {
public static void main(String[] args){
C c1 = new C();
C c2 = new C(1,2,3);
c1.setDato1(4);
c1.setDato3(5);
int n1 = c1.getDato2();
int n2 = c1.getDato3();
int n3 = c1.dato1;
int n3 = c1.dato2;
int n4 = c1.dato3;
}
}
Ejercicio 17 (objetos)
¿Qué imprime el siguiente programa?
class Ejercicio17 {
public static void main (String [] args) {
Clase1 obj1= new Clase1(5,4);
System.out.print(obj1.modificar(4)+" ");
Clase1 obj2= new Clase1(5,4);
System.out.print(obj2.modificar(5)+" ");
obj2=obj1;
System.out.println(obj2.modificar(5)+" ");
}//fin main
}
class Clase1{
int p1,p2;
public Clase1 (int i, int j){
p1=i;
p2=j;
}
public int Modificar(int i){
p1=p1+i;
p2=p2+i;
System.out.print(p2+" ");
return p1;
}
}
Ejercicio 18 (objetos)
Implementa un programa que calcule los n primeros términos de la sucesión de Fibonacci,
donde n es un valor entero especificado por el usuario. La secuencia con los siguientes
números: 1, 1, 2, 3, 5, 8, 13, 21. Después de los dos primeros unos, cada número de la
secuencia es la suma de los dos anteriores. Por ejemplo, 1 + 1=2, 1+2=3, 2+3=5, 3+5=8, y
así sucesivamente.
Ejercicio 19 (herencia)
Programa el siguiente diagrama de clases:
a) Razona el por qué de este diagrama
b) ¿Cuál es el significado de la flecha? ¿Qué beneficios comporta?
Ejercicio 20 (herencia)
Diseña dibujándola (no programándola) el diagrama de clases de una jerarquía de
clases que permita representar los distintos tipos de viviendas que ofrece una
inmobiliaria a sus clientes: estudios, pisos, áticos, dúplex y chalets. Algunos datos a
tener en cuenta pueden ser: la localización del inmueble, el número de metros
cuadrados que tiene, la planta del edificio en la que se sitúa, la superficie de la terraza,
el número de plantas, el número de dormitorios y baños, el estado en el que se
encuentra (para entrar a vivir, para reformar), si dispone de ascensor, portero, piscina,
garaje, zonas comunes, dimensiones del jardín o parcela, etc.
Ejercicio 21 (herencia)
Diseña dibujándola (no programándola) el diagrama de clases de una jerarquía de
clases que permita almacenar datos sobre los planetas y satélites que forman parte del
sistema solar (junto con el sol). Algunos atributos que puede ser interesante recoger
son: la masa del cuerpo, su diámetro medio, el período de rotación sobre el propio eje,
período de traslación alrededor del cuerpo que orbitan, distancia media a ese cuerpo,
excentricidad de la órbita, ...
Ejercicio 22 (herencia)
Define una clase padre llamada Animal con 4 atributos y dos métodos. Posteriormente define
dos posibles clases (que se te ocurran) hijas de Animal, con un atributo más y un método
más que la clase padre. Realiza una última clase que se llame MiZoologico que cree objetos
animales y muestre sus características (atributos) por pantalla.
Nota: Cuando se dice un método más NO significa que las clases hijas deban tener tres
métodos.
Ejercicio 23 (herencia)
Explica el siguiente ejemplo línea por línea.
public class Mamifero {
private int patas;
private int colorPelo;
private String nombre;
public void imprimirPatas() {
System.out.println(nombre +
patas\n");
}
"
tiene
public Mamifero(String nombre, int patas) {
this.nombre = nombre;
this.patas = patas;
}
}
class Perro extends Mamifero {
private int ladridos;
public Perro(String nombre) {
super(nombre, 4);
ladridos = 0;
}
}
"
+
patas
+
"
class Gato extends Mamifero {
private int maullidos;
public Gato(String nombre) {
super(nombre, 4);
maullidos = 0;
}
}
a)
b)
c)
d)
e)
class ChitePerro {
public static void main(String [] args) {
Perro bobi = new Perro("Bobi");
bobi.imprimirPatas();
/*Está en la clase mamífero*/
}
}
¿Cuál es el resultado de este programa?
¿Qué significa que patas, colorPelo y nombre tengan el modificador private?
¿Podemos acceder a ellas desde las otras clases?
Si no podemos acceder a ellas en el resultado del programa saldrán el número de
patas?
¿Para qué nos ha servido la herencia en este ejemplo?
Ejercicio 24 (herencia)
class Figura {
protected String color;
public Figura(String color ) {
this.color=color;
}
}
class Rectangulo extends Figura{
int largo,ancho;
public Rectangulo(String color,int largo,int ancho) {
super(color);
this.largo=largo;
this.ancho=ancho;
}
public double area(){
return (double)largo*ancho;
}
}
class Triangulo extends Figura {
int base,altura;
public Triangulo(String color,int base,int altura) {
super(color);
this.base=base;
this.altura=altura;
}
public double area(){
return (double)base*altura/2;
}
}
class TrianguloRectangulo extends Triangulo {
public TrianguloRectangulo(String color,int base,int altura){
super(color,base,altura);
}
}
class TrianguloIsosceles extends Triangulo {
public TrianguloIsosceles(String color, int base,int altura){
super(color,base,altura);
}
public double area(){
double calculoArea= super.area();
return calculoArea*2;
}
}
public class Principal {
public static void main(String[] args) {
double s;
Rectangulo r=new Rectangulo("verde",2,3);
s=r.area();
System.out.println("Este
rectángulo
es
de
color
"+r.color+"\nEl área es: "+s);
TrianguloIsosceles
ti=new
TrianguloIsosceles("amarillo",5,7);
s=ti.area();
System.out.println("Este triangulo isósceles es de color
"+ti.color+"\nEl área es: "+s);
TrianguloRectangulo
tr=new
TrianguloRectangulo("rojo",5,3);
s=tr.area();
System.out.println("Este triangulo isósceles es de color
"+tr.color+"\nEl área es: "+s);
}
}
a) Realiza un diagrama de clases como el del ejercicio 1. Razona el por qué de esta
estructura de clases.
b) ¿Qué ventaja presenta dicha estructura?
c) Programa el ejemplo con el Eclipse.
d) Podríamos obtener el mismo resultado del programa principal, programando con
alguna clase menos. ¿Crees que realizar el mismo programa con menos clases es
más eficiente? ¿ofrecería una mayor claridad?
e) ¿Para qué se sobreescriben métodos?
f) Explica para cada clase del código:
• Visibilidad de los atributos y de los métodos.
• El uso de la palabra clave super.
• Que hace cada uno de los constructores y métodos de cada clase; así como cual
será la salida del programa principal.
Ejercicio 25 (herencia)
class C1 {
int i;
C1() {i = 1;}
void m1() {
void m2() {
}
System.out.println( i );
m1(); m1(); }
class C2 extends C1 {
C2() {
i = 2;
}
void m1() {
System.out.println( -i );
}
class C3 extends C2 {
C3() { i++;
}
void m2() {
m1();
}
}
public class HerenciaYSobreescritura {
public static void main( String args[] ) {
C1 a = new C1();
a.m2();
C1 b = new C2();
b.m2();
C2 c = new C3();
c.m2();
}
}
a) ¿Cuál es el resultado de la ejecución de este programa?
}
}
Ejercicio 26 (herencia)
Supongamos que existe la clase F con la siguiente definición.
public class F {
private int valor;
public F(int x){
valor=x;
System.out.println("F fabricado: " + valor);
}
}
a) ¿Cuál es la salida del siguiente programa? Explica el por qué.
public class G extends F{
private F valor;
public G(int x,int y){
super(x);
valor=new F(y);
}
public static void main(String []args){
G g=new G(11,28);
}
}
Ejercicio 27 (herencia)
Decir cuál sería el resultado de la ejecución de este programa suponiendo que se han
eliminado previamente todas las sentencias erróneas. Identificar dichas sentencias erróneas.
class A {
void m1() {
void m2() {
}
System.out.println("Clase A - m1");
System.out.println("Clase A - m2");
}
}
class B extends A {
void m2() {
System.out.println("Clase B - m2");
void m3() {
System.out.println("Clase B - m3");
}
}
}
class EjercicioHerencia {
public static void main( String args[] ) {
A ob1 = new A();
A ob2 = new B();
B ob3 = new A();
B ob4 = new B();
ob1.m2();
ob2.m2();
ob2.m1();
ob2.m3();
((B)ob2).m3();
ob4.m1();
((B)ob1).m2();
}
}