0% encontró este documento útil (0 votos)

13 vistas227 páginas

Curso Java Básico Sopra Steria

Cargado por

mogog13938

Derechos de autor

Nos tomamos en serio los derechos de los contenidos. Si sospechas que se trata de tu contenido, reclámalo aquí.

Formatos disponibles

Descarga como PDF, TXT o lee en línea desde Scribd

0% encontró este documento útil (0 votos)

13 vistas227 páginas

Curso Java Básico Sopra Steria

Cargado por

mogog13938

Derechos de autor

Nos tomamos en serio los derechos de los contenidos. Si sospechas que se trata de tu contenido, reclámalo aquí.

Formatos disponibles

Descarga como PDF, TXT o lee en línea desde Scribd

Formación Sopra Steria / Java básico

29 de enero de 2019

Tutoriales Curso Java

Formación Sopra Steria

Formación JAVA

Bloque Java Básico

Versión 2.3 del martes, 29 de enero de 2019

1/227
Formación Sopra Steria / Java básico
29 de enero de 2019

Destinatario(s)

Historial
Versión Fecha Origen de la actualización Redactado por Validado por
1.0 25/04/2018 Sergio Comes
2.0 12/06/2018 Silvia Carpena
2.1 27/06/2018 Silvia Carpena
2.2 09/07/2018 Actualización expresiones lambda Silvia Carpena
2.3 29/01/2019 Actualización tutoriales 6 Alba Bermejo

2/227
Formación Sopra Steria / Java básico
29 de enero de 2019

Índice

1. Tutorial Capítulo 3: Bloques Básicos 5

1.1. Tutorial 1 - Comprender la estructura de clases de Java 5
1.2. Tutorial 2 - El método main() 8
1.3. Tutorial 3 - Paquetes e importaciones 9
1.4. Tutorial 4 - Crear objetos 11
1.5. Tutorial 5 - Diferencia entre referencias a objetos y primitivas de datos 13
1.6. Tutorial 6 - Declarando e inicializando variables 15
1.7. Tutorial 7 - Variables en Java: Comprensión de la inicialización por defecto y el ámbito de las
variables 17
1.7.1. Variables de instancia 17
1.7.2. Variables locales 20
1.7.3. Variables de clase 23
1.8. Tutorial 8 - Ordenando elementos en una clase 26
1.9. Tutorial 9 - Destruyendo Objetos 28

2. Tutorial Capítulo 4: Operadores y sentencias 31

2.1. Tutorial 1 - Trabajando con operadores binarios aritméticos - Operadores aritméticos 31
2.2. Tutorial 2 - Trabajando con operadores unarios - Operadores logicos (5 min) 33
2.3. Tutorial 3 - Trabajando con operadores unarios - Operadores de incremento 34
2.4. Tutorial 4 - Usando los operadores binarios adicionales - Operadores de asignación 36
2.5. Tutorial 5 - Usando los operadores binarios adicionales - Operadores relacionales 38
2.6. Tutorial 6 - Comprender las sentencias - Sentencia If-then 41
2.7. Tutorial 7 - Comprender las sentencias - Sentencia If-then-else 44
2.8. Tutorial 8 - Comprender las sentencias - Sentencia switch 46
2.9. Tutorial 9 - Comprender las sentencias - Sentencia while 48
2.10. Tutorial 10 - Comprender las sentencias - Sentencia do-while 52
2.11. Tutorial 11 - Comprender las sentencias - Sentencia for 56
2.12. Tutorial 12 - Comprendiendo el control de flujo avanzado - Sentencia break 59
2.13. Tutorial 13 - Comprendiendo el control de flujo avanzado - Sentencia continue 71
2.14. Tutorial 14 - Ejercicio global - Sentencias 1 81
2.15. Tutorial 15 - Ejercicio global - Sentencias 2 86
2.16. Tutorial 16 - Ejercicio global - Sentencias 3 92

3. Tutorial Capitulo 5: API de Java 98

3.1. Tutorial 1 - Creando y Manipulando Strings - Strings 98
3.2. Tutorial 2 - Entender Arrays de Java - Arrays 114
3.3. Tutorial 3 - Entender un ArrayList - ArrayList 120

3/227
Formación Sopra Steria / Java básico
29 de enero de 2019

3.4. Tutorial 4 - Trabajando con Fechas y Horas - DateTime 133

4. Tutorial Capitulo 6: Métodos y encapsulamiento 145

4.1. Tutorial 1 - Diseñando métodos 145
4.2. Tutorial 2 - Trabajando con Varargs (15 min) 146
4.3. Tutorial 3 - Aplicando Modificadores de Acceso 148
4.4. Tutorial 4 - Pasando Datos a Través de Métodos 155
4.5. Tutorial 5 - Sobrecargando Métodos 157
4.6. Tutorial 6 - Creando Constructores 158
4.7. Tutorial 7 - Encapsulando Datos 162
4.8. Tutorial 8 - Ejercicio de ejemplo: Home 165

5. Tutorial Capítulo 7: Diseño de clases 171

5.1. Tutorial 1 - Introducción a la herencia de clases - Herencia 171
5.2. Tutorial 2 - Creando clases abstractas - Clases abstractas 176
5.3. Tutorial 3 - Implementando interfaces - Interfaces 181
5.4. Tutorial 4 - Entendiendo el polimorfismo - Polimorfismo 190
5.5. Tutorial 5 - Escribiendo Lambdas Simples 195

6. Tutorial Capítulo 8: Excepciones 197

6.1. Tutorial 1 - Entendiendo las excepciones 197
6.2. Tutorial 2 - Entendiendo las excepciones 199
6.3. Tutorial 3 - Entendiendo las excepciones 200
6.4. Tutorial 4 - Usando try-catch-finally 202
6.5. Tutorial 5 - Usando try-catch-finally 205
6.6. Tutorial 6 - Multiples try-catch 207
6.7. Tutorial 7 - Multiples try-catch 211
6.8. Tutorial 8 - Tipos de excepciones: ArithmeticException 213
6.9. Tutorial 9 - Tipos de excepciones: ArrayIndexOutOfBoundsException 216
6.10. Tutorial 10 - Tipos de excepciones: NullPointerException 218
6.11. Tutorial 11 - Tipos de excepciones: NumberFormatException 219
6.12. Tutorial 12 - Tipos de excepciones: FileNotFoundException 221
6.13. Tutorial 13 – Tipos de excepciones: StringIndexOutOfBoundsException 225

4/227
Formación Sopra Steria / Java básico
29 de enero de 2019

1. Tutorial Capítulo 3: Bloques Básicos

1.1. Tutorial 1 - Comprender la estructura de clases de Java

Con este tutorial se pretende mostrar cuál es la estructura común de una clase Java, a modo de ejemplo,
se va a crear un paquete [Link], con una clase Dog con tres atributos (breed, age,
color) y tres métodos (barking, hungry, sleeping). Más adelante, se entrará en detalle sobre los
elementos que aquí se muestran: paquetes, atributos, métodos, etc

1. Se crea un paquete llamado [Link]

package [Link];

2. Dentro del paquete, se crea la clase Dog

package [Link];
public class Dog {
}

3. Se crean tres atributos en la clase Dog

package [Link];
public class Dog {
/*
* Los tres atributos de la case Dog son breed, age y color
*/
String breed;
int age;
String color;
}

4. Se crean tres métodos en la clase Dog

package [Link];
public class Dog {
/*
* Los tres atributos de la case Dog son breed, age y color
*/
String breed;
int age;
String color;
/*
* Los tres métodos de la clase Dog son barking(), hungry() y sleeping()

5/227
Formación Sopra Steria / Java básico
29 de enero de 2019

*/
public int barking(int bark) {
bark = bark + 1;
return bark;
}
void hungry() {
}
void sleeping() {
}
}

5. Como se ha visto en esta sección, es conveniente comentar el código utilizando javadocs o

comentarios de apoyo. Un ejemplo de los comentarios a realizar para el código anterior sería el
siguiente:
/**

package [Link];

/**

* Capítulo 3: Bloques básicos en Java

* Esta clase define objetos tipo Dog

* @author SopraSteria

public class Dog {

* Atributos de la case Dog

6/227
Formación Sopra Steria / Java básico
29 de enero de 2019

String breed;

int age;

String color;

/**

* Método que realiza un ladrido

* @param bark

* contiene el número de ladridos

* @return bark

* un entero con el número de ladridos modificado

public int barking(int bark) {

bark = bark + 1;

return bark;

}//Cierre método barking

/**

* Método en blanco

void hungry() {

}//Cierre método hungry

/**

* Método en blanco

7/227
Formación Sopra Steria / Java básico
29 de enero de 2019

void sleeping() {

}//Cierre método sleeping

}//Cierre de la clase Dog

1.2. Tutorial 2 - El método main()

El método main es, tal y como se ha visto en el bloque de teoría, uno de los métodos más importantes
de Java. En este tutorial se muestra cómo se crea dicho método main y se le añade la sencilla
funcionalidad de mostrar un mensaje por consola.

1. Se crea un paquete llamado [Link]

package [Link];

2. Dentro del paquete, se crea la clase FirstJavaProgram

package [Link];

public class FirstJavaProgram {

3. Dentro de la clase FirstJavaProgram, se crea el método public static void main(String[] args)
(método main)
package [Link];

public class FirstJavaProgram {

public static void main(String[] args){

4. Dentro del método main se escribe: [Link]("This is my first program in java");

package [Link];

public class FirstJavaProgram {

public static void main(String[] args){

[Link]("This is my first program in java");

8/227
Formación Sopra Steria / Java básico
29 de enero de 2019

5. Output
This is my first program in java

1.3. Tutorial 3 - Paquetes e importaciones

A lo largo de este tutorial se crearán dos paquetes java. En uno de ellos se creará la clase Calculadora,
a cuyos métodos se quiere acceder desde otra clase situada en un paquete diferente. Para ello, será
necesario importar dicha clase, viendo así cómo funcionan los imports en Java.

1. Se crea un paquete llamado [Link]

package [Link];

2. Se crea un paquete llamado letmecalculate dentro del paquete

[Link]
package [Link];

3. Se crea una clase llamada Calculator dentro del paquete letmecalculate

package [Link];
public class Calculator {

4. Se crea un método public int add que devuelva la suma de dos valores
package [Link];
public class Calculator {
public int add(int a, int b){
return a+b;
}
}

5. Se crea una clase llamada Demo dentro del paquete [Link]

package [Link];
public class Demo {
}

9/227
Formación Sopra Steria / Java básico
29 de enero de 2019

6. Se crea el método main

package [Link];
public class Demo {
public static void main(final String args[]) {
}
}

7. Se importa la clase Calculator del paquete

[Link]
package [Link];
import [Link];
public class Demo {
public static void main(final String args[]) {
}
}

8. Se crea un objeto Calculator

package [Link];
import [Link];
public class Demo {
public static void main(final String args[]) {
Calculator calc= new Calculator();
}
}

9. También es posible importar todas las clases del paquete

[Link] utilizando la wildcard *
package [Link];
import [Link].*;
public class Demo {
public static void main(final String args[]) {
Calculator calc = new Calculator();
}
}

10. El método main imprime por pantalla el restultado del método sum del objeto del tipo Calculator
que se acaba de crear
package [Link];
import [Link];

10/227
Formación Sopra Steria / Java básico
29 de enero de 2019

public class Demo {

public static void main(final String args[]) {
Calculator calc= new Calculator();
[Link]([Link](100, 200));
}
}

11. Output
300

1.4. Tutorial 4 - Crear objetos

En este tutorial se pretende mostrar cómo se crean los métodos constructores de una clase Java. Para
ello, se crearán dos constructores: uno de ellos sin parámetros, y el otro, con un parámetro de tipo
String.

1. Se crea un paquete llamado [Link]

package [Link];

2. Se crea una clase llamada Puppy dentro del paquete [Link]

package [Link];
public class Puppy {
}

3. Se crean dos constructores: un constructor vacío y un constructor con un parámetro de tipo

String llamado name
package [Link];
public class Puppy {
/*
* Constructor vacío
*/
public Puppy() {
}
/*
* Constructor con un parámetro de tipo String llamado name
*/
public Puppy(String name) {
[Link]("Passed Name is :" + name );

11/227
Formación Sopra Steria / Java básico
29 de enero de 2019

}
}

4. Se crea el método main

package [Link];
public class Puppy {
/*
* Constructor vacío
*/
public Puppy() {
}
/*
* Constructor con un parámetro de tipo String llamado name
*/
public Puppy(String name) {
[Link]("Passed Name is :" + name );
}
public static void main(String []args) {
}
}

5. Se crea un objeto Puppy y se usa su constructor con parámetros, al que se le pasa el parámetro
name con valor "tommy"
package [Link];
public class Puppy {
/*
* Constructor vacío
*/
public Puppy() {
}
/*
* Constructor con un parámetro de tipo String llamado name
*/
public Puppy(String name) {
[Link]("Passed Name is :" + name );
}
public static void main(String []args) {
/*
* Se crea un objeto Puppy al que se llama myPuppy y se hace uso para ello del
constructor con parámetros
* Es importante remarcar que siempre que se cree un objeto, se hará uso de la
palabra reservada new

12/227
Formación Sopra Steria / Java básico
29 de enero de 2019

*/
Puppy myPuppy = new Puppy( "tommy" );
}
}

6. Output
Passed Name is :tommy

1.5. Tutorial 5 - Diferencia entre referencias a objetos y primitivas de datos

Existen dos tipos de variables en Java: primitivas de datos y variables referencia. A lo largo de este
tutorial se pretende mostrar cuáles son las primitivas de datos de Java, así como un ejemplo de
referencias a objetos, haciendo uso de la clase String.

1. Se crea un paquete llamado [Link]

package [Link];

2. Dentro del paquete, se crea la clase PrimitiveDataTypes

package [Link];
public class PrimitiveDataTypes {
}

3. Dentro de la clase PrimitiveDataTypes, se crea el método main

package [Link];
public class PrimitiveDataTypes {
public static void main(final String[] args) {
}
}

4. Se crea un ejemplo de cada una de las primitivas de datos de Java: byte, short, long, double,
float, boolean y char
package [Link];
public class PrimitiveDataTypes {
public static void main(final String[] args) {
byte numByte = 113;
[Link](numByte);
short numShort = 150;
[Link](numShort);

13/227
Formación Sopra Steria / Java básico
29 de enero de 2019

int numInt = 7;
[Link](numInt);
long numLong = -12332252626L;
[Link](numLong);
double numDouble = -42937737.9d;
[Link](numDouble);
float numFloat = 19.98f;
[Link](numFloat);
boolean b = false;
[Link](b);
char ch = 'Z';
[Link](ch);
}
}

5. Output:
113
150
7
-12332252626
-4.29377379E7
19.98
false
Z

6. Dentro del paquete [Link], se crea la clase ReferenceTypes

package [Link];
public class ReferenceTypes {
}

7. Se crea el método main:

package [Link];
public class ReferenceTypes {
public static void main(final String[] args) {
}
}

14/227
Formación Sopra Steria / Java básico
29 de enero de 2019

8. Dentro de la clase ReferenceTypes se crea una variable de un tipo de dato que no sea una
primitiva de datos. Por ejemplo, String.
package [Link];
public class ReferenceTypes {
public static void main(final String[] args) {
String text1;
String text2;

text1 = "I'm text1";

text2 = null;

[Link](text1);
[Link](text2);
}
}

9. Output
I'm text1
null

1.6. Tutorial 6 - Declarando e inicializando variables

Existen diferentes maneras de declarar e inicializar variables en Java, por lo que el siguiente tutorial
muestra un conjunto de ejemplos de ello.

1. Se crea un paquete llamado [Link]

package [Link];

2. Dentro del paquete, se crea la clase DeclaringAndInitializingVariables

package [Link];
public class DeclaringAndInitializingVariables {
}

3. Dentro de la clase DeclaringAndInitializingVariables se crea el método main

package [Link];
public class DeclaringAndInitializingVariables {
public static void main(final String[] args) {
}
}

15/227
Formación Sopra Steria / Java básico
29 de enero de 2019

4. Se pretenden hacer diferentes pruebas para poder comprobar cuáles son las distintas formas de
crear e inicializar variables en Java: crear una variable e inicializarla en una sentencia diferente,
crear varias variables e inicializarlas en una sola línea, etc
package [Link];
public class DeclaringAndInitializingVariables {
public static void main(final String[] args) {
/*
* Se crea una variable que es inicializada en una sentencia diferente
*/
int num;
num = 20;

/*
* Se crea una variable y se inicializa
*/
char ch = 'A';
int number = 100;

/*
* Se crean varias variables sin inicializar en una sola sentencia
*/
boolean b1, b2;

/*
* Se crea una variable inicializada y una sin inicializar en la misma senten
cia
*/
String s1 = "1", s2;

/*
* Se crean dos variables en sentencias diferentes, pero en la misma línea
*/
int n1; int n2;
}
}

16/227
Formación Sopra Steria / Java básico
29 de enero de 2019

1.7. Tutorial 7 - Variables en Java: Comprensión de la inicialización por defecto y el

ámbito de las variables
El siguiente tutorial pretende mostrar los tres ámbitos de las variables en Java dependiendo de dónde
estas sean creadas: variables de instancia, variables locales y variables de clase. Para ello, se crearán
una serie de clases donde se declararán dichos tipos de variable y se comprobará cuál es el ámbito de
estas.

1.7.1. Variables de instancia

1. Se crea un paquete llamado [Link]
package [Link];

2. Dentro del paquete, se crea la clase InstanceVariables

package [Link];
public class InstanceVariables {
}

3. Dentro de la clase InstanceVariables se crea una variable de instancia inicializada

(myInstanceVar en este caso)
package [Link];
public class InstanceVariables {
/*
* Cada uno de los objetos de la clase InstanceVariables que se cree
* tendrá su propia variable de instancia myInstanceVar
*/
String myInstanceVar = "instance variable";
}

4. Se crea el método main

package [Link];
public class InstanceVariables {
/*
* Cada uno de los objetos de la clase InstanceVariables que se cree
* tendrá su propia variable de instancia myInstanceVar
*/
String myInstanceVar = "instance variable";
public static void main(final String args[]) {
}
}

17/227
Formación Sopra Steria / Java básico
29 de enero de 2019

5. Dentro del método main, se instancian una serie de objetos de la clase InstanceVariables
package [Link];
public class InstanceVariables {
/*
* Cada uno de los objetos de la clase InstanceVariables que se cree
* tendrá su propia variable de instancia myInstanceVar
*/
String myInstanceVar = "instance variable";
public static void main(final String args[]) {
InstanceVariables obj = new InstanceVariables();
InstanceVariables obj2 = new InstanceVariables();
InstanceVariables obj3 = new InstanceVariables();
}
}

6. Se imprime por pantalla la variable myInstanceVar para cada uno de los objetos
package [Link];
public class InstanceVariables {
/*
* Cada uno de los objetos de la clase InstanceVariables que se cree
* tendrá su propia variable de instancia myInstanceVar
*/
String myInstanceVar = "instance variable";
public static void main(final String args[]) {
InstanceVariables obj = new InstanceVariables();
InstanceVariables obj2 = new InstanceVariables();
InstanceVariables obj3 = new InstanceVariables();

[Link]([Link]);
[Link]([Link]);
[Link]([Link]);
}
}

7. Se cambia la variable myInstanceVar de uno de los objetos (obj2 en este caso)

18/227
Formación Sopra Steria / Java básico
29 de enero de 2019

public static void main(final String args[]) {

InstanceVariables obj = new InstanceVariables();
InstanceVariables obj2 = new InstanceVariables();
InstanceVariables obj3 = new InstanceVariables();

[Link]([Link]);
[Link]([Link]);
[Link]([Link]);

/*
* Se cambia la variable de instancia myInstanceVar del objeto obj2,
* pero no del resto.
*/
[Link] = "Changed Text";
}
}

8. Al imprimir de nuevo por pantalla las variables myInstanceVar de cada uno de los objetos, se
podrá ver como la variable de obj2 es ahora diferente, ya que ha sido modificada previamente.
package [Link];
public class InstanceVariables {
/*
* Cada uno de los objetos de la clase InstanceVariables que se cree
* tendrá su propia variable de instancia myInstanceVar
*/
String myInstanceVar = "instance variable";
public static void main(final String args[]) {
InstanceVariables obj = new InstanceVariables();
InstanceVariables obj2 = new InstanceVariables();
InstanceVariables obj3 = new InstanceVariables();

[Link]([Link]);
[Link]([Link]);
[Link]([Link]);

/*
* Se cambia la variable de instancia myInstanceVar del objeto obj2,
* pero no del resto.
*/
[Link] = "Changed Text";

19/227
Formación Sopra Steria / Java básico
29 de enero de 2019

[Link]([Link]);
[Link]([Link]);
[Link]([Link]);
}
}

9. Output
instance variable
instance variable
instance variable
instance variable
Changed Text

instance variable

1.7.2. Variables locales

10. Dentro del paquete [Link], se crea la clase LocalVariables
package [Link];
public class LocalVariables {
}

11. Dentro de la clase LocalVariables se crea una variable de instancia inicializada (myVar en este
caso)
package [Link];
public class LocalVariables {
/*
* Variable de instancia myVar
*/
public String myVar = "instance variable";
}

12. Se crea un método (myMethod()) que crea una variable local también llamada myVar y se
inicializa
package [Link];
public class LocalVariables {
/*
* Variable de instancia myVar
*/
public String myVar = "instance variable";

20/227
Formación Sopra Steria / Java básico
29 de enero de 2019

public void myMethod() {

/*
* Variable local myVar
*/
String myVar = "Inside Method";
[Link](myVar);
}
}

13. Se crea el método main

package [Link];
public class LocalVariables {
/*
* Variable de instancia myVar
*/
public String myVar = "instance variable";
public void myMethod() {
/*
* Variable local myVar
*/
String myVar = "Inside Method";
[Link](myVar);
}
public static void main(final String args[]) {
}
}

14. Dentro del método main, se instancian un objeto de la clase LocalVariables

21/227
Formación Sopra Steria / Java básico
29 de enero de 2019

/*
* Se crea un objeto LocalVariables llamado obj
*/
LocalVariables obj = new LocalVariables();
}
}

15. Se llama al método myMethod(), que imprime por pantalla el valor de la variable local myVar
package [Link];
public class LocalVariables {
/*
* Variable de instancia myVar
*/
public String myVar = "instance variable";
public void myMethod() {
/*
* Variable local myVar
*/
String myVar = "Inside Method";
[Link](myVar);
}
public static void main(final String args[]) {
/*
* Se crea un objeto LocalVariables llamado obj
*/
LocalVariables obj = new LocalVariables();
[Link]("Calling Method");
[Link]();
}
}

16. Se imprime por pantalla el valor de la variable de instancia myVar

package [Link];
public class LocalVariables {
/*
* Variable de instancia myVar
*/
public String myVar = "instance variable";
public void myMethod() {
/*
* Variable local myVar
*/

22/227
Formación Sopra Steria / Java básico
29 de enero de 2019

String myVar = "Inside Method";

[Link](myVar);
}
public static void main(final String args[]) {
/*
* Se crea un objeto LocalVariables llamado obj
*/
LocalVariables obj = new LocalVariables();
[Link]("Calling Method");
[Link]();
[Link]([Link]);
}
}

17. Output
Calling Method
Inside Method
instance variable

1.7.3. Variables de clase

18. Dentro del paquete [Link], se crea la clase ClassVariables
package [Link];
public class ClassVariables {
}

19. Dentro de la clase ClassVariables se crea una variable de clase o estática inicializada (myClassVar
en este caso)
package [Link];
public class ClassVariables {
/*
* Cada uno de los objetos de la clase ClassVariables que se cree
* tendrá la misma variable myClassVar
*/
public static String myClassVar="class or static variable";
}

20. Se crea el método main

package [Link];
public class ClassVariables {

23/227
Formación Sopra Steria / Java básico
29 de enero de 2019

/*
* Cada uno de los objetos de la clase ClassVariables que se cree
* tendrá la misma variable myClassVar
*/
public static String myClassVar="class or static variable";

public static void main(String args[]){

}
}

21. Dentro del método main, se instancian una serie de objetos de la clase ClassVariables
package [Link];
public class ClassVariables {
/*
* Cada uno de los objetos de la clase ClassVariables que se cree
* tendrá la misma variable myClassVar
*/
public static String myClassVar="class or static variable";

public static void main(String args[]){

ClassVariables obj = new ClassVariables();
ClassVariables obj2 = new ClassVariables();
ClassVariables obj3 = new ClassVariables();
}
}

22. Se imprime por pantalla la variable myClassVar para cada uno de los objetos
package [Link];
public class ClassVariables {
/*
* Cada uno de los objetos de la clase ClassVariables que se cree
* tendrá la misma variable myClassVar
*/
public static String myClassVar="class or static variable";

public static void main(String args[]){

ClassVariables obj = new ClassVariables();
ClassVariables obj2 = new ClassVariables();
ClassVariables obj3 = new ClassVariables();

24/227
Formación Sopra Steria / Java básico
29 de enero de 2019

[Link]([Link]);
[Link]([Link]);
[Link]([Link]);
}
}

23. Se cambia la variable myClassVar de uno de los objetos (obj2 en este caso)
package [Link];
public class ClassVariables {
/*
* Cada uno de los objetos de la clase ClassVariables que se cree
* tendrá la misma variable myClassVar
*/
public static String myClassVar="class or static variable";

public static void main(String args[]){

ClassVariables obj = new ClassVariables();
ClassVariables obj2 = new ClassVariables();
ClassVariables obj3 = new ClassVariables();

[Link]([Link]);
[Link]([Link]);
[Link]([Link]);

/*
* Se cambia la variable de instancia myClassVar del objeto obj2,
* y por tanto, puesto que es única, cambiará también para obj y obj3
*/
[Link] = "Changed Text";
}
}

24. Al imprimir de nuevo por pantalla las variables myClassVar de cada uno de los objetos, se podrá
ver como el resultado ha cambiado para todos los objetos a pesar de haber modificado solo
myClassVar en obj2. Esto se debe a que es una variable estática o de clase
package [Link];
public class ClassVariables {
/*
* Cada uno de los objetos de la clase ClassVariables que se cree

25/227
Formación Sopra Steria / Java básico
29 de enero de 2019

* tendrá la misma variable myClassVar

*/
public static String myClassVar="class or static variable";

public static void main(String args[]){

ClassVariables obj = new ClassVariables();
ClassVariables obj2 = new ClassVariables();
ClassVariables obj3 = new ClassVariables();

[Link]([Link]);
[Link]([Link]);
[Link]([Link]);

/*
* Se cambia la variable de instancia myClassVar del objeto obj2,
* y por tanto, puesto que es única, cambiará también para obj y obj3
*/
[Link] = "Changed Text";

[Link]([Link]);
[Link]([Link]);
[Link]([Link]);
}
}

25. Output
class or static variable
class or static variable
class or static variable
Changed Text
Changed Text
Changed Text

1.8. Tutorial 8 - Ordenando elementos en una clase

Este tutorial pretende hacer ver cuál es el orden correcto de los elementos de una clase Java. Esta
estructura debe de mantenerse siempre, y merece la pena prestar especial atención a los comentarios
para poder ver dónde se ha de escribir cada parte del código.

26/227
Formación Sopra Steria / Java básico
29 de enero de 2019

1. El siguiente código muestra los elementos básicos de una clase Java:

/*
* Declaración del package (primera línea de la clase).
*/
package [Link];

/*
* Imports, después de la declaración del paquete.
*/
import [Link];
import [Link];

/*
* Capítulo 3: Bloques básicos en Java
*
* @author SopraSteria
*
* Esta clase pretende mostrar la estructura de una clase Java sencilla.
* Como se puede ver, los comentarios pueden estar en cualquier parte de la clase.
*
*/

/*
* Declaración de la clase
*/
public class Website {
/*
* Variables de instancia
*/
String webName;
int webAge;

/*
* Constructor de la clase
*/
Website(String name, int age){
[Link] = name;
[Link] = age;
}

27/227
Formación Sopra Steria / Java básico
29 de enero de 2019

* Métodos de la clase
*/
public Date fechaActual() {
Calendar c1 = [Link]();
return [Link]();
}
}

1.9. Tutorial 9 - Destruyendo Objetos

En este tutorial se pretende mostrar cómo funciona el Garbage Collector, el cual elimina de forma
automática de la memoria objetos creados ya no referenciados en ninguna parte del código.

1. Se crea un paquete llamado [Link]

package [Link];

2. Dentro del paquete, se crea la clase DestroyingObjects

package [Link];
public class DestroyingObjects {
}

3. Dentro de la clase DestroyingObjects se crea el método main

package [Link];
public class DestroyingObjects {
public static void main(final String args[]) {
}
}

4. Se crea un objeto DestroyingObjects obj al que posteriormente se le asigna un valor NULL. Este
es por lo tanto eliminado por el Garbage Collector.
package [Link];
public class DestroyingObjects {
public static void main(final String args[]) {
DestroyingObjects obj = new DestroyingObjects();
/*
* El objeto al que hace referencia obj es destruído y recogido por e
l GC
*/
obj = null;

28/227
Formación Sopra Steria / Java básico
29 de enero de 2019

}
}

5. Se craen dos objetos DestroyingObjects a y b. Posteriormente, la referencia de b se actualiza

para que apunte a a, por lo tanto, el objeto creado en DestroyingObjects b = new
DestroyingObjects() es eliminado por el Garbage Collector.
package [Link];
public class DestroyingObjects {
public static void main(final String args[]) {
DestroyingObjects obj = new DestroyingObjects();
/*
* El objeto al que hace referencia obj es destruído y recogido por el GC
*/
obj = null;

DestroyingObjects a = new DestroyingObjects();

DestroyingObjects b = new DestroyingObjects();

* El objeto al que apunaba b es recogido por el GB al cambiar su referencia

al objeto al que apunta a

b = a;

6. Se invoca al Garbage Collector

package [Link];
public class DestroyingObjects {
public static void main(final String args[]) {
DestroyingObjects obj = new DestroyingObjects();
/*
* El objeto al que hace referencia obj es destruído y recogido por el GC
*/
obj = null;

29/227
Formación Sopra Steria / Java básico
29 de enero de 2019

DestroyingObjects a = new DestroyingObjects();

DestroyingObjects b = new DestroyingObjects();

/*
* El objeto al que apunaba b es recogido por el GB al cambiar su referencia
al objeto
* al que apunta a
*/
b = a;

/*
* Se invoca al Garbage Collector
*/
[Link]();
}
}

7. Cada vez que el GC deshecha un objeto, el método finalize() es invocado.

DestroyingObjects a = new DestroyingObjects();

DestroyingObjects b = new DestroyingObjects();

/*
* El objeto al que apunaba b es recogido por el GB al cambiar su referencia
al objeto
* al que apunta a
*/
b = a;

/*
* Se invoca al Garbage Collector

30/227
Formación Sopra Steria / Java básico
29 de enero de 2019

*/
[Link]();
}

@Override
protected void finalize() throws Throwable {
[Link]("Garbage collection is performed by JVM");
}
}

8. Output
Garbage collection is performed by JVM
Garbage collection is performed by JVM

2. Tutorial Capítulo 4: Operadores y sentencias

2.1. Tutorial 1 - Trabajando con operadores binarios aritméticos - Operadores

aritméticos
En este tutorial se pretende mostrar cuáles son los operadores aritméticos de Java haciendo un uso
práctico de ellos.

1. Se crea un paquete llamado [Link]

package [Link];

2. Dentro se crea una clase BasicOperators

package [Link];
public class BasicOperators {
}

3. Se crea un método main

package [Link];
public class BasicOperators {

public static void main(String args[]) {

}
}

31/227
Formación Sopra Steria / Java básico
29 de enero de 2019

4. Se inicializan 2 variables int

package [Link];
public class BasicOperators {

public static void main(String args[]) {

int num1 = 100;

int num2 = 20;

}
}

5. Se muestra por pantalla las operaciones básicas de aritmética

package [Link];
public class BasicOperators {

public static void main(String args[]) {

int num1 = 100;

int num2 = 20;

[Link]("num1 + num2: " + (num1 + num2));

[Link]("num1 - num2: " + (num1 - num2));

[Link]("num1 * num2: " + num1 * num2);

[Link]("num1 / num2: " + num1 / num2);

[Link]("num1 % num2: " + num1 % num2);

}
}

6. Output
num1 + num2: 120
num1 - num2: 80
num1 * num2: 2000
num1 / num2: 5
num1 % num2: 0

32/227
Formación Sopra Steria / Java básico
29 de enero de 2019

2.2. Tutorial 2 - Trabajando con operadores unarios - Operadores logicos (5 min)

En este tutorial se pretende mostrar cuáles son los operadores lógicos de Java haciendo un uso práctico
de ellos.

1. Se crea un paquete llamado [Link]

package [Link];

2. Dentro se crea una clase LogicalOperators

package [Link];

public class LogicalOperators {

3. Se crea un método main

package [Link];

public class LogicalOperators {

public static void main(String args[]) {

4. Se inicializan 2 variables boolean, una a false y la otra a true

package [Link];

public class LogicalOperators {

public static void main(String args[]) {

boolean b1 = true;

boolean b2 = false;

5. Se muestra por pantalla la comparación de las dos variables con todos los operadores lógicos
package [Link];

public class LogicalOperators {

public static void main(String args[]) {

boolean b1 = true;

33/227
Formación Sopra Steria / Java básico
29 de enero de 2019

boolean b2 = false;

[Link]("b1 && b2: " + (b1&&b2));

[Link]("b1 || b2: " + (b1||b2));

[Link]("!(b1 && b2): " + !(b1&&b2));

[Link]("b1 & b2: "+ (b1 & b2));

[Link]("b1 | b2: "+ (b1 | b2));

[Link]("b1 ^ b2: "+ (b1 ^ b2));

6. Output
b1 && b2: false
b1 || b2: true
!(b1 && b2): true
b1 & b2: false
b1 | b2: true
b1 ^ b2: true

2.3. Tutorial 3 - Trabajando con operadores unarios - Operadores de incremento

En este tutorial se pretende mostrar cuáles son los operadores de incremento de Java haciendo un uso
práctico de ellos.

1. Se crea un paquete llamado [Link]

package [Link];

2. Dentro se crea una clase AutoincrementOperators

package [Link];

public class AutoincrementOperators {

3. Se crea un método main

package [Link];

public class AutoincrementOperators {

34/227
Formación Sopra Steria / Java básico
29 de enero de 2019

public static void main(String args[]){

4. Se inicializan 2 variables int

package [Link];

public class AutoincrementOperators {

public static void main(String args[]){

int num1=100;

int num2=200;

5. Se auto-incrementa la primera variable

package [Link];

public class AutoincrementOperators {

public static void main(String args[]){

int num1=100;

int num2=200;

num1++;

6. Se auto-decrementa la segunda variable

package [Link];

public class AutoincrementOperators {

public static void main(String args[]){

int num1=100;

int num2=200;

num1++;

num2--;

35/227
Formación Sopra Steria / Java básico
29 de enero de 2019

7. Se muestran las dos variables por pantalla

package [Link];

public class AutoincrementOperators {

public static void main(String args[]){

int num1=100;

int num2=200;

num1++;

num2--;

[Link]("num1++ is: "+num1);

public class AssignmentOperators {

public static void main(String args[]) {

int num1 = 10;

int num2 = 20;

5. Se muestra por pantalla las operaciones de asignación y las operaciones compuestas de

asignación
package [Link];

public class AssignmentOperators {

public static void main(String args[]) {

int num1 = 10;

int num2 = 20;

num2 = num1;

[Link]("= Output: "+num2);

num2 += num1;

[Link]("+= Output: "+num2);

num2 -= num1;

public static void main(String args[]) {

int num1 = 10;

int num2 = 50;

5. Se realizan sentencias if donde se compara las dos variables con todos los operadores de
comparación
package [Link];

public class ComparisonOperators {

public static void main(String args[]) {

int num1 = 10;

int num2 = 50;

if(num1==num2) {

[Link]("num1 and num2 are equal");

else{

[Link]("num1 and num2 are not equal");

[Link]("num1 is not less than num2");

40/227
Formación Sopra Steria / Java básico
29 de enero de 2019

if( num1 <= num2){

[Link]("num1 is less than or equal to num2");

else{

[Link]("num1 is greater than num2");

6. Output
num1 and num2 are not equal
num1 and num2 are not equal
num1 is not greater than num2
num1 is less than num2
num1 is less than num2
num1 is less than or equal to num2

2.6. Tutorial 6 - Comprender las sentencias - Sentencia If-then

En este tutorial se pretende mostrar cómo funciona la sentencia if a través de una serie de ejemplos.

1. Se crea un paquete llamado [Link]

package [Link];

2. Dentro se crea una clase IfThen

package [Link];

public class IfThen {

3. Se crea un método main

package [Link];

public class IfThen {

public static void main(String args[]){

41/227
Formación Sopra Steria / Java básico
29 de enero de 2019

4. Se inicializa una variable int

package [Link];

public class IfThen {

public static void main(String args[]){

int num=70;

5. Se realiza una sentencia if que compara la variable con otro valor y muestra por pantalla un
mensaje cuando la comparación es verdadera
package [Link];

public class IfThen {

public static void main(String args[]){

int num=70;

if( num < 100 ){

[Link]("number is less than 100");

if(num > 50){

[Link]("number is greater than 50");

8. Output
number is less than 100
number is less than 100
number is greater than 50

43/227
Formación Sopra Steria / Java básico
29 de enero de 2019

2.7. Tutorial 7 - Comprender las sentencias - Sentencia If-then-else

En este tutorial se pretende mostrar cómo funciona la sentencia if-else a través de una serie de ejemplos.

1. Se crea un paquete llamado [Link]

package [Link];

2. Dentro se crea una clase IfThenElse

package [Link];

public class IfThenElse {

3. Se crea un método main

package [Link];

public class IfThenElse {

public static void main(String args[]){

4. Se inicializa una variable int

package [Link];

public class IfThenElse {

public static void main(String args[]){

int num=1234;

5. Se realiza una sentencia if-then-else que compara la variable con otro valor y muestra por
pantalla un mensaje cuando la comparación es verdadera
package [Link];

public class IfThenElse {

public static void main(String args[]){

int num=1234;

44/227
Formación Sopra Steria / Java básico
29 de enero de 2019

if( num < 50 ){

[Link]("num is greater than or equal 50");

45/227
Formación Sopra Steria / Java básico
29 de enero de 2019

if(num <100 && num>=1) {

[Link]("Its a two digit number");

else if(num <1000 && num>=100) {

[Link]("Its a three digit number");

else if(num <10000 && num>=1000) {

[Link]("Its a four digit number");

else if(num <100000 && num>=10000) {

[Link]("Its a five digit number");

else {

package [Link];

public class Switch {

public static void main(String args[]){

int i=2;

5. Se realiza una sentencia switch con 4 casos y uno por defecto. En cada caso se muestra un
mensaje del caso que se ha ejecutado. No hay que olvidar la anotación "break"
package [Link];

public class Switch {

public static void main(String args[]){

int i=2;

switch(i){

case 1:

[Link]("Case1 ");

break;

47/227
Formación Sopra Steria / Java básico
29 de enero de 2019

case 2:

[Link]("Case2 ");

break;

case 3:

[Link]("Case3 ");

break;

case 4:

[Link]("Case4 ");

break;

default:

[Link]("Default ");

public static void main(String args[]){

int y=0;

50/227
Formación Sopra Steria / Java básico
29 de enero de 2019

8. Se recorre el array mediante un bucle while y la variable creada anteriormente

package [Link];

public class While {

public static void main(String args[]){

int i=10;

while(i>1){

[Link](i);

i--;

int arr[]={2,11,45,9};

int y=0;

while(y<4){

9. Se muestra el valor de las posiciones del array

package [Link];

public class While {

public static void main(String args[]){

int i=10;

while(i>1){

[Link](i);

i--;

int arr[]={2,11,45,9};

int y=0;

while(y<4){

51/227
Formación Sopra Steria / Java básico
29 de enero de 2019

[Link]("pos "+ y +": "+ arr[y]);

y++;

10. Output
10
9
8
7
6
5
4
3
2
pos 0: 2
pos 1: 11
pos 2: 45
pos 3: 9

2.10. Tutorial 10 - Comprender las sentencias - Sentencia do-while

En este tutorial se pretende mostrar cómo funciona la sentencia do-while a través de una serie de
ejemplos.

1. Se crea un paquete llamado [Link]

package [Link];

2. Dentro se crea una clase WhileDo

[Link](i);

i--;

}while(i>1);

int arr[]={2,11,45,9};

int y=0;

do{

}while(y<4);

9. Se muestra el valor de las posiciones del array

package [Link];

public class WhileDo {

public static void main(String args[]){

int i=10;

do{

[Link](i);

i--;

}while(i>1);

int arr[]={2,11,45,9};

int y=0;

do{

[Link]("pos "+ y +": "+ arr[y]);

y++;

}while(y<4);

55/227
Formación Sopra Steria / Java básico
29 de enero de 2019

10. Output
10
9
8
7
6
5
4
3
2
pos 0: 2
pos 1: 11
pos 2: 45
pos 3: 9

2.11. Tutorial 11 - Comprender las sentencias - Sentencia for

En este tutorial se pretende mostrar cómo funciona la sentencia for a través de una serie de ejemplos.

1. Se crea un paquete llamado [Link]

package [Link];

2. Dentro se crea una clase For

package [Link];

public class For {

3. Se crea un método main

package [Link];

public class For {

public static void main(String args[]){

56/227
Formación Sopra Steria / Java básico
29 de enero de 2019

4. Se realiza un bucle for que imprime por pantalla el valor de la variable de inicialización y después
se decrementa en uno. El bucle se ejecutará mientras la variable sea mayor que 1
package [Link];

public class For {

public static void main(String args[]){

for(int i=10; i>1; i--){

[Link]("The value of i is: "+i);

5. A continuación se crea un array de int con cuatro valores

package [Link];

public class For {

public static void main(String args[]){

for(int i=10; i>1; i--){

[Link]("The value of i is: "+i);

int arr[]={2,11,45,9};

6. Se recorre el array mediante un bucle for

package [Link];

public class For {

public static void main(String args[]){

for(int i=10; i>1; i--){

[Link]("The value of i is: "+i);

57/227
Formación Sopra Steria / Java básico
29 de enero de 2019

int arr[]={2,11,45,9};

for(int i=0; i<[Link]; i++){

7. Se muestra el valor de las posiciones del array

package [Link];

public class For {

public static void main(String args[]){

for(int i=10; i>1; i--){

[Link]("The value of i is: "+i);

int arr[]={2,11,45,9};

for(int i=0; i<[Link]; i++){

[Link]("For: " + arr[i]);

8. A continuación se recorre el array creado anteriormente con un bucle forEach y se muestra por
pantalla sus valores
package [Link];

public class For {

public static void main(String args[]){

for(int i=10; i>1; i--){

[Link]("The value of i is: "+i);

int arr[]={2,11,45,9};

58/227
Formación Sopra Steria / Java básico
29 de enero de 2019

for(int i=0; i<[Link]; i++){

[Link]("For: " + arr[i]);

for (int num : arr) {

2.12. Tutorial 12 - Comprendiendo el control de flujo avanzado - Sentencia break

En este tutorial se pretende mostrar cómo funciona la sentencia break a través de una serie de ejemplos.

1. Se crea un paquete llamado [Link].

package [Link];

59/227
Formación Sopra Steria / Java básico
29 de enero de 2019

2. Dentro se crea una clase Break.

60/227
Formación Sopra Steria / Java básico
29 de enero de 2019

61/227
Formación Sopra Steria / Java básico
29 de enero de 2019

if (num1==2){

break;

9. Se incremente en uno el valor de la variable.

package [Link];

public class Break {

public static void main(String args[]){

int num1 =0;

while(num1<=100){

[Link]("Value of variable is: "+num1);

[Link]("Out of while-loop");

int var;

for (var =100; var>=10; var --){

13. Se imprime por pantalla el valor de la variable.

package [Link];

public class Break {

public static void main(String args[]){

int num1 =0;

while(num1<=100){

[Link]("Value of variable is: "+num1);

if (num1==2){

break;

64/227
Formación Sopra Steria / Java básico
29 de enero de 2019

num1++;

[Link]("Out of while-loop");

int var;

for (var =100; var>=10; var --){

[Link]("var: "+var);

14. Se realiza una sentencia if-then-else que la compara con otro valor.
package [Link];

public class Break {

public static void main(String args[]){

int num1 =0;

while(num1<=100){

[Link]("Value of variable is: "+num1);

if (num1==2){

break;

num1++;

[Link]("Out of while-loop");

int var;

for (var =100; var>=10; var --){

[Link]("var: "+var);

if (var==99){

65/227
Formación Sopra Steria / Java básico
29 de enero de 2019

15. Si la comparación es verdadera se utiliza la sentencia break para salir del bucle for, si no lo es,
se decrementa en uno el valor de la variable.
package [Link];

public class Break {

public static void main(String args[]){

int num1 =0;

while(num1<=100){

[Link]("Value of variable is: "+num1);

if (num1==2){

break;

num1++;

[Link]("Out of while-loop");

int var;

for (var =100; var>=10; var --){

[Link]("var: "+var);

if (var==99){

break;

66/227
Formación Sopra Steria / Java básico
29 de enero de 2019

16. Una vez salga del bucle se muestra por pantalla un mensaje de salida del bucle.
package [Link];

public class Break {

public static void main(String args[]){

int num1 =0;

while(num1<=100){

[Link]("Value of variable is: "+num1);

if (num1==2){

break;

num1++;

[Link]("Out of while-loop");

int var;

for (var =100; var>=10; var --){

[Link]("var: "+var);

if (var==99){

break;

[Link]("Out of for-loop");

17. Después, se crea una variable.

package [Link];

public class Break {

public static void main(String args[]){

int num1 =0;

67/227
Formación Sopra Steria / Java básico
29 de enero de 2019

while(num1<=100){

[Link]("Value of variable is: "+num1);

if (num1==2){

break;

num1++;

[Link]("Out of while-loop");

int var;

for (var =100; var>=10; var --){

[Link]("var: "+var);

if (var==99){

break;

[Link]("Out of for-loop");

int num2=2;

18. Se realiza una sentencia switch que compara esa variable con un caso del switch.
package [Link];

public class Break {

public static void main(String args[]){

int num1 =0;

while(num1<=100){

[Link]("Value of variable is: "+num1);

if (num1==2){

68/227
Formación Sopra Steria / Java básico
29 de enero de 2019

break;

num1++;

[Link]("Out of while-loop");

int var;

for (var =100; var>=10; var --){

[Link]("var: "+var);

if (var==99){

break;

[Link]("Out of for-loop");

int num2=2;

switch (num2){

19. Se imprime por pantalla el caso al que se ha accedido. Se utiliza la sentencia break para salir del
switch.
package [Link];

public class Break {

public static void main(String args[]){

int num1 =0;

while(num1<=100){

[Link]("Value of variable is: "+num1);

if (num1==2){

69/227
Formación Sopra Steria / Java básico
29 de enero de 2019

break;

num1++;

[Link]("Out of while-loop");

int var;

for (var =100; var>=10; var --){

[Link]("var: "+var);

if (var==99){

break;

[Link]("Out of for-loop");

int num2=2;

switch (num2){

case 1:

[Link]("Case 1 ");

break;

case 2:

[Link]("Case 2 ");

break;

case 3:

[Link]("Case 3 ");

break;

default:

[Link]("Default ");

70/227
Formación Sopra Steria / Java básico
29 de enero de 2019

20. Output
Value of variable is: 0
Value of variable is: 1
Value of variable is: 2
Out of while-loop
var: 100
var: 99
Out of for-loop
Case 2

2.13. Tutorial 13 - Comprendiendo el control de flujo avanzado - Sentencia continue

En este tutorial se pretende mostrar cómo funciona la sentencia continue a través de una serie de
ejemplos.

1. Se crea un paquete llamado [Link]

package [Link];

2. Dentro se crea una clase Continue

while (counter >=0){

6. Se realiza un sentencia if-then que la compara con otro valor

package [Link];

public class Continue {

public static void main(String args[]){

int counter=10;

while (counter >=0){

if (counter==7){

72/227
Formación Sopra Steria / Java básico
29 de enero de 2019

7. Si es verdadera la comparación se decrementa el valor de la variable y se ejecuta la sentencia

continue para pasar a la siguiente iteración
package [Link];

public class Continue {

public static void main(String args[]){

int counter=10;

while (counter >=0){

continue;

[Link](counter+" ");

74/227
Formación Sopra Steria / Java básico
29 de enero de 2019

counter--;

for (int j=0; j<=6; j++){

if (j==4){

11. Si la comparación es verdadera se utiliza la sentencia continue para pasar a la siguiente iteración
del bucle for
package [Link];

public class Continue {

public static void main(String args[]){

int counter=10;

while (counter >=0){

if (counter==7){

counter--;

continue;

[Link](counter+" ");

counter--;

for (int j=0; j<=6; j++){

if (j==4){

continue;

75/227
Formación Sopra Steria / Java básico
29 de enero de 2019

12. Se imprime por pantalla el valor de la variable

package [Link];

public class Continue {

public class Continue {

public static void main(String args[]){

int counter=10;

while (counter >=0){

if (counter==7){

counter--;

continue;

77/227
Formación Sopra Steria / Java básico
29 de enero de 2019

[Link](counter+" ");

counter--;

for (int j=0; j<=6; j++){

if (j==4){

continue;

[Link](j+" ");

int j=0;

do{

}while(j<10);

15. Se realiza un sentencia if-then-else que la compara con otro valor

package [Link];

public class Continue {

public static void main(String args[]){

int counter=10;

while (counter >=0){

if (counter==7){

counter--;

continue;

[Link](counter+" ");

counter--;

78/227
Formación Sopra Steria / Java básico
29 de enero de 2019

for (int j=0; j<=6; j++){

if (j==4){

continue;

[Link](j+" ");

int j=0;

do{

if (j==7){

}while(j<10);

16. Si la comparación es verdadera se incrementa el valor de la variable en uno y se utiliza la

sentencia continue para pasar a la siguiente iteración del bucle do-while
package [Link];

public class Continue {

public static void main(String args[]){

int counter=10;

while (counter >=0){

if (counter==7){

counter--;

continue;

[Link](counter+" ");

counter--;

79/227
Formación Sopra Steria / Java básico
29 de enero de 2019

for (int j=0; j<=6; j++){

if (j==4){

continue;

[Link](j+" ");

int j=0;

do{

if (j==7){

j++;

continue;

}while(j<10);

17. Se imprime por pantalla el valor de la variable y se incrementa en uno

package [Link];

public class Continue {

public static void main(String args[]){

int counter=10;

while (counter >=0){

if (counter==7){

counter--;

continue;

[Link](counter+" ");

80/227
Formación Sopra Steria / Java básico
29 de enero de 2019

counter--;

for (int j=0; j<=6; j++){

if (j==4){

continue;

[Link](j+" ");

int j=0;

do{

if (j==7){

j++;

continue;

[Link](j+ " ");

j++;

}while(j<10);

public class Sentences1 {

public static void main(String[] args) {
int num;

84/227
Formación Sopra Steria / Java básico
29 de enero de 2019

int cont_zeros; // the zero counter

int cont_pos; // positive counter
int cont_neg; // negative counter
int sum_pos,sum_neg; // sum of the positive and negative numbers
float average_pos,average_neg; // positive and negative averages can have
decimal places
cont_zeros=0;
cont_pos=0;
cont_neg=0;
sum_pos=0;
sum_neg=0;
for (int i=1;i<=10;i++)
{
num=(int) ([Link]() * 7) + 1;
[Link]("Random number: "+ num);
if(num==0)
cont_zeros++;
else {
if(num>0)
{
cont_pos++;
sum_pos+=num;
} else {
cont_neg++;
sum_neg+=num;
}
}
}
// Zeros
[Link]("The number of zeros entered is: "+cont_zeros);
//Positives
if (cont_pos ==0)
[Link]("You can't do the average of the positives");
else {
average_pos= (float)sum_pos/cont_pos;
[Link]("Average of positives: "+ average_pos);
}
// Negatives
if (cont_pos ==0)
[Link]("You can't do the average of the negatives.")
;
else {
average_neg= (float)sum_neg/cont_neg;

85/227
Formación Sopra Steria / Java básico
29 de enero de 2019

[Link]("Average of negatives: "+ average_neg);

}
}
}

9. Output:

(Es un ejemplo de Output, puede diferir ya que se generan valores aleatorios)

Random number: 5
Random number: 2
Random number: 3
Random number: 1
Random number: 6
Random number: 6
Random number: 1
Random number: 6
Random number: 7
Random number: 6
The number of zeros entered is: 0
Average of positives: 4.3
Average of negatives: NaN

2.15. Tutorial 15 - Ejercicio global - Sentencias 2

En este tutorial, vamos a ver cómo usar operadores de asignación, aritméticos, unario y generar datos
random.

Una empresa que se dedica a la venta de desinfectantes necesita un programa para gestionar las
facturas. En cada factura figura: el código del artículo, la cantidad vendida en litros y el precio por litro.
Se pide de 5 facturas introducidas: Facturación total, cantidad en litros vendidos del artículo 1 y cuantas
facturas se emitieron de más de 600 €.

1. Se crea un paquete llamado [Link]

package [Link];

2. Dentro se crea una clase Sentences2

package [Link];

public class Sentences2{}

86/227
Formación Sopra Steria / Java básico
29 de enero de 2019

3. Se crea un método main

package [Link];

public class Sentences2 {

public static void main(String[] args) {}

4. Se declaran y se inicializan las variables necesarias para almacenar los contadores de ceros,
negativos y positivos
package [Link];
public class Sentences2 {
public static void main(String[] args) {
int code; // the item code on each invoice
int liters; // the number of liters in each invoice
float price; // now the price is not asked per keyboard
float invoice_amount; // This saves the amount of the current invoice.
float total_invoicing; // the amount of all invoices
int liters_cod1; // the total litres sold of product 1 on all invoices
int over_600; // counter to keep track of all invoices over 600 €
total_invoicing = 0;
liters_cod1 = 0; over_600 = 0;
total_invoicing = 0;
code = 0; over_600 = 0;
}
}
}

5. Se realiza una sentencia for de 5 iteraciones

package [Link];
public class Sentences2 {
public static void main(String[] args) {
int code; // the item code on each invoice
int liters; // the number of liters in each invoice
float price; // now the price is not asked per keyboard
float invoice_amount; // This saves the amount of the current invoice.
float total_invoicing; // the amount of all invoices
int liters_cod1; // the total litres sold of product 1 on all invoices
int over_600; // counter to keep track of all invoices over 600 €
total_invoicing = 0;
liters_cod1 = 0; over_600 = 0;
total_invoicing = 0;

87/227
Formación Sopra Steria / Java básico
29 de enero de 2019

code = 0; over_600 = 0;
for (int i=1;i<=5;i++) { }
}
}

6. Se generan valores aleatorios para el código, los litros y el precio por litro
package [Link];
public class Sentences2 {
public static void main(String[] args) {
int code; // the item code on each invoice
int liters; // the number of liters in each invoice
float price; // now the price is not asked per keyboard
float invoice_amount; // This saves the amount of the current invoice.
float total_invoicing; // the amount of all invoices
int liters_cod1; // the total litres sold of product 1 on all invoices
int over_600; // counter to keep track of all invoices over 600 €
total_invoicing = 0;
liters_cod1 = 0; over_600 = 0;
total_invoicing = 0;
code = 0; over_600 = 0;
for (int i=1;i<=5;i++) {

[Link]("Invoice nº " + i);

code=(int) ([Link]() * 2) + 1;

[Link]("product code: "+code );

liters=(int) ([Link]() * 10) + 1;

[Link]("number (liters): "+liters);

price= (int) ([Link]() * 300) + 200;

[Link]("price (litre): "+price);

}
}
}

88/227
Formación Sopra Steria / Java básico
29 de enero de 2019

7. Se calcula el importe de la factura, el total de facturación y la cantidad de litros para el artículo

1
package [Link];
public class Sentences2 {
public static void main(String[] args) {
int code; // the item code on each invoice
int liters; // the number of liters in each invoice
float price; // now the price is not asked per keyboard
float invoice_amount; // This saves the amount of the current invoice.
float total_invoicing; // the amount of all invoices
int liters_cod1; // the total litres sold of product 1 on all invoices
int over_600; // counter to keep track of all invoices over 600 €
total_invoicing = 0;
liters_cod1 = 0; over_600 = 0;
total_invoicing = 0;
code = 0; over_600 = 0;
for (int i=1;i<=5;i++) {

[Link]("Invoice nº " + i);

code=(int) ([Link]() * 2) + 1;

[Link]("product code: "+code );

liters=(int) ([Link]() * 10) + 1;

[Link]("number (liters): "+liters);

price= (int) ([Link]() * 300) + 200;

[Link]("price (litre): "+price);

invoice_amount = liters*price;

total_invoicing += invoice_amount;

if (code == 1)

liters_cod1 += liters;

if(invoice_amount >= 600)

over_600 ++;

89/227
Formación Sopra Steria / Java básico
29 de enero de 2019

}
}

8. Se muestran los resultados por pantalla

[Link]("Invoice nº " + i);

code=(int) ([Link]() * 2) + 1;

[Link]("product code: "+code );

liters=(int) ([Link]() * 10) + 1;

[Link]("number (liters): "+liters);

price= (int) ([Link]() * 300) + 200;

[Link]("price (litre): "+price);

invoice_amount = liters*price;

total_invoicing += invoice_amount;

90/227
Formación Sopra Steria / Java básico
29 de enero de 2019

if (code == 1)

liters_cod1 += liters;

if(invoice_amount >= 600)

over_600 ++;

[Link]("\n\n\nSales Overview\n");

// total invoicing

[Link]("Total invoicing: " +total_invoicing + "€");

// liters of article 1

[Link]("Product sales 1: " + liters_cod1 + " liters");

// Invoice of more than 600 euros

[Link]("Invoice over 600€: " + over_600);

}
}

9. Output

(Es un ejemplo de Output, puede diferir ya que se generan valores aleatorios)

Invoice nº 1
product code: 2
number (liters): 9
price (litre): 480.0
Invoice nº 2
product code: 2
number (liters): 6
price (litre): 228.0
Invoice nº 3
product code: 1
number (liters): 7
price (litre): 214.0
Invoice nº 4
product code: 1
number (liters): 1
price (litre): 396.0
Invoice nº 5
product code: 2
number (liters): 2

91/227
Formación Sopra Steria / Java básico
29 de enero de 2019

price (litre): 298.0

Sales Overview
Total invoicing: 8178.0€
Product sales 1: 8 liters
Invoice over 600€: 3

2.16. Tutorial 16 - Ejercicio global - Sentencias 3

En este tutorial, vamos a ver cómo usar operadores de asignación, aritméticos, unario, la sentencia case
y generar datos aleatorios.

Igual que el anterior pero suponiendo que no se introduce el precio por litro. Solo existen tres productos
con precios:

1- 0,6 €/litro, 2- 30 €/litro y 3- 1,25 €/litro.

1. Se crea un paquete llamado [Link]

package [Link];

2. Dentro se crea una clase Sentences3

package [Link];

public class Sentences3{}

3. Se crea un método main

package [Link];

public class Sentences3 {

public static void main(String[] args) {}

4. Se declaran y se inicializan las variables necesarias para almacenar los contadores de ceros,
negativos y positivos
package [Link];
public class Sentences3 {
public static void main(String[] args) {
int code; // the item code on each invoice
int liters; // the number of liters in each invoice
float price; // now the price is not asked per keyboard
float invoice_amount; // This saves the amount of the current invoice.
float total_invoicing; // the amount of all invoices

92/227
Formación Sopra Steria / Java básico
29 de enero de 2019

int liters_cod1; // the total litres sold of product 1 on all invoices

int over_600; // counter to keep track of all invoices over 600 €
total_invoicing = 0;
liters_cod1 = 0; over_600 = 0;
total_invoicing = 0;
}
}
}

5. Se realiza una sentencia for de 5 iteraciones

package [Link];
public class Sentences3 {
public static void main(String[] args) {
int code; // the item code on each invoice
int liters; // the number of liters in each invoice
float price; // now the price is not asked per keyboard
float invoice_amount; // This saves the amount of the current invoice.
float total_invoicing; // the amount of all invoices
int liters_cod1; // the total litres sold of product 1 on all invoices
int over_600; // counter to keep track of all invoices over 600 €
total_invoicing = 0;
liters_cod1 = 0; over_600 = 0;
total_invoicing = 0;
for (int i=1;i<=5;i++) { }
}
}

6. Se generan valores aleatorios para el código, los litros y el case con los precios por litro según
el código
package [Link];
public class Sentences3 {
public static void main(String[] args) {
int code; // the item code on each invoice
int liters; // the number of liters in each invoice
float price; // now the price is not asked per keyboard
float invoice_amount; // This saves the amount of the current invoice.
float total_invoicing; // the amount of all invoices
int liters_cod1; // the total litres sold of product 1 on all invoices
int over_600; // counter to keep track of all invoices over 600 €
total_invoicing = 0;
liters_cod1 = 0; over_600 = 0;

93/227
Formación Sopra Steria / Java básico
29 de enero de 2019

total_invoicing = 0;
for (int i=1;i<=5;i++) {

[Link]("Invoice nº " + i);

code=(int) ([Link]() * 2) + 1;

[Link]("product code: "+code );

liters=(int) ([Link]() * 100) + 1;

[Link]("number (liters): "+liters);

switch (code) {

case 1:

price = 0.6f;

break;

case 2:

price = 30f;

break;

case 3:

price = 101.25f;

break;

default:

price = 0; // this case should not occur

}
}
}

7. Se calcula el importe de la factura, el total de facturación y la cantidad de litros para el artículo

1
package [Link];
public class Sentences3 {
public static void main(String[] args) {
int code; // the item code on each invoice

94/227
Formación Sopra Steria / Java básico
29 de enero de 2019

int liters; // the number of liters in each invoice

float price; // now the price is not asked per keyboard
float invoice_amount; // This saves the amount of the current invoice.
float total_invoicing; // the amount of all invoices
int liters_cod1; // the total litres sold of product 1 on all invoices
int over_600; // counter to keep track of all invoices over 600 €
total_invoicing = 0;
liters_cod1 = 0; over_600 = 0;
total_invoicing = 0;
for (int i=1;i<=5;i++) {

[Link]("Invoice nº " + i);

code=(int) ([Link]() * 2) + 1;

[Link]("product code: "+code );

liters=(int) ([Link]() * 10) + 1;

[Link]("number (liters): "+liters);

switch (code) {

case 1:

price = 0.6f;

break;

case 2:

price = 30f;

break;

case 3:

price = 101.25f;

break;

default:

price = 0; // this case should not occur

95/227
Formación Sopra Steria / Java básico
29 de enero de 2019

invoice_amount = liters*price;

total_invoicing += invoice_amount;

if (code == 1)

liters_cod1 += liters;

if(invoice_amount >= 600)

over_600 ++;

}
}

8. Se muestran los resultados por pantalla

package [Link];
public class Sentencies2 {
public static void main(String[] args) {
int code; // the item code on each invoice
int liters; // the number of liters in each invoice
float price; // now the price is not asked per keyboard
float invoice_amount; // This saves the amount of the current invoice.
float total_invoicing; // the amount of all invoices
int liters_cod1; // the total litres sold of product 1 on all invoices
int over_600; // counter to keep track of all invoices over 600 €
total_invoicing = 0;
liters_cod1 = 0; over_600 = 0;
total_invoicing = 0;
code = 0; over_600 = 0;
for (int i=1;i<=5;i++) {

[Link]("Invoice nº " + i);

code=(int) ([Link]() * 2) + 1;

[Link]("product code: "+code );

liters=(int) ([Link]() * 10) + 1;

[Link]("number (liters): "+liters);

switch (code) {

96/227
Formación Sopra Steria / Java básico
29 de enero de 2019

case 1:

price = 0.6f;

break;

case 2:

price = 30f;

break;

case 3:

price = 101.25f;

break;

default:

price = 0; // this case should not occur

invoice_amount = liters*price;

total_invoicing += invoice_amount;

if (code == 1)

liters_cod1 += liters;

if(invoice_amount >= 600)

over_600 ++;

[Link]("\n\n\nSales Overview\n");

// total invoicing

[Link]("Total invoicing: " +total_invoicing + "€");

// liters of article 1

[Link]("Liters Article 1: " + liters_cod1 + " liters");

// Invoice of more than 600 euros

97/227
Formación Sopra Steria / Java básico
29 de enero de 2019

[Link]("Invoice over 600€: " + over_600);

}
}

9. Output
Invoice nº 1
Product code: 2
Number (liters): 51
Invoice nº 2
Product code: 1
Number (liters): 87
Invoice nº 3
Product code: 1
Number (liters): 68
Invoice nº 4
Product code: 2
Number (liters): 97
Invoice nº 5
Product code: 2
Number (liters): 70
Sales Overview
The total invoicing is: 6633.0€
Liters Article 1 : 155 liters
Invoice over €600: 3

3. Tutorial Capitulo 5: API de Java

char[] helloArray = { 'H', 'e', 'l', 'l', 'o'};

5. Se convierte el array en un objeto String y se imprime por pantalla

package [Link];

public class StringType {

public static void main(final String args[]) {

char[] helloArray = { 'H', 'e', 'l', 'l', 'o'};

String helloString = new String(helloArray);

[Link](helloString);

6. Se crea una variable len y se le asigna la longitud del String. Después se imprime por pantalla
package [Link];

public class StringType {

public static void main(final String args[]) {

99/227
Formación Sopra Steria / Java básico
29 de enero de 2019

char[] helloArray = { 'H', 'e', 'l', 'l', 'o'};

String helloString = new String(helloArray);

[Link](helloString);

int len = [Link]();

[Link]("String Length is : " + len);

7. Se añade al String otro String y se imprime por pantalla

package [Link];

public class StringType {

public static void main(final String args[]) {

char[] helloArray = { 'H', 'e', 'l', 'l', 'o'};

[Link]([Link](6));

9. Se imprime por pantalla la posición del primer carácter "l"

package [Link];

public class StringType {

public static void main(final String args[]) {

char[] helloArray = { 'H', 'e', 'l', 'l', 'o'};

String helloString = new String(helloArray);

[Link](helloString);

int len = [Link]();

[Link]("String Length is : " + len);

helloString = [Link](" World ");

[Link](helloString);

[Link]([Link](6));

[Link]([Link]('l'));

101/227
Formación Sopra Steria / Java básico
29 de enero de 2019

10. Se imprime por pantalla el substring del String inicial desde la posición 3 hasta el final
package [Link];

public class StringType {

public static void main(final String args[]) {

char[] helloArray = { 'H', 'e', 'l', 'l', 'o'};

String helloString = new String(helloArray);

[Link](helloString);

int len = [Link]();

[Link]("String Length is : " + len);

helloString = [Link](" World ");

[Link](helloString);

[Link]([Link](6));

[Link]([Link]('l'));

[Link]([Link](3));

11. Se imprime por pantalla el String en mayúsculas

package [Link];

public class StringType {

public static void main(final String args[]) {

char[] helloArray = { 'H', 'e', 'l', 'l', 'o'};

102/227
Formación Sopra Steria / Java básico
29 de enero de 2019

String helloString = new String(helloArray);

[Link](helloString);

int len = [Link]();

[Link]("String Length is : " + len);

helloString = [Link](" World ");

[Link](helloString);

[Link]([Link](6));

[Link]([Link]('l'));

[Link]([Link](3));

[Link]([Link]());

12. Se imprime por pantalla si el String es igual al String "ABC"

package [Link];

public class StringType {

public static void main(final String args[]) {

char[] helloArray = { 'H', 'e', 'l', 'l', 'o'};

String helloString = new String(helloArray);

[Link](helloString);

int len = [Link]();

[Link]("String Length is : " + len);

103/227
Formación Sopra Steria / Java básico
29 de enero de 2019

helloString = [Link](" World ");

[Link](helloString);

[Link]([Link](6));

[Link]([Link]('l'));

[Link]([Link](3));

[Link]([Link]());

[Link]([Link]("ABC"));

13. Se imprime por pantalla si el String empieza por la letra "a"

package [Link];

public class StringType {

public static void main(final String args[]) {

char[] helloArray = { 'H', 'e', 'l', 'l', 'o'};

String helloString = new String(helloArray);

[Link](helloString);

int len = [Link]();

[Link]("String Length is : " + len);

helloString = [Link](" World ");

[Link](helloString);

[Link]([Link](6));

104/227
Formación Sopra Steria / Java básico
29 de enero de 2019

[Link]([Link]('l'));

[Link]([Link](3));

[Link]([Link]());

[Link]([Link]("ABC"));

[Link]([Link]("a"));

14. Se imprime por pantalla si el String contiene la letra "o"

package [Link];

public class StringType {

public static void main(final String args[]) {

char[] helloArray = { 'H', 'e', 'l', 'l', 'o'};

String helloString = new String(helloArray);

[Link](helloString);

int len = [Link]();

[Link]("String Length is : " + len);

helloString = [Link](" World ");

[Link](helloString);

[Link]([Link](6));

[Link]([Link]('l'));

105/227
Formación Sopra Steria / Java básico
29 de enero de 2019

[Link]([Link](3));

[Link]([Link]());

[Link]([Link]("ABC"));

[Link]([Link]("a"));

[Link]([Link]("o"));

15. Se imprime por pantalla el cambio de la letra "e" por la letra "a"
package [Link];

public class StringType {

public static void main(final String args[]) {

char[] helloArray = { 'H', 'e', 'l', 'l', 'o'};

String helloString = new String(helloArray);

[Link](helloString);

int len = [Link]();

[Link]("String Length is : " + len);

helloString = [Link](" World ");

[Link](helloString);

[Link]([Link](6));

[Link]([Link]('l'));

106/227
Formación Sopra Steria / Java básico
29 de enero de 2019

[Link]([Link](3));

[Link]([Link]());

[Link]([Link]("ABC"));

[Link]([Link]("a"));

[Link]([Link]("o"));

[Link]([Link]('e', 'a'));

16. Se imprime por pantalla el String sin espacios en blanco delante y detrás
package [Link];

public class StringType {

public static void main(final String args[]) {

char[] helloArray = { 'H', 'e', 'l', 'l', 'o'};

String helloString = new String(helloArray);

[Link](helloString);

int len = [Link]();

[Link]("String Length is : " + len);

helloString = [Link](" World ");

[Link](helloString);

[Link]([Link](6));

107/227
Formación Sopra Steria / Java básico
29 de enero de 2019

[Link]([Link]('l'));

[Link]([Link](3));

[Link]([Link]());

[Link]([Link]("ABC"));

[Link]([Link]("a"));

[Link]([Link]("o"));

[Link]([Link]('e', 'a'));

[Link]([Link]());

17. Se crea un String que contenga una palabra

package [Link];

public class StringType {

public static void main(final String args[]) {

char[] helloArray = { 'H', 'e', 'l', 'l', 'o'};

String helloString = new String(helloArray);

[Link](helloString);

int len = [Link]();

[Link]("String Length is : " + len);

108/227
Formación Sopra Steria / Java básico
29 de enero de 2019

helloString = [Link](" World ");

[Link](helloString);

[Link]([Link](6));

[Link]([Link]('l'));

[Link]([Link](3));

[Link]([Link]());

[Link]([Link]("ABC"));

[Link]([Link]("a"));

[Link]([Link]("o"));

[Link]([Link]('e', 'a'));

[Link]([Link]());

String str = "world";

18. Se crea un objeto StringBuilder con ese String

package [Link];

public class StringType {

public static void main(final String args[]) {

char[] helloArray = { 'H', 'e', 'l', 'l', 'o'};

109/227
Formación Sopra Steria / Java básico
29 de enero de 2019

String helloString = new String(helloArray);

[Link](helloString);

int len = [Link]();

[Link]("String Length is : " + len);

helloString = [Link](" World ");

[Link](helloString);

[Link]([Link](6));

[Link]([Link]('l'));

[Link]([Link](3));

[Link]([Link]());

[Link]([Link]("ABC"));

[Link]([Link]("a"));

[Link]([Link]("o"));

[Link]([Link]('e', 'a'));

[Link]([Link]());

String str = "world";

StringBuilder sb = new StringBuilder(str);

110/227
Formación Sopra Steria / Java básico
29 de enero de 2019

19. Se utiliza un método del objeto Stringbuilder para invertir el orden de las letras
package [Link];

public class StringType {

public static void main(final String args[]) {

char[] helloArray = { 'H', 'e', 'l', 'l', 'o'};

String helloString = new String(helloArray);

[Link](helloString);

int len = [Link]();

[Link]("String Length is : " + len);

helloString = [Link](" World ");

[Link](helloString);

[Link]([Link](6));

[Link]([Link]('l'));

[Link]([Link](3));

[Link]([Link]());

[Link]([Link]("ABC"));

[Link]([Link]("a"));

[Link]([Link]("o"));

111/227
Formación Sopra Steria / Java básico
29 de enero de 2019

[Link]([Link]('e', 'a'));

[Link]([Link]());

String str = "world";

StringBuilder sb = new StringBuilder(str);

[Link]();

20. Se imprime por pantalla

package [Link];

public class StringType {

public static void main(final String args[]) {

char[] helloArray = { 'H', 'e', 'l', 'l', 'o'};

String helloString = new String(helloArray);

[Link](helloString);

int len = [Link]();

[Link]("String Length is : " + len);

helloString = [Link](" World ");

[Link](helloString);

[Link]([Link](6));

[Link]([Link]('l'));

[Link]([Link](3));

112/227
Formación Sopra Steria / Java básico
29 de enero de 2019

[Link]([Link]());

[Link]([Link]("ABC"));

[Link]([Link]("a"));

[Link]([Link]("o"));

[Link]([Link]('e', 'a'));

[Link]([Link]());

String str = "world";

StringBuilder sb = new StringBuilder(str);

[Link]();

[Link](sb);

21. Output
Hello
String Length is : 5
Hello World
W
2
lo World
HELLO WORLD
false
false
true
Hallo World
Hello World
dlrow

113/227
Formación Sopra Steria / Java básico
29 de enero de 2019

3.2. Tutorial 2 - Entender Arrays de Java - Arrays

Se pretende en este tutorial hacer uso de los arrays de Java, teniendo un primer contacto con la forma
de trabajar con ellos y su forma de recorrerlos.

1. Se crea un paquete llamado [Link]

package [Link];

2. Dentro se crea una clase ArrayType

package [Link];

import [Link];

public class ArrayType {

public static void main(String[] args) {

int[] myList = {3, 5, 2, 1};

114/227
Formación Sopra Steria / Java básico
29 de enero de 2019

6. Se crea una función printArray que dado un array imprima el valor de sus posiciones mediante
un bucle for y pasándole el array creado anteriormente
package [Link];

import [Link];

public class ArrayType {

public static void main(String[] args) {

int[] myList = {3, 5, 2, 1};

printArray(myList);

public static void printArray(int[] myList) {

for (int i = 0; i < [Link]; i++) {

[Link](myList[i] + " ");

7. Se crea una función reverse que dado un array coja sus valores y los inserte de forma invertida
en otro array y después lo devuelva
package [Link];

import [Link];

public class ArrayType {

public static void main(String[] args) {

int[] myList = {3, 5, 2, 1};

printArray(myList);

115/227
Formación Sopra Steria / Java básico
29 de enero de 2019

reverse(myList);

public static void printArray(int[] myList) {

for (int i = 0; i < [Link]; i++) {

[Link](myList[i] + " ");

public static int[] reverse(int[] list) {

for (int i = 0, j = [Link] - 1; i < [Link]; i++, j--) {

8. Para ello se crea un array auxiliar con el tamaño del array actual. Se recorre con un bucle for el
array y se insertan en el array auxiliar los valores del array actual
package [Link];

import [Link];

public class ArrayType {

public static void main(String[] args) {

int[] myList = {3, 5, 2, 1};

printArray(myList);

reverse(myList);

public static void printArray(int[] myList) {

for (int i = 0; i < [Link]; i++) {

116/227
Formación Sopra Steria / Java básico
29 de enero de 2019

[Link](myList[i] + " ");

public static int[] reverse(int[] list) {

int[] result = new int[[Link]];

for (int i = 0, j = [Link] - 1; i < [Link]; i++, j--) {

result[j] = list[i];

9. Por último se devuelve el resultado

package [Link];

import [Link];

public class ArrayType {

public static void main(String[] args) {

int[] myList = {3, 5, 2, 1};

printArray(myList);

reverse(myList);

public static void printArray(int[] myList) {

for (int i = 0; i < [Link]; i++) {

[Link](myList[i] + " ");

117/227
Formación Sopra Steria / Java básico
29 de enero de 2019

public static int[] reverse(int[] list) {

int[] result = new int[[Link]];

for (int i = 0, j = [Link] - 1; i < [Link]; i++, j--) {

result[j] = list[i];

return result;

10. Se ordena el array inicial y se imprimen sus valores por pantalla

package [Link];

import [Link];

public class ArrayType {

public static void main(String[] args) {

int[] myList = {3, 5, 2, 1};

printArray(myList);

reverse(myList);

[Link](myList);

for (int num : myList)

[Link](num + " ");

public static void printArray(int[] myList) {

for (int i = 0; i < [Link]; i++) {

[Link](myList[i] + " ");

118/227
Formación Sopra Steria / Java básico
29 de enero de 2019

public static int[] reverse(int[] list) {

int[] result = new int[[Link]];

for (int i = 0, j = [Link] - 1; i < [Link]; i++, j--) {

result[j] = list[i];

return result;

11. Finalmente se imprime por pantalla la posición donde se encuentra el número 3

package [Link];

import [Link];

public class ArrayType {

public static void main(String[] args) {

int[] myList = {3, 5, 2, 1};

printArray(myList);

reverse(myList);

[Link](myList);

for (int num : myList)

[Link](num + " ");

[Link]([Link](myList, 3));

public static void printArray(int[] myList) {

for (int i = 0; i < [Link]; i++) {

119/227
Formación Sopra Steria / Java básico
29 de enero de 2019

[Link](myList[i] + " ");

public static int[] reverse(int[] list) {

int[] result = new int[[Link]];

for (int i = 0, j = [Link] - 1; i < [Link]; i++, j--) {

result[j] = list[i];

return result;

public static void main(String args[]) {

4. Se importan los paquetes [Link] y [Link]

package [Link];

import [Link];

public class ArrayListType {

public static void main(String args[]) {

5. Se crea un ArrayList de String

package [Link];

import [Link];

public class ArrayListType {

public static void main(String args[]) {

ArrayList<String> obj = new ArrayList<String>();

121/227
Formación Sopra Steria / Java básico
29 de enero de 2019

6. Se añaden 5 nombres al ArrayList

package [Link];

import [Link];

public class ArrayListType {

public static void main(String args[]) {

ArrayList<String> obj = new ArrayList<String>();

[Link]("Juan");

[Link]("Harry");

[Link]("Carlos");

[Link]("David");

[Link]("Pablo");

7. Se imprime por pantalla el contenido del ArrayList

package [Link];

import [Link];

public class ArrayListType {

public static void main(String args[]) {

ArrayList<String> obj = new ArrayList<String>();

[Link]("Juan");

[Link]("Harry");

[Link]("Carlos");

[Link]("David");

[Link]("Pablo");

122/227
Formación Sopra Steria / Java básico
29 de enero de 2019

[Link]("Elements of the array:"+obj);

8. Se añaden 2 nombres más al ArrayList

package [Link];

import [Link];

public class ArrayListType {

public static void main(String args[]) {

ArrayList<String> obj = new ArrayList<String>();

[Link]("Juan");

[Link]("Harry");

[Link]("Carlos");

[Link]("David");

[Link]("Pablo");

[Link]("Elements of the array:"+obj);

[Link](4, "Elena");

[Link](2, "Carla");

9. Se borran 2 nombres del ArrayList

package [Link];

import [Link];

public class ArrayListType {

123/227
Formación Sopra Steria / Java básico
29 de enero de 2019

public static void main(String args[]) {

ArrayList<String> obj = new ArrayList<String>();

[Link]("Juan");

[Link]("Harry");

[Link]("Carlos");

[Link]("David");

[Link]("Pablo");

[Link]("Elements of the array:"+obj);

[Link](4, "Elena");

[Link](2, "Carla");

[Link]("David");

[Link]("Harry");

10. Se cambia el nombre de la posición 0

package [Link];

import [Link];

public class ArrayListType {

public static void main(String args[]) {

ArrayList<String> obj = new ArrayList<String>();

[Link]("Juan");

[Link]("Harry");

[Link]("Carlos");

124/227
Formación Sopra Steria / Java básico
29 de enero de 2019

[Link]("David");

[Link]("Pablo");

[Link]("Elements of the array:"+obj);

[Link](4, "Elena");

[Link](2, "Carla");

[Link]("David");

[Link]("Harry");

[Link](0, "Robin");

11. Se imprime por pantalla si el ArrayList está vacío

package [Link];

import [Link];

public class ArrayListType {

public static void main(String args[]) {

ArrayList<String> obj = new ArrayList<String>();

[Link]("Juan");

[Link]("Harry");

[Link]("Carlos");

[Link]("David");

[Link]("Pablo");

125/227
Formación Sopra Steria / Java básico
29 de enero de 2019

[Link]("Elements of the array:"+obj);

[Link](4, "Elena");

[Link](2, "Carla");

[Link]("David");

[Link]("Harry");

[Link](0, "Robin");

[Link]([Link]());

12. Se imprime por pantalla el tamañano del ArrayList

package [Link];

import [Link];

public class ArrayListType {

public static void main(String args[]) {

ArrayList<String> obj = new ArrayList<String>();

[Link]("Juan");

[Link]("Harry");

[Link]("Carlos");

[Link]("David");

[Link]("Pablo");

[Link]("Elements of the array:"+obj);

126/227
Formación Sopra Steria / Java básico
29 de enero de 2019

[Link](4, "Elena");

[Link](2, "Carla");

[Link]("David");

[Link]("Harry");

[Link](0, "Robin");

[Link]([Link]());

13. Se imprime por pantalla si el ArrayList contiene el nombre "Carla"

package [Link];

import [Link];

public class ArrayListType {

public static void main(String args[]) {

ArrayList<String> obj = new ArrayList<String>();

[Link]("Juan");

[Link]("Harry");

[Link]("Carlos");

[Link]("David");

[Link]("Pablo");

[Link]("Elements of the array:"+obj);

127/227
Formación Sopra Steria / Java básico
29 de enero de 2019

[Link](4, "Elena");

[Link](2, "Carla");

[Link]("David");

[Link]("Harry");

[Link](0, "Robin");

[Link]([Link]());

[Link]([Link]("Carla"));

14. Se imprime por pantalla el contenido del ArrayList

package [Link];

import [Link];

public class ArrayListType {

public static void main(String args[]) {

ArrayList<String> obj = new ArrayList<String>();

[Link]("Juan");

[Link]("Harry");

[Link]("Carlos");

[Link]("David");

[Link]("Pablo");

128/227
Formación Sopra Steria / Java básico
29 de enero de 2019

[Link]("Elements of the array:"+obj);

[Link](4, "Elena");

[Link](2, "Carla");

[Link]("David");

[Link]("Harry");

[Link](0, "Robin");

[Link]([Link]());

[Link]([Link]("Carla"));

[Link]("Current array list is:"+obj);

15. Se ordenan los elementos del ArrayList

package [Link];

import [Link];

public class ArrayListType {

public static void main(String args[]) {

ArrayList<String> obj = new ArrayList<String>();

[Link]("Juan");

[Link]("Harry");

129/227
Formación Sopra Steria / Java básico
29 de enero de 2019

[Link]("Carlos");

[Link]("David");

[Link]("Pablo");

[Link]("Elements of the array:"+obj);

[Link](4, "Elena");

[Link](2, "Carla");

[Link]("David");

[Link]("Harry");

[Link](0, "Robin");

[Link]([Link]());

[Link]([Link]("Carla"));

[Link]("Current array list is:"+obj);

[Link](obj);

16. Se vuelve a imprimir el contenido del ArrayList para ver que se han ordenado
package [Link];

import [Link];

130/227
Formación Sopra Steria / Java básico
29 de enero de 2019

public class ArrayListType {

public static void main(String args[]) {

ArrayList<String> obj = new ArrayList<String>();

[Link]("Juan");

[Link]("Harry");

[Link]("Carlos");

[Link]("David");

[Link]("Pablo");

[Link]("Elements of the array:"+obj);

[Link](4, "Elena");

[Link](2, "Carla");

[Link]("David");

[Link]("Harry");

[Link](0, "Robin");

[Link]([Link]());

[Link]([Link]("Carla"));

[Link]("Current array list is:"+obj);

[Link](obj);

131/227
Formación Sopra Steria / Java básico
29 de enero de 2019

[Link]("Current array list is:"+obj);

17. Se borra completamente el contenido del ArrayList y se imprime por pantalla si el ArrayList está
vacío
package [Link];

import [Link];

public class ArrayListType {

public static void main(String args[]) {

ArrayList<String> obj = new ArrayList<String>();

[Link]("Juan");

[Link]("Harry");

[Link]("Carlos");

[Link]("David");

[Link]("Pablo");

[Link]("Elements of the array:"+obj);

[Link](4, "Elena");

[Link](2, "Carla");

[Link]("David");

[Link]("Harry");

[Link](0, "Robin");

132/227
Formación Sopra Steria / Java básico
29 de enero de 2019

[Link]([Link]());

[Link]([Link]("Carla"));

[Link]("Current array list is:"+obj);

[Link](obj);

[Link]("Current array list is:"+obj);

[Link]();

[Link]([Link]());

18. Output
Elements of the array:[Juan, Harry, Carlos, David, Pablo]
false
5
true
Current array list is:[Robin, Carla, Carlos, Elena, Pablo]
Current array list is:[Carla, Carlos, Elena, Pablo, Robin]
true

3.4. Tutorial 4 - Trabajando con Fechas y Horas - DateTime

Se pretende en este tutorial trabajar de múltiples formas con fechas en Java, haciendo uso de las clases
Date y SimpleDateFormat.

1. Se crea un paquete llamado [Link];

package [Link];

133/227
Formación Sopra Steria / Java básico
29 de enero de 2019

2. Dentro se crea una clase DateTimeType

package [Link];

import [Link];

public class DateTimeType {

public static void main(String args[]) {

134/227
Formación Sopra Steria / Java básico
29 de enero de 2019

Date date1 = new Date();

6. Se muestra por pantalla el objeto date creado

package [Link];

import [Link];

public class DateTimeType {

public static void main(String args[]) {

Date date1 = new Date();

[Link]([Link]());

7. Se crea un objeto Date()

package [Link];

import [Link];

public class DateTimeType {

public static void main(String args[]) {

Date date1 = new Date();

[Link]([Link]());

Date dNow = new Date();

135/227
Formación Sopra Steria / Java básico
29 de enero de 2019

8. Se crea un objeto SimpleDateFormat con un formato de hora (E [Link] 'at' hh:mm:ss a

zzz)
package [Link];

import [Link];

public class DateTimeType {

public static void main(String args[]) {

Date date1 = new Date();

[Link]([Link]());

Date dNow = new Date();

SimpleDateFormat ft1 = new SimpleDateFormat ("E [Link] 'at' hh:mm:ss a zzz");

9. Se imprime por pantalla el objeto Date creado con el formato creado anteriormente
package [Link];

import [Link];

public class DateTimeType {

public static void main(String args[]) {

Date date1 = new Date();

[Link]([Link]());

Date dNow = new Date();

SimpleDateFormat ft1 = new SimpleDateFormat ("E [Link] 'at' hh:mm:ss a zzz");

[Link]("Current Date: " + [Link](dNow));

136/227
Formación Sopra Steria / Java básico
29 de enero de 2019

10. Se crea un objeto Date()

package [Link];

import [Link];

public class DateTimeType {

public static void main(String args[]) {

Date date1 = new Date();

[Link]([Link]());

Date dNow = new Date();

SimpleDateFormat ft1 = new SimpleDateFormat ("E [Link] 'at' hh:mm:ss a zzz");

[Link]("Current Date: " + [Link](dNow));

Date date2 = new Date();

11. Se crea un String que con la función format formatee el objeto Date creado
package [Link];

import [Link];

public class DateTimeType {

public static void main(String args[]) {

Date date1 = new Date();

[Link]([Link]());

137/227
Formación Sopra Steria / Java básico
29 de enero de 2019

Date dNow = new Date();

SimpleDateFormat ft1 = new SimpleDateFormat ("E [Link] 'at' hh:mm:ss a zzz");

[Link]("Current Date: " + [Link](dNow));

Date date2 = new Date();

String str = [Link]("%1$s %2$tB %2$td, %2$tY", "Due date:", date2 );

12. Y se imprime por pantalla

package [Link];

import [Link];

public class DateTimeType {

public static void main(String args[]) {

Date date1 = new Date();

[Link]([Link]());

Date dNow = new Date();

SimpleDateFormat ft1 = new SimpleDateFormat ("E [Link] 'at' hh:mm:ss a zzz");

[Link]("Current Date: " + [Link](dNow));

Date date2 = new Date();

String str = [Link]("%1$s %2$tB %2$td, %2$tY", "Due date:", date2 );

[Link](str);

138/227
Formación Sopra Steria / Java básico
29 de enero de 2019

13. Se crea un objeto SimpleDateFormat con un formato (yyyy-MM-dd)

package [Link];

import [Link];

public class DateTimeType {

public static void main(String args[]) {

Date date1 = new Date();

[Link]([Link]());

Date dNow = new Date();

SimpleDateFormat ft1 = new SimpleDateFormat ("E [Link] 'at' hh:mm:ss a zzz");

[Link]("Current Date: " + [Link](dNow));

Date date2 = new Date();

String str = [Link]("%1$s %2$tB %2$td, %2$tY", "Due date:", date2 );

[Link](str);

SimpleDateFormat ft2 = new SimpleDateFormat ("yyyy-MM-dd");

14. Se crea un String que represente una fecha en el formato anterior

package [Link];

import [Link];

public class DateTimeType {

public static void main(String args[]) {

Date date1 = new Date();

139/227
Formación Sopra Steria / Java básico
29 de enero de 2019

[Link]([Link]());

Date dNow = new Date();

SimpleDateFormat ft1 = new SimpleDateFormat ("E [Link] 'at' hh:mm:ss a zzz");

[Link]("Current Date: " + [Link](dNow));

Date date2 = new Date();

String str = [Link]("%1$s %2$tB %2$td, %2$tY", "Due date:", date2 );

[Link](str);

SimpleDateFormat ft2 = new SimpleDateFormat ("yyyy-MM-dd");

String input = "1818-11-11";

15. Se imprime el contenido del String

package [Link];

import [Link];

public class DateTimeType {

public static void main(String args[]) {

Date date1 = new Date();

[Link]([Link]());

Date dNow = new Date();

SimpleDateFormat ft1 = new SimpleDateFormat ("E [Link] 'at' hh:mm:ss a zzz");

[Link]("Current Date: " + [Link](dNow));

Date date2 = new Date();

140/227
Formación Sopra Steria / Java básico
29 de enero de 2019

String str = [Link]("%1$s %2$tB %2$td, %2$tY", "Due date:", date2 );

[Link](str);

SimpleDateFormat ft2 = new SimpleDateFormat ("yyyy-MM-dd");

String input = "1818-11-11";

[Link](input + " Parses as ");

16. Se declara una variable Date

package [Link];

import [Link];

public class DateTimeType {

public static void main(String args[]) {

Date date1 = new Date();

[Link]([Link]());

Date dNow = new Date();

SimpleDateFormat ft1 = new SimpleDateFormat ("E [Link] 'at' hh:mm:ss a zzz");

[Link]("Current Date: " + [Link](dNow));

Date date2 = new Date();

String str = [Link]("%1$s %2$tB %2$td, %2$tY", "Due date:", date2 );

[Link](str);

SimpleDateFormat ft2 = new SimpleDateFormat ("yyyy-MM-dd");

String input = "1818-11-11";

[Link](input + " Parses as ");

141/227
Formación Sopra Steria / Java básico
29 de enero de 2019

Date t;

17. Se hace un parsing del String con el formato creado anteriormente y se guarda en la variable
Date creada
package [Link];

import [Link];

public class DateTimeType {

public static void main(String args[]) {

Date date1 = new Date();

[Link]([Link]());

Date dNow = new Date();

SimpleDateFormat ft1 = new SimpleDateFormat ("E [Link] 'at' hh:mm:ss a zzz")

;

[Link]("Current Date: " + [Link](dNow));

Date date2 = new Date();

String str = [Link]("%1$s %2$tB %2$td, %2$tY", "Due date:", date2 );

[Link](str);

SimpleDateFormat ft2 = new SimpleDateFormat ("yyyy-MM-dd");

String input = "1818-11-11";

[Link](input + " Parses as ");

Date t;

t = [Link](input);

142/227
Formación Sopra Steria / Java básico
29 de enero de 2019

18. Se imprime el objeto Date

package [Link];

import [Link];

public class DateTimeType {

public static void main(String args[]) {

Date date1 = new Date();

[Link]([Link]());

Date dNow = new Date();

SimpleDateFormat ft1 = new SimpleDateFormat ("E [Link] 'at' hh:mm:ss a zzz");

[Link]("Current Date: " + [Link](dNow));

Date date2 = new Date();

String str = [Link]("%1$s %2$tB %2$td, %2$tY", "Due date:", date2 );

[Link](str);

SimpleDateFormat ft2 = new SimpleDateFormat ("yyyy-MM-dd");

String input = "1818-11-11";

[Link](input + " Parses as ");

Date t;

t = [Link](input);

[Link](t);

143/227
Formación Sopra Steria / Java básico
29 de enero de 2019

19. Esta operación puede lanzar una excepción, por lo que se utiliza un try/catch para controlar la
excepción
package [Link];

import [Link];

public class DateTimeType {

public static void main(String args[]) {

Date date1 = new Date();

[Link]([Link]());

Date dNow = new Date();

SimpleDateFormat ft1 = new SimpleDateFormat ("E [Link] 'at' hh:mm:ss a zzz");

[Link]("Current Date: " + [Link](dNow));

Date date2 = new Date();

String str = [Link]("%1$s %2$tB %2$td, %2$tY", "Due date:", date2 );

[Link](str);

SimpleDateFormat ft2 = new SimpleDateFormat ("yyyy-MM-dd");

String input = "1818-11-11";

[Link](input + " Parses as ");

Date t;

try {

t = [Link](input);

[Link](t);

} catch (ParseException e) {

[Link]("Unparseable using " + ft2);

144/227
Formación Sopra Steria / Java básico
29 de enero de 2019

20. Output
Thu Apr 12 10:04:34 CEST 2018
Current Date: jue 2018.04.12 at 10:04:34 AM CEST
Due date: abril 12, 2018
1818-11-11 Parses as Wed Nov 11 00:00:00 CET 1818

4. Tutorial Capitulo 6: Métodos y encapsulamiento

4.1. Tutorial 1 - Diseñando métodos

En este breve tutorial se pretende mostrar cuál es la estructura de los métodos en Java, prestando
especial atención a cuáles son los elementos que los componen y el orden en el que deben estar dichos
elementos.

1. Se crea un paquete llamado [Link]

package [Link];

2. Se crea una clase llamada DesigningMethods dentro del paquete [Link]

package [Link];
public class DesigningMethods {
}

3. Se crean un método dentro de la clase que contenga: Un modificador de acceso, un tipo de

retorno, un nombre y una lista de parámetros.
package [Link];
public class DesigningMethods {
/**
* Declaración del método methodName
*
* Modificadores de acceso: public static
* Tipo de retorno: int
* Nombre del método: methodName
* Lista de parámetros: int a, int b
*

145/227
Formación Sopra Steria / Java básico
29 de enero de 2019

*/
public static int methodName(int a, int b) {
/**
* Cuerpo del método
*/
return 0;
}
}

4.2. Tutorial 2 - Trabajando con Varargs (15 min)

En este tutorial se muestra un método que utiliza varargs para que se pueda ver de forma práctica cómo
se hace uso de una entrada de parámetros variable a un método, así como la forma de llamar a este
método.

1. Se crea un paquete llamado [Link]

package [Link];

2. Se crea una clase llamada VarargsDemo dentro del paquete [Link]

package [Link];
public class VarargsDemo {
}

3. Se crea un método dentro de la clase que contenga un parámetro de entrada de talla variable
(En este caso, se crea un método printMax que devuelve el mayor de los números recibidos como
parámetros)
package [Link];
public class VarargsDemo {
/**
* Método que devuelve el mayor de los números recibidos como parámetro
*/
public static void printMax(double... numbers) {
/**
* En caso de que no haya parámetros, se imprimirá por pantalla "No argument
passed"
*/
if ([Link] == 0) {
[Link]("No argument passed");
return;
}
double result = numbers[0];

146/227
Formación Sopra Steria / Java básico
29 de enero de 2019

for (int i = 1; i < [Link]; i++) {

if (numbers[i] > result) {
result = numbers[i];
}
}
[Link]("The max value is " + result);
}
}

4. Se crea un método main para poder probar el método printMax

package [Link];
public class VarargsDemo {
/**
* Método que devuelve el mayor de los números recibidos como parámetro
*/
public static void printMax(double... numbers) {
/**
* En caso de que no haya parámetros, se imprimirá por pantalla "No argument
passed"
*/
if ([Link] == 0) {
[Link]("No argument passed");
return;
}
double result = numbers[0];
for (int i = 1; i < [Link]; i++) {
if (numbers[i] > result) {
result = numbers[i];
}
}
[Link]("The max value is " + result);
}

public static void main(String args[]) {

/**
* Se llama al método dos veces con diferentes parámetros
*/
[Link](34, 3, 3, 2, 56.5);
[Link](new double[] { 1, 2, 3 });
}
}

147/227
Formación Sopra Steria / Java básico
29 de enero de 2019

5. Output
The max value is 56.5
The max value is 3.0

4.3. Tutorial 3 - Aplicando Modificadores de Acceso

Este tutorial muestra una serie de ejemplos referentes a los ámbitos desde los cuales se pueden acceder
a los métodos y atributos de una clase dependiendo de sus modificadores de acceso.

1. Se crea un paquete llamado [Link]

package [Link];

2. Dentro de [Link] se crea el package1

package [Link].package1;

3. En el paquete [Link].package1 se crea la clase Default

package [Link].package1;
public class Default {
}

4. Se crea un método con el modificiador por defecto que suma dos números a y b pasados como
parámetros
package [Link].package1;
public class Default {

/**
* Al no poner ningún modificador de manera explícita, se aplica el modificador p
or defecto
*/
int addTwoNumbers(final int a, final int b) {
return a + b;
}
}

Este método solo podrá ser accesible por clases dentro de su mismo paquete, si no, se obtendrá un error
de compilación.

148/227
Formación Sopra Steria / Java básico
29 de enero de 2019

5. En el paquete [Link] se crea la clase Test

package [Link];
public class Test{
}

6. Se crea el método main

package [Link];
public class Test{
public static void main(String args[]) {
}
}

7. Se crea un objeto de la clase Default (para ello habrá que importarla)

package [Link];
import [Link].package1.*;
public class Test{
public static void main(String args[]) {
Default objDefault = new Default();
}
}

8. Si se intenta llamar al método .addTwoNumbers del objeto de la clase Default se podrá ver un
error de compilación, ya que este método es únicamente accesible desde clases que estén en el
mismo paquete que Default, y TestDefault está en un paquete diferente. Esto se debe a que su
modificador de acceso es default
package [Link];
import [Link].package1.*;
public class Test {
public static void main(String args[]) {
Default objDefault = new Default();
[Link](10, 21); //Error de compilación
}
}

9. En el paquete [Link] se crea la clase Private

package [Link];
class Private {
}

149/227
Formación Sopra Steria / Java básico
29 de enero de 2019

10. Se crea una propiedad double constante con el modificador private cuyo valor sea 100
package [Link];
class Private {
private final double num = 100;
}

11. Se crea un método con el modificiador private que calcule el cuadrado de un número
package [Link];
class Private {
private final double num = 100;
private int square(int a) {
return a * a;
}
}

Ni el método ni la propiedad podrán ser accesibles por ninguna otra clase, esté en el mismo paquete que
la clase Private o no.

Volviendo a la clase Test creada previamente.

12. Se crea un objeto de la clase Private

package [Link];
import [Link].package1.*;
public class Test{
public static void main(String args[]) {
Default objDefault = new Default();
[Link](10, 21); //Error de compilación

Private objPrivate = new Private();

}
}

13. Si se intenta leer el valor de la propiedad num de la clase Private o si se intenta llamar al método
.square se podrá ver un error de compilación, ya que el modificador private impide que tanto
la propiedad como el método sean utilizados fuera de la clase Private.
package [Link];
import [Link].package1.*;
public class Test{
public static void main(String args[]) {
Default objDefault = new Default();
[Link](10, 21); //Error de compilación

150/227
Formación Sopra Steria / Java básico
29 de enero de 2019

Private objPrivate = new Private();

double num = [Link]; //Error de compilación
[Link](10); //Error de compilación
}
}

14. En el paquete [Link].package1 se crea la clase Protected

package [Link].package1;
public class Protected {
}

15. Se crea un método con el modificiador protected que reste dos números a y b pasados como
parámetros
package [Link].package1;
public class Protected {
protected int subctractTwoNumbers(int a, int b) {
return a - b;
}
}

Este método solo podrá ser accesible por clases que extiendan a la clase Protected.

Volviendo a la clase Test.

16. Se extiende la clase Test para que extienda a la clase Protected

package [Link];
import [Link].package1.*;
public class Test extends Protected{
public static void main(String args[]) {
Default objDefault = new Default();
[Link](10, 21); //Error de compilación

Private objPrivate = new Private();

double num = [Link]; //Error de compilación
[Link](10); //Error de compilación
}
}

151/227
Formación Sopra Steria / Java básico
29 de enero de 2019

17. Se crea un objeto de la clase Test

package [Link];
import [Link].package1.*;
public class Test extends Protected{
public static void main(String args[]) {
Default objDefault = new Default();
[Link](10, 21); //Error de compilación

Private objPrivate = new Private();

double num = [Link]; //Error de compilación
[Link](10); //Error de compilación

Test obj = new Test();

}
}

18. Puesto que Test extiende a Protected, el objeto de clase Test podrá llamar al método con el
modificador de acceso protected .subctractTwoNumbers de la clase Protected
package [Link];
import [Link].package1.*;
public class Test extends Protected{
public static void main(String args[]) {
Default objDefault = new Default();
[Link](10, 21); //Error de compilación

Private objPrivate = new Private();

double num = [Link]; //Error de compilación
[Link](10); //Error de compilación

Test obj = new Test();

/**
* Se imprime por pantalla el restultado del método .subctractTwoNumbers
* de la clase [Link]
*/
[Link]([Link](20, 10));
}
}

152/227
Formación Sopra Steria / Java básico
29 de enero de 2019

19. En el paquete [Link].package1 se crea la clase Public

package [Link].package1;
public class Public {
}

20. Se crea un método con el modificiador public que divida dos números a y b pasados como
parámetros
package [Link].package1;
public class Public {
public int divideTwoNumbers(int a, int b){
return a/b;
}
}

Este método podrá ser accesible por cualquier clase, se encuentre en el mismo paquete que la clase
Public o en un paquete diferente.

Volviendo a la clase Test.

21. Se crea un objeto de la clase Public

package [Link];
import [Link].package1.*;
public class Test extends Protected{
public static void main(String args[]) {
Default objDefault = new Default();
[Link](10, 21); //Error de compilación

Private objPrivate = new Private();

double num = [Link]; //Error de compilación
[Link](10); //Error de compilación

Test obj = new Test();

/**
* Se imprime por pantalla el restultado del método .subctractTwoNumbers
* de la clase [Link]
*/
[Link]([Link](20, 10));

Public objPublic = new Public();

}
}

153/227
Formación Sopra Steria / Java básico
29 de enero de 2019

22. Puesto que el método .divideTwoNumbers de la clase Public tiene el modificador de acceso public,
se podrá llamar sin problema desde la clase Test
package [Link];
import [Link].package1.*;
public class Test extends Protected{
public static void main(String args[]) {
Default objDefault = new Default();
[Link](10, 21); //Error de compilación

Private objPrivate = new Private();

double num = [Link]; //Error de compilación
[Link](10); //Error de compilación

Test obj = new Test();

/**
* Se imprime por pantalla el restultado del método .subctractTwoNumbers
* de la clase [Link]
*/
[Link]([Link](20, 10));

Public objPublic = new Public();

/**
* Se imprime por pantalla el restultado del método .divideTwoNumbers
* de la clase [Link]
*/
[Link]([Link](20, 10));
}
}

Para poder ejecutar el programa, será necesario comentar las líneas de código que no compilen.

23. Output
10
2

154/227
Formación Sopra Steria / Java básico
29 de enero de 2019

4.4. Tutorial 4 - Pasando Datos a Través de Métodos

Este tutorial pretende exponer diferentes ejemplos sobre la forma de pasar datos (variables) a métodos
y de qué forma estos datos permanecen modificados o no tras finalizar la ejecución de dichos métodos.

1. Se crea un paquete llamado [Link]

package [Link];

2. En el paquete [Link] se crea la clase PassingDataAmongMethods

package [Link];
public class PassingDataAmongMethods {
}

3. Se crea el método main

package [Link];
public class PassingDataAmongMethods {
public static void main(final String[] args) {
}
}

4. Dentro del método main se han implementado una serie de ejemplos que permiten ver cuál es
el verdadero valor de ciertas variables a lo largo del código
package [Link];
public class PassingDataAmongMethods {
public static void main(final String[] args) {
/**
* Se crea una variable de tipo String con el valor "Hello!"
*/
String s1 = "Hello!";

/**
* Se llama al método bye y se le pasa s1 como parámetro
*/
bye(s1);

/**
* Se imprime en la consola el valor de s1, que será
* Hello!
* Esto se debe a que a pesar de que en el método bye
* hay una variable que se llama s1, es una variable
* de ámbito local completamente diferente a la variable
* s1 creada en el método main.

155/227
Formación Sopra Steria / Java básico
29 de enero de 2019

*/
[Link](s1);

/**
* Se crea una variable de tipo StringBuilder
*/
StringBuilder s2 = new StringBuilder();

/**
* Se llama al método goodMorning y se le pasa s2 como parámetro
*/
goodMorning(s2);

/**
* Se imprime en la consola el valor de s1, que será
* Good Morning
* Esto se debe a que s sí que es el mismo objeto que
* se le pasa como parámetro.
*/
[Link](s2);
}
public static void bye(String s1) {
s1 = "Bye!";
}

public static void goodMorning(StringBuilder s) {

[Link]("Good Morning");
}
}

5. Output
Hello!
Good Morning

156/227
Formación Sopra Steria / Java básico
29 de enero de 2019

4.5. Tutorial 5 - Sobrecargando Métodos

En el siguiente tutorial se muestra la forma en la que es posible sobrecargar métodos en Java, creando
métodos diferentes pero con el mismo nombre.

1. Se crea un paquete llamado [Link]

package [Link];

2. Se crea una clase llamada OverloadingMethods dentro del paqute [Link]

package [Link];
public class OverloadingMethods {
}

3. Se crean una serie de métodos llamados disp, con diferentes parámetros (overlad al método
disp)
package [Link];
public class OverloadingMethods {
public void disp(char c) {
[Link](c);
}

public void disp(char c, int num) {

[Link](c + " " + num);
}

public void disp(int c) {

[Link](c);
}

public void disp(int num, char c) {

[Link](num + " " + c);
}
}

4. Se crea el método main para poder hacer llamadas a los métodos y ver sus resultados
package [Link];
public class OverloadingMethods {
public void disp(char c) {
[Link](c);
}

157/227
Formación Sopra Steria / Java básico
29 de enero de 2019

public void disp(char c, int num) {

[Link](c + " " + num);
}
public void disp(int c) {
[Link](c);
}

public void disp(int num, char c) {

[Link](num + " " + c);
}

public static void main(String args[]) {

OverloadingMethods obj = new OverloadingMethods();
[Link]('a');
[Link]('a', 10);
[Link](2);
[Link](10, 'a');
}
}

5. Output
a
a 10
2
10 a

4.6. Tutorial 6 - Creando Constructores

Este tutorial pretende mostrar cuál es la forma de crear diferentes constructores para una misma clase
Java, y cómo se puede crear un objeto de una clase haciendo uso de uno u otro de sus constructores.

1. Se crea un paquete llamado [Link]

package [Link];

158/227
Formación Sopra Steria / Java básico
29 de enero de 2019

2. En el paquete [Link] se crea la clase Constructors

package [Link];
public class Constructors {
}

3. Se crea una propiedad que sea un número entero llamada var

package [Link];
public class Constructors {
private int var;
}

4. Se crea un constructor vacío que modifique var a 10

package [Link];
public class Constructors {
private int var;

/**
* Constructor vacío
*/
public Constructors(){
var = 10;
}
}

5. Se crea un constructor con un parámetro que da a var el valor que se le pase como parámetro
package [Link];
public class Constructors {
private int var;

/**
* Constructor vacío
*/
public Constructors(){
var = 10;
}

/**
* Constructor con parámetros
*/
public Constructors(int num){

159/227
Formación Sopra Steria / Java básico
29 de enero de 2019

public static void main(String args[]){

Constructors obj = new Constructors();
Constructors obj2 = new Constructors(100);
[Link]("var is: "+[Link]());
[Link]("var is: "+[Link]());
}
}

9. Output
var is: 10
var is: 100

4.7. Tutorial 7 - Encapsulando Datos

Este tutorial pretende mostrar cómo se deben encapsular los atributos de una clase para dar acceso a la
lectura y modificación de los mismos a través de métodos get y set (encapsulación).

1. Se crea un paquete llamado [Link]

package [Link];

2. Se crea una clase llamada EncapsulatingData dentro del paquete [Link]

package [Link];
public class EncapsulatingData {
}

3. Se crean tres propiedades privadas: ssn(int), empName(String) y empAge(int)

package [Link];
public class EncapsulatingData {
/**
* Propiedades de la clase EncapsulatingData
*/
private int ssn;
private String empName;
private int empAge;
}

162/227
Formación Sopra Steria / Java básico
29 de enero de 2019

4. Se crean todos los métodos get y set para las tres propiedades
package [Link];
public class EncapsulatingData {
/**
* Propiedades de la clase EncapsulatingData
*/
private int ssn;
private String empName;
private int empAge;

/**
* Métodos getterss y setterss
*/
public int getEmpSSN() {
return ssn;
}
public String getEmpName() {
return empName;
}
public int getEmpAge() {
return empAge;
}

public void setEmpAge(int newValue) {

empAge = newValue;
}
public void setEmpName(String newValue) {
empName = newValue;
}
public void setEmpSSN(int newValue) {
ssn = newValue;
}
}

Desde la clase [Link] se podrán recuperar y modificar las propiedades accediendo

a los métodos get y set de cada una de ellas

5. Se crea una clase llamada EncapsulatingDataTest dentro del paqute [Link]

package [Link];
public class EncapsulatingDataTest {
}

163/227
Formación Sopra Steria / Java básico
29 de enero de 2019

6. Se crea el médoto main

package [Link];
public class EncapsulatingDataTest {
public static void main(final String args[]) {
}
}

7. Se crea un objeto del tipo EncapsulatingData

package [Link];
public class EncapsulatingDataTest {
public static void main(final String args[]) {
EncapsulatingData obj = new EncapsulatingData();
}
}

8. Se modifican las propiedades del objeto con los métodos set implemetados en la clase
EncapsulatingData
package [Link];
public class EncapsulatingDataTest {
public static void main(final String args[]) {
EncapsulatingData obj = new EncapsulatingData();
[Link]("Mario");
[Link](32);
[Link](112233);
}
}

9. Se leen las propiedades del objeto con los métodos get implementados en la clase
EncapsulatingData
package [Link];
public class EncapsulatingDataTest {
public static void main(final String args[]) {
EncapsulatingData obj = new EncapsulatingData();

[Link]("Mario");
[Link](32);
[Link](112233);

[Link]("Employee Name: " + [Link]());

[Link]("Employee SSN: " + [Link]());

164/227
Formación Sopra Steria / Java básico
29 de enero de 2019

[Link]("Employee Age: " + [Link]());

}
}

10. Output
Employee Name: Mario
Employee SSN: 112233
Employee Age: 32

4.8. Tutorial 8 - Ejercicio de ejemplo: Home

En este tutorial se pretende implementar un ejemplo que se pueda usar como guía para hacer el ejercicio
del capítulo 6. En este ejercicio se implementarán tres clases con unos atributos específicos, que se
inicializarán dentro de los constructores correspondientes a dichas clases. También se implementarán
los getters y setters en cada clase necesarios para hacer uso de dichos atributos.

1. Se crea un paquete [Link].

package [Link];

2. Se definen tres clases dentro del paquete creado: House, LivingRoom y Kitchen.
package [Link];
public class House { }

package [Link];
public class Kitchen { }

package [Link];
public class LivingRoom { }

3. La clase LivingRoom debe tener como atributos privados numberOfTV (int) y livingRoomType
(String).
package [Link];
public class LivingRoom {
//Atributos de la clase LivingRoom
private int numberOfTV;
private String livingRoomType;
}

4. Se crea un constructor que los inicialice a 0 y "Unknown".

165/227
Formación Sopra Steria / Java básico
29 de enero de 2019

package [Link];
public class LivingRoom {
//Atributos de la clase LivingRoom
private int numberOfTV;
private String livingRoomType;
//Constructor
public LivingRoom() {
numberOfTV = 0;
livingRoomType = "Unknown";
}
}

5. Se crean los getters y setters de la clase LivingRoom, para quedar la clase implementada:
package [Link];
public class LivingRoom {
//Atributos de la clase LivingRoom
private int numberOfTV;
private String livingRoomType;
//Constructor
public LivingRoom() {
numberOfTV = 0;
livingRoomType = "Unknown";
}
//Metodos getters y setters
public void setNumberOfTV ( int valueNumberOfTV ) {
numberOfTV = valueNumberOfTV;
}
public void setLivingRoomType ( String valueLivingRoomType ) {
livingRoomType = valueLivingRoomType;
}
public int getNumberOfTV () {
return numberOfTV;
}
public String getLivingRoomType () {
return livingRoomType;
}
}

6. La clase Kitchen debe tener como atributos privados isIndependent (boolean) y numberOfStoves
(int).
package [Link];
public class Kitchen {
//Atributos de la clase Kitchen
private boolean isIndependent;

166/227
Formación Sopra Steria / Java básico
29 de enero de 2019

private int numberOfStoves;

}

7. Crear un constructor e inicializar los atributos anteriores a false y 0.

package [Link];
public class Kitchen {
//Atributos de la clase Kitchen
private boolean isIndependent;
private int numberOfStoves;
//Constructor
public Kitchen() {
isIndependent = false;
numberOfStoves = 0;
}
}

8. Se implementan los getters y setters de la clase Kitchen, para quedar la clase implementada:
package [Link];
public class Kitchen {
//Atributos de la clase Kitchen
private boolean isIndependent;
private int numberOfStoves;
//Constructor
public Kitchen() {
isIndependent = false;
numberOfStoves = 0;
}
//Metodos getters y setters
public void setIsIndependent ( boolean valueIsIndependent ) {
isIndependent = valueIsIndependent;
}
public void setNumberOfStoves ( int valueNumberOfStoves ) {
numberOfStoves = valueNumberOfStoves;
}
public boolean getIsIndependent () {
return isIndependent;
}
public int getNumberOfStoves () {
return numberOfStoves;
}
}

9. La clase House tendrá los siguientes atributos públicos de clase: area (double), address (String),
livingRoom (tipo LivingRoom) y kitchen (tipo Kitchen).

167/227
Formación Sopra Steria / Java básico
29 de enero de 2019

package [Link];
public class House {
//Atributos de la clase House
public static double area;
public static String address;
public static LivingRoom livingRoom;
public static Kitchen kitchen;
}

10. Se deberá definir un constructor para la clase House que establezca a unos valores por defecto
a sus atributos y que cree nuevos objetos si se trata de atributos objeto.
package [Link];
public class House {
//Atributos de la clase House
public static double area;
public static String address;
public static LivingRoom livingRoom;
public static Kitchen kitchen;
//Constructor
public House() {
area = 0.0d;
address = "Unknown";
livingRoom = new LivingRoom();
kitchen = new Kitchen();
}
}

11. Se implementarán los métodos getters y setters necesarios para poder trabajar con todos los
atributos de la clase.
package [Link];
public class House {
//Atributos de la clase House
public static double area;
public static String address;
public static LivingRoom livingRoom;
public static Kitchen kitchen;
//Constructor
public House() {
area = 0.0d;
address = "Unknown";
livingRoom = new LivingRoom();
kitchen = new Kitchen();
}
//Metodos getters y setters

168/227
Formación Sopra Steria / Java básico
29 de enero de 2019

public void setArea ( double valueArea ) {

area = valueArea;
}
public void setAddress ( String valueAddress ) {
address = valueAddress;
}
public void setLivingRoom ( LivingRoom valueLivingRoom ) {
[Link]([Link]());
[Link]([Link]());
}
public void setKitchen( Kitchen valueKitchen ) {
[Link]([Link]());
[Link]([Link]());
}
public double getArea () {
return area;
}
public String getAddress () {
return address;
}
public static LivingRoom getLivingRoom () {
return livingRoom;
}
public static Kitchen getKitchen () {
return kitchen;
}
}

12. Después se creara un método main en la propia clase House donde se instancie un objeto de la
clase House, quedando la clase implementada:
package [Link];
public class House {
//Atributos de la clase House
public static double area;
public static String address;
public static LivingRoom livingRoom;
public static Kitchen kitchen;
//Constructor
public House() {
area = 0.0d;
address = "Unknown";
livingRoom = new LivingRoom();
kitchen = new Kitchen();
}

169/227
Formación Sopra Steria / Java básico
29 de enero de 2019

//Metodos getters y setters

public void setArea ( double valueArea ) {
area = valueArea;
}
public void setAddress ( String valueAddress ) {
address = valueAddress;
}
public void setLivingRoom ( LivingRoom valueLivingRoom ) {
[Link]([Link]());
[Link]([Link]());
}
public void setKitchen( Kitchen valueKitchen ) {
[Link]([Link]());
[Link]([Link]());
}
public double getArea () {
return area;
}
public String getAddress () {
return address;
}
public static LivingRoom getLivingRoom () {
return livingRoom;
}
public static Kitchen getKitchen () {
return kitchen;
}
public static void main(String[] args) {
House house = new House();
String message = "House area: " + [Link] + "\n";
message = message + "House address: " + [Link] + ".\n";
message = message + "Let's go inside the house:\n";
message = message + "The house has a livingroom of type "

+ [Link]().getLivingRoomType()

+ " and with " + [Link]().getNumberOfTV()

+ " TV's \n";

message = message + "The house has a kitchen has "

+ [Link]().getNumberOfStoves()

+" stoves and the kitchen is "

+ [Link]().getIsIndependent()

170/227
Formación Sopra Steria / Java básico
29 de enero de 2019

+" independent \n";

message = message + "\n\n\tEnd!";
[Link] ( message ) ;
}
}

13. Output
House area: 0.0
House address: Unknown.
Let's go inside the house:
The house has a livingroom of type Unknown and with 0 TV's
The house has a kitchen has 0 stoves and the kitchen is false independent
End!

5. Tutorial Capítulo 7: Diseño de clases

5.1. Tutorial 1 - Introducción a la herencia de clases - Herencia

Este tutorial muestra un ejemplo sencillo de herencia en Java, haciendo uso de una clase padre y una
clase hija, así como de una serie de métodos que se definen en ambas clases.

1. Se crea un paquete llamado [Link]

package [Link];

2. Dentro se crea una clase ParentClass

package [Link];
class ParentClass{
}
}

3. Se crea un constructor vacío que muestre un mensaje por pantalla y otro con dos argumentos
proctected (name y age)
package [Link];
class ParentClass{
protected String name;
protected int age;
ParentClass(){
[Link]("Constructor of Parent");

171/227
Formación Sopra Steria / Java básico
29 de enero de 2019

}
ParentClass(String name, int age){
[Link] = name;
[Link] = age;
}
}

4. Se crea un método disp() que muestre por pantalla un mensaje indicando que es el método del
padre
package [Link];
class ParentClass{
protected String name;
protected int age;
ParentClass(){
[Link]("Constructor of Parent");
}
ParentClass(String name, int age){
[Link] = name;
[Link] = age;
}
}

5. Se crea una nueva clase public ChildClass que herede de la clase ParentClass
package [Link];
public class ChildClass extends ParentClass{
}

6. Se crea un constructor vacío que muestre por pantalla que es el constructor de la clase hijo. Se
crea también un constructor con un parámetro (age) en la clase hijo que utiliza el segundo
constructor heredado de la clase padre.
package [Link];
public class ChildClass extends ParentClass{
ChildClass(){
[Link]("Constructor of Child");
}
public ChildClass(int age){
super(“Child”, age);
}
}

172/227
Formación Sopra Steria / Java básico
29 de enero de 2019

7. Se crea un método disp() que muestre un mensaje por pantalla indicando que es el método del
hijo.
package [Link];
public class ChildClass extends ParentClass{
ChildClass(){
[Link]("Constructor of Child");
}
public ChildClass(int age){
super(“Child”, age);
}
void disp(){
[Link]("Child Method");
}
}

8. Se realiza una llamada al método disp() heredado del padre.

9. Se crea también un segundo método disp2() que muestre un mensaje por pantalla indicando el
nombre y la edad pasados al constructor hijo.
package [Link];
public class ChildClass extends ParentClass{
ChildClass(){
[Link]("Constructor of Child");
}
public ChildClass(int age){
super(“Child”, age);
}
void disp(){

173/227
Formación Sopra Steria / Java básico
29 de enero de 2019

[Link]("Child Method");
//Calling the disp() method of parent class
[Link]();
}
void disp2(){
[Link]([Link] + ” is “ + [Link] + “ years old”);
}
}

10. Se crea un método main dentro de la clase ChildClass

package [Link];
public class ChildClass extends ParentClass{
ChildClass(){
[Link]("Constructor of Child");
}
public ChildClass(int age){
super(“Child”, age);
}
void disp(){
[Link]("Child Method");
//Calling the disp() method of parent class
[Link]();
}
void disp2(){
[Link]([Link] + ” is “ + [Link] + “ years old”);
}
public static void main(String args[]){
}
}

11. Se crea un objeto ChildClass. Se crea también un segundo objeto ChildClass con
parámetro age=5.
package [Link];
public class ChildClass extends ParentClass{
ChildClass(){
[Link]("Constructor of Child");
}
public ChildClass(int age){
super(“Child”, age);
}
void disp(){
[Link]("Child Method");

174/227
Formación Sopra Steria / Java básico
29 de enero de 2019

//Calling the disp() method of parent class

[Link]();
}
void disp2(){
[Link]([Link] + ” is “ + [Link] “ years old”);
}
public static void main(String args[]){
ChildClass child = new ChildClass();
ChildClass child2 = new ChildClass(5);
}
}

12. Se realiza una llamada a los métodos disp() y disp2() del objeto child y child2, respectivamente.
package [Link];
public class ChildClass extends ParentClass{
ChildClass(){
[Link]("Constructor of Child");
}
public ChildClass(int age){
super(“Child”, age);
}
void disp(){
[Link]("Child Method");
//Calling the disp() method of parent class
[Link]();
}
void disp2(){
[Link]([Link] + ” is “ + [Link] + “ years old”);
}
public static void main(String args[]){
ChildClass child = new ChildClass();
ChildClass child2 = new ChildClass(5);
[Link]();
child2.disp2();
}
}

13. Output
Constructor of Parent

Constructor of Child

Child Method

175/227
Formación Sopra Steria / Java básico
29 de enero de 2019

Parent Method
Child is 5 years old

5.2. Tutorial 2 - Creando clases abstractas - Clases abstractas

Este tutorial pretende tener un primer contacto con una clase abstracta que tiene tanto métodos no-
abstractos como métodos abstractos implementados por las clases que extienden a la clase abstracta.

public void disp(){

[Link]("Concrete method of parent class");

public abstract void disp2();

public abstract int sumOfTwo(int n1, int n2);

6. Se crea una nueva clase Demo que herede de la clase abstracta AbstractDemo
package [Link];

public class Demo extends AbstractDemo{

7. Se implementa el método abstracto creado en la clase AbstractDemo y se muestra por pantalla

un mensaje
package [Link];

public class Demo extends AbstractDemo{

public void disp2(){

[Link]("overriding abstract method");

8. Se implementa el método abstracto que recibe dos parametros de la clase AbstractDemo y se

suman
package [Link];

public class Demo extends AbstractDemo{

public void disp2(){

[Link]("overriding abstract method");

177/227
Formación Sopra Steria / Java básico
29 de enero de 2019

public int sumOfTwo(int num1, int num2){

return num1+num2;

9. Se crea un método main

package [Link];

return num1+num2;

public static void main(String args[]){

//AbstractDemo obj = new AbstractDemo();

179/227
Formación Sopra Steria / Java básico
29 de enero de 2019

Demo obj = new Demo();

[Link]();

obj.disp2();

13. Se imprime por pantalla lo que devuelve el método de suma de la clase Demo
package [Link];

public class Demo extends AbstractDemo{

public void disp2(){

[Link]("overriding abstract method");

public int sumOfTwo(int num1, int num2){

return num1+num2;

public static void main(String args[]){

//AbstractDemo obj = new AbstractDemo();

Demo obj = new Demo();

[Link]();

obj.disp2();

[Link]([Link](3, 7));

14. Output
Concrete method of parent class
overriding abstract method
10

180/227
Formación Sopra Steria / Java básico
29 de enero de 2019

5.3. Tutorial 3 - Implementando interfaces - Interfaces

Este tutorial pretende hacer uso de una serie de interfaces que se implementan entre ellas para poder
ver qué es exactamente una interfaz en Java y cómo se puede hacer uso de ella.

1. Se crea un paquete llamado [Link]

package [Link];

2. Se crea una interfaz Inf1 con un método vacío

package [Link];

interface Inf1{

public void method1();

3. Se crea una interfaz Inf2 que herede de Inf1

static void anotherNewMethod(){

[Link]("Newly added static method");

public void method2();

interface Inf3{}

public class Demo implements Inf2,Inf3{

183/227
Formación Sopra Steria / Java básico
29 de enero de 2019

9. Se deben implementar los métodos no implementados de la interfaz Inf2 y Inf1 ya que la primera
hereda de la segunda
package [Link];

interface Inf1{

public void method1();

interface Inf2 extends Inf1 {

default void newMethod(){

[Link]("Newly added default method");

static void anotherNewMethod(){

[Link]("Newly added static method");

public void method2();

interface Inf3{}

public class Demo implements Inf2,Inf3{

public void method1(){

[Link]("method1");

public void method2(){

[Link]("method2");

10. Se crea un método main

package [Link];

interface Inf1{

public void method1();

184/227
Formación Sopra Steria / Java básico
29 de enero de 2019

interface Inf2 extends Inf1 {

default void newMethod(){

[Link]("Newly added default method");

static void anotherNewMethod(){

[Link]("Newly added static method");

public void method2();

interface Inf3{}

public class Demo implements Inf2,Inf3{

public void method1(){

[Link]("method1");

public void method2(){

[Link]("method2");

public static void main(String args[]){

11. Se crea un objeto Inf2 mediante el constructor de la clase Demo

package [Link];

interface Inf1{

public void method1();

interface Inf2 extends Inf1 {

default void newMethod(){

185/227
Formación Sopra Steria / Java básico
29 de enero de 2019

[Link]("Newly added default method");

static void anotherNewMethod(){

[Link]("Newly added static method");

public void method2();

interface Inf3{}

public class Demo implements Inf2,Inf3{

public void method1(){

[Link]("method1");

public void method2(){

[Link]("method2");

public static void main(String args[]){

Inf2 obj = new Demo();

12. Se llama al método default de la interfaz Inf2

package [Link];

interface Inf1{

public void method1();

interface Inf2 extends Inf1 {

default void newMethod(){

[Link]("Newly added default method");

186/227
Formación Sopra Steria / Java básico
29 de enero de 2019

static void anotherNewMethod(){

[Link]("Newly added static method");

public void method2();

interface Inf3{}

public class Demo implements Inf2,Inf3{

public void method1(){

[Link]("method1");

public void method2(){

[Link]("method2");

public static void main(String args[]){

Inf2 obj = new Demo();

[Link]();

13. Se llama al método estático de la interfaz Inf2

package [Link];

interface Inf1{

public void method1();

interface Inf2 extends Inf1 {

default void newMethod(){

[Link]("Newly added default method");

187/227
Formación Sopra Steria / Java básico
29 de enero de 2019

static void anotherNewMethod(){

[Link]("Newly added static method");

public void method2();

interface Inf3{}

public class Demo implements Inf2,Inf3{

public void method1(){

[Link]("method1");

public void method2(){

[Link]("method2");

public static void main(String args[]){

Inf2 obj = new Demo();

[Link]();

14. Por último se realiza una llamada a los métodos de implementados

package [Link];

interface Inf1{

public void method1();

interface Inf2 extends Inf1 {

default void newMethod(){

[Link]("Newly added default method");

188/227
Formación Sopra Steria / Java básico
29 de enero de 2019

static void anotherNewMethod(){

[Link]("Newly added static method");

public void method2();

interface Inf3{}

public class Demo implements Inf2,Inf3{

public void method1(){

[Link]("method1");

public void method2(){

[Link]("method2");

public static void main(String args[]){

Inf2 obj = new Demo();

[Link]();

obj.method1();

obj.method2();

15. Output
Newly added default method
Newly added static method
method1
method2

189/227
Formación Sopra Steria / Java básico
29 de enero de 2019

5.4. Tutorial 4 - Entendiendo el polimorfismo - Polimorfismo

El siguiente tutorial muestra una serie de ejemplos relacionados con el polimorfismo en Java, para ello,
se crean una serie de clases que se extienden unas a las otras y se sobreescribe uno de los métodos de
una de las clases. Se pretende observar cómo, depende del objeto que se cree y teniendo en cuenta la
herencia de estos objetos, se accede a los métodos de unas clases u otras.

1. Se crea un paquete llamado [Link]

package [Link];

2. Se crea una clase Animal

package [Link];
public class Animal{
}

3. Se crea un método getSound() que devuelva el string “Unknown”

package [Link];
public class Animal{
public String getSound(){
return “Unknown”;
}
}

4. Se crea otro método displayInformation() que muestre por pantalla un mensaje con el output
del método anterior.
package [Link];
public class Animal{
public String getSound(){
return “Unknown”;
}
public void displayInformation() {
[Link](“Animal is making a sound: “ + getSound()
}
}

5. Se crea una nueva clase Cat que herede de Animal

package [Link];
public class Cat extends Animal{
}

190/227
Formación Sopra Steria / Java básico
29 de enero de 2019

6. Se sobreescribe el método getSound() de la clase Animal para que devuelva otro string.
package [Link];
public class Cat extends Animal{
@Override
public String getSound(){
return "Meow";
}
}

7. Se crea un método main

package

[Link];
public class Cat extends Animal{
@Override
public String getSound(){
return "Meow";
}
public static void main(String args[]){
}
}

8. Se crea un objeto Animal con el constructor de la clase Cat

package [Link];
public class Cat extends Animal{
@Override
public String getSound(){
return "Meow";
}
public static void main(String args[]){
Animal cat = new Cat();
}
}

9. Se realiza una llamada al método displayInformation()

package [Link];
public class Cat extends Animal{
@Override
public String getSound(){
return "Meow";
}

191/227
Formación Sopra Steria / Java básico
29 de enero de 2019

public static void main(String args[]){

Animal cat = new Cat();
[Link]();
}
}

10. Output

Animal is making a sound: Meow

11. Se crea ahora otra nueva clase Horse que herede de Animal
package [Link];
public class Horse extends Animal{
}

12. Se sobrescribe el método getSound() de la clase Animal para que devuelva otro string distinto.
package [Link];
public class Horse extends Animal{
@Override
public String getSound(){
return "Neigh";
}
}

13. Se crea un método main

package [Link];
public class Horse extends Animal{
@Override
public String getSound(){
return "Neigh";
}
public static void main(String args[]){
}
}

14. Se crea un objeto Animal con el constructor de la clase Horse

package

192/227
Formación Sopra Steria / Java básico
29 de enero de 2019

[Link];
public class Horse extends Animal{
@Override
public String getSound(){
return "Neigh";
}
public static void main(String args[]){
Animal animal = new Horse();
}
}

15. Se crea un objeto Horse haciendo casting al objeto Animal creado anteriormente
package [Link];
public class Horse extends Animal{
@Override
public String getSound(){
return "Neigh";
}
public static void main(String args[]){
Animal animal = new Horse();
Horse horse = (Horse) animal;
}
}

16. Se realiza una llamada al método displayInformation()

package [Link];
public class Horse extends Animal{
@Override
public String getSound(){
return "Neigh";
}
public static void main(String args[]){
Animal animal = new Horse();
Horse horse = (Horse) animal;
[Link]();
}
}

17. Output
Animal is making a sound: Neigh

193/227
Formación Sopra Steria / Java básico
29 de enero de 2019

18. Se crea una nueva clase SoundAnimals

package [Link];
public class SoundAnimals {
}

19. Se crea un método sound que reciba como parámetro un objeto Animal y muestre un mensaje
por pantalla con “Sound Animals: “ y el sonido del animal recibido como parámetro.
package

[Link];
public

class SoundAnimals {
public static void sound(Animal animal){
[Link](“Sound Animal: “ + [Link]());
}
}

20. Se crea un método main

package

[Link];
public

class SoundAnimals {
public static void sound(Animal animal){
[Link](“Sound Animal: “ + [Link]());
}
public static void main(String[] args){
}
}

21. Se llama a las distintas clases con el método sound(Animal animal)

package [Link];
public class SoundAnimals {
public static void sound(Animal animal){
[Link](“Sound Animal: “ + [Link]());
}
public static void main(String[] args){
sound(new Cat());
sound(new Horse());
sound(new Animal());

194/227
Formación Sopra Steria / Java básico
29 de enero de 2019

}
}

22. Output
Sound Animal: Meow
Sound Animal: Neigh
Sound Animal: Unknown

5.5. Tutorial 5 - Escribiendo Lambdas Simples

El siguiente tutorial muestra el contexto en el que se puede hacer uso de una expresión lambda, así
como un ejemplo de una expresión lambda sencilla.

1. Se crea un paquete llamado [Link]

package [Link]

2. Se crea una clase llamada Lambdas dentro del paquete [Link]

[Link]("Result: " + [Link](5));

6. Output
Result: true
Result: false

El siguiente tutorial muestra el uso de una interfaz y una expresión lambda, así como un ejemplo de
cómo utilizarlas.

1. Se crea una interfaz llamada StringModify dentro del paquete [Link]

package [Link];
public interface StringModify {

2. Se crea un método en la interfaz de nombre sModify y cuyos parámetros un String a y un String

b
package [Link];

public interface StringModify {

public String sModify(String a, String b);

3. Se crea una clase llamada Lambdas2 dentro del paquete [Link]

package [Link];
public class Lambdas2 {

4. Se crea el método main

package [Link];

public class Lambdas2 {

public static void main(String args[]) {

196/227
Formación Sopra Steria / Java básico
29 de enero de 2019

5. Se crea la expresión lambda que implemente el método sModify de StringModify

package [Link];

public class Lambdas2 {

public static void main(String args[]) {

StringModify s = (str1, str2) -> (str1 + str2).toUpperCase();

[Link]("Result: " + [Link]("Hello", "World"));

6. Output

Result: HELLO WORLD

6. Tutorial Capítulo 8: Excepciones

6.1. Tutorial 1 - Entendiendo las excepciones

En el siguiente tutorial se pretende lanzar una excepción en tiempo de ejecución, mediante la palabra
reservada throw.

1. Se crea un paquete llamado [Link].

package [Link];

2. Se crea una clase llamada 'Person' y una variable de tipo int llamada 'age'.
package [Link];

public class Person {

private int age;

197/227
Formación Sopra Steria / Java básico
29 de enero de 2019

3. Se crean los métodos 'getAge' y 'setAge' , este último solamente puede recibir por parámetro un
número positivo, de lo contrario se va a lanzar una excepción mediante la palabra reservada
throw.
package [Link];
public class Person {
private int age;
public int getAge() {
return age;
}
public void setAge(int age) {
if (age <= 0) {
throw new RuntimeException("Age should be positive.");
}
[Link] = age;
}
}

4. Se crea el método main, donde se crea una persona y se establece la edad en -10.
package [Link];
public class Person {
private int age;
public int getAge() {
return age;
}

public void setAge(int age) {

if (age <= 0) {
throw new RuntimeException("Age should be positive.");
}
[Link] = age;
}
public static void main(String[] args) {
final Person person = new Person();
[Link](-10);
}

5. Output.
Exception in thread "main" [Link]: Age should be positive.

at [Link]([Link])

198/227
Formación Sopra Steria / Java básico
29 de enero de 2019

6.2. Tutorial 2 - Entendiendo las excepciones

En el siguiente tutorial se pretende mostrar como lanzar una excepción en tiempo de ejecución, mediante
la palabra reservada throws.

1. Se crea un paquete llamado [Link].

package [Link];

2. Se crea una clase llamada 'Person' y una variable de tipo int llamada 'age'.
package [Link];

public class Person {

private int age;

3. Se crea los métodos 'getAge' y 'setAge', en este último se debe indicar que ese método puede
lanzar una excepción, eso se hace con la palabra clave throws.
package [Link];

public class Person {

private int age;

public int getAge() {

return age;

public void setAge(int age) throws Exception {

if (age <= 0) {

throw new Exception("Age should be positive.");

[Link] = age;

4. Ahora se crea una persona y se establece una edad, pero en este caso es obligatorio manejar la
excepción, de lo contrario no se va a poder ejecutar el programa. Para ello hay que introducir
un try-catch. Dentro del bloque try se va a incluir el código que puede lanzar la excepción,
mientras que dentro del catch se va a manejar la posible excepcion lanzada dentro del try, en
este caso simplemente se va a mostrar el mensaje (Age should be positive) de error que nos
proporciona la excepción.
package [Link];
public class Person {

199/227
Formación Sopra Steria / Java básico
29 de enero de 2019

private int age;

public int getAge() {
return age;
}
public void setAge(int age) throws Exception {
if (age <= 0) {
throw new Exception("Age should be positive.");
}
[Link] = age;
}
public static void main(String[] args) {
try {
final Person person = new Person();
[Link](-10);
} catch (Exception e) {
[Link]([Link]());
}
}

5. Output.
Age should be positive.

6.3. Tutorial 3 - Entendiendo las excepciones

En el siguiente tutorial se pretende mostrar la estructura básica de un bloque try-catch, así como
establecer un primer contacto con las excepciones en Java y la palabra reservada throw.

1. Se crea un paquete llamado [Link].

package [Link];

2. Se crea una clase llamada TryCatchThrowExceptionExercise dentro del paquete

[Link].
package [Link];
public class TryCatchThrowExceptionExercise {
}

3. Se crea el método 'fall()' el cual lanza una excepción de tipo 'RuntimeException'.

package [Link];
public class TryCatchThrowExceptionExercise {
private static void fall() {

throw new RuntimeException();

200/227
Formación Sopra Steria / Java básico
29 de enero de 2019

}
}

4. Se crea el método main.

package [Link];
public class TryCatchThrowExceptionExercise {
private static void fall() {

throw new RuntimeException();

}
public static void main(String args[]) {
}
}

5. Se crea un try-catch.
package [Link];
public class TryCatchThrowExceptionExercise {
private static void fall() {

throw new RuntimeException();

}
public static void main(String args[]) {

try {
} catch () {
}
}
}

6. Dentro del try, se llama al método 'fall()' creado anteriormente.

package [Link];
public class TryCatchThrowExceptionExercise {
private static void fall() {

throw new RuntimeException();

}
public static void main(String args[]) {
try {
fall();
} catch () {
}
}
}

7. Al catch, se le pasa como parámetro una excepción de tipo 'RuntimeException' y dentro del catch
se crea un mensaje indicando el tipo de error.

201/227
Formación Sopra Steria / Java básico
29 de enero de 2019

package [Link];
public class TryCatchThrowExceptionExercise {
private static void fall() {

throw new RuntimeException();

}
public static void main(String args[]) {
try {
fall();
} catch (RuntimeException e) {
[Link]("RuntimeException");
}
}
}

8. Fuera del try-catch, se crea un mensaje indicando que el try-catch ha finalizado.

package [Link];
public class TryCatchThrowExceptionExercise {
private static void fall() {

throw new RuntimeException();

}
public static void main(String args[]) {
try {
fall();
} catch (RuntimeException e) {
[Link]("RuntimeException");
}
[Link]("Finished Try-catch.");
}
}

9. Output.
RuntimeException.

public class TryCatchFinallyExercise {

public static void main(String args[]) {

int a[] = new int[2];

try {

[Link]("Access element three:" + a[3]);

5. Al catch, se le pasa como parámetro una excepción de tipo 'ArrayIndexOutOfBoundsException'

y dentro del catch se crea un mensaje indicando el tipo de error.
package [Link];

public class TryCatchFinallyExercise {

public static void main(String args[]) {

int a[] = new int[2];

try {

203/227
Formación Sopra Steria / Java básico
29 de enero de 2019

[Link]("Access element three:" + a[3]);

} catch (ArrayIndexOutOfBoundsException e) {

[Link]("Exception thrown:" + e);

6. Dentro del finally se le asigna al array en la posición 0 un 6 y se imprimime por pantalla. Además,
se imprime un mensaje que dice: 'La sentencia finally se ha ejecutado'.
package [Link];

public class TryCatchFinallyExercise {

public static void main(String args[]) {

int a[] = new int[2];

try {

[Link]("Access element three:" + a[3]);

} catch (ArrayIndexOutOfBoundsException e) {

[Link]("Exception thrown:" + e);

} finally {

a[0] = 6;

[Link]("First element value: " + a[0]);

[Link]("The finally statement is executed.");

7. Output.
Exception thrown:[Link]: 3
The finally statement is executed.
First element value: 6

204/227
Formación Sopra Steria / Java básico
29 de enero de 2019

6.5. Tutorial 5 - Usando try-catch-finally

En el siguiente tutorial se pretende seguir ver como se utilizan las sentencias try y catch incluyendo
también la clausula finally.

1. Se crea un paquete llamado [Link].

package [Link];

2. Se crea una clase llamada TryCatchFinallyExercise2 dentro del paquete

[Link].
package [Link];

public class TryCatchFinallyExercise2 {

3. Se crea el método 'fall()' el cual lanza una excepción de tipo 'RuntimeException'.

package [Link];
public class TryCatchFinallyExercise2 {
private static void fall() {

throw new RuntimeException();

}
}

4. Se crea el método main.

package [Link];
public class TryCatchFinallyExercise2 {
private static void fall() {

throw new RuntimeException();

}
public static void main(String args[]) {
}
}

5. Se crea un try-catch-finally.
package [Link];
public class TryCatchFinallyExercise2 {
private static void fall() {

throw new RuntimeException();

}
public static void main(String args[]) {
try {
} catch () {
} finally {
}

205/227
Formación Sopra Steria / Java básico
29 de enero de 2019

}
}

6. Dentro del try, se llama al método 'fall()' creado anteriormente.

package [Link];
public class TryCatchFinallyExercise2 {
private static void fall() {

throw new RuntimeException();

}
public static void main(String args[]) {
try {
fall();
} catch () {
} finally {
}
}
}

7. Al catch, se le pasa como parámetro una excepción de tipo 'RuntimeException' y dentro del catch
se crea un mensaje indicando el tipo de error.
package [Link];
public class TryCatchFinallyExercise2 {
private static void fall() {

throw new RuntimeException();

}
public static void main(String args[]) {
try {
fall();
} catch (RuntimeException e) {
[Link]("RuntimeException.");
} finally {
}
}
}

8. Dentro del finally se crea un mensaje indicando que aun no ha terminado el método.
package [Link];
public class TryCatchFinallyExercise2 {
private static void fall() {

throw new RuntimeException();

}
public static void main(String args[]) {

206/227
Formación Sopra Steria / Java básico
29 de enero de 2019

try {
fall();
} catch (Exception e) {
[Link]("RuntimeException.");
} finally {
[Link]("I'm finishing.");
}
}
}

9. Fuera del try-catch-finally, se crea un mensaje, indicando que el try-catch ha finalizado.

package [Link];
public class TryCatchFinallyExercise2 {
private static void fall() {

throw new RuntimeException();

}
public static void main(String args[]) {
try {
fall();
} catch (Exception e) {
[Link]("RuntimeException");
} finally {
[Link]("I'm finishing.");
}
[Link]("Finished Try-catch.");
}
}

10. Output.
RuntimeException.

I'm finishing.

Finished Try-catch.

6.6. Tutorial 6 - Multiples try-catch

El siguiente tutorial pretende mostrar cómo es posible tener varios bloques catch para un mismo try,
teniendo en cuenta para ello las excepciones que pueden darse si se realiza una operación de división
entre 0.

207/227
Formación Sopra Steria / Java básico
29 de enero de 2019

1. Se crea un paquete llamado [Link].

package [Link];

2. Se crea una clase llamada MultipleTryCatch dentro del paquete [Link].

package [Link];
public class MultipleTryCatch {
}

3. Se crea el método main.

package [Link];
public class MultipleTryCatch {
public static void main(String args[]){
}
}

4. Se crea un try-catch.
package [Link];
public class MultipleTryCatch {
public static void main(String args[]){

try{
} catch(){

}
}

5. Dentro del try, se crea un array de tamaño 7, y luego se guarda en la posición 10 el resultado
de una división entre cero, y se muestra un mensaje.
package [Link];
public class MultipleTryCatch {
public static void main(String args[]){

try {

int arr[] = new int[7];

arr[10] = 10 / 0;

[Link]("Last Statement of try block.");

} catch(){

}
}

208/227
Formación Sopra Steria / Java básico
29 de enero de 2019

6. Se crean tres catch para soportar diversas excepciones que se pueden dar. En el primer catch,
se le pasa como parámetro la excepción 'ArithmeticException' que indica si se ha
cometido alguna excepción aritmética, y dentro del catch se muestra un mensaje.
package [Link];
public class MultipleTryCatch {
public static void main(String args[]){
try{
int arr[] = new int[7];

arr[10] = 10 / 0;

[Link]("Last Statement of try block.");

} catch(ArithmeticException e){
[Link]("You should not divide a number by zero.");
} catch(){

} catch(){
}
}
}

7. En el segundo catch, se le pasa como parámetro una excepción

'ArrayIndexOutOfBoundsException' que indica si se ha accedido a una posición del array que no
existe, y dentro del catch se muestra un mensaje.
package [Link];
public class MultipleTryCatch {
public static void main(String args[]){
try{
int arr[] = new int[7];

arr[10] = 10 / 0;

[Link]("Last Statement of try block.");

} catch(ArithmeticException e){
[Link]("You should not divide a number by zero.");
} catch(ArrayIndexOutOfBoundsException e){
[Link]("Accessing array elements outside of the limit.");
} catch(){
}
}
}

8. En el tercer catch, se le pasa como parámetro una excepción genérica, y dentro del catch se
muestra un mensaje.
package [Link];
public class MultipleTryCatch {

209/227
Formación Sopra Steria / Java básico
29 de enero de 2019

public static void main(String args[]){

try{
int arr[] = new int[7];

arr[10] = 10 / 0;

[Link]("Last Statement of try block.");

[Link]("Some Other Exception.");

}
}
}

9. Al final se muestra un mensaje de finalizado del try-catch.

package [Link];
public class MultipleTryCatch {
public static void main(String args[]){
try{
int arr[] = new int[7];

arr[10] = 10 / 0;

[Link]("Last Statement of try block.");

[Link]("Some Other Exception.");

}

[Link]("Out of the try-catch block.");

}
}

10. Output.
You should not divide a number by zero.

Out of the try-catch block.

210/227
Formación Sopra Steria / Java básico
29 de enero de 2019

6.7. Tutorial 7 - Multiples try-catch

El siguiente tutorial pretende mostrar cómo es posible tener varios bloques catch para un mismo try,
teniendo en cuenta para ello las excepciones que pueden darse si se realiza la búsqueda de un fichero
que no existe.

1. Se crea un paquete llamado [Link].

package [Link];

2. Se crea una clase llamada MultipleTryCatch2 dentro del paquete [Link].

package [Link];
public class MultipleTryCatch2 {
}

3. Se crea el método main.

package [Link];
public class MultipleTryCatch2 {
public static void main(String args[]){
}
}

212/227
Formación Sopra Steria / Java básico
29 de enero de 2019

} catch(FileNotFoundException e){
[Link]("Source file does not exist.\n" + e);

} catch(IOException e){

[Link]("Some I/O problem.\n" + e);

}
}
}

8. Output.
Source file does not exist.

[Link]: [Link] (El sistema no puede encontrar el archivo e

specificado)

6.8. Tutorial 8 - Tipos de excepciones: ArithmeticException

Este tutorial pretende mostrar la excepción Java ArithmeticException, la cual extiende a
RuntimeException (siendo por lo tanto una excepción opcional). Esta excepción es lanzada cuando tiene
lugar una división entre 0, que es el ejemplo que muestra el código.

1. Se crea un paquete llamado [Link].

package [Link];

2. Se crea una clase llamada ArithmeticExceptionExercise dentro del paquete

[Link].
package [Link];
class ArithmeticExceptionExercise {
}

3. Se crea el método main.

package [Link];
class ArithmeticExceptionExercise {
public static void main(String args[]) {
}
}

4. Se crean dos variables: num 1 (entero) y num2 (entero).

package [Link];
class ArithmeticExceptionExercise {
public static void main(String args[]) {
int num1;
int num2;

213/227
Formación Sopra Steria / Java básico
29 de enero de 2019

}
}

5. Se crea un try catch.

package [Link];
class ArithmeticExceptionExercise {
public static void main(String args[]) {
int num1;
int num2;

try {
} catch () {
} catch () {

}
}
}

6. Dentro del try se inicializan las variables num1 y num2 y se crean dos mensajes indicando que
ha finalizado.
package [Link];
class ArithmeticExceptionExercise {

public static void main(String args[]) {

int num1;
int num2;
try {
num1 = 0;
num2 = 62 / num1;
[Link](num2);
[Link]("Try finished.");
} catch () {
} catch () {

}
}
}

7. En el primer catch se le pasa como parámetro una excepción 'ArithmeticException' para la

división entre cero y dentro se crea un mensaje indicando el error.
package [Link];
class ArithmeticExceptionExercise {
public static void main(String args[]) {
int num1;
int num2;
try {

214/227
Formación Sopra Steria / Java básico
29 de enero de 2019

num1 = 0;
num2 = 62 / num1;
[Link](num2);
[Link]("Ha terminado el try");
} catch (ArithmeticException e) {
[Link]("It should not be divided by zero.");
} catch () {
}
}
}

8. En el segundo catch se le pasa como parámetro una excepción genérica y dentro se crea un
mensaje indicando el error.
package [Link];
class ArithmeticExceptionExercise {
public static void main(String args[]) {
int num1;
int num2;
try {
num1 = 0;
num2 = 62 / num1;
[Link](num2);
[Link]("Ha terminado el try");
} catch (ArithmeticException e) {
[Link]("No se debería dividir entre cero");
} catch (Exception e) {
[Link]("An exception has ocurred.");
}
}
}

9. Por último, se crea un mensaje indicando que ha finalizado el try-catch.

package [Link];
class ArithmeticExceptionExercise {
public static void main(String args[]) {
int num1;
int num2;
try {
num1 = 0;
num2 = 62 / num1;
[Link](num2);
[Link]("Ha terminado el try");
} catch (ArithmeticException e) {
[Link]("No se debería dividir entre cero");

215/227
Formación Sopra Steria / Java básico
29 de enero de 2019

} catch (Exception e) {
[Link]("Ha ocurrido una excepción");
}
[Link]("Try-catch has finished.");
}
}

10. Output.
It should not be divided by zero.

Try-catch has finished.

public class ArrayIndexOutOfBoundsExceptionExercise {

public static void main(String args[]) {

try{

} catch(){

216/227
Formación Sopra Steria / Java básico
29 de enero de 2019

5. Dentro del try se crea un array de tamaño 10 y se añade a la posición 11 del array el valor 9.
package [Link];

public class ArrayIndexOutOfBoundsExceptionExercise {

public static void main(String args[]) {

try{

int a[]=new int[10];

a[11] = 9;

} catch(){

6. En el catch se le pasa como parámetro una excepción ArrayIndexOutOfBoundsException, que es

lanzada si se añade algún elemento fuera del rango establecido en un array. También se creará
dentro del catch un mensaje indicando el tipo de error.
package [Link];

public class ArrayIndexOutOfBoundsExceptionExercise {

public static void main(String args[]) {

try{

int a[]=new int[10];

a[11] = 9;

} catch(ArrayIndexOutOfBoundsException e){

[Link] ("It should not be divided by zero.

Try-catch has finished.");

7. Output.
Accessing array elements outside of the limit.

217/227
Formación Sopra Steria / Java básico
29 de enero de 2019

6.10. Tutorial 10 - Tipos de excepciones: NullPointerException

Este tutorial pretende mostrar la excepción Java NullPointerException, la cual extiende a
RuntimeException (siendo por lo tanto una excepción opcional). Esta excepción es lanzada cuando se
hace referencia a ningún objeto (dirección de memoria null).

1. Se crea un paquete llamado [Link].

package [Link];

2. Se crea una clase llamada NullPointerExceptionExercise dentro del paquete

[Link].
package [Link];

public class NullPointerExceptionExercise {

3. Se crea el método main.

package [Link];
public class NullPointerExceptionExercise {
public static void main(String args[]) {
}
}

4. Se crea un try catch.

package [Link];

public class NullPointerExceptionExercise {

public static void main(String args[]) {

try{

} catch(){

5. Dentro del try se crea una variable de tipo String con valor nulo, y se muestra la longitud de la
variable.
package [Link];

public class NullPointerExceptionExercise {

public static void main(String args[]) {

try{

218/227
Formación Sopra Steria / Java básico
29 de enero de 2019

String str=null;

[Link] ([Link]());

} catch(){

6. En el catch se le pasa como parámetro una excepción concreta indicando que se accede a un
valor nulo, cuando espera acceder a un objeto y dentro del catch se crea un mensaje indicando
el tipo de error.
package [Link];

public class NullPointerExceptionExercise {

public static void main(String args[]) {

try{

String str=null;

[Link] ([Link]());

} catch(NullPointerException e){

[Link]("The object is null.");

7. Output.
The object is null.

6.11. Tutorial 11 - Tipos de excepciones: NumberFormatException

Este tutorial pretende mostrar la excepción Java NumberFormatException, la cual extiende a
RuntimeException (siendo por lo tanto una excepción opcional). Esta excepción es lanzada cuando no es
posible transformar un objeto String a un objeto de algún tipo de datos numérico.

1. Se crea un paquete llamado [Link].

package [Link];

2. Se crea una clase llamada NumberFormatExceptionExercise dentro del paquete

[Link].

219/227
Formación Sopra Steria / Java básico
29 de enero de 2019

package [Link];

public class NumberFormatExceptionExercise {

3. Se crea el método main.

package [Link];

public class NumberFormatExceptionExercise {

public static void main(String args[]) {

4. Se crea un try catch.

package [Link];

public class NumberFormatExceptionExercise {

public static void main(String args[]) {

try{

} catch(){

5. Dentro del try se crea una variable con valor "XYZ" (texto) y se cambia el tipo de la variable (a
entero). Después, se crea un mensaje donde se muestra el valor de la variable.
package [Link];

public class NumberFormatExceptionExercise {

public static void main(String args[]) {

try{

int num=[Link] ("XYZ") ;

[Link](num);

} catch(){

220/227
Formación Sopra Steria / Java básico
29 de enero de 2019

6. En el catch se le pasa como parámetro una excepción concreta que señaliza si el formato del
número es incorrecto y dentro del catch se crea un mensaje indicando el tipo de error.
package [Link];

public class NumberFormatExceptionExercise {

public static void main(String args[]) {

try{

int num=[Link] ("XYZ") ;

[Link](num);

}catch(NumberFormatException e){

[Link]("The XYZ value can not be converted to Integer type.");

7. Output.
The XYZ value can not be converted to Integer type.

6.12. Tutorial 12 - Tipos de excepciones: FileNotFoundException

Este tutorial pretende mostrar las excepciones Java FileNotFoundException y IOException, las cuales
extienden a Exception (siendo por lo tanto una excepciones obligatorias que deben ser tratadas en el
código). FileNotFoundException es una excepción lanzada cuando no se encuentra el fichero que se debe
leer en la ruta especificada o hay otro problema de lectura del fichero, e IOException es lanzada cuando
hay algún problema o interrupción con operaciones de entrada o salida.

1. Se crea un paquete llamado [Link].

package [Link];

2. Se crean los import necesarios para controlar las excepciones.

package [Link];
import [Link];
import [Link];
import [Link];

3. Se crea una clase llamada FileNotFoundExceptionExercise dentro del paquete

[Link].
package [Link];

import [Link];

221/227
Formación Sopra Steria / Java básico
29 de enero de 2019

import [Link];

public class FileNotFoundExceptionExercise {

4. Se crea el método main.

package [Link];

import [Link];

public class FileNotFoundExceptionExercise {

public static void main(String args[]) {

public static void main(String args[]) {

try {

FileReader fr = new FileReader("C://[Link]");

[Link](c);

} catch () {

7. Se crea un array tipo char de tamaño 50 y se lee el contenido del array.

package [Link];
import [Link];
import [Link];
import [Link];
public class FileNotFoundExceptionExercise {
public static void main(String args[]) {
try {
FileReader fr = new FileReader("C://[Link]");
char [] a = new char[50];
[Link](a);
} catch () {
} catch () {
}
}
}

8. Luego se crea un bucle for que recorre el contenido del fichero y lo muestra por pantalla.
package [Link];
import [Link];
import [Link];
import [Link];
public class FileNotFoundExceptionExercise {
public static void main(String args[]) {
try {
FileReader fr = new FileReader("C://[Link]");

223/227
Formación Sopra Steria / Java básico
29 de enero de 2019

char [] a = new char[50];

[Link](a);

for(char c : a)

[Link](c);
} catch () {
} catch () {
}
}
}

9. En primer catch, se le pasa como parámetro una excepción 'FileNotFoundException' que indica
si existe el fichero y dentro del catch, se muestra un mensaje de error.
package [Link];

import [Link];

public class FileNotFoundExceptionExercise {

public static void main(String args[]) {

try {

FileReader fr = new FileReader("C://[Link]");

char [] a = new char[50];

[Link](a);

for(char c : a)

[Link](c);

} catch (FileNotFoundException e) {

[Link]("File not found.");

} catch () {

10. En el segundo catch, se le pasa como parámetro una excepción 'IOException' que indica si hay
problemas en la lectura y escritura del fichero, y dentro del catch, se muestra un mensaje de
error.

224/227
Formación Sopra Steria / Java básico
29 de enero de 2019

[Link]("File could not be read/write.");

}
}
}

11. Output.
File not found.

6.13. Tutorial 13 – Tipos de excepciones: StringIndexOutOfBoundsException

Este tutorial pretende mostrar la excepción Java StringIndexOutOfBoundsException, la cual extiende a

Exception (siendo por lo tanto una excepción obligatoria que debe ser tratada en el
código). StringIndexOutOfBoundsException es una excepción lanzada cuando se intenta acceder a una
posición que no existe en un string.

1. Se crea un paquete llamado [Link].

package [Link];

2. Se crea una clase llamada StringIndexOutOfBoundExceptionExercisedentro del paquete

[Link].

package [Link];

public class StringIndexOutOfBoundExceptionExercise{

225/227
Formación Sopra Steria / Java básico
29 de enero de 2019

3. Se crea el método main.

package [Link];

public class StringIndexOutOfBoundExceptionExercise{

[Link](c);

} catch (StringIndexOutOfBoundsException e) {

[Link]("The position you are trying to access does not exist,

outside of the limits.");

7. Output.

The position you are trying to access does not exist, outside of the limits.

227/227

También podría gustarte

Introducción a Cursos de Java
Aún no hay calificaciones
Introducción a Cursos de Java
15 páginas
Tipos de Constructores en Java
Aún no hay calificaciones
Tipos de Constructores en Java
4 páginas
Herencia y Sobrecarga en Programación
Aún no hay calificaciones
Herencia y Sobrecarga en Programación
7 páginas
Ejercicios Básicos de Java
Aún no hay calificaciones
Ejercicios Básicos de Java
11 páginas
Herencia y Sobrecarga en Programación
Aún no hay calificaciones
Herencia y Sobrecarga en Programación
7 páginas
Introducción a la Programación Orientada a Objetos
Aún no hay calificaciones
Introducción a la Programación Orientada a Objetos
51 páginas
? Curso Completo de Java
Aún no hay calificaciones
? Curso Completo de Java
69 páginas
3 Ejercicios POO
Aún no hay calificaciones
3 Ejercicios POO
8 páginas
Herencia en Java: Conceptos y Ejemplos
Aún no hay calificaciones
Herencia en Java: Conceptos y Ejemplos
20 páginas
Fundamentos de Programación Orientada a Objetos
Aún no hay calificaciones
Fundamentos de Programación Orientada a Objetos
23 páginas
Clases y Objetos en Java: Guía Práctica
100% (1)
Clases y Objetos en Java: Guía Práctica
6 páginas
Apuntes
Aún no hay calificaciones
Apuntes
13 páginas
Herencia en Programación Java
Aún no hay calificaciones
Herencia en Programación Java
42 páginas
Herencia y Polimorfismo en Java
Aún no hay calificaciones
Herencia y Polimorfismo en Java
31 páginas
Introducción A JavaConceptos Básicos Del Lenguaje Java
Aún no hay calificaciones
Introducción A JavaConceptos Básicos Del Lenguaje Java
6 páginas
Guía Rápida de Fundamentos en Java
Aún no hay calificaciones
Guía Rápida de Fundamentos en Java
16 páginas
Sobrecarga en Programación Java
Aún no hay calificaciones
Sobrecarga en Programación Java
7 páginas
Java Unidad 8
Aún no hay calificaciones
Java Unidad 8
73 páginas
Clases y Objetos en Java: Guía Básica
Aún no hay calificaciones
Clases y Objetos en Java: Guía Básica
31 páginas
Fundamentos de Java: JVM, Modificadores y Más
Aún no hay calificaciones
Fundamentos de Java: JVM, Modificadores y Más
12 páginas
Pass Mast Private Java
Aún no hay calificaciones
Pass Mast Private Java
8 páginas
Clases y Modificadores en Java
Aún no hay calificaciones
Clases y Modificadores en Java
4 páginas
Guía para Examen de Java - Programación Orientada A Objetos
Aún no hay calificaciones
Guía para Examen de Java - Programación Orientada A Objetos
14 páginas
Programación Orientada a Objetos en Java
Aún no hay calificaciones
Programación Orientada a Objetos en Java
95 páginas
So2 - Unidad I - Introduccion
Aún no hay calificaciones
So2 - Unidad I - Introduccion
13 páginas
Modelar Objetos en Java
0% (1)
Modelar Objetos en Java
25 páginas
Guía de Práctica CLASES Y OBJETOS-METODOS
Aún no hay calificaciones
Guía de Práctica CLASES Y OBJETOS-METODOS
9 páginas
Guía de Práctica Clases y Objetos-Metodos
Aún no hay calificaciones
Guía de Práctica Clases y Objetos-Metodos
9 páginas
Guía de Práctica Clases y Objetos-Metodos
Aún no hay calificaciones
Guía de Práctica Clases y Objetos-Metodos
9 páginas
Herencia y Polimorfismo en Java
Aún no hay calificaciones
Herencia y Polimorfismo en Java
51 páginas
Herencia y Polimorfismo en Java
Aún no hay calificaciones
Herencia y Polimorfismo en Java
4 páginas
Estructura de Clases y Atributos en Java
Aún no hay calificaciones
Estructura de Clases y Atributos en Java
5 páginas
Atributos y Clases en Java
Aún no hay calificaciones
Atributos y Clases en Java
14 páginas
Programación Avanzada en Java: Herencia
Aún no hay calificaciones
Programación Avanzada en Java: Herencia
21 páginas
Ejemplo de Herencia en Java
100% (1)
Ejemplo de Herencia en Java
7 páginas
Introducción a la Programación Orientada a Objetos
Aún no hay calificaciones
Introducción a la Programación Orientada a Objetos
13 páginas
Introducción a Java: Arreglos y Bucles
Aún no hay calificaciones
Introducción a Java: Arreglos y Bucles
4 páginas
Test Técnico Multiple Choice - Programación y POO (Estilo Junior)
Aún no hay calificaciones
Test Técnico Multiple Choice - Programación y POO (Estilo Junior)
4 páginas
Introducción a Clases en JavaScript
100% (1)
Introducción a Clases en JavaScript
51 páginas
Java
Aún no hay calificaciones
Java
4 páginas
Introducción a POO en Java: Clases y Objetos
Aún no hay calificaciones
Introducción a POO en Java: Clases y Objetos
57 páginas
Introducción a la Programación Orientada a Objetos
Aún no hay calificaciones
Introducción a la Programación Orientada a Objetos
57 páginas
Resumen del Lenguaje Java y Comandos
Aún no hay calificaciones
Resumen del Lenguaje Java y Comandos
9 páginas
Taller Introducción A POO en Java
Aún no hay calificaciones
Taller Introducción A POO en Java
2 páginas
Conceptos Clave de POO
Aún no hay calificaciones
Conceptos Clave de POO
4 páginas
Objetos en Programación Orientada a Objetos
100% (1)
Objetos en Programación Orientada a Objetos
96 páginas
Fundamentos de Programación en Java
Aún no hay calificaciones
Fundamentos de Programación en Java
74 páginas
Aprender Java Desde Cero: Guía Completa
Aún no hay calificaciones
Aprender Java Desde Cero: Guía Completa
9 páginas
Estructuras y Clases en Java
Aún no hay calificaciones
Estructuras y Clases en Java
3 páginas
Fundamentos de Programación en Java
Aún no hay calificaciones
Fundamentos de Programación en Java
8 páginas
Fundamentos de POO en Java
Aún no hay calificaciones
Fundamentos de POO en Java
5 páginas
Tipos de Variables en Java
Aún no hay calificaciones
Tipos de Variables en Java
49 páginas
Conceptos Básicos de POO
Aún no hay calificaciones
Conceptos Básicos de POO
4 páginas
Clases y Objetos en Programación Java
Aún no hay calificaciones
Clases y Objetos en Programación Java
93 páginas
Herencia en Java: Conceptos y Ejemplos
Aún no hay calificaciones
Herencia en Java: Conceptos y Ejemplos
8 páginas
Introducción a la Programación en Java
Aún no hay calificaciones
Introducción a la Programación en Java
39 páginas
Fundamentos de Programación Orientada a Objetos
Aún no hay calificaciones
Fundamentos de Programación Orientada a Objetos
11 páginas
Introducción a Java en 3 Horas
Aún no hay calificaciones
Introducción a Java en 3 Horas
24 páginas
Clases y Objetos en Java: Guía Básica
Aún no hay calificaciones
Clases y Objetos en Java: Guía Básica
30 páginas
Estudio sobre movilidad activa en Concepción
Aún no hay calificaciones
Estudio sobre movilidad activa en Concepción
16 páginas
Examen CONAIP Resuelto 2016-2
Aún no hay calificaciones
Examen CONAIP Resuelto 2016-2
29 páginas
Contrato de Licencia de Patente USAL
Aún no hay calificaciones
Contrato de Licencia de Patente USAL
8 páginas
Participación Ciudadana en Democracia Colombiana
Aún no hay calificaciones
Participación Ciudadana en Democracia Colombiana
5 páginas
Tarea 5 Practica de Contabilidad 2
Aún no hay calificaciones
Tarea 5 Practica de Contabilidad 2
7 páginas
Programa Debate Juvenil
Aún no hay calificaciones
Programa Debate Juvenil
7 páginas
Etiquetas de Seguridad Retroexcavadora 420E
Aún no hay calificaciones
Etiquetas de Seguridad Retroexcavadora 420E
13 páginas
Cálculo de M.C.D. y M.C.M.
Aún no hay calificaciones
Cálculo de M.C.D. y M.C.M.
3 páginas
Guía de Repaso de Lenguaje 5to Grado
Aún no hay calificaciones
Guía de Repaso de Lenguaje 5to Grado
2 páginas
Precursores de la Lectura y Escritura
Aún no hay calificaciones
Precursores de la Lectura y Escritura
3 páginas
Conductividad y Disociación de Electrolitos
Aún no hay calificaciones
Conductividad y Disociación de Electrolitos
22 páginas
Medicion Del Clima Laboral
Aún no hay calificaciones
Medicion Del Clima Laboral
25 páginas
Análisis de Costos Agrícolas en Perú
100% (1)
Análisis de Costos Agrícolas en Perú
25 páginas
Control Interno: Claves y Beneficios
Aún no hay calificaciones
Control Interno: Claves y Beneficios
9 páginas
Formas Jurídicas para Emprendedores
Aún no hay calificaciones
Formas Jurídicas para Emprendedores
12 páginas
Teoría de Competencias en Enfermería
Aún no hay calificaciones
Teoría de Competencias en Enfermería
2 páginas
Tipos de Fórmulas Químicas Orgánicas
100% (1)
Tipos de Fórmulas Químicas Orgánicas
4 páginas
Análisis de Casos y Controles en SPSS
Aún no hay calificaciones
Análisis de Casos y Controles en SPSS
13 páginas
Ejercicios de Conversión y Notación Científica
Aún no hay calificaciones
Ejercicios de Conversión y Notación Científica
68 páginas
Casa de Retiro en La Calera, Michoacán
Aún no hay calificaciones
Casa de Retiro en La Calera, Michoacán
1 página
Ventajas de la Piedra Pishilata en Construcción
Aún no hay calificaciones
Ventajas de la Piedra Pishilata en Construcción
7 páginas
Estructura de la Criminalística Identificativa
100% (1)
Estructura de la Criminalística Identificativa
11 páginas
Quiénes son los Rosacruces
Aún no hay calificaciones
Quiénes son los Rosacruces
4 páginas
Taller de Danza: Marinera Norteña
Aún no hay calificaciones
Taller de Danza: Marinera Norteña
2 páginas
Medios y Recursos Instruccionales
Aún no hay calificaciones
Medios y Recursos Instruccionales
13 páginas
2 - Productora y Comercializadora Famark Cieza
Aún no hay calificaciones
2 - Productora y Comercializadora Famark Cieza
1 página
Educación Musical en Currículas Escolares
Aún no hay calificaciones
Educación Musical en Currículas Escolares
55 páginas
Ficha Técnica de Termas Eléctricas Verticales
Aún no hay calificaciones
Ficha Técnica de Termas Eléctricas Verticales
1 página
Modelos Instruccionales: ADDIE y ASSURE
Aún no hay calificaciones
Modelos Instruccionales: ADDIE y ASSURE
23 páginas
Cálculos de Combustión de Etileno C2H4
Aún no hay calificaciones
Cálculos de Combustión de Etileno C2H4
3 páginas