Ejercicios-Propuestos1 java

Vista previa del material en texto

Ejercicios Propuestos Parte I - Unidad I
Investigar y presentar en un documento de Word las siguientes preguntas:
1. ¿Qué es?, ¿Cómo utilizar? y diferencias entre Scanner y/o BufferedReader en Java. Muestre Un ejemplo de cada una. 
2. Como se llama el modificador que se utiliza para declarar constantes en Java, de un ejemplo.
3. Realice un glosario con los siguientes términos: public, private, protected, package, sentencias Break, Continue y Return, bloque Try Catch Finally.
Realizar los siguientes ejercicios, utilizando como lenguaje JAVA:
1. Dado el valor del lado en un triángulo equilátero, realice un programa que permita obtener e imprimir el perímetro, el valor de la altura y el área del triángulo.
2. Realizar un programa que permita leer un número y obtenga e imprima su cuadrado y su cubo.
3. Una frutera ofrece las manzanas con descuentos según la siguiente tabla:
	N° Manzanas Compradas
	% Descuento
	0-2
	0%
	3-5
	10%
	6-10
	15%
	11 en Adelante
	20%
Determinar e imprimir ¿Cuánto pagara una persona que compre manzanas en la frutera?
4. Un proveedor de computadores ofrece descuento del 10%, si cuesta $1.000.000 o más. Además, independientemente, ofrece el 5% de descuento si la marca es ABACO. Determinar cuánto pagara, con IVA incluido, un cliente cualquiera por la compra de una computadora.
5. Cierta universidad tiene un programa para estimular a los estudiantes con buen rendimiento académico. 
	Promedio
	El alumno cursara
	Créditos
	Descuento
	>= 4.5
	Pregrado
	28
	25%
	>=4.0 y <4.5
	Pregrado
	25
	10%
	>=3.5 y < 4.0
	Pregrado
	20
	0%
	>=2.5 y < 3.5
	Pregrado
	15
	0%
	<2.5
	Pregrado
	No podrá Matricularse
	>=4.5
	Posgrado
	20
	20%
	<4.5
	Posgrado
	10
	0%
Realizar un programa que determine e imprima ¿cuánto debe pagar un estudiante? y ¿cuantos créditos registra? si el valor de cada crédito es de $50.000 para pregrado y de $300.000 para posgrado.
¿Qué es?, ¿Cómo utilizar? y diferencias entre Scanner y/o BufferedReader en Java. Muestre Un ejemplo de cada una. 
SOLUCIÓN
Clase Scanner en Java 
El uso de la clase Scanner es una de las mejores maneras de ingresar datos por teclado en Java.
Scanner es una clase en el paquete java.util utilizada para obtener la entrada de los tipos primitivos como int, doublé etc. y también String. Es la forma más fácil de leer datos en un programa Java, aunque no es muy eficiente si se quiere un método de entrada para escenarios donde el tiempo es una restricción, como en la programación competitiva.
En resumen:
· Para crear un objeto de clase Scanner, normalmente pasamos el objeto predefinido System.in, que representa el flujo de entrada estándar. Podemos pasar un objeto de clase File si queremos leer la entrada de un archivo.
· Para leer valores numéricos de un determinado tipo de datos XYZ, la función que se utilizará es nextXYZ(). Por ejemplo, para leer un valor de tipo short, podemos usar nextShort().
· Para leer cadenas (strings), usamos nextLine().
· Para leer un solo carácter, se usa next().charAt(0). La función next()devuelve el siguiente token/palabra en la entrada como cadena y la función charAt (0) devuelve el primer carácter de esa cadena.
Ejemplos con la clase Scanner
Echemos un vistazo al fragmento de código para leer datos de varios tipos de datos.
Ejemplo:
1. // Programa Java para leer datos de varios tipos usando la clase Scanner
2. import java.util.Scanner;
3. 
4. public class ScannerDemo
5. {
6. public static void main(String[] args)
7. {
8. // Declarar el objeto e inicializar con
9. // el objeto de entrada estándar predefinido
10. 
11. Scanner sc = new Scanner(System.in);
12. 
13. // entrada de una cadena
14. String name = sc.nextLine();
15. 
16. // entrada de un carácter
17. char gender = sc.next().charAt(0);
18. 
19. // Entrada de datos numéricos
20. // byte, short y float
21. int age = sc.nextInt();
22. long mobileNo = sc.nextLong();
23. double average = sc.nextDouble();
24. 
25. // Imprima los valores para verificar si la entrada
26. // fue obtenida correctamente.
27. System.out.println("Nombre: "+name);
28. System.out.println("Género: "+gender);
29. System.out.println("Edad: "+age);
30. System.out.println("Teléfono: "+mobileNo);
31. System.out.println("Promedio: "+average);
32. }
33. }
Entrada:
Alex
masculino
23
92578458
20
Salida:
Nombre: Alex
Género: m
Edad: 23
Teléfono: 92578458
Promedio: 20.0
Ejemplo con hasNextXYZ()
A veces, debemos verificar si el siguiente valor que leemos es de cierto tipo o si la entrada ha finalizado (se encontró el marcador EOF).
Luego, verificamos si la entrada del Scanner es del tipo que queremos con la ayuda de las funciones hasNextXYZ() donde XYZ es del tipo que nos interesa. La función devuelve true (verdadero) si el scanner tiene un token de ese tipo, de lo contrario es false (falso). Por ejemplo, en el siguiente código, hemos utilizado hasNextInt(). Para verificar una cadena, usamos hasNextLine(). De manera similar, para verificar si hay un solo carácter, usamos hasNext().CharAt(0).
Echemos un vistazo al fragmento de código para leer algunos números de la consola e imprimir su media.
Ejemplo:
1. // Programa Java para leer algunos valores usando la clase Scanner
2. // e imprimir su media
3. import java.util.Scanner;
4. 
5. public class ScannerDemo2
6. {
7. public static void main(String[] args)
8. {
9. // Declarar un objeto e inicializar con
10. // el objeto de entrada estándar predefinido
11. Scanner sc = new Scanner(System.in);
12. 
13. // Inicializar la suma y el recuento
14. // de los elementos de entrada
15. int sum = 0, count = 0;
16. 
17. // Compruebe si un valor int está disponible
18. while (sc.hasNextInt())
19. {
20. // Lee un valor int
21. int num = sc.nextInt();
22. sum += num;
23. count++;
24. }
25. int mean = sum / count;
26. System.out.println("La media es: " + mean);
27. }
28. }
Entrada:
1
2
3
4
5
6.0
Salida:
La media es: 3
¿Qué es BufferedReader en Java?
BufferedReader es una clase de Java para leer el texto de una secuencia de entrada (como un archivo) almacenando en el búfer caracteres que leen a la perfección caracteres, matrices o líneas.
En general, cada solicitud de lectura hecha de un Reader hace que se realice una solicitud de lectura correspondiente del carácter subyacente o secuencia de bytes.
Por lo tanto, es aconsejable incluir un BufferedReader en cualquier lector cuyas operaciones de lectura () puedan ser costosas, como java FileReaders y InputStreamReaders.
Utilizando la Clase Buffered Reader
Este es el método clásico de Java para leer datos de entrada, introducido en JDK 1.0. Este método se usa envolviendo System.in (flujo de entrada estándar) en un InputStreamReader que está envuelto en un BufferedReader, podemos leer la entrada del usuario en la línea de comando.
×Lo bueno: La entrada está almacenada temporalmente para una lectura eficiente.
×Lo malo: El código de envoltura es difícil de recordar.
Ejemplo:
1. // Programa Java para demostrar BufferedReader
2. import java.io.BufferedReader;
3. import java.io.IOException;
4. import java.io.InputStreamReader;
5. public class LecturaDatos 
6. {
7. public static void main(String[] args) throws IOException 
8. {
9. //Ingrese datos usando BufferReader
10. BufferedReader reader = 
11. new BufferedReader(new InputStreamReader(System.in));
12. 
13. // Leyendo datos usando readLine
14. String name = reader.readLine();
15. 
16. // Imprimir la línea de lectura
17. System.out.println(name); 
18. }
19. }
Entrada:
Javeros
Salida:
Javeros
×Nota: Para leer otros tipos, usamos funciones como Integer.parseInt(), Double.parseDouble(). Para leer valores múltiples, utilizamos split().
Como se llama el modificador que se utiliza para declarar constantes en Java, de un ejemplo.
SOLUCION
Palabra Clave “final” en Java
La palabra clave “final” se usa en diferentes contextos. En primer lugar, final es un modificador de no acceso aplicable solo a una variable, un método o una clase. A continuación, se muestran los contextos diferentes en los que se utiliza final
Table de Contenido
· 1. Variables con PalabraClave final
· 1.1. Inicializar una variable final
· 1.2. Cuándo usar una variable final
· 1.3. Variable final de referencia
· 1.4. Notas Importantes
· 2. Clases finales
· 3. Métodos finales
1. Variables con Palabra Clave final
Cuando una variable se declara con la palabra clave final, su valor no se puede modificar, esencialmente, es una constante. Esto también significa que debe inicializar una variable final.
Si la variable final es una referencia, esto significa que la variable no se puede volver a vincular para hacer referencia a otro objeto, pero el estado interno del objeto apuntado por esa variable de referencia se puede cambiar, es decir, puede agregar o eliminar elementos de la matriz final o colección final.
Es una buena práctica representar las variables finales en mayúsculas, utilizando guiones bajos para separar las palabras.
Ejemplos:
final int LIMITE=5;
final int LIMITE;
static final double PI = 3.141592653589793;
1.1. Inicializar una variable final
Debemos inicializar una variable final, de lo contrario el compilador emitirá un error en tiempo de compilación. Una variable final solo se puede inicializar una vez, ya sea a través de un inicializador o una declaración de asignación. Hay tres formas de inicializar una variable final:
1. Puede inicializar una variable final cuando se declara. Este enfoque es el más común. Una variable final se llama variable final en blanco si no se inicializa en la declaración.
2. Se puede inicializar una variable final en blanco dentro del bloque inicializador de instancias o dentro del constructor. Si tiene más de un constructor en tu clase, debe inicializarse en todos ellos, de lo contrario se generará un error de tiempo de compilación.
3. Una variable estática final en blanco se puede inicializar dentro de un bloque estático.
Veamos diferentes formas de inicializar una variable final a través de un ejemplo.
1. // Programa Java para demostrar diferentes formas 
2. // de inicializar una variable final
3. 
4. class JDC
5. {
6. // una variable final
7. // inicialización directa
8. final int LIMITE = 5;
9. 
10. // una variable final en blanco
11. final int CAPACIDAD;
12. 
13. // otra variable final en blanco
14. final int MINIMO;
15. 
16. // una variable static final PI
17. // inicialización directa
18. static final double PI = 3.141592653589793;
19. 
20. // una variable static final en blanco
21. static final double CONSTANTEEULER;
22. 
23. // bloque inicializador de instancias
24. // para inicializar CAPACIDAD
25. {
26. CAPACIDAD = 25;
27. }
28. 
29. // bloque inicializador static 
30. // para inicializar CONSTANTEEULER
31. static{
32. CONSTANTEEULER = 2.3;
33. }
34. 
35. // consctructor para inicializar MINIMO
36. // Tenga en cuenta que si hay más de un constructor, 
37. // debe inicializar MINIMO en ellos también
38. public JDC() 
39. {
40. MINIMO = -1;
41. }
42. 
43. }
1.2. Cuándo usar una variable final
La única diferencia entre una variable normal y una variable final es que podemos reasignar el valor a una variable normal, pero no podemos cambiar el valor de una variable final una vez asignada. Por lo tanto, las variables finales deben usarse solo para los valores que queremos que permanezcan constantes durante la ejecución del programa.
1.3. Variable final de referencia
Cuando una variable final es una referencia a un objeto, esta variable final se denomina variable final de referencia. Por ejemplo, una variable final de StringBuffer se parece a:
final StringBuffer cadena;
Como sabes, una variable final no se puede reasignar. Pero en el caso de una variable final de referencia, se puede cambiar el estado interno del objeto señalado por esa variable de referencia. Tenga en cuenta que esto no es una reasignación. Esta propiedad de final se llama no-transitividad. Para entender qué significa el estado interno del objeto, consulte el siguiente ejemplo:
1. //Programa Java para demostrar
2. // la variable final de referencia
3. class JDC {
4. public static void main(String[] args) {
5. //una variable final de referencia
6. final StringBuilder cadena=new StringBuilder("Java");
7. 
8. System.out.println(cadena);
9. 
10. //cambiando estado interno de referencia del objeto
11. //por variable de referencia final 'cadena'
12. 
13. cadena.append("desdeCero");
14. System.out.println(cadena);
15. }
16. }
Salida:
Java
JavadesdeCero
La propiedad no-transitividad también se aplica a las matrices, porque las matrices son objetos en Java. Las matrices con palabra clave final también se llaman matrices finales.
1.4. Notas Importantes
· Como se discutió anteriormente, una variable final no se puede reasignar, y arrojará un error en tiempo de compilación.
1. //Programa Java para demostrar
2. //que la reasignación de la variable final
3. //lanzará un error en tiempo de compilación
4. class JDC {
5. static final int CAPACIDAD=4;
6. 
7. public static void main(String[] args) {
8. //reasignando variable final
9. CAPACIDAD=5;
10. }
11. }
Salida:
Compiler Error: cannot assign a value to final variable CAPACIDAD
· Cuando se crea una variable final dentro de un método/constructor/bloque, se denomina variable final local, y debe inicializarse una vez donde se crea. Ver a continuación el programa para la variable final local:
1. //Programa Java para demostrar
2. //una variable local final
3. class JDC {
4. public static void main(String[] args) {
5. //variable local final
6. final int i;
7. i=20;
8. System.out.println(i);
9. }
10. }
Salida:
20
· Tenga en cuenta la diferencia entre las variables const de C++ y las variables final de Java. Las variables const en C++ deben tener un valor cuando se declaran. Para las variables final en Java, no es necesario como vemos en los ejemplos anteriores. A una variable final se le puede asignar valor más adelante, pero solo una vez.
· final dentro del bucle for-each: la declaración final en for-each es una declaración legal.
1. //Programa Java para demostrar
2. //final con for-each
3. class JDC {
4. public static void main(String[] args) {
5. int arr[]={1,2,3};
6. //final con sentencia for-each
7. for (final int i:arr)
8. System.out.println(i+"");
9. }
10. }
Salida:
1
2
3
×Explicación: Dado que la variable i está fuera del alcance de cada iteración del bucle, en realidad se vuelve a declarar cada iteración, lo que permite utilizar el mismo símbolo (es decir, i) para representar múltiples variables.
2. Clases finales
Cuando una clase se declara con la palabra clave final, se denomina clase final. Una clase final no se puede extender (heredar). Hay dos usos de una clase final:
· Una es definitivamente evitar la herencia, ya que las clases finales no se pueden extender. Por ejemplo, todas las clases Wrapper como Integer, Float, etc. son clases finales. No podemos extenderlos.
1. final class A
2. {
3. // métodos y campos
4. }
5. // La siguiente clase es ilegal.
6. class B extends A 
7. { 
8. // COMPILACIÓN-ERROR!
9. }
· El otro uso de final con clases es crear una clase inmutable como la clase String predefinida. No puede hacer que una clase sea inmutable sin que sea definitiva.
3. Métodos finales
Cuando se declara un método con la palabra clave final, se denomina método final. Un método final no puede ser anulado. La clase Object hace esto: varios de sus métodos son FINALES. Debemos declarar los métodos con la palabra clave final para la cual necesitamos seguir la misma implementación en todas las clases derivadas. El siguiente fragmento ilustra la palabra clave final con un método:
1. class A 
2. {
3. final void m1() 
4. {
5. System.out.println("Este es un método final.");
6. }
7. }
8. 
9. class B extends A 
10. {
11. void m1()
12. { 
13. // COMPILACIÓN-ERROR! 
14. System.out.println("Ilegal!");
15. }
16. }
Realice un glosario con los siguientes términos: public, private, protected, package, sentencias Break, Continue y Return, bloque Try Catch Finally
SOLUCION
GLOSARIO
PUBLIC:  Es el modificador de acceso del método. Pueden ser public (cualquier clase en cualquier paquete puede acceder al método). Este nivel de acceso permite a accederal elemento desde cualquier clase, independientemente de que esta pertenezca o no al paquete en que se encuentra el elemento.
PRIVATE: Es el modificador más restrictivo y especifica que los elementos que lo utilizan sólo pueden ser accedidos desde la misma clase en la que se encuentran. Este modificador sólo puede utilizarse sobre los miembros de una clase y sobre interfaces y clases internas, no sobre clases o interfaces de primer nivel, dado que esto no tendría sentido.
PROTECTED: Indica que los elementos sólo pueden ser accedidos desde su mismo paquete y desde cualquier clase que extienda la clase en que se encuentra, independientemente de si esta se encuentra en el mismo paquete o no. Este modificador, como private, no tiene sentido a nivel de clases o interfaces no internas.
En otras palabras, si determinada clase Hijo hereda el comportamiento de una clase Padre, la clase Hijo tendrá acceso a todos aquellos campos/métodos definidos como protected en Padre, pero no aquellos declarados como private en Padre.
PACKAGE: Los paquetes son el mecanismo que usa Java para facilitar la modularidad del código. Un paquete puede contener una o más definiciones de interfaces y clases, distribuyéndose habitualmente como un archivo. Para utilizar los elementos de un paquete es necesario importar este en el módulo de código en curso, usando para ello la sentencia import.
La funcionalidad de una aplicación Java se implementa habitualmente en múltiples clases, entre las que suelen existir distintas relaciones. Las clases se agrupan en unidades de un nivel superior, los paquetes, que actúan como ámbitos de contención de tipos. Cada módulo de código establece, mediante la palabra clave package al inicio, a qué paquete pertenece. Como ya sabrás, con la cláusula import cualquier módulo de código puede hacer referencia a tipos definidos en otros paquetes.
BREAK: La sentencia break puede encontrarse en sentencias switch o en bucles. Al ejecutarse, deja el ámbito de la sentencia en la que se encuentra y pasa a la siguiente sentencia. Puede emplearse con etiquetas, especificando sobre qué sentencia se aplica si hay varias anidadas.
CONTINUE: La sentencia continue se emplea sólo en bucles. Al ejecutarse la iteración en la que se encuentra, el bucle finaliza y se inicia la siguiente. También puede emplearse con etiquetas, especificando sobre que sentencia se aplica si hay varias anidadas. 
RETURN: La sentencia return se emplea para salir de la secuencia de ejecución de las sentencias de un método y, opcionalmente, devolver un valor. Tras la salida del método se vuelve a la secuencia de ejecución del programa al lugar de llamada de dicho método.
 BLOQUE TRY: En el bloque try se encuentran las instrucciones que pueden lanzar una excepción.
Solamente se pueden capturar las excepciones lanzadas dentro de un bloque try.
Una excepción se puede lanzar de forma automática o mediante la palabra reservada throw.
Cuando se lanza la excepción se transfiere la ejecución del programa desde el punto donde se lanza la excepción a otro punto donde se captura la excepción.
BLOQUE CATCH: Es el bloque de código donde se captura la excepción. El bloque catch es el manejador o handler de la excepción. Aquí se decide qué hacer con la excepción capturada. Puede haber varios bloques catch relacionados con un bloque try.
Una vez finalizado un bloque catch la ejecución no vuelve al punto donde se lanzó la excepción. La ejecución continúa por la primera instrucción a continuación de los bloques catch.
BLOQUE FINALLY: Es opcional.
Debe aparecer a continuación de los bloques catch.
También puede aparecer a continuación de un bloque try si no hay bloques catch.
La ejecución de sus instrucciones queda garantizada independientemente de que el bloque try acabe o no su ejecución incluso en estos casos:
· Aunque el bloque try tenga una sentencia return, continue o break, se ejecutará el bloque finally
· Cuando se haya lanzado una excepción que ha sido capturada por un bloque catch. El finally se ejecuta después del catch correspondiente.
· Si se ha lanzado una excepción que no ha sido capturada, se ejecuta el finally antes de acabar el programa.
Un bloque finally se usa para dejar un estado consistente después de ejecutar el bloque try.
Un ejemplo de uso de bloques finally puede ser cuando estamos tratando con ficheros y se produce una excepción. Podemos escribir un bloque finally para cerrar el fichero. Este bloque se ejecutará siempre y se liberarán los recursos ocupados por el fichero.