Check the new version here

Popular channels

Curso de Java para Android (Para fines Educativos) [CLASE 8]



Hola gente linda, tantos días sin colgar algo del curso que estábamos por la clase 7. Bueno hoy casualmente me acordé de Uds y me decidí a colgarles otro Post. Veamos:




CLASE 8: ELEMENTOS DEL LENGUAJE JAVA

8.1 ¿QUÉ SON LOS OBJETOS?
En informática, un objeto es un conjunto de variables y de los métodos relacionados con esas variables.
Un poco más sencillo: un objeto contiene en sí mismo la información y los métodos o funciones necesarios para manipular esa información
Lo más importante de los objetos es que permiten tener un control total sobre 'quien' o 'que' puede acceder a sus miembros, es decir, los objetos pueden tener miembros públicos a los que podrán acceder otros objetos o miembros privados a los que solo puede acceder él. Estos miembros pueden set tanto variables como funciones.
El gran beneficio de todo esto es la encapsulación, el código fuente de un objeto puede escribirse y mantenerse de forma independiente a los otros objetos contenidos en la aplicación.

8.2 LAS CLASES
Una clase es un proyecto, o prototipo, que define las variables y los métodos comunes a un cierto tipo de objetos.
Un poco más sencillo: las clases son las matrices de las que luego se pueden crear múltiples objetos del mismo tipo.
La clase define las variables y los métodos comunes a los objetos de ese tipo, pero luego, cada objeto tendrá sus propios valores y compartirán las mismas funciones.
Primero deberemos crear una clase antes de poder crear objetos o ejemplares de esa clase.
Veremos en la figura para tener una mejor idea:



En este ejemplo hemos considerado que el problema consta de tres tipos de vehículo: taxi, autobús y tranvía, y que esos tipos los denominamos clases. ¿Qué haríamos en Java para definir una clase? Indicar sus propiedades y operaciones (métodos) disponibles, por ejemplo:



Las partes habituales las identificaremos ene le siguiente esquema:


8.3 MODIFICADORES DE ACCESO
Los modificadores son elementos del lenguaje que se colocan delante de la definición de variables locales, datos miembro, métodos o clases y que alteran o condicionan el significado del elemento estos permiten al diseñador de clases delimitar la frontera entre lo que es accesible para los usuarios de la clase, lo que es estrictamente privado y 'no importa' a nadie más que al diseñador de la clase e incluso lo que podría llegar a importar a otros diseñadores de clases que quisieran alterar, completar o especializar el comportamiento de la clase.

Con el uso de estos modificadores se consigue uno de los principios básicos de la Programación Orientada a Objetos, que es la encapsulación: Las clases tienen un comportamiento definido para quienes las usan conformado por los elementos que tienen un acceso público, y una implementación oculta formada por los elementos privados, de la que no tienen que preocuparse los usuarios de la clase.
Los otros dos modificadores, protected y el acceso por defecto (package) complementan a los otros dos. El primero es muy importante cuando se utilizan relaciones de herencia entre las clases y el segundo establece relaciones de 'confianza' entre clases afines dentro del mismo package. Así, la pertenencia de las clases a un mismo package es algo más que una clasificación de clases por cuestiones de orden.
Cuando se diseñan clases, es importante pararse a pensar en términos de quien debe tener acceso a qué. Qué cosas son parte de la implantación y deberían ocultarse (y en qué grado) y que cosas forman parte de la interface y deberían ser públicas.
Existen los siguientes modificadores de acceso:

•public - Todo el mundo puede acceder al elemento. Si es un dato miembro, todo el mundo puede ver el elemento, es decir, usarlo y asignarlo. Si es un método todo el mundo puede invocarlo.
•private - Sólo se puede acceder al elemento desde métodos de la clase, o sólo puede invocarse el método desde otro método de la clase.
•protected - Sólo pueden obtener acceso al tipo o miembro código de la misma clase o estructura o de una clase derivada
•sin modificador - Se puede acceder al elemento desde cualquier clase del package donde se define la clase.
Los modificadores de acceso preceden a la declaración de un elemento de la clase (ya sea dato o método), de la siguiente forma:

[modificadores] tipo_variable nombre;
[modificadores] tipo_devuelto nombre_Metodo ( lista_Argumentos );


8.4 CUESTIONES A TENER EN CUENTA

1. Un objeto es una cosa distinta a un tipo primitivo, aunque “porten” la misma información.
Tener siempre presente que los objetos en Java tienen un tipo de tratamiento y los tipos primitivos, otro. Que en un momento dado contengan la misma información no significa en ningún caso que sea lo mismo. Iremos viendo las diferencias entre ambos poco a poco. De momento, recuerda que el tipo primitivo es algo elemental y el objeto algo complejo. Supón una cesta de manzanas en la calle: algo elemental. Suponemos una cesta de manzanas dentro de una nave espacial (considerando el conjunto nave + cesta): algo complejo. La información que portan puede ser la misma, pero no son lo mismo.
2. ¿Para qué tener esa aparente duplicidad entre tipos primitivos y tipos envoltorio?
Esto es una cuestión que atañe a la concepción del lenguaje de programación. Tener en cuenta una cosa: un tipo primitivo es un dato elemental y carece de métodos, mientras que un objeto es una entidad compleja y dispone de métodos. Por otro lado, de acuerdo con la especificación de Java, es posible que necesitemos utilizar dentro de un programa un objeto que “porte” como contenido un número entero. Desde el momento en que sea necesario un objeto habremos de pensar en un envoltorio, por ejemplo Integer. Inicialmente nos puede costar un poco distinguir cuándo usar un tipo primitivo y cuándo un envoltorio en situaciones en las que ambos sean válidos. Seguiremos esta regla: usaremos por norma general tipos primitivos. Cuando para la estructura de datos o el proceso a realizar sea necesario un objeto, usaremos un envoltorio.
3. Los nombres de tipos primitivos y envoltorio se parecen mucho.
En realidad, excepto entre int e Integer y char y Character, la diferencia se limita a que en un caso la inicial es minúscula (por ejemplo double) y en el otro es mayúscula (Double). Esa similitud puede confundirnos inicialmente, pero hemos de tener muy claro qué es cada tipo y cuándo utilizar cada tipo.
4. Una cadena de caracteres es un objeto.
El tipo String en Java nos permite crear objetos que contienen texto (palabras, frases, etc.). El texto debe ir siempre entre comillas. Muchas veces se cree erróneamente que el tipo String es un tipo primitivo por analogía con otros lenguajes donde String funciona como una variable elemental. En Java no es así.
5. Hay distintos tipos primitivos enteros. ¿Cuál usar?
Por norma general usaremos el tipo int. Para casos en los que el entero pueda ser muy grande usaremos el tipo long. Los tipos byte y short los usaremos cuando tengamos un mayor dominio del lenguaje.
6. ¿Cuántos tipos de la biblioteca estándar de Java hay?
Cientos o miles. Es imposible conocerlos todos.
7. ¿Un array es un objeto?
Los arrays los consideraremos objetos especiales, los únicos objetos en Java que carecen de métodos.


8.5 DECLARACIÓN E INICIALIZACIÓN DE VARIABLES
Vamos a ver ejemplos de uso de tipos de datos en Java. Para ello nos valdremos primeramente de algunos tipos primitivos usados habitualmente como son int (entero), String (cadena de caracteres), boolean (valor booleano verdadero o falso), float (decimal simple), etc.
Aquí mostramos ejemplos de uso de tipos de datos en Java:

public class ejemploVariables {
private int precio; // Las instrucciones y declaraciones finalizan con ;
private int importe_acumulado;
private String profesor;
private String aula;
private int capacidad;
private boolean funciona;
private boolean esVisible;
private float diametro;
private float peso;
private short edad;
private long masa;
private char letra1;
}


La palabra clave private es un indicador de en qué ámbito del programa va a estar disponible la variable. Supongamos que el programa es un edificio con gente trabajando y que hay elementos en el edificio, por ejemplo una impresora, que pueden tener un uso: individual para una persona, colectivo para un grupo de personas, colectivo para todas las personas de una planta, colectivo para todas las personas de un departamento aunque estén en varias plantas, o colectivo para todo el edificio. Pues bien, las variables en Java van a quedar disponibles para su uso en ciertas partes del programa según especifiquemos con las palabras clave public, private, protected, package, etc. Lo veremos más adelante, ahora simplemente nos interesa ver cómo declarar variables y usaremos de forma preferente la palabra clave private.

El hecho de declarar una variable implica que se reserva un espacio de memoria para ella, pero no que ese espacio de memoria esté ocupado aunque pueda tener un contenido por defecto. Ten en cuenta que en Java no puedes aplicar algunas normas que rigen en otros lenguajes, como que al declarar una variable entera ésta contendrá por defecto el valor cero. En Java esta situación puede dar lugar a errores de compilación: una variable entera no debemos suponer que contenga nada. Para que contenga algo debemos asignarle un contenido. Veamos ejemplos de asignación de contenido:

Precio = 42; // Entero tipo int. Un número sin punto decimal se interpreta normalmente como int.

importe_acumulado = 210; // Entero tipo int

profesor = “Juan Pérez”; // Tipo String

aula = “A-44”; // Tipo String

capacidad = 1500; // Entero tipo int

funciona = true; // Tipo boolean

esVisible = false; // Tipo boolean

diametro = 34.25f; // Tipo float. Una f o F final indica que es float.

peso = 82.77; // Tipo double. Un número con punto decimal se interpreta normalmente como double.

edad = 19; // Entero tipo short

masa = 178823411L; // Entero tipo long. Una l o L final indica que es long.

letra1 = ‘h’; // Tipo char (carácter). Se escribe entre comillas simples.


Hemos planteado la declaración de variables en primer lugar y la asignación de contenido en segundo lugar y por separado porque será una forma habitual de trabajar en Java.



Esto no significa que en determinadas ocasiones no podamos declarar e inicializar (asignar contenido) simultáneamente. Por ejemplo: int edad = 19; será una expresión válida y que utilizaremos en determinadas ocasiones, según iremos viendo.

LA INICIALIZACIÓN
Es un paso importante de cara a permitir un uso seguro de una variable. Es tan importante, que en general plantearemos que se haga como paso previo a cualquier otra cosa. Por ejemplo, si pensamos utilizar una variable denominada precio lo primero que haremos será establecer un valor de precio o, si no lo conocemos o lo vamos a establecer más adelante, estableceremos explícitamente un valor por defecto: por ejemplo precio = - 99; ó precio = 0;. Utilizar una variable sin haberla inicializado es una práctica no recomendada en Java (mal estilo de programación) que puede dar lugar a errores o al mal funcionamiento de los programas.

8.6 LOOPS

Continuando con la clase 7 -estructuras de repetición- veremos un poco a mayor detalle de lo que suceden con los loops. A continuación un ejemplo, con algunas variantes:

import java.util.Scanner;
import java.util.Random;

public class juego {


public static void main(String[] args) {

Scanner miScanner =new Scanner(System.in);
int numIntentos = 0;
int numAleatorio = new Random().nextInt(10)+1;
System.out.println("******* *******" );
System.out.println("¡¡¡ Bienvenido al juego "Acertá el número y ganá YA"!!! " );
System.out.println("******* *******" );
System.out.println();
System.out.print("Escribe un número del 1 al 10: " );
int numEscrito = miScanner.nextInt();
numIntentos++;

while (numEscrito !=numAleatorio){
System.out.println();
System.out.println("Intentálo de nuevo . . . " );
System.out.println("Escribe un número del 1 al 10; " );
numEscrito = miScanner.nextInt();
numIntentos++;
}
System.out.print( "Has ganado después de " );
System.out.println( numIntentos + " intentos " );


}

}



Explicaremos lo que significan algunas de las novedades en este código;

1.En la primera parte importamos algunas de las clases para que Java trabaje, por ejemplo: Random, permite que Java realice el número aleatorio, Scanner, hace que podamos ingresar valores a través de la consola.
2.Posteriormente habrá un mensaje de Bienvenida al juego y una invitación a escribir un número para ser comparado con el aleatorio, previamente ya calculado por el programa.
3.Además de ir comparando los números (el ingresado y el aleatorio) el programa va agregando en 1 el número de intentos en la variable (numIntentos) para ello hemos puesto numIntentos++
4.Cuando llegamos a la parte de While, el programa hace una comparación del número ingresado y si es el mismo al aleatorio, el mismo terminará, caso contrario seguirá el bucle hasta que logremos acertar..
5.Al final, nos saldrá en pantalla que hemos ganado y el número de intentos realizados.
6.Como ejercicio adicional, intentemos que el programa a la vez que nos indica que no hemos acertado, que también nos indique cuantos en qué nro. intentos vamos.
7.Podríamos asimismo hacer que el programa pida los números y nos responda a través de cuadros de diálogo, con métodos antes vistos.

Veremos ahora un ejemplo con el loop for, para desglosar su estructura:

public class multiplo7 {

public static void main(String[] args) {

for (int x=1; x<=200; x++){
int multiplo = 7*x;
System.out.println( multiplo + " " );

}
}

}


Entonces le damos un valor inicial de 1, la condición a cumplir es que busque 200 o menos números y el actualizador que irá aumentando el valor en 1 del valor inicial.
Dentro de la condición entre llaves {} le hemos puesto un parámetro para que busque sólo a múltiples de 7.

Loop Do… While
Veremos un claro ejemplo en donde se ven si cumple una condición, que haga una cosa, hasta que… Si no que haga lo otro:

import java.io.File;
import java.util.Scanner;
public class hacerMientras {

public static void main(String[] args) {
File archivo = new File ( "C:CarpetamiArchivo.txt" ) ;
Scanner miScanner = new Scanner (System.in);
char replica;
do {
System.out.println( "¿Borrar Archivo? (s/n) " );
replica =miScanner.findWithinHorizon (".",0).charAt(0);}
while (replica != 's' && replica != 'n' && replica != 'S' && replica != 'N' );
if (replica == 's' || replica == 'S'){
System.out.println("OK, borrando archivo . . . " );
archivo.delete();}
else {
System.out.println( "OK, confirmado NO BORRAR." );


}

}
}


Analizaremos paso a paso lo que hizo el código:

1.Importamos una clase (java.io.File), la que nos traerá al programa un archivo que exista en la computadora.
2.La fila: File archivo = new File ("C:CarpetamiArchivo.txt"; ), nos indica la ruta en donde está el archivo a tratar.
3.En: while ( eplica != 's' && replica != 'n' );si la variable es distinta de… Y ( &&; ) distinta de… y vuelve a comprobar y vuelve a ejecutar el do.
4.En caso que a respuesta sea: s o n, entonces se mete al if. Ahí realizará según sea la respuesta del usuario.
5.Luego hemos modificado el código del original, agregándoles que también tome las respuestas en S o N. Veremos que agregamos && y dentro del if un ||

USO DE BREAK Y CONTINUE

Podemos usar ciertas declaraciones para modificar el flujo de un loop, a decir;
Hacemos una declaración break cuando queremos cortar un loop a pesar que no ha terminado.
Veamos el siguiente código y lo desglosaremos:

public class salirLoop {

public static void main(String[] args) {
int index = 0;
while (index <=1000){
index =index + 5;
System.out.println (index);
if (index == 400){
System.out.println ( "index=400. Saliendo . . . " );
break;
}
}
}

}



Cuando el index llega a 400 el loop se va cortar, aun cuando en principio debería continuar. Esto lo realiza la declaración break.
Ahora, otra declaración es el uso de continue; que hace que el loop se salga de la iteración que está haciendo y vuelva al inicio. Veremos con un ejemplo:

public class continueLoop {

public static void main(String[] args) {
int index = 0;
while (index <=1000){
index =index + 5;
System.out.println (index);
if (index == 400)
continue;
System.out.println ("el index es " + index);
}

}

}


Vemos en la consola, que cuando llega a 400, lo salta y continúa con el resto del index:



ANIDAMIENTOS DENTRO DE UN LOOP

Veamos el siguiente ejemplo, como dentro de un loop hemos anidado más loops. Cuando ejecutamos el programa, nunca va salir del loop (loop infinito), por lo tanto se imprimirá el mensaje siempre:

public class anidarLoop {

public static void main(String[] args) {
int points = 0;
int target = 100;
while (target <=100){
for (int i = 0; i < target; i++){
if (points > 50){

System.out.println ( "Saliendo del loop for" );

break;}
points = points + 1;
}
}
}
}



Para solucionar este loop infinito, lo que deberíamos hacer es darle nombres, como veremos en el código siguiente:




VARIAS INICIALIZACIONES

Podemos hacer loops más complejos con más de una inicialización y más de una variable; para verlo mejor en el siguiente ejemplo:

public class masComplejos {


public static void main(String[] args) {
int i,j;
for (i=0,j=0;i*j<1000;i++,j+=2){
System.out.println(i + " * " + j + " = " + (i*j));
}
}

}


Desmenuzando el código, sería:
1.Dentro del bucle for, tenemos dos variables a la que hemos asignado valores iniciales,, luego que se produzca un producto entre ambos (<100o) y además que i aumente en 1 y j aumente en 2.
2.Finalmente nos imprime la multiplicación de i*j.
3.Termina en 22 * 44 = 968, pues después nos dará: 1058.

Ejemplo de loops en un CPU:

import java.util.*;
public class calendario {


public static void main(String[] args) {
Calendar start = Calendar.getInstance();
int startMinute=start.get(Calendar. MINUTE);
int startSecond=start.get(Calendar. SECOND);
start.roll(Calendar.MINUTE,true);
int nextMinute= start.get(Calendar. MINUTE);
int nextSecond= start.get(Calendar. SECOND);
int index =0 ;
while (true){
double x =Math.sqrt(index);
GregorianCalendar now= new GregorianCalendar();
if (now.get(Calendar.MINUTE) >= nextMinute){
if (now. get(Calendar.SECOND) >= nextSecond){
break;
}
}

index++;
}
System.out.println(index + " loops en 1 minuto, " );

}

}





EJERCICIOS

1.Solicitar el ingreso del nombre y edad de dos personas. Mostrar el nombre de la persona con mayor edad.
SOLUCIÓN:

import java.util.Scanner;
public class uno {

public static void main(String[] args) {
Scanner teclado=new Scanner(System.in);
String nombre1,nombre2;
int edad1,edad2;
System.out.print("Ingrese el nombre:" );
nombre1=teclado.next();
System.out.print("Ingrese edad:" );
edad1=teclado.nextInt();
System.out.print("Ingrese el nombre:" );
nombre2=teclado.next();
System.out.print("Ingrese edad:" );
edad2=teclado.nextInt();
System.out.print("La persona de mayor edad es:" );
if (edad1>edad2) {
System.out.print(nombre1);
} else {
System.out.print(nombre2);
}


}

}




2.Solicitar el ingreso del apellido, nombre y edad de dos personas. Mostrar el nombre de la persona con mayor edad. Realizar la carga del apellido y nombre en una variable de tipo String.
SOLUCIÓN:

import java.util.Scanner;
public class dos {

public static void main(String[] args) {
Scanner teclado=new Scanner(System.in);
String apenom1,apenom2;
int edad1,edad2;
System.out.print("Ingrese el apellido y el nombre:" );
apenom1=teclado.nextLine();
System.out.print("Ingrese edad:" );
edad1=teclado.nextInt();
System.out.print("Ingrese el apellido y el nombre:" );
teclado.nextLine();
apenom2=teclado.nextLine();
System.out.print("Ingrese edad:" );
edad2=teclado.nextInt();
System.out.print("La persona de mayor edad es:" );
if (edad1>edad2) {
System.out.print(apenom1);
} else {
System.out.print(apenom2);
}


}

}





3.Desarrollar un programa que cargue los lados de un triángulo e implemente los siguientes métodos: inicializar los atributos, imprimir el valor del lado mayor y otro método que muestre si es equilátero o no.
SOLUCIÓN:

import java.util.Scanner;
public class tres {
private Scanner teclado;
private int lado1,lado2,lado3;

public void inicializar() {
teclado=new Scanner(System.in);
System.out.print("Medida lado 1:" );
lado1=teclado.nextInt();
System.out.print("Medida lado 2:" );
lado2=teclado.nextInt();
System.out.print("Medida lado 3:" );
lado3=teclado.nextInt();
}

public void ladoMayor() {
System.out.print("Lado mayor:" );
if (lado1>lado2 && lado1>lado3) {
System.out.println(lado1);
} else {
if (lado2>lado3) {
System.out.println(lado2);
} else {
System.out.println(lado3);
}
}
}

public void esEquilatero() {
if (lado1==lado2 && lado1==lado3) {
System.out.print("Es un triángulo equilátero" );
} else {
System.out.print("No es un triángulo equilátero" );
}
}

public static void main(String []ar) {
tres triangulo1=new tres();
triangulo1.inicializar();
triangulo1.ladoMayor();
triangulo1.esEquilatero();
}
}




EJERCICIOS RESUELTOS

1.- TIRAR UN DADO 100 VECES. HACER QUE EL PROGRAMA INDIQUE LA FRECUENCIA POSIBLE EN CADA LADO CON EL MÉTODO RANDOM.
SOLUCIÓN:

package bucles;
import java.util.Random;
public class tirarDados {

public static void main(String[] args) {
Random numerosAleatorios = new Random(); //

int frecuencia1 = 0 ; // cuenta las veces que se tiró 1
int frecuencia2 = 0 ; // cuenta las veces que se tiró 2 y así con todos hasta 6
int frecuencia3 = 0 ;
int frecuencia4 = 0 ;
int frecuencia5 = 0 ;
int frecuencia6 = 0 ;

int cara; // almacena el valor que se lanzó recientemente

// Sintetiza los resultados de tirar un dado n veces
for (int tiro = 1; tiro <=100; tiro++)
{
cara = 1 + numerosAleatorios.nextInt(6); // número del 1 al 5
// determina el valor del tiro de 1 a 6 e incrementa el contador apropiado

switch (cara)
{
case 1:
++frecuencia1; //Incrementa el contador de 1s
break;

case 2:
++frecuencia2; //Incrementa el contador de 2s
break;
case 3:
++frecuencia3; //Incrementa el contador de 3s
break;

case 4:
++frecuencia4; //Incrementa el contador de 4s
break;

case 5:
++frecuencia5; //Incrementa el contador de 5s
break;

case 6:
++frecuencia6; //Incrementa el contador de 6s
break;

}//fin de switch
}//fin de for

System.out.println( "CaratFrecuencia" ); //encabezados de salida

System.out.println("Cara 1 ---"+ frecuencia1);
System.out.println("Cara 2 ---"+ frecuencia2);
System.out.println("Cara 3 ---"+ frecuencia3);
System.out.println("Cara 4 ---"+ frecuencia4);
System.out.println("Cara 5 ---"+ frecuencia4);
System.out.println("Cara 6 ---"+ frecuencia5);
System.out.println("Total Tiros" + ": "+ (frecuencia1+ frecuencia2+frecuencia3+frecuencia4+frecuencia5+frecuencia6));

}

}


En resumen los temas que tocamos hoy son variados y cruciales para ciertos temas en Java, no estaría de más hacer variantes de los ejercicios.


Hasta la clase....




CLASE 7 <<< IR A LA CLASE >>> CLASE 9
0
0
0
0
0No comments yet