Embed Size (px)
Citation preview
Rafael García Maliga | 1º DAW | September 27, 2012
Listado de ejercicios JAVA BÁSICO
PAGE 1
1. Los tipos de datos “primitivos” tienen un tratamiento especial, ya que no son objetos (no
se crean con new) y se usan frecuentemente en los programas. La razón para el
tratamiento especial es que crear un objeto con new -especialmente variables pequeñas y
simples- no es eficiente porque new coloca el objeto en el montículo (trozo de memoria
RAM). Para estos tipos, Java crea una variable "automática" que no es una referencia. La
variable guarda el valor, y se coloca en la pila (otro trozo de memoria RAM más rápida y
eficiente) para que sea más eficiente. Java determina el tamaño de cada tipo primitivo.
Estos tamaños no varían de una plataforma a otra Indica los bits (no bytes) que ocupan y
rango de valores posibles.
Tipo de variable Bytes que ocupa Rango de valores
boolean 2 true, false
byte 1 -128 a 127
short 2 -32.768 a 32.767
int 4 -2.147.483.648 a 2.147.483.649
long 8 -9 · 1018 a 9 · 1018
double 8 -1,79 · 10308 a 1,79 · 10308
float 4 -3,4 · 1038 a 3,4 · 1038
char 2 Caracteres (en Unicode)
2. Crea la clase EjemploListaAnidada que muestre la siguiente salida. Para ello utiliza el
método System.out.print() con los caracteres \n y \t
Código:
/**
Crea la clase EjemploListaAnidada que muestre la siguiente salida. Para
ello utiliza el
método System.out.print() con los caracteres \n y \t
* @author Rafael García Maliga
* @version 0.1
*/
public class EjemploListaAnidada {
public static void main (String[] args) {
System.out.print("Ejemplo de lista anidad en HTML: ");
System.out.print("\n\t<ul>\n\t\t<li>\n\t\t<li>\n\t\t<li>\n\t\t\t<ul>\n\
t\t\t\t<li>\n\t\t\t\t<li>\n\t\t\t\t<li>\n\t\t\t<\\ul>\n\t<\\ul>\n");
}
}
Resultado:
PAGE 2
3. Crea la clase TablaAbecedarioMinusculas que muestre la siguiente salida. Para ello
utiliza el método System.out.print() con los caracteres \n y \t. Utiliza una variable char
con el código Unicode para mostrar la letra ñ. (no uses \udddd).
Código:
/**
Crea la clase TablaAbecedarioMinusculas que muestre la siguiente
salida. Para ello
utiliza el método System.out.print() con los caracteres \n y \t.
Utiliza una variable char
con el código Unicode para mostrar la letra ñ. (no uses \udddd)
* @author Rafael García Maliga
* @version 0.1
*/
public class TablaAbecedarioMinusculas {
public static void main (String[] args) {
char ene = 241; // Caracter ñ en unicode (\u00f1)
int contador = 0;
//Imprimir en pantalla el abecedario
System.out.print("Esto es una tabla con el abecedario en
minúsculas: \n");
//Arreglo que contiene el abecedario
String abecedario[] =
{"a","b","c","d","e","f","g","h","i","j","k","l","m","n",""+ene,"o","p"
,"q","r","s","t","u","v","w","x","y","z",""};
for (int ln=0; ln<=6; ++ln){
for (int i=0; i<=3; ++i){
System.out.print("\t"+abecedario[i+contador]);
}
contador=contador+4;
System.out.print("\n"); //Salto de linea
}
}
}
Resultado:
PAGE 3
4. Crea la clase CaracteresEspagnoles que muestre la siguiente salida. Para ello utiliza el
método System.out.print() con los caracteres \n y \t. Utiliza el formato de carácter
\udddd .
Código:
/**
Crea la clase CaracteresEspagnoles que muestre la siguiente salida.
Para ello utiliza el
método System.out.print() con los caracteres \n y \t. Utiliza el
formato de carácter
\udddd
* @author Rafael García Maliga
* @version 0.1
*/
public class CaracteresEspagnoles {
public static void main (String[] args) {
System.out.print("Esto carácteres son muy nuestros: \n");
System.out.print("\t\u00e1\t\u00ed\t\u00f3\t\u00fa\t\u00f1\t\u00d1\t\u0
0aa\t\u00ba\n");
}
}
Resultado:
5. Crea la siguiente clase y justifica los resultados.
Código:
/**
Crea la siguiente clase y justifica los resultados.
PAGE 4
* @author Rafael García Maliga
* @version 0.1
*/
public class ConversionExplicitaExtensora {
public static void main (String[] args) {
byte b1=100, b2=100, b3;
//Conversión explícita
b3= (byte) (b1*b2*b1/100);
System.out.println("Con conversión Explícita: " + b3);
//Conversión extensora
int n;
n= b1*b2*b1/100;
System.out.println("Con conversión Extensora: " + n);
}
}
Resultado:
El resultado correcto de la operación es 10000. El primer resultado que nos arroja es incorrecto ya
que hacemos uso de una variable tipo “byte” (1 byte), y al ser el resultado de la operación un
número superior a 127 este no puede ser representado, sin embargo en la segunda solución es
correcta porque estamos haciendo uso de una variable de tipo “int” (32byte) que permite valores
desde -2.147.483.648 hasta 2.147.483.649.
6. Crea la siguiente clase y justifica por qué el sufijo float (f ó F) es necesario:
Código:
/**
Crea la siguiente clase y justifica por qué el sufijo float (f ó F) es
necesario:
* @author Rafael García Maliga
* @version 0.1
*/
public class PotenciaConversion {
public static void main (String[] args) {
float f = 1e-39f;
double d = 1e-39;
System.out.println("float: " + f);
System.out.println("double: " + d);
}
PAGE 5
}
Resultado:
El sufijo es necesario puesto que si no lo incluimos java lo considera por defecto de tipo “double” en
lugar de un valor float.
7. Crea la clase EsconditeConfuso con las siguientes sentencias. Interprétalas y
coméntalas en el código.
Código:
/**
Crea la clase EsconditeConfuso con las siguientes sentencias.
Interprétalas y coméntalas en el código
* @author Rafael García Maliga
* @version 0.1
*/
public class EsconditeConfuso {
public static void main (String[] args) {
int x = 17; //Se declara e inicializa la variable
{
int x = 77; /*Se vuelve a declarar y se le asigna un nuevo
valor.
Esto es incorrecto puesto que ya la habíamos declarado. Por tanto o
bien le cambiamos el nombre de la variable (nueva variable) o
eliminamos la declaración (int).
*/
}
}
}
Resultado:
PAGE 6
8. Indica si es verdadero o falso:
a. El tamaño del tipo boolean no está explícitamente definido; sólo se especifica que debe
ser capaz de tomar los valores true o false.
Verdadero
b. Todos los tipos numéricos tienen signo, de forma que es inútil tratar de utilizar tipos sin
signo.
Verdadero (Permiten el uso de signos + y – según se requiera).
c. El ámbito determina tanto la visibilidad como la vida de los nombres definidos dentro.
Se delimita mediante corchetes [].
Falso (Se limita mediante claves {}).
d. La asignación de una variable dentro de un ámbito se mantiene fuera del ámbito.
Falso (Se mantiene en el ámbito al cual pertenece).
e. Una variable definida dentro de un ámbito está disponible también fuera de su ámbito.
Falso (Solo está disponible dentro de su ámbito).
f. Java permite convertir (casting) cualquier tipo primitivo en cualquier otro tipo, excepto
boolean, que no permite ninguna conversión.
Verdadero
g. Java convierte automáticamente un tipo de datos en otro cuando sea adecuado (de int a
float, p.ej.).
PAGE 7
Verdadero (si es de menor a mayor).
h. Con las conversiones reductoras (de float a int, p.ej.) nunca se corre el riesgo de perder
información.
Falso (Se perderían los decimales).
i. Hay representación literal de números binarios en Java.
Falso
j. Los sufijos de double, float y long pueden aparecer tanto en mayúsculas como en
minúsculas: 0d, 0D, 0f, 0F, 0l, 0L.
Verdadero
k. El prefijo hexadecimal 0x siempre ha de ir en minúsculas.
Falso (puede ir en ambas).
9. Si se asigna un valor a una variable fuera de rango (mayor de lo establecido), ¿qué
ocurre? ¿Existe alguna manera de resolverlo? Demuéstralo mediante un ejemplo.
(VariableFueraDeRango).
Produciría un error en el resultado, puesto que es incapaz de representar dicho valor.
Código:
/**
Si se asigna un valor a una variable fuera de rango (mayor de lo
establecido), ¿qué ocurre? ¿Existe alguna manera de resolverlo?
Demuéstralo mediante un ejemplo. (VariableFueraDeRango)
* @author Rafael García Maliga
* @version 0.1
*/
public class VariableFueraDeRango {
public static void main (String[] args) {
{
int i = 1500;
byte b = (byte) i; //realizamos la conversión (cast)
System.out.println("Valor dentro de rango (int)" + i);
//mostramos el valor de i (int)
System.out.println("Valor fuera de rango (byte)" + b);
//mostramos el valor de b (byte)
}
}
}
Resultado:
PAGE 8
10. Crea una clase AsignacionVariables con el siguiente código. Corrígela si es necesario y
coméntala en el mismo código fuente, indicando errores y valores de variables.
Código:
/**
Crea una clase AsignacionVariables con el siguiente código. Corrígela
si es necesario y coméntala en el mismo código fuente, indicando
errores y valores de variables.
* @author Rafael García Maliga
* @version 0.1
*/
public class AsignacionVariables {
public static void main (String[] args) {
{
int i; //La variable no ha sido inicializada
/*
Para solucionar el error debemos de asignarle un
valor a la variable i
*/
i= 22; /* Le asignamos un valor dentro del rango
dentro del rango byte para que no produzca error
al realizar la conversión de tipo integer a byte.*/
byte b = (byte) i; //realizamos la conversión (cast)
System.out.println(i); //mostramos el valor de i (int)
System.out.println(b); //mostramos el valor de b (byte)
}
}
}
Resultado:
PAGE 9
11. Como veremos más adelante, para garantizar que un objeto ha sido inicializado existen
los constructores. ¿Existe algún problema si se intenta acceder al valor de una variable y
ésta no ha sido inicializada?
Si, en java es necesario inicializar las variables antes de ser usada. Si esta está declarada pero no
inicializada producirá un error en el código puesto que no posee ningún valor.
12. ¿Qué tipo de problema puede existir con la asignación de variables?
Que produzca un error al asignarle valores que estén fuera de su rango, por tanto hay que tener
muy en cuenta que tipo de valores va a ser necesario manejar y elegir un tipo en consecuencia.
