RSS

Archivos Mensuales: abril 2011

Powerpoints SCJP Ezequiel Aranda

Añado a los recursos estos powerpoints que ha realizado Ezequiel Aranda. Están muy bien. Se agradece que lo comparta con todos.
Son los siguientes:

  • SCJP, Clase 1: Introducción al curso, Intro a Java, Declaración y Control de Acceso
  • SCJP, Clase 2: Ejemplos de Enum, POO

Read the rest of this entry »

 
8 comentarios

Publicado por en 28 abril, 2011 en Enlaces, Recursos

 

Etiquetas: , , ,

Deberes – Arrays y Enumerados

Después del último post de estudio sobre Arrays y tipos Enumerados, vamos a realizar los siguientes ejercicios:

  • Ejercicio1: Realizar varios ejemplos de declaraciones de arrays, de tipos primitivos y de clase.
    Comprobar que no es posible indicar la dimensión de los arrays en la declaración.
    Comprobar que llamadas a métodos como length dan error de compilación.
  • Ejercicio2:
    • Crear una clase PreguntaExamen con los siguientes atributos, enunciadoPregunta de tipo String, respuestaCorrecta de tipo char y puntuacionPregunta de tipo float. Escribir un método toString() que nos devuelva el enunciado, los puntos que vale y un literal “Respuesta: “
    • Crear una clase RespuestaAlumno como un array de char. El char en la posición i será la respuesta que el alumno considera correcta para la pregunta en la posición i. Crear un constructor RespuestaAlumno(int dimension) y un método addRespuesta (char resp, int pos) para poder ir añadiendo respuestas en el array.
    • Crear una clase PrincipalExamen en la que con un array de PreguntaExamen dado y un array de respuestas de un alumno, rellenemos un array de float puntuacion, que contendrá la puntuación del alumno para cada pregunta. Sumar todas las puntuaciones del array para mostrar la nota final del alumno.
  • Ejercicio3: Declarar un tipo enumerado Semana con los valores de los días de la semana y usar este tipo de datos en una clase Cita que tenga un atributo tarea y un dia de Semana.
  • Ejercicio4: Declarar un tipo enumerado Hamburguesa que tenga los siguientes valores  (MINI, NORMAL, MAXI, LUXURY) y los atributos nombre de tipo String, precio de tipo float y peso de tipo float.
    Escribir un constructor sin argumentos y otro con argumentos.
    Escribir los métodos getters asociados a los atributos.
    Escribir una clase PrincipalHamburguesa donde utilizar el enumerado.

Ya están todos resueltos.

Para ver los ejercicios resueltos click en Leer más…

Read the rest of this entry »

 
1 comentario

Publicado por en 27 abril, 2011 en Deberes

 

Etiquetas: , , ,

Declaración y control de acceso (V)

Declaración de un array

Los arrays se usan normalmente para agrupar objetos del mismo tipo. Permiten hacer referencia al grupo de objetos a través de un nombre común.

Es posible declarar arrays de cualquier tipo, ya sea de tipos primitivos o tipos de referencia.

En cualquier caso, un array en Java es un objeto incluso cuando esté compuesto de tipos primitivos.

Como en el caso de otros tipos de clase, la declaración del array no crea el objeto en sí. La declaración de un array crea una referencia al array. La memoria utilizada por los elementos del array se asigna de forma dinámica mediante una sentencia new o mediante el inicializador del array.

La sintaxis de declaración es:

tipoElementos [] nombreArray;
tipoElementos nombreArray [];

Las dos opciones son válidas. Aunque se suele recomendar los corchetes a la izquierda por ser más legible y porque éstos se aplican a todas las variables a la derecha de ellos.

int [] puntuacion, puntuacionMaxima; //Recomendada
int puntuacion[], puntuacionMaxima [];

En la declaración no se debe indicar el tamaño concreto del array, dará error de compilación. Veremos esto más adelante en la construcción e incialización de arrays.

Tipos Enumerados

Una práctica habitual en programación es tener un número finito de nombres simbólicos que representan los valores de un atributo.
Por ejemplo para representar los colores de un semáforo: ROJO, AMARILLO, VERDE.

A partir de la versión 5.0, Java SE incluye una modalidad de tipos enumerados que mantiene la seguridad de los tipos.

Veamos un ejemplo de declaración:

public class Semaforo {
enum ColorSemaforo{
 ROJO,
 AMARILLO,
 VERDE
 };// el punto y coma es opcional en la declaracion de enums.
 ...

Habría que pensar en el tipo Semaforo como en una clase con un conjunto finito de valores que reciben los nombres simbólicos incluidos en la definición del tipo. Los valores serían realmente instancias de esa clase. El compilador no permitirá que pueda asignarse otro valor diferente a los especificados.

El orden en el que definamos los valores importa, pero se verá más adelante

ColorSemaforo colorActual = ColorSemaforo.VERDE; // VERDE es de tipo ColorSemaforo
ColorSemaforo colorIncorrecto = ColorSemaforo.AZUL; //provocará error de compilación.

Los tipos enumerados pueden declararse como miembro de una clase, como una clase aparte, pero nunca dentro de un método.

Declarando constructores, variables y métodos en un Tipo Enumerado

La nueva modalidad de tipos enumerados permite usar atributos y métodos, igual que en otras clases.
Un constructor enum siempre debería usar acceso privado. Los argumentos del constructor se suministran después de cada valor declarado. Los tipos enumerados pueden tener cualquier cantidad de atributos y métodos.

Para nuestro ejemplo, definamos un atributo nombreColor con un literal más amigable que las mayúsculas y un atributo segundosColor que indicará el tiempo en segundos que está activado cada color.

//Argumentos para el constructor en la declaración
public enum ColorSemaforo{
ROJO ("Rojo", 60),
AMARILLO ("Amarillo", 25),
VERDE ("Verde", 45); //Se requiere el punto y coma cuando hay
 //mas código en la definición del enum

private String nombreColor; //atributos
private int segundosColor; // atributos

//Constructor
private ColorSemaforo (String nombreColor, int segundosColor){
 this.nombreColor = nombreColor;
 this.segundosColor = segundosColor;
}

//Métodos getters
public String getNombreColor(){
 return nombreColor;
}
public int getSegundosColor(){
 return segundosColor;
}
}

Recordaremos de los constructores de tipos enumerados:

  • No se puede invocar un constructor de un enum directamente. Se llama automáticamente cuando especificamos los argumentos en la declaración de los valores del tipo enumerado.
  • Se puede definir más de un argumento para el constructor y se puede sobrecargar los constructores.
 
3 comentarios

Publicado por en 25 abril, 2011 en Estudio, Tema 1

 

Etiquetas: , , ,

Deberes – Variables

Vamos a realizar los siguientes ejercicios:

  • Ejercicio1: Crear un programa principal y declarar variables para todos los tipos primitivos de Java. Comprobar que si alguna no se inicializa da error de compilación.
  • Ejercicio2: Crear una clase Cuenta que tendrá los siguientes atributos, String numCuenta, double importeCuenta y boolean vip.
    No especificar constructor. Realizar un metodo verDetalles que devuelva un String con los valores de los atributos de la cuenta.
    Crear una clase PrincipalCuenta con un método main que declare un objeto Cuenta y llame al método verDetalles.
  • Ejercicio3: Modificar la clase Cuenta para suministrar un constructor con argumentos.
    Crear una clase Cliente que tendrá los siguientes atributos:
    – una variable de clase cuentasVIP de tipo array de Cuenta con una dimensión de 100
    – una variable de clase contArray de tipo entero para recorrer el array cuentasVIP,
    – un String nombre,
    – un String domicilio
    – y una cuenta del tipo Cuenta.

En el constructor de Cliente preguntaremos si la cuenta del cliente es vip y si es así se añadirá a la variable de clase cuentasVIP.

Crear una clase PrincipalCuentasVip para probar lo anterior.

Para ver los ejercicios resueltos click en Leer más…

Read the rest of this entry »

 
4 comentarios

Publicado por en 21 abril, 2011 en Deberes

 

Etiquetas: , , ,

Declaraciones y control de acceso (IV)

Variables

Por el tipo se pueden dividir en:

  • variables de tipos primitivos.
  • variables de tipos de referencia.

Por el lugar en que se definen:

  • variables locales (dentro de un método, parámetros del método)
  • variables miembro (fuera de un método, en la definición de la clase)
  • variable de clase (fuera de un método, en la definición de una clase, lleva la palabra static)

Tipos Primitivos en Java

Los tipos primitivos son simples valores, no objetos. Los tipos de referencia se utilizan para tipos más complejos, incluidos los que declara el propio programador.

Java define ocho tipos de datos primitivos, que se dividen en cuatro categorías:

  • Lógicos: boolean
  • Texto: char
  • Enteros: byte, short, int, long
  • Reales: float, double

Boolean

Los valores lógicos se representan mediante el tipo boolean, que puede contener uno de estos dos valores: true (verdadero) o false (falso).
Decimos que el tipo boolean admite dos valores literales: true y false.

Char

Los caracteres se representan mediante el tipo char. Un valor char representa un carácter Unicode de 16 bits sin signo. Los literales char se escriben entre ‘ ‘.

Enteros

Hay cuatro tipos de datos enteros en Java. Cada uno de ellos se declara usando las palabras clave byte, short, int o long.
Se puede representar los literales de los tipos enteros utilizando una notación decimal, octal o hexadecimal.

Por ejemplo:
70 sería 70 en decimal, 046 en octal y 0x106 en hexadecimal.

Todos los tipos numéricos en Java representan números con signo.
Por defecto  los literales enteros son del tipo int, a menos que vayan seguidos de la letra L, que indicaría que es un long.

Por ejemplo:
24L indicaría que el valor decimal 24 se representaría como un entero largo.

La tabla siguiente indica el tamaño en bits de cada tipo y su rango de valores:


Reales

Las variables de tipo real se declaran con las palabras float o double. Un literal numérico es un número real si incluye un separador decimal y un exponente, o bien si va seguido de la letra F o f (float) o de la letra D o d (double).

Los literales reales se consideran double de forma predeterminada. Es posible declarar literales del tipo float agregando F o f al valor.

Ejemplos:

5.15               Valor corto de precisión simple, pero por defecto sería double.
3.35E25          Valor largo double
4.393F             Valor corto de precisión simple (float)
76.5E800D        Valor largo double

Tabla de los reales:

Declarando variables primitivas

Pueden ser declaradas como variables de clase (static), como variables miembro o como variables locales.
Se pueden declarar en una misma linea varias variables del mismo tipo.

Ejemplos:

boolean resultado, existe, estaEncendido;   //declaraciones de variables locales
char nuevaLinea;
byte b;

public class claseX {
public static int contador = 0;      //ejemplo de declaración de variable de clase

private int codigo;                  //ejemplo de declaración de variables miembro.
private boolean hayExistencias;
...
}

Declarando variables de referencia

Pueden ser declaradas como variables de clase (static), como variables miembro o como variables locales.
Se pueden declarar en una misma linea varias variables del mismo tipo.

Ejemplos:

String nombre, direccion, provincia;    // declaración de variables de referencia locales
MiObjeto x;
Informe i;

public class Cliente{
public static Cuenta[] cuentasVIP = new Cuenta [100]; //declaración como variable de clase
private String nombre;               //declaración de variables de referencia como miembros
private Domicilio domicilioActual;
private Cuenta cuenta;
...
}

Variables Locales

Las variables que se definen dentro de un método se denominan locales, aunque algunas veces también reciben el nombre de variables temporales o de pila.

Es preciso inicializarlas antes de usarlas por primera vez, de lo contrario el compilador dará error.
Los parámetros de los métodos y los constructores también son variables locales, pero las inicializa el código de llamada.

Las variables locales se crean cuando el programa empieza a ejecutar el método y se destruyen cuando finaliza dicha ejecución.

Las variables que se definen dentro de los métodos de una clase son locales para ese método, por lo que es posible usar el mismo nombre de variable en distintas funciones miembro para hacer referencia a  distintas variables.

El único modificador que pueden usar las variables locales es static.

Variables Miembro y de Clase

Las variables de clase, marcadas con static, se crean cuando se carga la clase y siguen existiendo mientras ésta se mantenga cargada.
Las variables miembro existen mientras exista el objeto asociado.

Las variables de clase y variables miembro se inicializan automáticamente en el momento de crearse. Si el programador no asigna un valor predeterminado lo hará el compilador.

Las variables no locales (miembro y de clase) pueden utilizar los siguientes modificadores: public, protected, private, static, final, transient, volatile.

 
4 comentarios

Publicado por en 21 abril, 2011 en Estudio, Tema 1

 

Etiquetas: , , ,

Recopilación de exámenes de prueba

En este post voy a recopilar todos los exámenes de prueba que vaya encontrando por la red. Espero ir ampliando la lista.

  • CertPal, necesita registro. Tiene tres exámenes de prueba de SCJP 1.6. Se pueden realizar exámenes completos o por temas.
  • JavaPrepare. Dos exámenes SCJP 1.6. Examen 1, Examen 2. Preguntas por temas.
  • JavaCertifications.net. Examen de prueba. Preguntas por temas.
  • Exámenes de prueba de Marcus Green. Examen 1. Examen 2. Examen 3.
  • JavaChamp, necesita registro. Una vez registrado puedes hacer examenes, crear examenes, añadir preguntas…
    Aquí os dejo unas preguntas en pdf, SCJP, Collections, Hilos, pero para comprobar las soluciones hay que entrar en la web.
  • ScjpTest. Se pueden realizar tests y nos dirá nuestro porcentaje de aciertos. Si además nos registramos permite ver las soluciones y guarda el histórico de los tests que realizas.
    Permite personalizar el test eligiendo un tema concreto, el tiempo de duración del test y el porcentaje de aciertos para aprobar.
  • Whizlabs. Existe un examen de prueba para ver tu nivel, y luego existen varios por temas y finales gratis. También se pueden comprar otros.
 
13 comentarios

Publicado por en 19 abril, 2011 en Preguntas, Recursos

 

Etiquetas: , , ,

Deberes – Interfaces

Vamos a realizar los siguientes ejercicios:

  • Ejercicio 1: Crear una interface Heroe que contenga los métodos luchar, correr, salvar y disparar. Tendrá también un atributo, saludInicial. Crear una clase Batman que la concrete.
  • Ejercicio 2: Crear las siguientes interfaces hijas de Heroe:
  • HeroeVolador: con los métodos volar y aterrizar.
  • HeroeLlamas: con los métodos encenderse, apagarse, lanzarFuego.
  • HeroeIntangible: con los métodos volverseTangible, volverseIntangible.

Y las siguientes clases:

  • Spiderman, que implementa la interfaz Heroe.
  • Superman y Ironman,  que implementa la interfaz Heroe y HeroeVolador.
  • AntorchaHumana, que implementa la interfaz Heroe, HeroeVolador y HeroeLlamas.
  • GataSombra, que implementa la interfaz Heroe y HeroeIntangible.
  • LaVision, que implementa la interfaz Heroe, HeroeVolador y HeroeIntangible.

Para ver los ejercicios resueltos click en Leer más…

Read the rest of this entry »

 
3 comentarios

Publicado por en 18 abril, 2011 en Deberes

 

Etiquetas: , , ,

 
A %d blogueros les gusta esto: