2 Java

TABLA DE CONTENIDO
JAVA .................................................................................................................................................................... 5
DEFINICIÓN ..................................................................................................................................................................... 5
INSTALACIÓN .................................................................................................................................................................. 5
VARIABLES ...................................................................................................................................................................... 6
TIPOS DE VARIABLES ....................................................................................................................................................... 7
• PRIMITIVOS .................................................................................................................................................... 7
o TIPOS DE VARIABLES .................................................................................................................................. 7
o RESUMEN................................................................................................................................................... 8
o PALABRAS RESERVADAS DEL LENGUAJE.................................................................................................... 9
• REFERENCIA ................................................................................................................................................. 10
o TIPOS DE VARIABLES ................................................................................................................................ 10
• NORMAS PARA EL NOMBRE DE UNA VARIABLE .......................................................................................... 11
ENTRADAS DE DATOS ................................................................................................................................................... 12
• VENTANAS ................................................................................................................................................... 12
• TERMINAL .................................................................................................................................................... 12
CONVERSIONES............................................................................................................................................................. 13
• CONVERSIÓN DE CADENAS A TIPOS PRIMITIVOS ........................................................................................ 13
• CONVERSIÓN DE TIPOS PRIMITIVOS A CADENAS ........................................................................................ 13
• CONVERSIÓN ENTRE TIPOS PRIMITIVOS ..................................................................................................... 14
OPERACIONES ............................................................................................................................................................... 15
PRECEDENCIA DE OPERADORES ................................................................................................................................... 16
OPERADORES DE ASIGNACIÓN (INCREMENTALES O DECREMÉNTALES) ..................................................................... 16
HERENCIA...................................................................................................................................................................... 17
• EJEMPLO ...................................................................................................................................................... 18
DIFERENCIA MÉTODO Y FUNCIÓN ................................................................................................................................ 18
CLASES ABSTRACTAS..................................................................................................................................................... 19
• EJEMPLO ...................................................................................................................................................... 20
INTERFACES .................................................................................................................................................................. 21
• CARACTERISTICAS ........................................................................................................................................ 22
MODIFICADOR DE ACCESO ........................................................................................................................................... 23
VALORES DE RETORNO ................................................................................................................................................. 24
• TIPOS DE VALORES DE RETORNO ................................................................................................................ 24
ENCAPSULACIÓN .......................................................................................................................................................... 26
• VENTAJAS..................................................................................................................................................... 26
1
POLIMORFISMO ............................................................................................................................................................ 27
• EJEMPLO ...................................................................................................................................................... 27
• SOBRECARGA DE MÉTODOS (OVERLOADING) ............................................................................................ 29
• SOBREESCRITURA DE MÉTODOS (OVERRIDING) ......................................................................................... 30
o EJEMPLO .................................................................................................................................................. 30
CONSTRUCTOR ............................................................................................................................................................. 32
TABLAS DE VERDAD ...................................................................................................................................................... 33
UPCASTING & DOWNCASTING ..................................................................................................................................... 33
• UPCASTING .................................................................................................................................................. 33
• DOWNCASTING............................................................................................................................................ 33
PALABRAS RESERVADAS DE JAVA (KEYWORDS) ........................................................................................................... 34
• THIS .............................................................................................................................................................. 34
• FINAL ............................................................................................................................................................ 34
• SUPER........................................................................................................................................................... 35
• STATIC .......................................................................................................................................................... 37
NOTAS TIPOS DE DATOS...................................................................................................................................... 38
CADENAS....................................................................................................................................................................... 38
MÉTODOS........................................................................................................................................................... 39
DEFINICIÓN ................................................................................................................................................................... 39
NORMAS PARA EL NOMBRE DE UN MÉTODO .............................................................................................................. 39
EXPRESIONES LAMBDA ................................................................................................................................................. 39
MÉTODOS DE LA CLASE STRING ................................................................................................................................... 40
• INT LENGHT() ............................................................................................................................................... 40
• BOOLEAN EQUALS(STRING B) ...................................................................................................................... 40
• BOOLEAN EQUALSIGNORECASE(STRING B)................................................................................................. 40
• INT COMPARETO(STRING B) ........................................................................................................................ 40
• STRING TRIM() ............................................................................................................................................. 40
• CHAR CHARAT(INT POSICION) ..................................................................................................................... 40
• CHAR[] TOCHARARRAY() .............................................................................................................................. 40
• STRING SUBSTRING(INT A, INT B) ................................................................................................................ 41
• STRING SUBSTRING(INT DESDE) .................................................................................................................. 41
• INT INDEXOF(STRING CADENA) ................................................................................................................... 41
• INT LASTINDEXOF(STRING CADENA) ........................................................................................................... 41
• BOOLEAN STARTSWITH(STRING PREFIJO) ................................................................................................... 41
• BOOLEAN ENDSWITH(STRING SUFIJO) ........................................................................................................ 41
• STRING[] SPLIT(STRING PATRON) ................................................................................................................ 41
2
POO ................................................................................................................................................................... 42
DEFINICIÓN ................................................................................................................................................................... 42
CLASES .......................................................................................................................................................................... 42
CONTROLADORES DE FLUJO ................................................................................................................................ 43
IF ................................................................................................................................................................................... 43
SWITCH ......................................................................................................................................................................... 43
WHILE ........................................................................................................................................................................... 44
DO-WHILE ..................................................................................................................................................................... 44
FOR ............................................................................................................................................................................... 45
FOREACH....................................................................................................................................................................... 45
ARREGLOS .......................................................................................................................................................... 46
DEFINICIÓN ................................................................................................................................................................... 46
ESTRUCTURA................................................................................................................................................................. 46
MATRICES........................................................................................................................................................... 48
DEFINICIÓN ................................................................................................................................................................... 48
EJEMPLO ....................................................................................................................................................................... 49
MATRIZ DE 3 X 3 CON LOS NÚMEROS DEL 1 AL 9 ........................................................................................................ 49
LLENADO DE UNA MATRIZ............................................................................................................................................ 49
RECORRIDO DE UNA MATRIZ........................................................................................................................................ 50
COLECCIONES ..................................................................................................................................................... 52
ARRAYLIST ..................................................................................................................................................................... 52
• MÉTODOS .................................................................................................................................................... 53
o .GET() ....................................................................................................................................................... 54
o .ADD() ...................................................................................................................................................... 54
o .SIZE() ....................................................................................................................................................... 54
STACK - PILA .................................................................................................................................................................. 55
• MÉTODOS .................................................................................................................................................... 56
o .PUSH() ..................................................................................................................................................... 56
o .POP() ....................................................................................................................................................... 56
o .CLEAR() ................................................................................................................................................... 56
QUEUE - COLA............................................................................................................................................................... 57
• MÉTODOS .................................................................................................................................................... 58
o .ADD() ...................................................................................................................................................... 58
o .PEEK()...................................................................................................................................................... 58
o .POLL()...................................................................................................................................................... 58
HASHTABLE - DICCIONARIO .......................................................................................................................................... 59
• MÉTODOS .................................................................................................................................................... 60
3
o .PUT() ....................................................................................................................................................... 60
o .GET() ....................................................................................................................................................... 60
ARCHIVOS O DATA .............................................................................................................................................. 61
PROPERTY FILE .............................................................................................................................................................. 61
• PASOS PARA CREAR UN PROPERTY FILE ...................................................................................................... 61
• REGLAS PARA UN PROPERTY FILE ................................................................................................................ 61
• OBTENER DATOS DE UN PROPERTY FILE ..................................................................................................... 62
MANEJO DE ARCHIVOS ....................................................................................................................................... 63
LEER UN ARCHIVO POR MEDIO DE FILEREADER ........................................................................................................... 63
LEER UN ARCHIVO POR MEDIO DE BUFFERREAD ......................................................................................................... 63
CREAR UN ARCHIVO Y ESCRIBIR EN ÉL POR MEDIO DE FILEWRITER ............................................................................ 64
CREAR UN ARCHIVO Y ESCRIBIR EN ÉL POR MEDIO DE BUFFEREDWRITER ................................................................. 65
MANEJO DE EXCEPCIONES .................................................................................................................................. 66
DEFINICIÓN ................................................................................................................................................................... 66
¿QUE HACER PARA EL MANEJO DE EXCEPCIONES?...................................................................................................... 67
• AÑADIENDO EXCEPCIONES PARA QUE ALGO MÁS SE ENCARGUE DE ELLAS .............................................. 67
• USANDO TRY – CATCH - FINALLY ................................................................................................................. 68
• ARROJANDO EXCEPCIONES MANUALMENTE .............................................................................................. 69
DEBUGGING (DEPURACIÓN) ................................................................................................................................ 70
DEFINICIÓN ................................................................................................................................................................... 70
PASO A PASO ................................................................................................................................................................ 70
INTELLIJ .............................................................................................................................................................. 71
COMANDOS .................................................................................................................................................................. 71
OTROS ................................................................................................................................................................ 72
4
JAVA
DEFINICIÓN
• Java es un lenguaje fuertemente tipado (Cada variable debe estar asociada a un tipo de dato).
• Java es un lenguaje orientado a objetos.
o Un objeto es una abstracción de la realidad.

▪ Para yo poder definir un objeto en el lenguaje de programación debo tener antes definida ya
una clase del objeto.
▪ El objeto puede acceder a los atributos y métodos de la clase con que fue creado.
o Una clase es la abstracción de ese objeto en un lenguaje de programación.

▪ En una clase se definen los atributos o características (Nombre, edad, peso, altura, apellido,
etc.) y existen métodos o funciones (Comer, caminar, correr, dormir, etc.).
INSTALACIÓN
• Descargamos el JDK que queramos, ingresamos a: https://www.oracle.com/lad/java/technologies/javase-

downloads.html
• Descargamos la opción de “Windows x64” (Si no deja descargar desde Chrome, intenta cambiar de
navegador para descargar).
• Le damos SI a todo y terminamos la instalación.
• Buscamos Editar variables de entorno/ Copiamos la ruta de la carpeta bin adentro del JDK que instalamos
• Pegamos esa dirección en la variable Path del panel de arriba y en la variable JAVA_HOME del panel de abajo
quitamos de la ruta \bin
o Si alguna variable no existe la creamos.
o Nos aseguramos de que no haya otras rutas de otras versiones de JDK en esas variables.
• Descargamos el IDE con el que vamos a trabajar, ingresamos a: https://www.jetbrains.com/es-

es/idea/download/#section=windows y descargamos IntelliJ.
• Instalamos la versión Community.
5
VARIABLES
• Es un espacio de memoria que almacenará datos.
• CONSTANTE: Una variable constante es aquella que se inicializa en un valor y ese valor nunca cambia en el
recorrido del código.
• VARIABLE ESTÁTICA: Pertenece a la clase y no al objeto, y se inicializa solo una vez al inicio de una ejecución.
o Vamos a tener 1 sola copia de esa variable que va a ser compartida por todas las instancias de la
clase.
o Estas variables se inicializarán primero, antes de la inicialización de cualquier variable de instancia
o Para acceder, se accede directamente por el nombre de la clase y no se necesita hacer referencia a
ningún objeto.
o Ósea que, se puede acceder directamente con el nombre de la clase sin necesidad de crear un objeto.
o Son, esencialmente, variables globales.
o Cuando se declara un objeto, no se realiza una copia de una variable estática; En cambio, todas las
instancias de la clase comparten la misma variable estática.
6
TIPOS DE VARIABLES
PRIMITIVOS
o Contienen 1 solo valor e incluyen los tipos como los enteros, flotantes, caracteres, booleanos, etc.
o Como todo en Java es de tipado estático, es decir, se define el tipo de dato de la variable a la hora de
definir esta.
o El tipo de dato se escribe completamente en minúscula.
TIPOS DE VARIABLES
▪ BOOLEAN: Este es el tipo más simple de un solo bit.

➢ Expresa un valor de verdad, puede ser VERDADERO o FALSO.
➢ para especificar un literal boolean, se usan las palabras clave true o false.
➢ El valor por defecto es false.
❖ boolean a = false;
▪ CHAR: Usa el código UNICODE y ocupa cada carácter 16 bits.

➢ Podemos usar cualquier carácter UNICODE buscando Mapa de caracteres y
seleccionando el que queramos, y en la base aparecerá el código.
❖ char a = ‘a’;
❖ char a = ‘\u0040’; //= @
▪ NÚMEROS ENTEROS: Un entero es un número del conjunto Z = {…, -2, -1, 0, 1, 2, …}

➢ Difieren en las precisiones y pueden ser positivos o negativos.
➢ Son 4 tipos:
❖ BYTE: Entre -128 a 127.
❖ SHORT: Entre -32768 a 32767.
❖ INT: Entre -2147483648 a 2147483647.
Si ponemos un 0b al principio de un numero binario me lo convierte
a un número entero: 0b111110100 // = 500
Si ponemos un 0 al principio de un numero octal me lo convierte a un
número entero: 0764 // = 500
Si ponemos un 0x al principio de un numero hexadecimal me lo
convierte a un número entero: 0x1f4 // = 500
❖ LONG: Entre -9223372036854775808 a 9223372036854775807.

Después de 2147483648 debemos colocar al final L.
7
▪ NÚMEROS REALES: Es un tipo de dato para guardar números reales en coma flotante con
precisión simple y doble.
➢ Los números de punto flotante (También conocidos como “Flotantes”, “Dobles” o
“Números reales”).
➢ Se utiliza punto y no coma.
➢ Son 2 tipos:
❖ FLOAT: Entre -1.4E-45 a 3.4028235E8.
Para poner un decimal debemos poner una f F al final (1.0f).
Puede escribirse en notación científica.
✓ 2.12e3 = 2120
✓ 1.5e-10f = 0.00000000015f
❖ DOUBLE: Entre -4.9E-324 a 1.7976931348623157E308.

No es necesario especificar una letra al final.
▪ VAR: Variable dinámica que cambia según su valor.

➢ No se soporta en Java 8, sino en Java 10 en adelante.
➢ Debe especificarse si es un número real con f o nada al final.
❖ var var = “5”
RESUMEN
8
PALABRAS RESERVADAS DEL LENGUAJE
9
REFERENCIA
o Contienen más de 1 valor como: arreglos, clases e interfaces.
TIPOS DE VARIABLES
▪ STRING: Los String son objetos de java, del tipo de referencia.
➢ Aunque también los String se pueden representar con una sintaxis especialmente
cómoda.
➢ Los String son siempre inmutables (No cambian).
➢ Un String es un arreglo.
➢ El tipo String tiene una característica especial, permite crear objetos también en la
literal entre comillas:
❖ String cadena = “Hola como estas”;
➢ Los caracteres de un String se codifican usando Unicode.

➢ Son inmutables.
➢ Para incluir el carácter comillas dobles, se debe escapar “\””.
➢ Sobre las cadenas se define la operación de concatenar con el operador de suma:
➢ Con el operador relacional de igualdad == compara por referencia.

➢ Con el método equals() compara por valor.
10
NORMAS PARA EL NOMBRE DE UNA VARIABLE
o Empiezan con minúscula.

o Si una variable está compuesta por más de 1 palabra, como ‘nombreDato’ las palabras se ponen
juntas y cada palabra después de la primera empieza con una letra mayúscula.
o No utilizar acentos ni ñ.
o No puede comenzar por un número.
o No puede contener espacios.
o No puede contener símbolos especiales (á, é, í, ¿, ?).
o Podemos utilizar _ para los espacios.
11
ENTRADAS DE DATOS
• Existen 2 formas globales de ingresar datos en un programa de Java, puede ser por medio de ventanas o de la
terminal.
VENTANAS
o Debemos atrapar la variable que queramos con la librería JOptionPane:
o También podemos mostrar ventanas de alertas o mensajes:
TERMINAL
o Para atrapar datos desde la terminal debemos usar la librería Scanner:

o Debemos primero iniciar el Scanner para que me atrape lo que vaya a ingresar, luego mostrar el
mensaje que me indicara que dato debo ingresar, y por último guardo en una variable lo que se
ingresó, especificando con los métodos del Scanner que tipo de dato debe atrapar:
12
CONVERSIONES
CONVERSIÓN DE CADENAS A TIPOS PRIMITIVOS
o Para convertir de cadena a un tipo primitivo:

▪ 1. Declaramos el tipo de variable a la que se va a convertir la cadena.
▪ 2. Ingresamos la clase Wrapper de la variable que declaramos (Integer, Double, etc.).
▪ 3. Invocamos el método parse con el método de variable que declaramos (parseInt,
parseDouble, etc.)
▪ 4. Ingresamos la cadena dentro del paréntesis.
CONVERSIÓN DE TIPOS PRIMITIVOS A CADENAS
o Para convertir de tipos primitivos a cadenas existen 2 formas:
▪ FORMA 1:
➢ 1. Creamos la variable String donde vamos a convertir el dato primitivo.
➢ 2. Ingresamos la clase Wrapper del dato primitivo que vamos a convertir (Integer,
Double, etc.)
➢ 3. Invocamos el método toString
➢ 4. Ingresamos el dato primitivo dentro del paréntesis.
▪ FORMA 2:
➢ 1. Creamos la variable String donde vamos a convertir el dato primitivo.
➢ 2. Ingresamos la clase String para convertir el dato.
➢ 3. Invocamos el método valueOf y dentro del paréntesis ponemos el dato primitivo.
13
CONVERSIÓN ENTRE TIPOS PRIMITIVOS
o NÚMEROS:
▪ Debemos tener cuidado al convertir entre números cuidando los límites de cada tipo de dato.
▪ Para convertir entre número debo hacer un Cast, que es poner un paréntesis con el tipo de
dato que voy a convertir y al lado la variable que voy a convertir.
▪ Existen 2 tipos de conversión:
➢ IMPLICIT TYPE CASTING: Cuando convertimos archivos de tipo de dato pequeño o
del mismo tipo de dato hacia un tipo de dato mayor.
❖ Ejemplo: int i = s (s es un tipo short)
➢ EXPLICIT TYPE CASTING: Cuando convertimos archivos de tipo de dato más grandes
hacia un tipo de dato menor.
❖ Ejemplo:
14
OPERACIONES
• SUMA: (int numero = 1 + 2;)
• RESTA: (int numero = 1 – 2;)
• MULTIPLICACIÓN: (int numero = 1 * 2;)
• DIVISIÓN: (int numero = 1 / 2;) Devuelve el resultado en decimal.
• MODULO: (int numero = 1 % 2;) Devuelve el residuo de una división.
• INCREMENTO: (uno++;) Incrementa en 1 unidad el valor de la variable.

o (uno += 20;) Incrementa en 20 unidades el valor de la variable.
o (uno *= 20;) Multiplica por 20 unidades el valor de la variable.
• DECREMENTO: (uno--;) Decrementa en 1 unidad el valor de la variable.
• MAYOR: (1 > 2)
• MENOR: (1 < 2)
• MAYOR O IGUAL: (1 >= 2)
• MENOR O IGUAL: (1 <= 2)
• IGUAL: (1 == 2)
• DIFERENTE: (1 != 2)
• Y: (1 && 2)
• O: (1 || 2)
• NEGACIÓN: (!(uno == 19))
15
PRECEDENCIA DE OPERADORES
• 1. Los paréntesis porque tienen prioridad.

• 2. Expresiones aritméticas por sus reglas: (Siempre de izquierda a derecha)
o Exponentes y raíces.
o Multiplicaciones y divisiones.
o Sumas y restas.
• 3. Relacionales: >= ; !=.
• 4. Lógicos: not False, False y True.
OPERADORES DE ASIGNACIÓN (INCREMENTALES O DECREMÉNTALES)
o += : n = n + 1
o -= : n = n - 1
o *= : n = n * 1
o /= : n = n / 1
o %= : n = n % 1
o **= : n = n ** 1
16
HERENCIA
• En Java la herencia es, permitirle a una clase utilizar las mismas variables y los mismos métodos para un fin.
• La herencia es un mecanismo que permite la definición de una clase a partir de la definición de otra ya
existente.
• La herencia permite compartir automáticamente métodos y datos entre clases, subclases y objetos.
• La herencia está fuertemente ligada a la reutilización del código en la OOP.
o Esto es, el código de cualquiera de las clases puede ser utilizado sin más que crear una clase derivada
de ella, o bien una subclase.
• Hay dos tipos de herencia: Herencia Simple y Herencia Múltiple.

o La primera indica que se pueden definir nuevas clases solamente a partir de una clase inicial mientras
que la segunda indica que se pueden definir nuevas clases a partir de dos o más clases iniciales.
o Java sólo permite herencia simple.
• El concepto de herencia conduce a una estructura jerárquica de clases o estructura de árbol, lo cual significa
que en la POO todas las relaciones entre clases deben ajustarse a dicha estructura.
• En esta estructura jerárquica, cada clase tiene sólo una clase padre.
• La clase padre de cualquier clase es conocida como su superclase.

o Una superclase puede tener cualquier número de subclases.
• La clase hija de una superclase es llamada una subclase.

o Una subclase puede tener sólo una superclase.
17
EJEMPLO
o Aquí vemos la clase Transporte con variables y funciones públicas para su uso en otras clases.
public class Transporte {
public int capacidad;
public void avanzar() {

System.out.println("El transporte esta avanzando");
}
public void detenerse() {

System.out.println("El transporte se ha detenido");
}
o Esta es la clase Aeronave que se encuentra en un archivo externo dentro del mismo paquete.
o Para que esta clase pueda usar las variables y las funciones de la clase Transporte añadimos:
▪ extends nombreClase
public class Aeronave extends Transporte {
o Esta clase es la clase Main que se encuentra en un archivo externo dentro del mismo paquete.
o Aquí podemos ejecutar el código creando un objeto de la clase Aeronave y usando una función de la
clase Transporte.
public class Main {
public static void main(String[] args) {
Aeronave avion = new Aeronave();

avion.avanzar();
DIFERENCIA MÉTODO Y FUNCIÓN
• Un método es lo mismo que una función, pero el método es llamado por una variable.
o Método: .nombre()
o Función: nombre() (Se escribe antes que la lista para la cual es llamada, sin punto).
• Para crear una función seguimos la siguiente estructura:

o ModificadorAcceso + ValorRetorno + NombreFuncion + (Parámetros) + {}
o public void Hola() {}
• Para llamar a una función desde la misma clase ponemos nombreFuncion();
18
CLASES ABSTRACTAS
• Una clase abstracta es prácticamente idéntica a una clase convencional; las clases abstractas pueden poseer
atributos, métodos, constructores, etc.
• La principal diferencia entre una clase convencional y una clase abstracta es que la clase abstracta debe
poseer por lo menos un método abstracto.
o Un método abstracto no es más que un método vacío, un método el cual no posee cuerpo, por ende,
no puede realizar ninguna acción.
o La utilidad de un método abstracto es definir qué se debe hacer, pero no el cómo se debe hacer.
o No tiene cuerpo (Llaves): Sólo consta de signatura con paréntesis.
o Su signatura termina con un punto y coma.
o Sólo puede existir dentro de una clase abstracta.
▪ De esta forma se evita que haya métodos que no se puedan ejecutar dentro de clases
concretas.
▪ Visto de otra manera, si una clase incluye un método abstracto, forzosamente la clase será
una clase abstracta.
o Los métodos abstractos forzosamente habrán de estar sobrescritos en las subclases.

▪ Si una subclase no implementa un método abstracto de la superclase tiene un método no
ejecutable, lo que la fuerza a ser una subclase abstracta.
▪ Para que la subclase sea concreta habrá de implementar métodos sobrescritos para todos los
métodos abstractos de sus superclases.
o Un método abstracto para Java es un método que nunca va a ser ejecutado porque no tiene cuerpo.
o Simplemente, un método abstracto referencia a otros métodos de las subclases.
o ¿QUÉ UTILIDAD TIENE UN MÉTODO ABSTRACTO?: Podemos ver un método abstracto como una
palanca que fuerza dos cosas:
▪ La primera, que no se puedan crear objetos de una clase.
▪ La segunda, que todas las subclases sobrescriban el método declarado como abstracto.
• En Java se dice que son clases abstractas aquellas clases base (Superclases) de las que no se permite la
creación de objetos.
• Para ello, se utiliza la palabra clave abstract.
• En una clase abstracta es posible definir métodos abstractos, los cuales se caracterizan por el hecho de que
no pueden ser implementados en la clase base.
• La diferencia principal radica en que no se pueden crear objetos de esta clase.
public abstract class NombreDeLaClase { … }
19
EJEMPLO
public class Figura {
private int numeroLados;
public Figura() {
this.numeroLados = 0;
}
public float area() {

return 0f;
}
}
o En este caso la clase posee un atributo, un constructor y un método, a partir de esta clase podré
generar la n cantidad de figuras que necesite, ya sean cuadrados, rectángulos, triángulos, círculos etc.
o Dentro de la clase encontramos el método área, método que se encuentra pensado para obtener el
área de cualquier figura, sin embargo, cómo sabemos todas las figuras poseen su propia fórmula
matemática para calcular su área.
o Si yo comienzo a heredar de la clase Figura todas las clases hijas tendrían que sobre escribir el
método área e implementar su propia fórmula para así poder calcular su área.
o En estos casos, en los casos donde la clase hija siempre deba que sobre escribir el método lo que
podemos hacer es convertir al método convencional en un método abstracto, un método que defina
qué hacer, pero no cómo se deba hacer.
public abstract float area();
o Ahora que el método área es un método abstracto la clase se convierte en una clase abstracta.
public abstract class Figura {
o Es importante mencionar que las clases abstractas pueden ser heredadas por la n cantidad de clases
que necesitemos, pero no pueden ser instanciadas (No resulta posible crear objetos de ese tipo en la
clase Main, sino que otras clases hereden métodos y atributos de ella).
o Para heredar de una clase abstracta basta con utilizar la palabra reservada extends.
public class Triangulo extends Figura {
o Al nosotros heredar de una clase abstracta es obligatorio implementar todos sus métodos abstractos,
es decir debemos definir comportamiento, definir cómo se va a realizar la tarea.
20
INTERFACES
• Una interfaz () es sintácticamente similar a una clase abstracta, en la que puede especificar uno o más
métodos que no tienen cuerpo ({}).
• Una interfaz puede tener metodos con una estructura definida solo si son Estáticos o Default:
o static void nombreMetodo(){}
o default void nombreMetodo(){}
• Esos métodos deben ser implementados por una clase para que se definan sus acciones.
• Por lo tanto, una interfaz especifica qué se debe hacer, pero no cómo hacerlo.
• Una vez que se define una interfaz, cualquier cantidad de clases puede implementarla.
• Además, una clase puede implementar cualquier cantidad de interfaces.
• Para implementar una interfaz, una clase debe proporcionar cuerpos (Implementaciones) para los métodos
descritos por la interfaz.
• Cada clase es libre de determinar los detalles de su propia implementación.
• Una interfaz es una lista de acciones que puede llevar a cabo un determinado objeto.
• ¿Eso no eran los métodos que se definen en una clase? Casi, en una clase además de aparecer los métodos
aparecía el código para dichos métodos, en cambio en un interfaz sólo existe el prototipo de una función, no
su código.
• Veámoslo con un ejemplo: Pensemos en un interfaz que en su lista de métodos aparezcan los métodos
despegar, aterrizar, servirComida y volar.
o Todos pensamos en un avión, ¿verdad? El motivo es sencillamente que avión es el concepto que
engloba las acciones que hemos detallado antes, a pesar de que existan muchos objetos avión
diferentes entre sí, por ejemplo, Boeing 747, Boeing 737, MacDonell-Douglas.
o Lo realmente interesante es que todos ellos, a pesar de pertenecer a clases distintas, poseen el
interfaz avión, es decir poseen los métodos detallados en la lista del interfaz avión.
o Esto significa también que a cualquier avión le podemos pedir que vuele, sin importarnos a que clase
real pertenezca el avión, evidentemente cada clase especificará como volará el avión (Porque
proporciona el código de la función volar).
21
CARACTERISTICAS
o Todos los métodos de una interfaz se declaran implícitamente como abstractos y públicos.
o Una clase abstracta no puede implementar los métodos declarados como abstractos, una interfaz no
puede implementar ningún método (ya que todos son abstractos).
o Una interfaz no declara variables de instancia.
o Una clase puede implementar varias interfaces, pero sólo puede tener una clase ascendiente directa.
o Una clase abstracta pertenece a una jerarquía de clases mientras que una interfaz no pertenece a una
jerarquía de clases.
▪ En consecuencia, clases sin relación de herencia pueden implementar la misma interfaz.
o Dos clases pueden implementar la misma interfaz de diferentes maneras, pero cada clase aún admite
el mismo conjunto de métodos.
▪ Por lo tanto, el código que tiene conocimiento de la interfaz puede usar objetos de cualquier
clase, ya que la interfaz con esos objetos es la misma.
o En una interfaz, los métodos son implícitamente públicos.

o Las variables declaradas en una interfaz no son variables de instancia.
▪ En cambio, son implícitamente public, final, y static, y deben inicializarse.
▪ Por lo tanto, son esencialmente constantes.
o Los métodos que implementan una interfaz deben declararse públicos.

▪ Además, la firma de tipo del método de implementación debe coincidir exactamente con la
firma de tipo especificada en la definición de la interfaz.
o Sí una clase incluye una interfaz, pero no implementa completamente los métodos definidos por esa
interfaz, esa clase debe declararse como abstracta ().
▪ No se pueden crear objetos de dicha clase, pero se puede usar como una superclase
abstracta, lo que permite que las subclases proporcionen la implementación completa.
22
MODIFICADOR DE ACCESO
• Lo que va a hacer es modificar el acceso a las variables, atributos, clases, etc.

• Nos va a restringir o nos va a permitir el acceso a ese elemento que tengamos.
• Si a los atributos no les asignamos un modificador de acceso, por defecto están públicos (public).
• Existen los siguientes modificadores de acceso:
o private: Únicamente la clase puede acceder a la propiedad o método.

o Default (package private) (Valor por defecto si no se indica ninguno): Solo las clases en el mismo
paquete pueden acceder a la propiedad o método.
o protected: Las clases del mismo paquete y que heredan de la clase pueden acceder a la propiedad o
método.
o public: La propiedad o método es accesible desde cualquier método de otra clase.
• En este gráfico hay representados paquetes que contienen clases, clases con rectángulos, las flechas indican
herencia entre clases y las clases que están coloreadas indican que tienen visibilidad de la propiedad y
método según el ámbito de acceso, la ubicación de la clase que accede y si hay una relación de herencia.
23
VALORES DE RETORNO
• Los métodos pueden realizar una función y no devolver un valor, lo que se indica con la cláusula void, o
pueden comportarse como una función y devolver un valor primitivo o una referencia a un objeto.
• En este caso, se pone delante del nombre del método el tipo o clase del valor devuelto.
• En algunas ocasiones, no es necesario que el método estático tenga que devolver un valor al finalizar su
ejecución.
o En este caso, el tipo de dato que debe indicar en la cabecera de declaración del método es el tipo
void y la sentencia return no viene seguida de ninguna expresión.
• Si no hay sentencia return dentro de un método, su ejecución continúa hasta que se alcanza el final del
método y entonces se devuelve la secuencia de ejecución al lugar dónde se invocó al método.
• Un método cuyo tipo de retorno no es void necesita siempre devolver algo.

• Si el código de un método contiene varias sentencias if debe asegurarse de que cada una de las posibles
opciones devuelve un valor.
o En caso contrario, se generaría un error de compilación.
TIPOS DE VALORES DE RETORNO
o QUE EJECUTAN CÓDIGO:
public class Main {

Hola();
}
public static void Hola() {

System.out.println("Hola");
}
}
Hola
o QUE DEVUELVEN UN VALOR:
public class Main {

int res = devuelveValor();
System.out.println(res);
}
public static int devuelveValor() {

return 5;
}
}
5
24
o QUE DEVUELVEN Y RECIBEN VALORES:
public class Main {

int res = sumaNumeros(5, 8);
System.out.println("El resultado de la suma es: " + res);
}
public static int sumaNumeros(int num1, int num2) {

return num1 + num2;
}
}
El resultado de la suma es: 13
25
ENCAPSULACIÓN
• Quiere decir que una clase encapsula todos sus atributos (Ósea que los hace privados y no puede acceder una
clase externa a ellos, solamente puede acceder otra clase a estos atributos a través de métodos (Getters y
Setters)).
o GETTER: Es una función o método que va a devolver el valor de un atributo privado (Dame ese valor).
o SETTER: Es una función o método que le va a asignar un valor a un atributo privado (Ponle este valor).
• Es acceder a atributos que están privados por medio de los métodos get y set.
• Este concepto consiste en la ocultación del estado o de los datos miembro de un objeto, de forma que sólo es
posible modificar los mismos mediante los métodos definidos para dicho objeto.
• Hace referencia a limitar el acceso a las variables de nuestras clases Java de tal forma que podamos tener un
mayor control sobre ellas.
• La encapsulación se trata más de “cómo” lograr una funcionalidad.
• La abstracción se trata más de “Qué” puede hacer una clase.
• Un simple ejemplo para entender esta diferencia es un teléfono móvil; donde la lógica compleja en la placa
de circuito está encapsulada en una pantalla táctil, y se proporciona la interfaz para abstraerla.
VENTAJAS
o La encapsulación vincula los datos con sus funcionalidades relacionadas; Aquí las funcionalidades
significan “métodos” y los datos significan “variables”.
o Entonces mantenemos variables y métodos en un solo lugar; Ese lugar es “clase”; La clase es la base
para la encapsulación.
o Con Java Encapsulation, puede ocultar (Restringir el acceso) a los miembros de datos críticos en su
código, lo que mejora la seguridad.
o Como mencionamos anteriormente, si un miembro de datos se declara “privado”, solo se puede
acceder a él dentro de la misma clase; Ninguna clase externa puede acceder al miembro de datos
(Variable) de otra clase.
o Sin embargo, si necesita acceder a estas variables, debe utilizar los métodos públicos “getter” y
“setter” .
26
POLIMORFISMO
• Significa mismo nombre, diferente uso.

• Es la capacidad del método para realizar diferentes cosas en función del objeto sobre el que actúa.
• Es la capacidad que tienen los objetos de una clase en ofrecer respuesta distinta e independiente en función
de los parámetros (Diferentes implementaciones) utilizados durante su invocación.
• Dicho de otro modo, el objeto como entidad puede contener valores de diferentes tipos durante la ejecución
del programa.
• En JAVA el término polimorfismo también suele definirse como ‘SOBRECARGA DE PARÁMETROS’, que así de
pronto no suena tan divertido, pero como veremos más adelante induce a cierta confusión.
• En realidad, suele confundirse con el tipo de polimorfismo más común, pero no es del todo exacto usar esta
denominación.
EJEMPLO
o Un ejemplo clásico de polimorfismo es el siguiente.

o Podemos crear dos clases distintas: Gato y Perro, que heredan de la superclase Animal.
o La clase Animal tiene el método abstracto makesound() que se implementa de forma distinta en cada
una de las subclases (Gatos y perros suenan de forma distinta).
o Entonces, un tercer objeto puede enviar el mensaje de hacer sonido a un grupo de objetos Gato y
Perro por medio de una variable de referencia de clase Animal, haciendo así un uso polimórfico de
dichos objetos respecto del mensaje mover.
o Como todos los objetos Gato y Perro son objetos Animales, podemos hacer lo siguiente:
27
o Creamos dos variables de referencia de tipo Animal y las apuntamos a los objetos Gato y Perro.
o Ahora, podemos llamar a los métodos makeSound().
o Como decía el polimorfismo, que se refiere a la idea de "tener muchas formas", ocurre cuando hay
una jerarquía de clases relacionadas entre sí a través de la herencia y este es un buen ejemplo.
o Por lo general diremos que existen 3 tipos de polimorfismo:
▪ SOBRECARGA: El más conocido y se aplica cuando existen funciones con el mismo nombre en
clases que son completamente independientes una de la otra.
▪ PARAMÉTRICO: Existen funciones con el mismo nombre, pero se usan diferentes parámetros
(Nombre o tipo).
❖ Se selecciona el método dependiendo del tipo de datos que se envíe.
▪ INCLUSIÓN: Es cuando se puede llamar a un método sin tener que conocer su tipo, así no se
toma en cuenta los detalles de las clases especializadas, utilizando una interfaz común.
o En líneas generales en lo que se refiere a la POO, la idea fundamental es proveer una funcionalidad
predeterminada o común en la clase base y de las clases derivadas se espera que provean una
funcionalidad más específica.
o Generalmente existen 2 tipo de polimorfismo: OVERLOADING y OVERRIDING.
28
SOBRECARGA DE MÉTODOS (OVERLOADING)
o Básicamente es cuando tenemos dentro de una misma clase más de 1 método con el mismo nombre,
pero diferentes armazones.
o Estos armazones pueden significar 2 cosas:
▪ Que el número de argumentos sea diferente.
▪ Que el tipo de datos sean diferentes.
o La sobrecarga de métodos es la creación de varios métodos con el mismo nombre, pero con diferente
lista de tipos de parámetros.
o Java utiliza el número y tipo de parámetros para seleccionar cuál definición de método ejecutar.
o Java diferencia los métodos sobrecargados con base en el número y tipo de parámetros o
argumentos que tiene el método y no por el tipo que devuelve.
o También existe la sobrecarga de constructores: Cuando en una clase existen constructores múltiples,
se dice que hay sobrecarga de constructores.
o ¿Y No es igual? para que sobrecargar si en ultimas se crea el mismo número de métodos?
▪ Por ejemplo, encender un motor; Y si tenemos diferentes tipos de encendido como el
eléctrico, encendido térmico, encendido de combustión etc.
▪ Donde los procesos son muy diferentes, pero en ultimas el objetivo es el mismo, pero cada
uno necesita ciertas características únicas para encender.
▪ Aquí podríamos aplicar la sobrecarga para no preocuparnos por llamar los métodos por su
nombre sino tan solo llamando al mismo, pero enviando los parámetros (Características)
propios de cada tipo de motor y listo, dependiendo de lo que mandemos java sabrá que
motor queremos iniciar.
/* Métodos sobrecargados */
int calculaSuma(int x, int y, int z){
...
}
int calculaSuma(double x, double y, double z){
...
}
/* Error: estos métodos no están sobrecargados */

int calculaSuma(int x, int y, int z){
...
}
double calculaSuma(int x, int y, int z){
...
}
29
SOBREESCRITURA DE MÉTODOS (OVERRIDING)
o Es cuando la clase padre y la clase hija tienen el mismo nombre y armazón, pero los métodos pueden
tener diferentes tipos de acciones.
o
o Estos armazones pueden significar 2 cosas:
▪ Que el número de argumentos sea diferente.
▪ Que el tipo de datos sean diferentes.
o Si yo tengo una clase padre, donde tengo un método declarado y tengo una clase hijo, donde quiero
yo definir nuevamente este método, lo puedo hacer sobrescribiéndolo.
o Ósea que creo un objeto desde una clase, pero utilizando el método en una clase distinta con una
ejecución diferente.
o La Sobreescritura es la forma por la cual una clase que hereda puede redefinir los métodos de su
clase Padre, de esta manera puede crear nuevos métodos con el mismo nombre de su superclase.
o Las subclases emplean la sobreescritura de métodos la mayoría de las veces para agregar o modificar
la funcionalidad del método heredado de la clase padre.
o Para sobrescribir un método en una clase hacemos lo siguiente:
▪ 1. Heredamos la clase de la cual queremos sobrescribir con extends en la clase.
▪ 2. Nos paramos en la clase donde vamos a sobrescribir el método existente.
▪ 3. Clic Derecho dentro de la clase/ Source/ Override/Implement Methods…
▪ 4. Seleccionamos el método que queremos sobrescribir.
▪ 5. Podemos eliminar super().
▪ 6. Modificamos el método a nuestro gusto.
EJEMPLO
▪ Esta es la clase Figura con un método area().
public class Figura {
public void area() {

System.out.println("Se esta calculando el area...");
}
}
▪ Esta es la clase Circulo, que hereda las variables y los métodos de la clase Figura, pero donde
sobreescrimos el método de area().
public class Circulo extends Figura{
@Override
public void area() {
System.out.println("R2 * D");
}
}
30
▪ Este es el Main de la aplicación, donde creamos un objeto de la clase Figura, pero como si
fuera un Circulo.
public class Main {
Figura fig = new Circulo();

fig.area();
}
}
R2 * D
31
CONSTRUCTOR
• Por defecto toda clase tiene un constructor sin parámetros cuyo identificador coincide con el de la clase y
que, al ejecutarse, inicializa el valor de cada atributo de la nueva instancia: los atributos de tipo primitivo se
inicializan a 0 o false, mientras que los atributos de tipo objeto (referencia) se inicializan a null.
• Los constructores son métodos que se llaman automáticamente a la hora de crear un objeto a partir de una
clase, no necesitan llamar un método en particular para ejecutarse, solo con crear el objeto de una clase se
activan.
• Los constructores son inicializadores.
• Los constructores los usamos cuando queremos ejecutar una tarea al principio de la clase.
• El constructor es similar a un método.
• El nombre del constructor siempre es igual al nombre de la clase.
• El constructor puede tomar argumentos, pero nunca retornar un valor.
• Los constructores son llamados automáticamente cuando creamos el objeto de una clase.
• Pueden existir varios constructores, pero siguiendo las reglas de la sobrecarga de funciones.
• De entre los constructores que existan, tan sólo uno se ejecutará al crear un objeto de la clase.
• Dentro del código de un constructor generalmente suele existir inicializaciones de variables y objetos, para
conseguir que el objeto sea creado con dichos valores iniciales.
• Para definir los constructores se emplea la siguiente sintaxis:
[modifVisibilidad] nombreConstructor (listaParámetros) [throws listaExcepciones] {

}
• Para modifVisibilidad se aplica las mismas normas que para atributos y métodos:
o public: indica que es un método accesible a través de una instancia del objeto.
o private: indica que a través de una instancia no es accesible el método. Al heredar el método se
convierte en inaccesible.
o protected: indica que a través de una instancia no es accesible el método. Al heredar si se puede usar
desde la clase derivada.
o Sin especificar: indica visibilidad de paquete, se puede acceder a través de una instancia, pero sólo de
clases que se encuentren en el mismo paquete.
• nombreConstructor debe de coincidir con el nombre de la clase.

• listaParámetros es la lista de los parámetros que tomará la función separados por comas y definidos cada
uno de ellos como: tipo nombreParámetro
32
TABLAS DE VERDAD
• True: 1.
• False: 0.
• not True: Negación de la verdad (Es la mentira).
• not False: Negación de la mentira (Es la verdad).
• AND (Y): Viene de conjunto, sinónimo de unido, contiguo o cercano (Agrupa uniendo).
• OR (O): Viene de disyunto, sinónimo de separado, apartado o distante (Agrupa separando).
FALSO Y FALSO FALSO

FALSO Y VERDAD FALSO
VERDAD Y FALSO FALSO
VERDAD Y VERDAD VERDAD
FALSO O FALSO FALSO

FALSO O VERDAD VERDAD
VERDAD O FALSO VERDAD
VERDAD O VERDAD VERDAD
UPCASTING & DOWNCASTING
UPCASTING
o Es cuando creamos un objeto de la clase padre pasando la referencia de la clase hijo.
DOWNCASTING
o Es cuando tomamos un objeto con Upcasting devuelta a su clase de objeto hija.
33
PALABRAS RESERVADAS DE JAVA (KEYWORDS)
THIS
o Con la ayuda de esta palabra, podemos diferenciar entre miembros locales y globales.
o Con ella podemos acceder a los miembros de nuestra propia la clase.
FINAL
o Puede usarse para especificar que una variable es constante (No cambia).
o Puede usarse con las clases para que no puedan heredar hacia otras clases.
o Puede usarse con métodos para que no puedan sobrescribirse.
34
SUPER
o Con esta palabra podemos acceder desde una clase hija, a las variables de la clase padre.
o Con esta palabra podemos acceder desde una clase hija, a los métodos de la clase padre en caso de
que sobrescribamos alguno.
35
o Con esta palabra podemos acceder desde una clase hija, al constructor de la clase padre
explícitamente.
36
STATIC
o Con esta palabra podemos llamar miembros de una clase sin tener que crear un objeto ni heredar de
esa clase.
o En si se usa para compartir múltiples objetos.
o Los métodos estáticos solo pueden llamar variables estáticas.
37
NOTAS TIPOS DE DATOS
CADENAS
• StringBuilder: Nos permite crear un String.

o Es muchísimo óptimo para concatenar Strings en tiempo de ejecución.
o El StringBuilder es MUTABLE (Por lo tanto, el String se puede ir modificando con los elementos).
o Permite anexar elementos String con el método append.
o Y después con el método toString generamos el String completo de una forma mucho más
optimizada.
• Solo usamos CONCATENAR cuando el String no es nulo.
38
MÉTODOS
DEFINICIÓN
• MÉTODOS ESTÁTICOS: Pertenecen a la clase y no al objeto.

o Solo puede acceder a datos estáticos.
o Solo puede acceder a variables o tipos de datos declarados como static.
o Solo puede llamar a otros métodos estáticos.
o Se puede acceder directamente por el nombre de la clase y no se necesita crear un objeto para
acceder al método (Aunque se puede hacerlo).
o Un método static no puede hacer referencia a “this” o “super”.
o La diferencia entre un método estático y un método normal es que el método estático se llama a
través de su nombre de clase, sin que se cree ningún objeto de esa clase.
NORMAS PARA EL NOMBRE DE UN MÉTODO
• Empiezan con minúscula.
EXPRESIONES LAMBDA
• Una expresión Lambda es una función anónima (Una función sin nombre y que no pertenece a ninguna
clase).
• Para crear una expresión Lambda necesitamos especificar los parámetros de entrada (Si hay) en la parte
izquierda del operador lambda ->, y poner la expresión o bloque de argumentos en la parte derecha del
operador.
• Para utilizar la expresión lambda, es necesario crear una interfaz funcional propia o utilizar la interfaz
funcional predefinida que proporciona Java.
o Una interfaz con un solo método abstracto es llamada una interfaz funcional.
39
MÉTODOS DE LA CLASE STRING
INT LENGHT()
lenght()
o Nos dice el número de caracteres.
BOOLEAN EQUALS(STRING B)
equals(cadena)
o Compara si ambas cadenas son iguales, por valor.
BOOLEAN EQUALSIGNORECASE(STRING B)
equalsIgnoreCase(cadena)
o Compara si ambas cadenas son iguales, independientemente de mayúsculas o minúsculas.
INT COMPARETO(STRING B)
compareTo(cadena)
o Compara contra la cadena del argumento, devolviendo:

▪ Un valor negativo si la cadena es anterior a b.
▪ Cero (0) si la cadena es igual a b.
▪ Un valor positivo si la cadena es posterior a b.
STRING TRIM()
trim()
o Crea un nuevo objeto eliminado el espacio en blanco que pudiera haber al principio o al final.
CHAR CHARAT(INT POSICION)

charAt(posicion)
o Extrae un carácter en la posición indicada.
CHAR[] TOCHARARRAY()
toCharArray()
o Convierte la cadena en un arreglo de caracteres.
40
STRING SUBSTRING(INT A, INT B)
substring(int a, int b)
o Extrae la subcadena entre las posiciones a y b.
STRING SUBSTRING(INT DESDE)

substring(int desde)
o Extrae la subcadena desde la posición indicada.
INT INDEXOF(STRING CADENA)

indexOf(String cadena)
o Indica en que posición se encuentra el carácter (O cadena) indicando por primera vez, buscando
desde el principio.
INT LASTINDEXOF(STRING CADENA)

lastIndexOf(String cadena)
o Indica en que posición se encuentra el carácter (O cadena) indicando por primera vez, buscando
desde el final.
BOOLEAN STARTSWITH(STRING PREFIJO)

startsWith(String prefijo)
o Dice si la cadena comienza con el prefijo indicado.
BOOLEAN ENDSWITH(STRING SUFIJO)

endsWith(String sufijo)
o Dice si la cadena termina con el sufijo indicado.
STRING[] SPLIT(STRING PATRON)

split(String patron)
o Divide la cadena en varias subcadenas utilizando el patrón indicado como separador.
41
POO
DEFINICIÓN
• También llamada Programación Orientada a Objetos, es un paradigma de solución de problemas que

identifica entidades de la realidad y las traslada a clases y objetos.
• INSTANCIACIÓN: Crear un objeto a partir de su clase.
• ATRIBUTOS: Hacen referencia a los valores internos de la clase.
• MÉTODOS: Hacen referencia a las funciones internas de la clase.
CLASES
• Son los moldes de los objetos.

• Empiezan en mayúscula.
Automovil.java
//Clase Automovil
public class Automovil {
//Atributos o Características
boolean estado = false;
//Definición de constructor: Es la inicialización de un objeto de este tipo de clase

public Automovil() {
System.out.println("Se creo un objeto de tipo automóvil");
}
//Método o Acción
public void encender() {
if(estado == true) {
System.out.println("El automóvil ya está encendido");
}else {
System.out.println("El automóvil ha encendido");
estado = true;
}
}
}
Main.java
//Función principal, todo lo que ejecute el programa, va a venir a hacerlo aquí
public class Main {
Automovil ferrari = new Automovil();

ferrari.encender();
}
}
El automóvil ha encendido
42
CONTROLADORES DE FLUJO
IF
• Es un condicional que divide el flujo en diferentes caminos.

• Ejecuta una sentencia si una condición especificada es evaluada como verdadera.
• Si la condición es evaluada como falsa, otra sentencia puede ser ejecutada.
int num = 10;
if(num < 10) {

System.out.println("El número es menor a 10");
}else {
System.out.println("El número no es menor a 10");
}
El número no es menor a 10
SWITCH
• Es una estructura de control, que permite varios casos de selección.

• Los casos de prueba se ponen al lado de la palabra case.
• Si no se activan ninguno de los case, entonces se ejecuta lo que haya dentro del default.
• Es necesario poner el break, porque con el acabamos el algoritmo cuando un case resulte verdadero.
• Podemos poner un continue para seguir la iteración.
public class Main {
int var = 3;
switch(var) {
case 0:
System.out.println("La variable está vacía");
break;
case 1:
System.out.println("La variable Contiene el número 1");
break;
case 2:
System.out.println("La variable Contiene el número 2");
break;
default:
System.out.println("La variable es diferente");
break;
}
}
La variable es diferente
43
WHILE
• Se basa en repetir un bloque a partir de evaluar una condición lógica, siempre que esta sea True.
• Se debe planificar un momento en que la condición cambie a False y el While finalice su ejecución.
• Se usa cuando:
o No tenemos confirmado cuantas veces necesito iterar.
o El incremento o decremento no es constante.
int num = 0;
while(num < 10) {
System.out.println("Hola Mundo");
num++;
}
}
Hola Mundo
Hola Mundo
Hola Mundo
Hola Mundo
Hola Mundo
Hola Mundo
Hola Mundo
Hola Mundo
Hola Mundo
Hola Mundo
DO-WHILE
• A diferencia del While, este ciclo si se ejecuta por lo menos 1 vez y luego se evalúa la condición.
• Se puede poner un break para terminar la iteración.
int num = 11;
do {
num++;
}while(num < 10);
}
Hola
44
FOR
• for ([expresión-inicial]; [condición]; [expresión-final])sentencia

• Ejecuta de manera controlada el # de veces una condición.
• Se puede poner un break para terminar la iteración.
• Se usa cuando:
o Confirmamos cuantas veces necesitamos iterar.
o El incremento o decremento es constante.
for(int num = 0; num < 10; num++) {

}
}
Hola Mundo
Hola Mundo
Hola Mundo
Hola Mundo
Hola Mundo
Hola Mundo
Hola Mundo
Hola Mundo
Hola Mundo
Hola Mundo
FOREACH
• Se usa para ejecutar iteraciones por cada elemento de un arreglo de datos, como una lista, arreglo, etc.
45
ARREGLOS
DEFINICIÓN
• Son colecciones de objetos.

• Es un contenedor de elementos.
• Sirve para almacenar datos.
• En Java debemos especificar el tipo de arreglo que estemos creando.
• Al momento de mostrar el arreglo debemos especificar el índice, o si no nos saldrá un error.
• Un array es un objeto, por lo tanto, cuando se crea, a sus elementos se les asigna automáticamente un valor
inicial:
o 0 para arrays numéricos.
o '\u0000' (carácter nulo) para arrays de caracteres.
o false para arrays booleanos.
o null para arrays de String y de referencias a objetos.
ESTRUCTURA
(int[] juguete = new int[10];)
//Defino un arreglo de 10 posiciones

int[] arregloEnteros = new int[10];
arregloEnteros[0] = 10;
System.out.println(arregloEnteros[0]);
}
10
46
• Para recorrer un arreglo entero, usamos el ciclo For.
//Defino un arreglo de 10 posiciones

int[] arregloEnteros = new int[10];
for(int i = 0; i < arregloEnteros.length;i++) {

System.out.println(arregloEnteros[i]);
}
}
10
20
30
40
50
60
70
80
90
100
47
MATRICES
DEFINICIÓN
• Un array en Java puede tener más de una dimensión.

• El caso más general son los arrays bidimensionales también llamados matrices o tablas.
• La dimensión de un array la determina el número de índices necesarios para acceder a sus elementos.
• Los son arrays unidimensionales porque solo utilizan un índice para acceder a cada elemento.
• Una matriz necesita dos índices para acceder a sus elementos.
• En realidad, una matriz en Java es un array de arrays.
• Gráficamente podemos representar una matriz como una tabla de n filas y m columnas cuyos elementos son
todos del mismo tipo.
• Los valores iniciales se escriben entre llaves separados por comas.
• Los valores que se le asignen a cada fila aparecerán a su vez entre llaves separados por comas.
• El número de valores determina el tamaño de la matriz.
• La siguiente figura representa un array M de 3 filas y 5 columnas:
• Gráficamente podemos representar la disposición real en memoria del array anterior así:
• La longitud del array M (M.length) es 3.

• La longitud de cada fila del array (M[i].length) es 5.
• Para acceder a cada elemento de la matriz se utilizan dos índices.
o El primero indica la fila y el segundo la columna.
48
EJEMPLO
int[][] matriz = new int[3][3];
matriz[0][0] = 5;
matriz[1][2] = 8;
//Matriz de números de tipo int, de 4 filas y 3 columnas

int [][] numeros = {{6,7,5},{3, 8, 4}, {1,0,2}, {9,5,2}};
//Asignando valores iniciales se pueden crear también matrices irregulares.

int [][] a = {{6,7,5,0,4}, {3, 8, 4}, {1,0,2,7}, {9,5}};
System.out.println(numeros[0][1]);
}
7
MATRIZ DE 3 X 3 CON LOS NÚMEROS DEL 1 AL 9
int matriz[][]=new int[3][3];
//i = filas y j = columnas

for(int i=0;i<matriz.length;i++){
for(int j=0;j<matriz[0].length;j++){
matriz[i][j]=(i*matriz.length)+(j+1);
System.out.print(matriz[i][j]+" ");
System.out.println("");
}
LLENADO DE UNA MATRIZ
for(int i = 0; i < 3; i++) {

for(int j = 0; j < 3; j++) {
matriz[i][j] = 5;
}
}
49
RECORRIDO DE UNA MATRIZ
• Para recorrer una matriz se anidan dos bucles for.

• En general para recorrer un array multidimensional se anidan tantas instrucciones for como dimensiones
tenga el array.
• Ahora pasaremos a imprimirla.

• Para ello utilizamos dos estructuras for anidadas.
• La primera irá incrementando las filas, es decir, el valor de la X y la segunda incrementará por cada fila el
valor de las columnas, es decir, la Y.
for (int x=0; x < matriz.length; x++) {

for (int y=0; y < matriz[x].length; y++) { ... }
}
• Vemos que los bucles for van desde la posición 0 hasta el tamaño que tenga la matriz Java.
• En el caso de las filas será el tamaño general.
matriz.length;
• Y en el caso de cada fila fijamos la dimensión x.
matriz[x].length;
• Ahora, por cada fila vamos a imprimir los elementos, pero sin salto de línea.
• Es decir, utilizando un System.out.print:
for (int y=0; y < matriz[x].length; y++) {

System.out.print (matriz[x][y]);
if (y!=matriz[x].length-1) System.out.print("\t");
}
• Además, hemos añadido, una tabulación, es decir, una separación entre cada posición.
• Recuerda que las tabulaciones se consiguen mediante el carácter escapado \t
• La tabulación la aplicaremos detrás de cada número, excepto del último.
• Es por ello que hacemos la validación:
50
• Una vez impresa cada fila, ahora es cuando hay que dar un salto de línea mediante un System.out.println

}
}
• Ya solo nos quedará meter algún decorador adicional, al gusto, y el código final Java que nos imprimirá la
matriz quedará de la siguiente forma:

System.out.print("|");
}
System.out.println("|");
}
|0 0 0|
|0 0 0|
|0 0 0|
51
COLECCIONES
ARRAYLIST
• Es una estructura de datos, pero es un poco más amigable que el arreglo y las matrices.
• La clase ArrayList en Java, es una clase que permite almacenar datos en memoria de forma similar a los
Arrays, con la ventaja de que el número de elementos que almacena, lo hace de forma dinámica, es decir,
que no es necesario declarar su tamaño como pasa con los Arrays.
• los ArrayList nos permiten añadir, eliminar y modificar elementos (Que pueden ser objetos o elementos
atómicos) de forma trasparente para el programador.
• Tienen la opción de que se les defina un tamaño al inicio, o a medida que se le ingresen elementos.
• Lo mejor es dejarlo vacío, para que sea más dinámico.
• Va a guardar la información en forma de lista.
• Ósea que vamos a poder acceder a cualquier elemento de la lista en cualquier momento, no necesitamos
como en un arreglo tener una posición definida y recorrer todo el arreglo mediante un ciclo).
• A diferencia de los arreglos, con el ArrayList podemos imprimir todos los elementos que tenga con solo
imprimir el nombre del ArrayList, no son necesarios ciclos para recórrelo.
//Debemos importar esta librería para que podamos usar ArrayList

import java.util.ArrayList;
public class Main {
//Definiéndole un tamaño
ArrayList datos = new ArrayList(40);
//Insertar datos
ArrayList datos1 = new ArrayList();
datos1.add(5);
datos1.add(10);
datos1.add(8);
//Con el .get() imprimimos la posición que queramos igual en los arreglos

System.out.println(datos1.get(1));
//Con el .size() nos muestra el tamaño del ArrayList

System.out.println(datos1.size());
10
3
52
MÉTODOS
import java.util.ArrayList;
public class Ejemplos {
// Declaración de un ArrayList de "String". Puede ser de cualquier otro Elemento u Objeto

(float, Boolean, Object, ...)
ArrayList datos = new ArrayList();
// Añade el elemento al ArrayList

nombreArrayList.add("Elemento");
// Añade el elemento al ArrayList en la posición 'n'

nombreArrayList.add(n, "Elemento 2");
// Devuelve el numero de elementos del ArrayList

nombreArrayList.size();
// Devuelve el elemento que esta en la posición '2' del ArrayList

nombreArrayList.get(2);
// Comprueba se existe del elemento ('Elemento') que se le pasa como parametro

nombreArrayList.contains("Elemento");
// Devuelve la posición de la primera ocurrencia ('Elemento') en el ArrayList

nombreArrayList.indexOf("Elemento");
// Devuelve la posición de la última ocurrencia ('Elemento') en el ArrayList

nombreArrayList.lastIndexOf("Elemento");
// Borra el elemento de la posición '5' del ArrayList

nombreArrayList.remove(5);
// Borra la primera ocurrencia del 'Elemento' que se le pasa como parametro.

nombreArrayList.remove("Elemento");
//Borra todos los elementos de ArrayList

nombreArrayList.clear();
// Devuelve True si el ArrayList esta vacio. Sino Devuelve False

nombreArrayList.isEmpty();
// Copiar un ArrayList
ArrayList arrayListCopia = (ArrayList) nombreArrayList.clone();
// Pasa el ArrayList a un Array

Object[] array = nombreArrayList.toArray();
53
.GET()
nombreArrayList.get(5);
▪ Sirve para mostrar el elemento que halla en la posición que pongamos dentro del paréntesis.
▪ Funciona igual que en los arreglos.
.ADD()
nombreArrayList.add(5);
▪ Sirve para agregar un elemento al ArrayList.
.SIZE()
nombreArrayList.size();
▪ Sirve para mostrar el tamaño REAL de un ArrayList, ósea que muestra cuantos elementos
tiene realmente el ArrayList, no muestra el tamaño con el que fue definido inicialmente.
54
STACK - PILA
• Es una colección de elementos ordenados, solo permiten dos acciones:

o Añadir un elemento a la pila.
o Sacar un elemento de la pila.
o El último elemento en entrar es el primero en salir.
o Estructura: LIFO (Last In First Out).
o Ejemplo: Pringles.
//Debemos importar esta librería para que podamos usar Stack

import java.util.Stack;
public class Main {
//Asi defino un tipo de variables para la pila

Stack<String> miPila = new Stack<String>();
//Asi defino cualquier tipo de variable para la pila

Stack miPila2 = new Stack();
miPila2.push("Lola");
miPila2.push("Carmen");
miPila2.push("La mona Lisa");
String elemento;
elemento = (String) miPila2.pop();
System.out.println(elemento);
}
La mona Lisa
55
MÉTODOS
.PUSH()
pares.push(“Lola”)
▪ Este método agrega un elemento a la pila.
Stack pila = new Stack();

pila.push(“Carmen”);
pila.pop()
.POP()
pares.pop()
▪ Este método devuelve el último elemento de la lista y la borra de adentro.

▪ Debe asignarse a una variable o si no se pierde.

pila.push(“Lola”);
pila.push(“La mona Lisa”);
elemento = (String)pila.pop() //Se debe poner String para especificar que lo convierta a ese tipo
System.out.println(elemento);
La mona Lisa
.CLEAR()
pares.clear()
▪ Este método limpia la pila.

▪ Debe asignarse a una variable o si no se pierde.

pila.push(“Lola”);
pila.push(“La mona Lisa”);
pila.clear();
System.out.println(pila);
ERROR //Porque la pila esta vacía
56
QUEUE - COLA
• Es una colección de elementos ordenados, solo permiten dos acciones:

o Añadir un elemento a la pila.
o Sacar un elemento de la pila.
o El primer elemento en entrar es el primer elemento en salir.
o Estructura: FIFO (First In First Out).
o Ejemplo: El primero en llegar donde el médico, es el primero que se atiende.
//Debemos importar estas librerías para poder utilizar los Queue

import java.util.LinkedList;
import java.util.Queue;
public class Main {
Queue cola = new LinkedList();
cola.add(5);
cola.add(10);
cola.add(15);
//Mostramos la cola
System.out.println(cola);
//Mostrar el primer elemento que se ingresó a la cola

System.out.println(cola.peek());
//Elimina el primer elemento que se ingresó a la cola

cola.poll();
[5, 10, 15]

5
[10, 15]
57
MÉTODOS
.ADD()
pares.add(10)
▪ Este método agrega un elemento a la cola.

cola.add(5);
cola.add(10);
cola.add(15);
[5, 10, 15]
.PEEK()
pares.peek()
▪ Este método consulta cual fue el primer elemento que se ingresó.

cola.add(5);
cola.add(10);
cola.add(15);
System.out.println(cola.peek());
.POLL()
pares.poll()
▪ Este método elimina el primer elemento de la cola.

cola.add(5);
cola.add(10);
cola.add(15);
cola.poll();
[10, 15]
58
HASHTABLE - DICCIONARIO
• Es una estructura de datos dinámica que nos va a permitir guardar objetos dentro de ella.
• Es parecido al diccionario de Python.
• Cada elemento de la colección se encuentra identificado con una clave única.
• No puede haber 2 claves iguales en el mismo diccionario.
• No existen índices numéricos, sino claves asociativas a elementos.
• Los registros del diccionario se muestran de forma desordenada.
• No es recomendable poner valores con tilde en el diccionario.
//Debemos importar estas librerías para poder utilizar los Hashtable

import java.util.Hashtable;
public class Main {
//Diccionario sin restricciones

Hashtable tabla = new Hashtable();
//Diccionario Con restricciones

Hashtable<Integer, String> tabla2 = new Hashtable<>();
tabla2.put(1, "Bienvenido");
tabla2.put(2, "Hola");
tabla2.put(5, "Adios");
//Me muestra el diccionario con sus claves y sus valore

System.out.println(tabla2);
//Me muestra el valor de la clave que ponga dentro del get

System.out.println(tabla2.get(1));
{5=Adios, 2=Hola, 1=Bienvenido}

Bienvenido
59
MÉTODOS
.PUT()
diccionario.put(10, “Juegos”)
▪ Este método agrega una clave con un valor en el diccionario.
Hashtable diccionario = new Hashtable();

diccionario.put(1, “Apple”);
diccionario.put(2, “Sony”);
diccionario.put(6, “Samsung”);
diccionario.put(“Ferrari”, 400);
System.out.println(diccionario);
{“Ferrari=400, 6=”Samsung”, 2=”Sony”, 1=”Apple”}
.GET()
diccionario.get(“Ferrari”)
▪ Este método muestra el valor de una clave que agreguemos.
Hashtable diccionario = new Hashtable();

diccionario.put(1, “Apple”);
diccionario.put(2, “Sony”);
diccionario.put(6, “Samsung”);
diccionario.put(“Ferrari”, 400);
System.out.println(diccionario.get(“Ferrari”));
System.out.println(diccionario);
400
{“Ferrari=400, 6=”Samsung”, 2=”Sony”, 1=”Apple”}
60
ARCHIVOS O DATA
PROPERTY FILE
• Es un archivo separado donde vamos a poner unos datos que pueden cambiar en el tiempo.
• Básicamente es un archivo desde el cual se toma información para alimentar el framework.
• La ventaja de este archivo es que no vamos a tener que cambiar dato por dato en el código, sino que solo
cambiamos el valor de una variable y automáticamente se cambia para todo el framework.
PASOS PARA CREAR UN PROPERTY FILE
o 1. Creamos una carpeta directa en el proyecto a nivel de src llamada ConfigFiles.

o 2. Creamos un nuevo archivo en la carpeta: ApplicationConfiguration.properties
o 3. Creamos los parámetros y les asignamos sus respectivos valores.
REGLAS PARA UN PROPERTY FILE
o En un Property File comentamos con #.

o No pueden existir espacios en el nombre de los parámetros.
o Los valores se asignan directamente sin ponerlos dentro de comillas dobles (“”).
o En los valores, los espacios después del = cuentan como valor del parámetro.
61
OBTENER DATOS DE UN PROPERTY FILE
62
MANEJO DE ARCHIVOS
LEER UN ARCHIVO POR MEDIO DE FILEREADER
• Primero debemos especificar donde se encuentra el archivo que queremos leer, luego creamos un objeto que
deja leer el archivo, pero solo carácter por carácter y los almacena en enteros, y luego creamos un ciclo para
recorrer todos los caracteres y convertirlos en char (Caracteres).
LEER UN ARCHIVO POR MEDIO DE BUFFERREAD
• Primero debemos especificar donde se encuentra el archivo que queremos leer, luego creamos un objeto que
deja leer el archivo, luego creamos otro objeto que deja leer líneas completas del archivo, y luego creamos un
ciclo para recorrer todas las líneas.
63
CREAR UN ARCHIVO Y ESCRIBIR EN ÉL POR MEDIO DE FILEWRITER
• Primero debemos especificar donde se va a crear el archivo, luego creamos un objeto que deja escribir en el
archivo, hay 2 formas, una para que lo sobrescriba y otra para que añada texto al archivo si ya existe; luego
escribimos lo que queramos en el archivo, luego lo guardamos, y por último lo cerramos.
64
CREAR UN ARCHIVO Y ESCRIBIR EN ÉL POR MEDIO DE BUFFEREDWRITER
• La diferencia, es que con este método tenemos un mayor control sobre lo que suceda con el texto (Como
añadir nuevas líneas); primero debemos especificar donde se va a crear el archivo, luego creamos un objeto
que deja escribir en el archivo, hay 2 formas, una para que lo sobrescriba y otra para que añada texto al
archivo si ya existe; luego escribimos lo que queramos en el archivo, luego lo guardamos, y por último lo
cerramos.
65
MANEJO DE EXCEPCIONES
DEFINICIÓN
• Son las acciones que queremos ejecutar en caso de que una excepción ocurra en el tiempo de ejecución.
• Si no manejamos excepciones, en el caso de que una línea falle, entonces mi ejecución va a parar en esa
línea, pero si manejamos excepciones, podemos continuar el flujo de ejecución.
• En Java podemos tener 2 tipos de error:
o COMPILE TIME (TIEMPO DE COMPILACIÓN): Es algo que ocurre cuando tenemos un error de sintaxis
o semántica en el código (Cuando nos aparece en el IDE subrayado con rojo).
o RUNTIME (TIEMPO DE EJECUCIÓN): Es algo que ocurre cuando la compilación no arrojo ningún
problema y al momento de la ejecución la prueba falla por lógica o problemas de interacción entre
líneas de código.
▪ también llamado excepción.
▪ Es el tipo de error que arroja excepciones.
▪ Existen 2 tipos de excepciones:
➢ CHECKED: Cuando el mismo compilador me dice que una línea de código puede tener
una excepción (Cuando me dice que la añada al método en cuestión).
➢ UNCHECKED: Cuando el compilador NO me dice que una línea de código puede tener
una excepción, pero al momento de ejecutar el código me aparece un error con su
excepción.
66
¿QUE HACER PARA EL MANEJO DE EXCEPCIONES?
• Podemos manejar excepciones de 3 formas:
AÑADIENDO EXCEPCIONES PARA QUE ALGO MÁS SE ENCARGUE DE ELLAS
o Esto sucede cuando tenemos una línea de código que podría arrojar una excepción, entonces
debemos declarar esta excepción a nivel de método, pero ya existe un manejo de excepciones
interno de Java para que trate estos casos.
▪ Ejemplo:
▪ Donde sea que vallamos a invocar el método es necesario declarar la excepción.

▪ Podemos declarar varias excepciones separadas por una coma.
▪ Si no sabemos que excepción podamos tener, podemos declarar una excepción general:
67
USANDO TRY – CATCH - FINALLY
o Es cuando añadimos bloques que manejan excepciones.

o Con esto nos aseguramos de que el código no va a romperse en caso de una excepción.
▪ TRY: es lo que vamos a intentar ejecutar.
▪ CATCH: Es lo que se va a ejecutar en caso de que TRY falle.
➢ Si se arroja alguna excepción, el código saltara al bloque de CATCH.
➢ Este bloque realmente es el que maneja las excepciones.
➢ Podemos tener múltiples bloques de CATCH para manejar múltiples excepciones.
▪ FINALLY: Contiene el código que queremos ejecutar en todos los casos (Pase TRY o CATCH).
o Si declaramos una Excepción general en un bloque CATCH y tenemos otros bloques CATCH con otras
excepciones, debemos mover el bloque CATCH con la excepción general para lo último, porque si no
nunca se van a arrojar las demás excepciones.
68
ARROJANDO EXCEPCIONES MANUALMENTE
o Es cuando consideramos que una condición especifica puede generar una excepción.
o Esto lo hacemos con el comando Throw.
o Necesita invocarse en el cuerpo del método.
o Solo se puede arrojar 1 excepción a la vez.
o Se debe crear el objeto de la clase de la excepción.
o La diferencia entre Throw y Throws es:
▪ Throw: Es para levantar excepciones manualmente en puntos específicos.

➢ Solo puede levantar 1 excepción a la vez.
➢ Debe invocarse en el cuerpo del método.
➢ Se debe crear el objeto de la clase de la excepción.
▪ Throws: Se invocan a nivel de método y cubre todo el método.

➢ Podemos declarar múltiples excepciones al tiempo.
69
DEBUGGING (DEPURACIÓN)
DEFINICIÓN
• Es el proceso para encontrar un punto de error especifico.

• Cuando el desarrollador o tester arregla ese error, el proceso es conocido como Bug Fixing.
PASO A PASO
• Básicamente creamos un BREAKPOINT (Ponemos un punto rojo al lado izquierdo de la línea que queremos
depurar), y luego cuando ejecutemos en el modo depurador tendremos los siguientes comandos:
o STEP INTO (F7): Nos redirige a la función o método que estemos invocando línea por línea.
o STEP OVER (F8): Con esto pasamos para la siguiente línea de código, pero si la línea invoca un
método o función la pasa por alto para seguir a la siguiente línea.
▪ Si cuando ejecutamos este comando no pasa para la siguiente línea, significa que tenemos un
error en esa línea.
▪ Y si lo volvemos a ejecutar nos va a arrojar la excepción que se disparó.
o STEP OUT (F8 + SHIFT): O STEP RETURN solo puede usarse si utilizamos STEP INTO, y lo que hace es
devolvernos a la línea donde invocamos el método o la función en la que nos encontremos parados.
70
INTELLIJ
COMANDOS
• ALT + CTRL + S: Abre la configuración.

• CTRL + D: Duplica una línea de código hacia abajo.
• CTRL + SHIFT + F10: Ejecuta un script.
• CTRL + ALT + SHIFT + A: Toma pantallazo del código si tenemos instalado la extensión “Code Screenshots”.
• CRTL + ALT + O: Borra las librerías que no se usen.
• CRTL + ALT + L: Refactoriza un código limpio.
71
OTROS
• Las Clases deben empezar con mayúscula.

• En Java se comenta con // o si el multilínea /* */.
• Un parámetro es un valor que se le da a una función (Van dentro de los paréntesis en una función).
• Cuando hablamos de la firma de un método, nos referimos a sus parámetros.
• CONSTRUCTOR: Es el primero método que se ejecuta al crear un objeto del tipo de clase que sea.
• PARA QUE SIRVE NEW: Al momento de crear un objeto sin la sentencia new (Figura fig) lo único que estoy
haciendo es reservando el espacio de memoria para que este objeto pueda ser creada, pero en ningún
momento la estoy inicializando.
o Con la sentencia new (Figura fig = new Figura();) lo que hacemos nosotros es mandar a llamar al
constructor de esa clase y dentro de ese constructor, nosotros podemos definir cualquier cosa (Es
decir inicializar los datos de esa variable).
• PARA QUE SIRVE THIS: Con esto hacemos referencia a todas las variables o métodos que están dentro de la
misma clase.
o This nos sirve para hacer referencia a nuestros atributos sin prestarse a errores ni ambigüedades,
como, por ejemplo:
public class Cuadrado{
private String nombre;
public Cuadrado(String nombre) {
//Con esto le decimos que la variable nombre que esta por fuera sea igual a
la que está por dentro
this.nombre = nombre;
//No tiene ningún efecto, porque siempre estamos llamando a la misma variable
interna
nombre = nombre;
}
}
• Con ./ especificamos la ruta actual de nuestro proyecto.
72
• Es importante la precedencia de las variables a la hora de imprimir en consola para que pueda saber qué tipo
de variable tiene mayor presencia.
73

2 Java

Cargado por

Información del documento

Descripción original:

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

2 Java

Cargado por

Copyright:

Formatos disponibles

TABLA DE CONTENIDO

o Un objeto es una abstracción de la realidad.

o Una clase es la abstracción de ese objeto en un lenguaje de programación.

• Descargamos el JDK que queramos, ingresamos a: https://www.oracle.com/lad/java/technologies/javase-

• Descargamos el IDE con el que vamos a trabajar, ingresamos a: https://www.jetbrains.com/es-

• Es un espacio de memoria que almacenará datos.

▪ BOOLEAN: Este es el tipo más simple de un solo bit.

▪ CHAR: Usa el código UNICODE y ocupa cada carácter 16 bits.

▪ NÚMEROS ENTEROS: Un entero es un número del conjunto Z = {…, -2, -1, 0, 1, 2, …}

❖ LONG: Entre -9223372036854775808 a 9223372036854775807.

❖ DOUBLE: Entre -4.9E-324 a 1.7976931348623157E308.

▪ VAR: Variable dinámica que cambia según su valor.

o Contienen más de 1 valor como: arreglos, clases e interfaces.

▪ STRING: Los String son objetos de java, del tipo de referencia.

➢ Los caracteres de un String se codifican usando Unicode.

➢ Sobre las cadenas se define la operación de concatenar con el operador de suma:

➢ Con el operador relacional de igualdad == compara por referencia.

o Empiezan con minúscula.

o Debemos atrapar la variable que queramos con la librería JOptionPane:

o También podemos mostrar ventanas de alertas o mensajes:

o Para atrapar datos desde la terminal debemos usar la librería Scanner:

CONVERSIÓN DE CADENAS A TIPOS PRIMITIVOS

o Para convertir de cadena a un tipo primitivo:

CONVERSIÓN DE TIPOS PRIMITIVOS A CADENAS

o Para convertir de tipos primitivos a cadenas existen 2 formas:

• SUMA: (int numero = 1 + 2;)

• RESTA: (int numero = 1 – 2;)

• MULTIPLICACIÓN: (int numero = 1 * 2;)

• DIVISIÓN: (int numero = 1 / 2;) Devuelve el resultado en decimal.

• MODULO: (int numero = 1 % 2;) Devuelve el residuo de una división.

• INCREMENTO: (uno++;) Incrementa en 1 unidad el valor de la variable.

• DECREMENTO: (uno--;) Decrementa en 1 unidad el valor de la variable.

• MAYOR O IGUAL: (1 >= 2)

• MENOR O IGUAL: (1 <= 2)

• NEGACIÓN: (!(uno == 19))

• 1. Los paréntesis porque tienen prioridad.

OPERADORES DE ASIGNACIÓN (INCREMENTALES O DECREMÉNTALES)

• Hay dos tipos de herencia: Herencia Simple y Herencia Múltiple.

• La clase padre de cualquier clase es conocida como su superclase.

• La clase hija de una superclase es llamada una subclase.

public class Transporte {

public int capacidad;

public void avanzar() {

public void detenerse() {

public class Aeronave extends Transporte {

public class Main {

public static void main(String[] args) {

Aeronave avion = new Aeronave();

DIFERENCIA MÉTODO Y FUNCIÓN

• Para crear una función seguimos la siguiente estructura:

• Para llamar a una función desde la misma clase ponemos nombreFuncion();

o Los métodos abstractos forzosamente habrán de estar sobrescritos en las subclases.

public abstract class NombreDeLaClase { … }

public class Figura {

private int numeroLados;

public float area() {

public abstract float area();

public abstract class Figura {

public class Triangulo extends Figura {

o En una interfaz, los métodos son implícitamente públicos.

o Los métodos que implementan una interfaz deben declararse públicos.

• Lo que va a hacer es modificar el acceso a las variables, atributos, clases, etc.

o private: Únicamente la clase puede acceder a la propiedad o método.