Entrada y Salida Por Consola Con JAVA

Entrada y Salida por la consola
Vamos a trabajar con la entrada y salida de datos por consola que hará que los
tutoriales siguientes sean mucho más didácticos y entretenidos.
Para la entrada de datos utilizaremos la clase Scanner, que tiene un
método next() que nos da la siguiente entrada por consola y que guardaremos en
la variable "entrada".
Para la salida de datos seguiremos utilizando la instrucción "System.out.println(x)"
como en los anteriores video tutoriales
La clase Tutorial4, que tenemos a continuación, nos muestra el código del
programa:
package tutorial4.edu4java.com;
import java.util.Scanner;
public class Tutorial4 {

public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("escanear:");
String entrada = scanner.next();
System.out.println("mostrar lo escaneado");
System.out.println(entrada);
}
}
Instrucción if o sentencia if
Las instrucciones de control de flujo, como if else y switch, cambian el flujo de la
ejecución del programa en tiempo de ejecución según ciertas condiciones.
La forma general de la sentencia if es:
if (condición)
sentencia;
Si el resultado del test es verdadero (true) se ejecuta la sentencia que sigue a

continuación de if, en caso contrario, falso (false), se salta dicha sentencia, tal como
se indica en la figura. La sentencia puede consistir a su vez, en un conjunto de
sentencias agrupadas en un bloque.
if (condición){
sentencia1;
sentencia2;
}
Podemos jugar con las condiciones que queramos a partir del ejemplo del video
tutorial:
package com.edu4java.tutorial5;

System.out.println("instrucción 1");
if (3 > 2) {
}
}
}
La sentencia if...else completa la sentencia if, para realizar una acción alternativa
if (condición)
sentencia1;
else
sentencia2
Las dos primeras líneas indican que si la condición es verdadera se ejecuta la
sentencia 1. La palabra clave else, significa que si la condición no es verdadera se
ejecuta la sentencia 2.
Dado que las sentencias pueden ser simples o compuestas la forma general de
if...else es
if (condición){
sentencia1;
sentencia2;
}else{
sentencia3
sentencia4;
sentencia5;
}
En la clase Tutorial5 se muestra el código del ejemplo del tutorial:

if (1 > 2) {
} else {
}
}
}
Estos son ejemplos simples de las instrucciones if-else. A continuación podemos
ver el código de un ejemplo un poco más complicado, explicado en el tutorial:


System.out.print("escanear edad:");
int edad = scanner.nextInt();
if (edad >= 18) {
System.out.println("puede beber");
} else {
System.out.println("no puede beber");
}
System.out.print("mostrar la edad: ");
System.out.println(edad);
}
}
Expresiones Lógicas y Operadores Lógicos
Los Operadores lógicos son los operadores que funcionan con valores booleanos;
los valores son verdaderos o falsos.
Operador lógico Simbolos Java

y &&
ó ||
No !
Expresiones booleanas:
-Boolean es un tipo de dato java primitivo
-Una expresión booleana es una expresión que evalúa si es falso o verdadero.
- True y false son palabras reservadas en java.
- Las expresiones booleanas están hechas de operadores lógicos y de comparación.
- Las expresiones booleanas se pueden utilizar en las sentencias if y en los bucles

de condición.
- Las expresiones booleanas también se pueden usar en una sentencia de

asignación.
Los operadores de comparación comparan dos valores y evalúan si son

verdaderos o falsos.
Comparación Símbolos java

menor que <
mayor que >
igual a ==
no igual a !=
menor o igual a <=
mayor o igual a >=
En la clase Tutorial6 tenemos el código del ejemplo del video tutorial.


System.out.print("escanear edad:");
int edad = scanner.nextInt();
// boolean puedeBeber=(edad>=18)&&(edad<=60);
boolean noPuedeBeber=(edad<18)||(edad>60);
if (noPuedeBeber) {
System.out.println(" no puede beber");
} else {
System.out.println("puede beber");
}
System.out.print("mostrar la edad: ");
System.out.println(edad);
}
}
Instrucción switch o sentencia switch
Otra manera de controlar el flujo de un programa, es con una sentencia switch. La
sentencia switch te da la opción de testear un rango de valores de variables. Se
pueden utilizar en caso de sentencias if-else complejas o excesivamentes largas.
La estructura de una sentencia switch es:
switch ( variable_to_test ) {
case value:
code_here;
break;
case value:
code_here;
break;
default:
values_not_caught_above;
break;
}
Comienza con la palabra "switch", seguido de la variable a chequear, entre
paréntesis. El resto de la sentencia switch va entre llaves. Cada caso a testear,
empieza con la palabra "case", seguido del valor del variable: case value:
A continuación viene el código a ejecutar, seguido de la palabra "break", necesaria
para salir de cada caso de la sentencia switch.
El valor "default" del final, es opcional. Se incluye cuando puede haber más valores
de la variable que no han sido chequeados en el switch.
A continuación tenemos el código del video tutorial:

System.out.println("Menú de opciones");
System.out.println("1. Sumar dos números (x+y)");
System.out.println("2. Restar a un número otro número (x-y)");
System.out.println("3. Multiplicar un número otro número
(x*y)");
System.out.println("4. Dividir un número otro número (x/y)");
System.out.println();
System.out.println("Ingresar opción:");
int opcion = scanner.nextInt();
System.out.println("Ingresar el primer número");

int x = scanner.nextInt();
System.out.println("Ingresar el segundo número");
int y = scanner.nextInt();
int resultado = 0;
switch (opcion) {
case 1:
resultado = x + y;
break;
case 2:
resultado = x - y;
break;
case 3:
resultado = x * y;
break;
case 4:
resultado = x / y;
break;
default:
System.out.println("error en la opción.");
break;
}
System.out.print("mostrar el resultado:");
System.out.println(resultado);
}
}
Instrucción while o sentencia while

La sentencia while ejecuta continuamente un bloque de instrucciones mientras sea
verdadera una determinada condición. Su sintaxis es la siguiente:
while (expresion) {
sentencia(s)
}
La sentencia while evalúa la expresión, que debe devolver un valor booleano. Si

es verdadero, la sentencia while ejecuta las instrucciones dentro del bloque. La
sentencia while sigue evaluando la expresión y ejecutando el bloque hasta que la
expresión evaluada sea falsa.
Se puede implementar un loop infinito utilizando la sentencia while, de la siguiente

manera:
while (verdadero){
// código a ejecutar
}
El lenguaje de programación Java también tiene la sentencia do-while, con
sintaxis;
do {
sentencia(s)
} while (expresion);
La diferencia entre "while" y el "do-while" es que el "do-while" evalúa la expresión
al final del bucle, en vez de al principio. Debido a esto, las instrucciones dentro del
bucle se ejecutan por lo menos una vez.
En los dos ejemplos siguientes, que están explicados en el video tutorial, podemos
ver como funciona la sentencia while:

int contador=2;
while (contador<=5) {
System.out.println(contador);
// contador=contador+1;
contador++;
}
}
}
public class Tutorial8_1 {

System.out.println("Programa para sumar varios
números");
int acumulador = 0;
int nuevoNumero = 0;
while (nuevoNumero >= 0) {
System.out.println("Insertar un nuevo número a
sumar o -1 para finalizar");
nuevoNumero = scanner.nextInt();
if (nuevoNumero > 0) {
acumulador = acumulador + nuevoNumero;
}
}
System.out.println("Total: " + acumulador);
}
}
Instrucción o sentencia for y arrays
Otra manera de controlar el flujo es utilizar bucles. Un bucle fuerza al programa a

volver al principio. Si esto ocurre, se repetirán líneas de código, una y otra vez.
Analicemos el bucle for.
La sentencia for, nos ofrece una manera de iterar sobre un rango de valores. Se le
llama "bucle for", porque da vueltas al bucle hasta que la condición se cumple.
La sintaxis de la sentencia for es la siguiente:
for (inicialización; terminación; iteración por ciclo) {

sentencia(s)
}
Cuando se utiliza esta sintaxis hay que tener en cuenta que:
-La expresión de inicialización inicia el bucle; se ejecuta una vez y el bucle

comienza.
-Cuando la expresión de terminación es igual a "false", el bucle termina.
-Finalmente, la última parte especifica como serán manipulados los valores iniciales
en cada iteración del ciclo.
Arrays
Otro concepto de programación que se debe conocer, para desarrollar un código
eficazmente, es el array.
Un array es una forma de guardar más de un valor al mismo tiempo. Piensa que un
array es como las columnas en una hoja de cálculo, en donde cada fila tiene un
número de posición, igual que los arrays. Las posiciones en un array empiezan en
0 y ascienden secuencialmente. Cada posición en un array puede contener un valor.
Sintaxis de una array;
// declaración de un array de integers.

int[] unArray;
Igual que las variables de otros tipos, la declaración de un array tiene dos
componentes; el tipo del array y su nombre.
El tipo del array se escribe como tipo[], donde el tipo es el tipo del dato de los
elementos contenidos en el array; los corchetes son símbolos indicando que esa
variable contiene un array.
El nombre de un array debe seguir las reglas y convenciones igual que el resto de
las variables.
Para definir cuantas posiciones queremos que tenga el array, tendremos que crear
un objeto array de la siguiente manera:
unArray = new int[6];
Primero vendrá el nombre del array, seguido del signo =. Después vendrá la palabra
clave new y a continuación el tipo de data de nuevo. Después unos corchetes que
tendrán dentro el tamaño del array. El tamaño se refiere a la cantidad de posiciones
que tendrá el array.
En el ejemplo del video tutorial aprenderemos a como iterar sobre un array,

utilizando el bucle for:
package com.edu4java.Tutorial9;

int[] array = { 2, 3, 5, 7, 1, 4, 7, 3, 0, 5 };
for (int i = 0; i < array.length; i++) {

System.out.print(array[i] + ",");
}
System.out.println("incrementamos en uno");

array[i]++;
}
System.out.print(array[i] + ",");
}
}
}
Ejemplo con arrays, métodos estáticos y variables estáticas
En este tutorial, analizamos el uso de la palabra clave static, para crear atributos
y métodos que pertenecen a una clase y no a la instancia de una clase.
Cuando se crean varios objetos a partir del mismo molde, cada uno tiene sus
propias copias de variables de instancia.
Cuando se quiere tener variables comunes a todos los objetos, se consigue creando
variables estáticas. Las variables que tienen la palabra static en su declaración, se
llaman atributos estáticos o variables de clase. En el caso de la clase "Tutorial10",
las variables de clase son array y scanner. Están asociadas a la clase, en vez de
al objeto.
Todas las instancias de la clase comparten la variable de clase, que tiene una
posición fija en la memoria. Cualquier objeto puede cambiar el valor de la variable
de clase, pero las variables de clase también pueden ser manipuladas sin crear una
instancia de la clase.
El lenguaje de programación Java, permite, tanto métodos estáticos como variables

estáticas. Los métodos estáticos son llamados con el nombre de la clase, sin tener
que crear la instancia de la clase;
ClassName.methodName(args)
Los métodos estáticos se suelen utilizar para acceder a las propiedades estáticas,
como veremos en el Tutorial 13, JavaBeans, public y private.".
En el video tutorial, explicaremos la clase que tenemos a continuación; Tutorial10,

que tiene cuatro métodos; insertarDatosArray, sumarArray(), maxArray() y
promedioArray():
static int[] array = new int[5];

static Scanner scanner = new Scanner(System.in);

insertarDatosArray();
sumarArray();
maxArray();
promedioArray();
}
private static void insertarDatosArray() {

System.out.print("insertar array[" + i + "]:");
array[i] = scanner.nextInt();
}
private static void sumarArray() {

System.out.print("Suma: ");
int acumulador = 0;
acumulador = acumulador + array[i];
System.out.print("+" + array[i]);
}
System.out.println("= " + acumulador);
}
private static void maxArray() {

System.out.print("Maximo: ");
int max = 0;
if (array[i] > max) {
max = array[i];
}
}
System.out.println(max);
}
private static void promedioArray() {

System.out.print("Promedio: ");
double promedio = 0;
promedio = promedio + array[i];
}
promedio = promedio / array.length;
System.out.println(promedio);
Parámetros, Argumentos y retorno de un método
Parámetros y argumentos
Estos dos términos; parámetros y argumentos, son a menudo intercambiados
incorrectamente en su uso. El contexto ayuda a diferenciar su significado. El
término parámetro, se usa a menudo para referirse a la variable en la declaración
del método, mientras que argumento, se refiere al valor que se envia. Para evitar
confusiones, es común ver a un parámetro como una variable y un argumento como
un valor.
Los parámetros aparecen en la declaración de los métodos y los argumentos en

las llamadas a los métodos. En la declaración del método, la variable es un
parámetro y en la llamada del método, la variable es el argumento del método.
En el ejemplo del video tutorial (clase Tutorial11, que está al final de la página),
vemos por ejemplo, que en el método insertarDatosArray(array, scanner), array y
scanner son los argumentos y en la declaración del método,
array y scanner son los parámetros.
private static void insertarDatosArray(int[] array, Scanner

scanner) {
}
Métodos con retorno

Un método vuelve al código del que se llamó en el momento en el que alguna de
estas circunstancias se de:
- se completan todas las sentencias del método,
- llega a una sentencia retorno o
- lanza una excepción,
El tipo de retorno de un método se especifica en la declaración del método. Dentro

del cuerpo del método, se utiliza la sentencia return para devolver el valor.
Cualquier método que esté declarado como void, no devolverá ningún valor.
Si se intenta devolver un valor desde un método declarado void, aparecerá un error

de compilación.
Cualquier método que no sea declarado void, deberá contener una sentencia return
con su correspondiente valor de retorno;
return valorRetorno;
El tipo de dato del valor de retorno deberá coincidir con el tipo de retorno de la
declaración del método. No se puede retornar un valor integer, a un método en el
que en su declaración aparece como valor de retorno, un boolean.

int[] array = new int[5];
insertarDatosArray(array, scanner);
sumarArray(array);
int max = maxArray(array);
System.out.println("Max= " + max);
double promedio = promedioArray(array);

System.out.println("Promedio= " + promedio);
private static void insertarDatosArray(int[] array, Scanner

scanner) {
}
private static void sumarArray(int[] array) {

System.out.print("Suma: ");
int acumulador = 0;
acumulador = acumulador + array[i];
System.out.print("+" + array[i]);
}
System.out.println("= " + acumulador);
}
private static int maxArray(int[] array) {

int max = 0;
if (array[i] > max) {
max = array[i];
}
}
return max;
}
private static double promedioArray(int[] array) {

double promedio = 0;
promedio = promedio + array[i];
}
promedio = promedio / array.length;
return promedio;
}
}
¿Qué es un objeto, una instancia y una clase en POO?
En este tutorial vamos a definir el concepto de objeto, instancia y clase en la

programación orientada a objetos.
Para ello vamos a utilizar un ejemplo en el que vamos a guardar información acerca
de un perro. Con lo que hemos aprendido hasta ahora, guardamos la información
en variables locales en nuestro método main;

// local variables
String name = "Coco";
String colour = "brown";
double weight = 1.5;
String name2 = "Rope";

String colour2 = "green";
double weight2 = 50;
}
}
Hasta ahora hemos guardado la información de dos perros sin problemas, pero
imaginémonos que queremos guardar la información de 10 perros...tendríamos 30
variables y el código se volvería menos legible.
Para evitar esto en la programación orientada a objetos, se ha creado el concepto

de clase, que agrupa datos. Una clase es un molde para crear un objeto o instancia.
En este caso tendríamos la clase Dog (perro) a partir de la cual crearíamos un
objeto que tendría asociados todas las variables definidas en la clase Dog.
/**
* @author Eli
* A class is a mould from which we can create objects or instances
* An object is an instance of a class
*/
public class Dog {
//object variables
public String name;

public double weight;
public String colour;
}
}
Ahora creamos un nuevo objeto y lo guardamos en una variable de tipo

Dog. A partir de ese momento se crean las variables asociadas a ese
objeto, donde podemos guardar nuestra información sobre el perro;
nombre, color y peso.
Dog dog1 = new Dog();

dog1.name = "Coco";
dog1.colour = "brown";
dog1.weight = 1.5;

dog2.name = "Rope";
dog2.colour = "green";
dog2.weight = 50;
printToConsole(dog1);
printToConsole(dog2);
private static void printToConsole(Dog dog) {

System.out.println("name: " + dog.name);
System.out.println("colour: " + dog.colour);
System.out.println("weight: " + dog.weight);
}
}
Ahora tenemos dos objetos que pertenecen a la misma clase Dog. Cada
objeto lo tenemos guardado en una variable distinta; dog1 y dog2. Para
ver como funciona he creado un método que los imprime;
printToConsole(Dog dog).
JavaBeans, public y private.
En este tutorial vamos a definir las palabras "public", "private" y a hablar del
concepto "javabean".
Hasta ahora veiamos que las variables eran "public" y se podían acceder desde el
exterior de su propia clase, cuando en este ejemplo cambiamos la variable name
de "public" a "private" vemos que desde el main de la Clase Tutorial12 ya no
podemos acceder a ella de la manera en que lo haciamos hasta ahora. La palabra
"private" hace que no se pueda acceder a esa variable.
/**
*
* JavaBeans are reusable software components for Java
* that can be manipulated visually in a builder tool.
*/
public class Dog {
// instance variables
private String name;

public double weight;
public String colour;
public void printToConsole() {

System.out.println("name: " + this.name);
System.out.println("colour: " + this.colour);
System.out.println("weight: " + this.weight);
}
}

dog1.name = "Coco";
dog1.colour = "brown";
dog1.weight = 1.5;
dog1.printToConsole();

dog2.name = "Rope";
dog2.colour = "green";
dog2.weight = 50;
// printToConsole(dog1);
}

System.out.println("name: " + dog.name);
System.out.println("colour: " + dog.colour);
System.out.println("weight: " + dog.weight);
}
Relacionado con el acceso a los datos tenemos el concepto JavaBean; que según la
especificación de Sun Microsystems los define como "componentes de software
reutilizables que se puedan manipular visualmente en una herramienta de
construcción".
Para funcionar como una clase JavaBean, una clase debe obedecer ciertas
convenciones sobre nomenclatura de métodos, construcción y comportamiento.
Una de estas convenciones es que sus propiedades deben ser accesibles mediante
métodos get y set que siguen una convención de nomenclatura estándar.
A continuación tenemos la clase Dog funcionando como JavaBean y la clase

Tutorial12 que accede a las propiedades de Dog mediante los métodos getters y
setters como establece el estandar JavaBean.
/**
*
*/
public class Dog {

private double weight;
private String colour;
public String getName() {

return name;
}
public void setName(String name) {

this.name = name;
}
public double getWeight() {

return weight;
}
public void setWeight(double weight) {

this.weight = weight;
}
public String getColour() {

return colour;
}
public void setColour(String colour) {

this.colour = colour;
}
System.out.println("name: " + this.name);
System.out.println("colour: " + this.colour);
System.out.println("weight: " + this.weight);
}
}

dog1.setName("Coco");
dog1.setColour("brown");
dog1.setWeight(1.5);

dog2.setName("Rope");
dog2.setColour("green");
dog2.setWeight(50);
}

System.out.println("name: " + dog.getName());
System.out.println("colour: " + dog.getColour());
System.out.println("weight: " + dog.getWeight());
Herencia. Programación básica java: Tutorial 14.

La idea de herencia es sencilla pero poderosa: cuando se quiere crear una nueva
clase y ya existe una clase que incluye código que vas a usar, se puede derivar la
nueva clase a partir de la clase existente. Al hacer esto, se puede utilizar tanto las
propiedades, como los métodos de esa clase, sin tener que escribirlos de nuevo.
Para poder comprender esto vamos a verlo en un ejemplo. En este ejemplo vamos
a crear un hotel para perros, donde vamos a registrarlos mediante su nombre, peso
y color, reutilizando la clase Dog de los pasados tutoriales.
/**
*
*/
public class Dog {

private String colour;

return name;
}

this.name = name;
}

return weight;
}

}

return colour;
}

}

System.out.print(" name: " + getName());
System.out.print(" colour: " + this.colour);
System.out.println(" weight: " + this.weight);
}
}
Después de registrar los perros con el método insertDog(), los imprimimos por
consola para mostrar cada uno de los perros. En la siguiente instrucción de la clase
"Tutorial13", les damos de comer 500gr de comida con el método feed(dogs) y los
volvermos a imprimir para ver que pesan 500gramos más.

Dog[] dogs = insertDog();
printDogsOnConsole(dogs);
feed(dogs);
System.out.println("After eating------------");
private static void feed(Dog[] dogs) {

for (int i = 0; i < dogs.length; i++) {
// we give feed them with 500gr of food
double weightBeforefeeding =
dogs[i].getWeight();
dogs[i].setWeight(weightBeforefeeding + 0.5);
}
private static void printDogsOnConsole(Dog[] dogs) {

dogs[i].printToConsole();
}
private static Dog[] insertDog() {
Dog[] dogs = new Dog[4];
// list of Dogs
String[] names = { "Coco", "Sultan", "Boby", "Drak" };
String[] colours = { "brown", "black", "white", "blue"
};
double[] weight = { 1.5, 75, 3.5, 45.1 };

Dog dog = new Dog();
dog.setName(names[i]);
dog.setColour(colours[i]);
dog.setWeight(weight[i]);
dogs[i] = dog;
}
return dogs;
}
}
Ahora queremos añadir una nueva propiedad a nuestro perro; "portion" (ración).
No podemos modificar la clase "Dog" porque está siendo utilizada en otras clases,
por lo que creamos una nueva clase Dog2 extendiéndola de Dog, con la nueva
propiedad "portion". De esta manera tenemos una clase Dog2 con todas las
propiedades de nuestra antigua clase Dog; "name", "colour" y "weight" y además
una nueva propiedad "portion", añadida en la clase Dog2.
public class Dog2 extends Dog {
private double portion;
public double getPortion() {

return portion;
}
public void setPortion(double portion) {

this.portion = portion;
}
}
Ahora sustituimos Dog por Dog2 y trabajamos con esta nueva clase, para darle de
comer a cada perro, una ración específica, dependiendo de su peso;

Dog2[] dogs = insertDog();
feed(dogs);
private static void feed(Dog2[] dogs) {

dogs[i].setWeight(weightBeforefeeding +
dogs[i].getPortion());
}
private static void printDogsOnConsole(Dog2[] dogs) {

}
private static Dog2[] insertDog() {
Dog2[] dogs = new Dog2[4];
// list of Dogs
};
double[] weight = { 1.5, 75, 3.5, 45.1 };
double[] portion = { 0.2, 1, 0.2, 0.8 };

Dog2 dog = new Dog2();
dog.setPortion(portion[i]);
dogs[i] = dog;
}
return dogs;
}
Sobreescribir un método; @override, protected y super
En este tutorial vamos a continuar con el ejemplo del hotel de perros que hemos
estado haciendo en los anteriores tutoriales, para explicar las palabras "override,
protected y super".
Vamos a utilizar la misma clase main (ahora llamada Tutorial14):

Dog2[] dogs = insertDog();
feed(dogs);
private static void feed(Dog2[] dogs) {

dogs[i].setWeight(weightBeforefeeding +
dogs[i].getPortion());
}
private static void printDogsOnConsole(Dog2[] dogs) {

}
private static Dog2[] insertDog() {
Dog2[] dogs = new Dog2[4];
// list of Dogs
};
double[] weight = { 1.5, 75, 3.5, 45.1 };
double[] portion = { 0.2, 1, 0.2, 0.8 };

Dog2 dog = new Dog2();
dog.setPortion(portion[i]);
dogs[i] = dog;
}
return dogs;
}
}
En la clase Dog, introduciremos el concepto de protected, haciendo que la variable
colour sea accesible desde la clase hija Dog2.
/**
*
*/
public class Dog {
protected String colour;

return name;
}

this.name = name;
}

return weight;
}

}

return colour;
}

}

System.out.print(" name: " + getName());
System.out.print(" colour: " + this.colour);
System.out.println(" weight: " + this.weight);
}
}
En la clase Dog2 conseguimos imprimir la variable "portion" sin tener que modificar
la clase Dog, sobreescribiendo el método printOnConsole.
public class Dog2 extends Dog {

private double portion;
public double getPortion() {

return portion;
}
public void setPortion(double portion) {

this.portion = portion;
}
@Override
super.printToConsole();
System.out.println(" portion: " + this.portion);
}
}
Polimorfismo en programación orientada a objetos
Polimorfismo es la capacidad de un objeto de adquirir varias formas. El uso más

común de polimorfismo en programación orientada a objetos se da cuando se utiliza
la referencia de una clase padre, para referirse al objeto de la clase hijo.
Cualquier objeto java que pueda pasar más de un test "ES-UN" es considerado
polimórfico. En Java, todos los objetos son polimórficos ya que cualquier objeto
pasaría un test "ES-UN" dado que son de su propio tipo, además del de la clase
Object.
Es importante saber que la única manera de acceder a un objeto es a través de una

variable de referencia. La variable de referencia sólo puede ser de un tipo. Una vez
declarado el tipo de la variable de referencia, no se puede cambiar.
La variable de referencia puede ser reasignada a otros objetos, siempre y cuando

no haya sido declarada "final". El tipo de la variable de referencia, determina los
métodos que podrán ser llamados sobre el objeto.
Una variable de referencia puede hacer referencia a cualquier objeto o cualquier

subtipo de su propio tipo.
En el video tutorial, utilizamos el siguiente código para explicar el concepto:
public class A extends B {

public void print() {
System.out.println("A");
}
}
public class B {
System.out.println("B");
}
}
public class C extends B {
System.out.println("C");
}
}
public class Main {
B[] bs = new B[3];
bs[0] = new B();
bs[1] = new A();
bs[2] = new C();
naivePrinter(bs);
private static void naivePrinter(B[] bs) {

for (int i = 0; i < bs.length; i++) {
bs[i].print();
}
}
}
Interfaces
Una interface en Java, es un tipo abstracto que se utiliza para definir una interfaz
a implementar por las clases. Las interfaces se declaran utilizando la palabra
clave interface y conteniendo solamente la firma del método y las declaraciones
de las constantes (que pueden ser static y final). Una interfaz no puede contener
las definiciones de los métodos.
Las interfaces son implementadas y no pueden ser instanciadas. Una clase que
implementa una interfaz debe implementar todos los métodos descritos en la
interfaz.
Una ventaja del uso de las interfaces es que simulan la herencia múltiple. Todas las
clases en Java tienen solamente una clase base, la única excepción es
java.lang.Object (la clase raiz del sistema tipo de Java); la herencia múltiple de
clase no está permitida.
Para explicar el concepto de interfaces, vamos a jugar al bingo y para esto vamos
a crear 20 tarjetas de bingo, con 15 números en cada una de las tarjetas.
Primero, creamos una clase Main con un new ArrayList de Bingo Cards(tarjetas de
bingo). Después de añadir cada una de las tarjetas a la lista, las imprimimos.
import java.util.ArrayList;
public class Main {

ArrayList<BingoCard> bingoList = new ArrayList<BingoCard>();
for (int i = 0; i < 20; i++) {

BingoCard bingo=new BingoCard();
bingoList.add(bingo);
bingo.syso();
}
}
}
En la clase "BingoCard", creamos un new array de ints con 15 posiciones. Después
de crearlo, se llama al constructor y utilizamos el objeto Random para sortear los
números.
Utilizamos un for para iterar sobre el array y en cada bucle, añadimos un número,
sorteado entre los números 0 a 99.
Sorteamos los números, los incluimos en el array de ints "bingo", para que estén
guardados en una variable de instancia de "BingoCard" y cada vez que se llame al
método "syso", llamamos al método "toString()".
El método "toString", itera sobre el array de ints "bingo", concatenando cada uno
de ellos con el anterior e imprimiéndolos.
import java.util.Random;
public class BingoCard {

int[] bingo = new int[15];
public BingoCard() {
Random random = new Random();
for (int i = 0; i < bingo.length; i++) {
bingo[i] = random.nextInt(100);
}
}
public int[] getBingo() {

return bingo;
}
public void setBingo(int[] bingo) {

this.bingo = bingo;
}
@Override
public String toString() {
String s = "[";
s = s + bingo[i] + ",";
}
return s + "]";
public void syso() {

System.out.println(this.toString());
}
}
El constructor de la clase "BingoCard1" tiene un filtro para evitar los números
repetidos en las tarjetas de bingo. Esto es una mejora con respecto a la clase
"BingoCard".
public class BingoCard1 {

public BingoCard1() {
if (isRepeated(i)) {
i--;
}
}
}
private boolean isRepeated(int i) {

for (int j = 0; j < i; j++) {
if (bingo[i] == bingo[j]) {
return true;
}
}
return false;
}

return bingo;
}

this.bingo = bingo;
}
@Override
String s = "[";
s = s + bingo[i] + ",";
}
return s + "]";
public void toConsole() {

}
}
BingoCard2 tiene otra mejora más; el método printoToConsole(), elimina la coma

del final que no quedaba muy bien.
public class BingoCard2 {

}
}

return bingo;
}

this.bingo = bingo;
}
public void printoToConsole() {

System.out.print("[");
System.out.print(bingo[i]);
if (i + 1 < bingo.length) {
System.out.print(",");
}
}
System.out.println("]");
}
Cada vez que hacemos una mejora, tenemos que cambiar mucho código en la clase
Main. Esto puede ser bastante problemático cuando tenemos miles de clases. Para
evitar esto, definimos una interface;
public interface IBingoCard {
void syso();
}
Y hacemos que todas las clases BingoCard implementen la interfaz IBingoCard y
sus métodos;
public class BingoCard implements IBingoCard {

public BingoCard() {
}
}

return bingo;
}

this.bingo = bingo;
}
@Override
String s = "[";
s = s + bingo[i] + ",";
}
return s + "]";
/* (non-Javadoc)
* @see com.edu4java.tutorial16.IBingoCard#syso()
*/
@Override
}
public class BingoCard1 implements IBingoCard{

if (isRepeated(i)) {
i--;
}
}
}
private boolean isRepeated(int i) {
for (int j = 0; j < i; j++) {
if (bingo[i] == bingo[j]) {
return true;
}
}
return false;
}

return bingo;
}
this.bingo = bingo;
}
@Override
String s = "[";
s = s + bingo[i] + ",";
}
return s + "]";
}
@Override
}
}
public class BingoCard2 implements IBingoCard {

}
}

return bingo;
}
this.bingo = bingo;
}
@Override
System.out.print("[");
System.out.print(bingo[i]);
if (i + 1 < bingo.length) {
System.out.print(",");
}
}
System.out.println("]");
}
Por último, utilizamos esa interfaz en la clase Main. La podemos usar por ejemplo
para probar la clase BingoCard2 y solamente tendremos que modificar la clase Main
en un lugar;
import java.util.ArrayList;
public class Main {

ArrayList<IBingoCard> bingoList = new
ArrayList<IBingoCard>();
for (int i = 0; i < 20; i++) {

IBingoCard bingo=new BingoCard2();
bingoList.add(bingo);
bingo.syso();
}
}
}

Entrada y Salida Por Consola Con JAVA

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Entrada y Salida Por Consola Con JAVA

Cargado por

Copyright:

Formatos disponibles

Entrada y Salida por la consola

public class Tutorial4 {

Si el resultado del test es verdadero (true) se ejecuta la sentencia que sigue a

public class Tutorial5 {

En la clase Tutorial5 se muestra el código del ejemplo del tutorial:

public class Tutorial5 {

public class Tutorial5 {

Scanner scanner = new Scanner(System.in);

Expresiones Lógicas y Operadores Lógicos

Operador lógico Simbolos Java

-Boolean es un tipo de dato java primitivo

-Una expresión booleana es una expresión que evalúa si es falso o verdadero.

- True y false son palabras reservadas en java.

- Las expresiones booleanas están hechas de operadores lógicos y de comparación.

- Las expresiones booleanas se pueden utilizar en las sentencias if y en los bucles

- Las expresiones booleanas también se pueden usar en una sentencia de

Los operadores de comparación comparan dos valores y evalúan si son

Comparación Símbolos java

public class Tutorial6 {

Scanner scanner = new Scanner(System.in);

public class Tutorial7 {

System.out.println("Ingresar el primer número");

Instrucción while o sentencia while

La sentencia while evalúa la expresión, que debe devolver un valor booleano. Si

Se puede implementar un loop infinito utilizando la sentencia while, de la siguiente

public class Tutorial8 {

public class Tutorial8_1 {

Instrucción o sentencia for y arrays

Otra manera de controlar el flujo es utilizar bucles. Un bucle fuerza al programa a

Analicemos el bucle for.

La sintaxis de la sentencia for es la siguiente:

for (inicialización; terminación; iteración por ciclo) {

-La expresión de inicialización inicia el bucle; se ejecuta una vez y el bucle

-Cuando la expresión de terminación es igual a "false", el bucle termina.

// declaración de un array de integers.

unArray = new int[6];

En el ejemplo del video tutorial aprenderemos a como iterar sobre un array,

public class Tutorial9 {

for (int i = 0; i < array.length; i++) {

for (int i = 0; i < array.length; i++) {

Ejemplo con arrays, métodos estáticos y variables estáticas

El lenguaje de programación Java, permite, tanto métodos estáticos como variables

En el video tutorial, explicaremos la clase que tenemos a continuación; Tutorial10,

public class Tutorial10 {

static int[] array = new int[5];

public static void main(String[] args) {

private static void insertarDatosArray() {

private static void sumarArray() {

private static void maxArray() {

private static void promedioArray() {

Parámetros, Argumentos y retorno de un método

Los parámetros aparecen en la declaración de los métodos y los argumentos en

array y scanner son los parámetros.

private static void insertarDatosArray(int[] array, Scanner

Métodos con retorno

- se completan todas las sentencias del método,

- llega a una sentencia retorno o

- lanza una excepción,

El tipo de retorno de un método se especifica en la declaración del método. Dentro

Si se intenta devolver un valor desde un método declarado void, aparecerá un error

public class Tutorial11 {

double promedio = promedioArray(array);

private static void insertarDatosArray(int[] array, Scanner