inbound7567055703303194596 - Keygii Vlog

Vista previa del material en texto

MÓDULO DE PROGRAMACIÓN ORIENTADA A OBJETOS
PERÍODO ACADÉMICO: MAYO - OCTUBRE 2022
VICERRECTORADO ACADÉMICO
TECNOLOGÍA SUPERIOR EN DESARROLLO DE 
SOFTWARE
MÓDULO DE
PROGRAMACION ORIENTADA A OBJETOS
 SEGUNDO SEMESTRE 
REALIZADO POR:
Ing. Marcelo Acuña
 
INSTITUTO 
SUPERIOR TECNOLÓGICO
BOLÍVAR
REALIZADO POR: 
NOMBRES Y APELLIDOS DEL DOCENTE
	
Registro Institucional Nro. 2215
Dirección: Sucre 0438 entre Laláma y Martínez 
www.itsbolivar.edu.ec
DATOS INFORMATIVOS
	ASIGNATURA: Programación Orientada a Objetos
	CÓDIGO: DSP2_IT_09
	CARRERA: DESARROLLO DE SOFTWARE
	SEMESTRE: SEGUNDO
	NOMBRE DEL DOCENTE: 
ING. MARCELO ACUÑA
	HORAS SEMESTRALES: 126 = 72 horas teóricas + 54 horas practicas
	HORAS SEMANALES: 7 por semana
PRESENTACIÓN
Se desea dar visión general de la Programación Orientada al Objeto (POO o también del inglés OOP = Object Oriented Programming). 
Ya que la OOP no es un lenguaje de programación, puede aplicarse a cualquier lenguaje, y de hecho hoy en día está disponible en mayor o menor medida en todos los lenguajes tradicionales (C se ha convertido en C++, Pascal en Delphi, VB incorpora parte de la OOP) y no aparece un lenguaje nuevo sin que incluya OOP (como es el caso de Java). 
Es por esto que intentaremos que todo lo que aquí se diga pueda ser aplicado a cualquier lenguaje OOP.
El objetivo de este libro es, pues, el aprendizaje de los términos teóricos que todos manejamos hoy en día, en cualquier entorno de programación cuando nos referimos a la orientación a objetos.
OBJETIVOS
· Manejar conocimientos para el desarrollo de programas informáticos basados en clases y objetos.
· Desarrollar aplicaciones informáticas utilizando herencia y Polimorfismo
· Desarrollar software con variables y métodos estáticos.
· Controlar errores y excepciones en el diseño y el desarrollo de software.
· Desarrollar software utilizando colecciones.
· Crear aplicaciones informáticas con interface gráfica.
· Dar soluciones informáticas a los problemas con aplicaciones informáticas con base de datos.
ÍNDICE
1.	CLASES Y OBJETOS	8
1.1.	Objetivos de Aprendizaje:	8
1.2.	Fundamentación teórica:	8
1.2.1. Introducción a la Programación Orientada a Objetos	8
1.2.2. Caracteristicas de la programación	9
1.2.3. Identificadores, separadores, operadores.	11
1.2.4. Tipos de datos, variables, expresiones.	23
1.2.5. Modificadores de acceso.	38
1.2.6. Alcance de las variables.	41
1.2.7. Constructores.	41
1.2.8. Librerias	44
1.2.9. Encapsulamiento: métodos getters y setters.	48
1.3.	Guía Practica	51
1.4.	Evaluación	53
1.5.	Bibliografía Y Web grafía Sugerida:	54
2. HERENCIA Y POLIMORFISMO	54
2.1. Objetivos de Aprendizaje:	54
2.2. Fundamentación teórica:	54
2.2.1. Relación de herencia	54
2.2.2. Sobre-escritura	62
2.2.3. Sobrecarga de método	64
2.2.4. Clases abstractas e interfaz	65
2.2.5. Implementación de métodos y clases abstractos	68
2.2.6. Definición de polimorfismo	72
2.2.7. Upcasting y Downcasting	75
2.3. Guía Practica	78
2.4. Evaluación	81
2.5. Bibliografía Y Web grafía Sugerida:	82
3. VARIABLES Y MÉTODOS ESTÁTICOS.	83
3.1. Objetivos de Aprendizaje:	83
3.2. Fundamentación teórica:	83
3.2.1. Variables estáticas	83
3.2.2. Metodos estáticos	83
3.2.3. Constantes	86
3.2.4. Clases	89
3.3. Guía Practica	91
3.4. Evaluación	93
3.5. Bibliografía Y Web grafía Sugerida:	94
4. MANEJO DE ERRORES Y EXCEPCIONES	95
4.1. Objetivos de Aprendizaje:	95
4.2. Fundamentación teórica:	95
4.2.1. Definisión de una Excepción	95
4.2.2. Tipos de Excepciones	98
4.2.3. Manejo de excepciones	101
4.3. Guía Practica	104
4.4. Evaluación	106
4.5. Bibliografía Y Web grafía Sugerida:	107
5. COLECCIONES	108
5.1. Objetivos de Aprendizaje:	108
5.2. Fundamentación teórica:	108
5.2.1. Definisión	108
5.2.2. Tipos de colecciones	109
5.2.3. Uso de colecciones	112
5.3. Guía Practica	115
5.4. Evaluación	117
5.5. Bibliografía Y Web grafía Sugerida:	118
6. INTERFAZ GRÁFICA	120
6.1. Objetivos de Aprendizaje:	120
6.2. Fundamentación teórica:	120
6.2.1. Introducción	120
6.2.2. Componentes GUI Boton, CheckBox, List	124
6.2.3. Creacción de la Interfaz	127
6.2.4. Manejo de Eventos	130
6.3. Guía Practica	149
6.4. Evaluación	152
6.5. Bibliografía Y Web grafía Sugerida:	152
7. CONEXIÓN A BD	153
7.1. Objetivos de Aprendizaje:	153
7.2. Fundamentación teórica:	153
7.2.1. Introducción	153
7.2.2. Drive JDBC	154
7.2.3. Conexión a la BD	158
7.3. Guía Practica	169
7.4. Evaluación	172
7.5. Bibliografía y Web grafía Sugerida:	172
UNIDAD
1
1. CLASES Y OBJETOS
	NUMERO DE HORAS
	TOTAL
	DOCENCIA: 17
	PRACTICA: 12
	AUTONOMA: 16
	45
1.1. Objetivos de Aprendizaje:
Manejar conocimientos para el desarrollo de programas informáticos basados en clases y objetos.
1.2. Fundamentación teórica:
1.2.1. Introducción a la Programación Orientada a Objetos
La Programación Orientada a Objetos (OOP) es un método de programación en el cual los programas se organizan en colecciones cooperativas de objetos, cada uno de los cuales representa una instancia de alguna clase, y cuyas clases son, todas ellas, miembros de una jerarquía de clases unidas mediante relaciones de herencia.
La programación orientada a objetos es una evolución de la programación procedural basada en funciones. La POO nos permite agrupar secciones de código con funcionalidades comunes.
Una de las principales desventajas de la programación procedural basada en funciones es su construcción, cuando una aplicación bajo este tipo de programación crece, la modificación del código se hace muy trabajosa y difícil debido a que el cambio de una sola línea en una función, puede acarrear la modificación de muchas otras líneas de código pertenecientes a otras funciones que estén relacionadas.
Con la programación orientada a objetos se pretende agrupar el código encapsulándolo y haciéndolo independiente, de manera que una modificación debida al crecimiento de la aplicación solo afecte a unas pocas líneas.
La organización de una aplicación en POO se realiza mediante estructuras de código, también llamados objetos. Estos objetos contienen una serie de procedimientos e información destinados a resolver un grupo de tareas con un denominador común. Un procedimiento que este situado en un objeto no podrá ser usado por otro procedimiento perteneciente a otro objeto, si no es bajo una serie de reglas. Los datos que mantenga el objeto, permanecerán aislados del exterior y sólo se podrá acceder a ellos siguiendo ciertas normas.
El objetivo de POO es catalogar y diferenciar el código, en base a estructuras jerárquicas dependientes, al estilo de un árbol genealógico.
Los objetos se crean a partir de una serie de especificaciones o normas que definen como va a ser el objeto, esto es lo que en POO se conoce como una clase.
Las clases definen la estructura que van a tener los objetos que se creen a partir de ella, indicando que propiedades y métodos tendrán los objetos.
Las propiedades definen los datos o información del objeto, permitiendo modificar o consultar su estado, mientras que los métodos son las rutinas que definen el comportamiento del objeto. Es necesario tener muy clara cuál es la diferencia entre un objeto y una clase, a este respecto podemos decir que una clase constituye la representación abstracta de algo mientras que un objeto constituye la representación concreta de lo que la clase define. Imaginemos los planos de una casa diseñados por un arquitecto, en ellos encontramos el esquema de la casa, las medidas, los materiales etc... Una vez construida la casa podremos comprobar que cumple todo lo que los planos determinaban, de esta manera podemos comparar los planos de la casa con las clases en POO, y la casa en si con un objeto creado a partir de una clase. Se debe destacar también que con los mismos planos se pueden crear muchas casas iguales, lo mismo ocurre en POO, a partir de una clase se pueden crear muchos objetos iguales.
La creación de un objeto a partir de una clase se conoce como instanciación de un objeto.
1.2.2. Características de la programaciónLa programación intenta resolver problemas atravesó de una determinada metodología. Es el proceso de escribir programas. Un programa de computador es una serie de instrucciones órdenes dadas a la máquina para que se produzca la ejecución de una determinada tarea.
Tipos de Programación
Los tipos o técnicas de programación son bastantes variados.
La idea es que el programador los conozca y sepa seleccionar el adecuado para resolver el problema que se le plantea (La mayoría de los lenguajes de programación han sido creados para ser utilizados en determinados ambientes de programación, por lo que para cada técnica conviene utilizar un determinado lenguaje).
Programación Secuencial
Se basa en la creación de programas atravesó de sentencias escritas de forma secuencial (continuidad., sucesión ordenada).
Programación spaguetti
Spaguetti es un término peyorativo Para los programas que tienen una estructura de control de flujo (Determinación del orden en el que se ejecutan las instrucciones) difícil de entender. El nombre se deriva del hecho de que su código se asemeja a un plato de espaguetis. Suele asociarse a lenguajes de programación antiguos, pero en la actualidad lenguajes como javascript, sql, php lo utilizan para poder entrelazaren.
Programación Estructurada
Es una de las más antiguas que existen. Aunque actualmente los nuevos tipos de programación están copando el mercado la programación estructurada se mantiene en la esencia de los lenguajes modernos. Está basada en el modularidad (unión de varias partes), en la que se divide el programa en módulos y cada uno realiza una tarea específica. De esta manera la complejidad del problema se reduce al dividir las tareas ya que al unirlas permiten la resolución del este. La programación estructurada se puede dividir en dos:
· funcional: Dentro del mismo programa se llaman las diferentes funciones (módulos).
· Procedimental o procedural: Las funciones se guardan como archivos aparte
Programación orientada a eventos
Le proporciona al programador que no tiene mucha experiencia en desarrollo a crear sus aplicaciones en base a entorno gráfico y en la ocurrencia de eventos.
Programación orientada a objetos (POO)
Cada elemento dentro de un programa que se trabaje con esta técnica es considerado como un objeto que tiene propiedades y métodos. La ejecución del programa depende de la interacción de los objetos que lo componen. Las propiedades y métodos de cada objeto se especifican en su clase. La clase es como el molde de la instancia de cada objeto. Cuando se programa con esta técnica se definen clases y se crean instancias de objetos dentro de estas clases para que después los objetos interaccionen entre sí.
Programación lógica
Lo más importante es definir un conjunto de hechos y un conjunto de reglas que definen las relaciones que existen entre los componentes de los programas (base del conocimiento). Utiliza lenguajes de alto nivel (expresan los algoritmos de una manera adecuada para el entendimiento humano). Una de las utilidades más importantes es la inteligencia artificial.
Características de la programación
· Exactitud y precisión: resultados sin errores d sintaxis o de lógica
· Integridad o completitud: Un programa es completo sólo si ejecuta todas las operaciones se esperan al procesar un conjunto de datos
· Generalidad: Un programa bien diseñado puede procesar un conjunto de datos que varían en el número de transacciones. Las instrucciones se deben elaborar para que no se limiten a un número específico de transacciones en el conjunto de datos.
· Eficiencia: Debe asegurarse de que la instrucción para manejar datos sea tan rápida y fácilmente como sea posible.
· Documentación: consiste en el uso de auxiliares que expliquen como ocurre el procesamiento de los datos en su programa.
1.2.3. Identificadores, separadores, operadores.
Identificadores
En los lenguajes de programación, los identificadores (como su nombre lo indica) se utilizan con fines de identificación. En Java, un identificador puede ser un nombre de clase, un nombre de método o un nombre de variable. Por ejemplo:
public class Test
{
public static void main(String[] args)
{
int a = 28;
}
}
En el código java anterior, tenemos 5 identificadores, a saber:
· Test: nombre de clase.
· main: nombre del método.
· String: nombre de clase predefinido.
· args: nombre de la variable.
· a: nombre de la variable.
Separadores
Sólo hay un par de secuencias con otros caracteres que pueden aparecer en el código Java; son los separadores simples, que van a definir la forma y función del código. Los separadores admitidos en Java son:
() – paréntesis. Para contener listas de parámetros en la definición y llamada a métodos. También se utiliza para definir precedencia en expresiones, contener expresiones para control de flujo y rodear las conversiones de tipo.
{} – llaves. Para contener los valores de matrices inicializadas automáticamente. También se utiliza para definir un bloque de código, para clases, métodos y ámbitos locales.
[] – corchetes. Para declarar tipos matriz. También se utiliza cuando se referencian valores de matriz.
; – punto y coma. Separa sentencias.
, – coma. Separa identificadores consecutivos en una declaración de variables. También se utiliza para encadenar sentencias dentro de una sentencia for.
. – punto. Para separar nombres de paquete de subpaquetes y clases. También se utiliza para separar una variable o método de una variable de referencia.
Operadores
Operadores aritméticos
Se utilizan para realizar operaciones aritméticas simples en tipos de datos primitivos.
· *: Multiplicación
· /: División
· %: Modulo
· +: Adición
· –: Resta
Ejemplo:
// Programa Java para ilustrar
// operadores aritméticos
public class operators
{
public static void main(String[] args) 
{
int a = 20, b = 10, c = 0, d = 20, e = 40, f = 30;
String x = "Thank", y = "You";
// Operador + y - 
System.out.println("a + b = "+(a + b));
System.out.println("a - b = "+(a - b));
// El operador + si se usa con strings
// concatena las cadenas dadas.
System.out.println("x + y = "+x + y);
// Operador * y /
System.out.println("a * b = "+(a * b));
System.out.println("a / b = "+(a / b));
// operador de módulo da el resto
// de dividir el primer operando con el segundo
System.out.println("a % b = "+(a % b));
// si el denominador es 0 en la división
// System.out.println(a/c);
// lanzaría una java.lang.ArithmeticException
}
}
Salida:
a + b = 30
a - b = 10
x + y = ThankYou
a * b = 200
a / b = 2
a % b = 0
Operadores unarios
Los operadores unarios solo necesitan un operando. Se usan para incrementar, disminuir o negar un valor.
· –: Unario menos, utilizado para negar los valores.
· +: Unario más, usado para dar valores positivos. Solo se usa cuando se convierte deliberadamente un valor negativo en positivo.
· ++: Operador de incremento, utilizado para incrementar el valor en 1. Hay dos variedades de operador de incremento.
1. Pre-Incremento: el valor se incrementa primero y luego se calcula el resultado.
2. Post-Incremento: el valor se usa por primera vez para calcular el resultado y luego se incrementa.
· —: Operador de decremento, usado para incrementar el valor en 1. Hay dos variedades de operador de incremento.
1. Pre-Decremento: el valor se disminuye primero y luego se calcula el resultado.
2. Post-Decremento: el valor se usa por primera vez para calcular el resultado y luego se disminuye.
· ! : Operador lógico “no”, utilizado para invertir un valor booleano.
Ejemplo:
// Programa Java para ilustrar
// operadores unarios
public class operators 
{
public static void main(String[] args) 
{
int a = 20, b = 10, c = 0, d = 20, e = 40, f = 30;
boolean condition = true;
// operador de pre-incremento
// a = a+1 y entonces c = a;
c = ++a;
System.out.println("Valor de c (++a) = " + c);
// operador de post-incremento
// c=b entonces b=b+1 (b pasa a ser 11)
c = b++;
System.out.println("Valor de c (b++) = " + c);
// operador de pre-decremento
// d=d-1 entonces c=d
c = --d;
System.out.println("Valor de c (--d) = " + c);
// operador de post-decremento// c=e entonces e=e-1 (e pasa a ser 39)
c = e--;
System.out.println("Valor de c (e--) = " + c);
// Operador lógico not
System.out.println("Valor de !condition = " + !condition);
}
}
Salida:
Valor de c (++a) = 21
Valor de c (b++) = 10
Valor de c (--d) = 19
Valor de c (e--) = 40
Valor de !condition = false
Operador de asignación (=)
El operador de asignación se usa para asignar un valor a cualquier variable. Tiene una asociación de derecha a izquierda, es decir, el valor dado en el lado derecho del operador se asigna a la variable de la izquierda y, por lo tanto, el valor del lado derecho debe declararse antes de usarlo o debe ser una constante.
El formato general del operador de asignación es,
En muchos casos, el operador de asignación se puede combinar con otros operadores para construir una versión más corta de la declaración llamada Declaración Compuesta (Compound Statement). Por ejemplo, en lugar de a = a + 5, podemos escribir a + = 5.
int a = 5;
a += 5; // a = a + 5;
· + = , para sumar el operando izquierdo con el operando derecho y luego asignarlo a la variable de la izquierda.
· – = , para restar el operando izquierdo con el operando derecho y luego asignarlo a la variable de la izquierda.
· * = , para multiplicar el operando izquierdo con el operando derecho y luego asignándolo a la variable de la izquierda.
· / = , para dividir el operando izquierdo con el operando derecho y luego asignarlo a la variable de la izquierda.
· ^ = , para aumentar la potencia del operando izquierdo al operando derecho y asignarlo a la variable de la izquierda.
· % = , para asignar el módulo del operando izquierdo con el operando derecho y luego asignarlo a la variable de la izquierda.
Ejemplo:
// Programa Java para ilustrar
// Operadores de Asignación
public class operators 
{
public static void main(String[] args) 
{
int a = 20, b = 10, c, d, e = 10, f = 4, g = 9;
// operador de asignación simple
c = b;
System.out.println("Valor de c = " + c);
// Esta siguiente declaración arrojaría una exception
// porque el valor del operando derecho debe ser inicializado
// antes de la asignación, entonces el programa no
// compila.
// c = d;
// operadores de asignación simples
a = a + 1;
b = b - 1;
e = e * 2;
f = f / 2;
System.out.println("a,b,e,f = " + a + ","
+ b + "," + e + "," + f);
a = a - 1;
b = b + 1;
e = e / 2;
f = f * 2;
// operados de asignación compuestos/cortos
a += 1;
b -= 1;
e *= 2;
f /= 2;
System.out.println("a,b,e,f (usando operadores cortos)= " + 
a + "," + b + "," + e + "," + f);
}
}
Salida:
Valor de c = 10
a,b,e,f = 21,9,20,2
a,b,e,f (usando operadores cortos)= 21,9,20,2
Operadores relacionales
Estos operadores se utilizan para verificar relaciones como igualdad, mayor que, menor que. Devuelven el resultado booleano después de la comparación y se usan ampliamente en las instrucciones de bucle, así como en las sentencias condicionales if/else. El formato general es, variable operador_relacion valor
Algunos de los operadores relacionales son:
· ==, Igual a: devuelve verdadero si el valor del lado izquierdo es igual al lado derecho.
· ! =, No igual a: devuelve verdadero si el valor del lado izquierdo no es igual al lado derecho.
· <, menos que: el resultado verdadero si el valor del lado izquierdo es inferior al del lado derecho.
· <=, menor o igual que: devuelve verdadero si el valor del lado izquierdo es menor o igual que el lado derecho.
· >, Mayor que: devuelve verdadero si el valor del lado izquierdo es mayor que el lado derecho.
· > =, Mayor que o igual a: regresa verdadero si el valor del lado izquierdo es mayor o igual que el lado derecho.
Ejemplo:
// Programa Java para ilustrar
// operadores relacionales
public class operators 
{
public static void main(String[] args) 
{
int a = 20, b = 10;
String x = "Thank", y = "Thank";
int ar[] = { 1, 2, 3 };
int br[] = { 1, 2, 3 };
boolean condicion = true;
//varios operadores condicionales
System.out.println("a == b :" + (a == b));
System.out.println("a < b :" + (a < b));
System.out.println("a <= b :" + (a <= b));
System.out.println("a > b :" + (a > b));
System.out.println("a >= b :" + (a >= b));
System.out.println("a != b :" + (a != b));
// Los Arrays no se pueden comparar con
// operadores relacionales porque los objetos
// almacenan referencias, mas no el valor
System.out.println("x == y : " + (ar == br));
System.out.println("condicion==true :" + (condicion == true)); }}
Salida:
a == b :false
a < b :false
a <= b :false
a > b :true
a >= b :true
a != b :true
x == y : false
condicion==true :true
Operadores lógicos
Estos operadores se utilizan para realizar operaciones “lógicas AND” y “lógicas OR”, es decir, la función similar a la puerta AND y la puerta OR en electrónica digital. Una cosa a tener en cuenta es que la segunda condición no se evalúa si la primera es falsa, es decir, tiene un efecto de cortocircuito. Se usa ampliamente para probar varias condiciones para tomar una decisión.
Los operadores condicionales son:
· &&, AND lógico: devuelve verdadero cuando ambas condiciones son verdaderas.
· || , O lógico: devuelve verdadero si al menos una condición es verdadera.
Ejemplo:
// Programa Java para ilustrar
// operadores logicos
import java.util.Scanner;
public class operators 
{
public static void main(String[] args) 
{
String x = "java";
String y = "desdecero";
Scanner s = new Scanner(System.in);
System.out.print("Ingrese usuario:");
String uuid = s.next();
System.out.print("Ingrese contraseña:");
String upwd = s.next();
// Verifique si el nombre de usuario y la contraseña coinciden o no.
if ((uuid.equals(x) && upwd.equals(y)) || 
(uuid.equals(y) && upwd.equals(x))) {
System.out.println("Bienvenido usuario.");
} else {
System.out.println("ID o Contraseña equivocada");
} }
}
Salida:
Ingrese usuario:java
Ingrese contraseña:desdecero
Bienvenido usuario.
Operador ternario
Ternario es una versión abreviada de la declaración if-else. Tiene tres operandos y de ahí el nombre ternario. El formato general es:
La declaración anterior significa que si la condición se evalúa como verdadera, entonces ejecuta las instrucciones después del ‘?‘ de lo contrario, ejecuta las instrucciones después de ‘:‘.
Ejemplo:
// Programa Java para ilustrar
// el máximo de tres números utilizando
// operador ternario.
public class operators 
{
public static void main(String[] args) 
{
int a = 20, b = 10, c = 30, result;
//el resultado obtiene el máximo de tres
//numeros
result = ((a > b) ? (a > c) ? a : 
c : (b > c) ? b : c);
System.out.println("Máximo de tres números = "+result);
}}
Salida:
Máximo de tres números = 30
Operadores bit a bit
Los operadores a nivel de bits se utilizan para realizar la manipulación de bits individuales de un número. Se pueden usar con cualquiera de los tipos enteros. Se utilizan al realizar operaciones de actualización y consulta de árbol indexado binario.
· &, Operador bit a bit AND: Si ambos bits de entrada son 1, establece el resultado en 1. De lo contrario da como resultado 0. El resultado binario final se muestra en decimal.
· | , Operador bit a bit OR: Si al menos uno de los dos bits de entrada es 1, establece el resultado en 1. De lo contrario da como resultado 0. El resultado binario final se muestra en decimal.
· ^, Operador bit a bit XOR: Si uno de los bits de entrada es 0 y el otro 1, el resultado es 1. Si ambos bits comparados son iguales, el resultado es 0. El resultado binario final se muestra en decimal.
· ~, Operador bit a bit de complemento (NOT): este es un operador unario que devuelve la representación complementaria del valor de entrada, es decir, con todos los bits invertidos. El resultado binario final se muestra en decimal.
Ejemplo:
// Programa Java para ilustrar
// operadores bit a bit (bitwise)
public class operators 
{
public static void main(String[] args) 
{
int a = 0x0005;
int b = 0x0007;
// bitwise AND
// 0101 & 0111=0101
System.out.println("a&b = " + (a & b));
// bitwise or
// 0101 | 0111=0111
System.out.println("a|b = " + (a | b));
// bitwise xor
// 0101 ^ 0111=0010
System.out.println("a^b = " + (a ^ b));
// bitwisecomplemento
// ~0101=1010
System.out.println("~a = " + ~a);
// también se puede combinar con el
// operador de asignación
// a=a&b
a &= b;
System.out.println("a= " + a);
}
}
Salida:
a&b = 5
a|b = 7
a^b = 2
~a = -6
a= 5
Operadores shift
Los operadores shift de Java se usan para desplazar los bits de un número hacia la izquierda o hacia la derecha, multiplicando o dividiendo el número por dos, respectivamente. Se pueden usar cuando tenemos que multiplicar o dividir un número por dos.
· <<, operador de desplazamiento a la izquierda : desplaza los bits del número hacia la izquierda y llena con “0” los bits desplazados. Efecto similar a la multiplicación del número con una potencia de dos.
· >>, Operador de desplazamiento a la derecha firmado: desplaza los bits del número a la derecha y llena con “0” los bits desplazados. El bit más a la izquierda depende del signo del número inicial. Efecto similar a partir de dividir el número con alguna potencia de dos.
· >>>, Operador de cambio a la derecha sin signo: desplaza los bits del número a la derecha y llena con “0” los bits desplazados. El bit más a la izquierda se establece en 0.
Ejemplo:
// Programa Java para ilustrar
// operadores shift
public class operators 
{
public static void main(String[] args) 
{
int a = 0x0005;
int b = -10;
// operador de desplazamiento a la izquierda
// 0000 0101<<2 =0001 0100(20)
// similar a 5*(2^2)
System.out.println("a<<2 = " + (a << 2));
// operador de desplazamiento a la derecha
// 0000 0101 >> 2 =0000 0001(1)
// similar a 5/(2^2)
System.out.println("a>>2 = " + (a >> 2));
// operador de cambio a la derecha sin firmar
System.out.println("b>>>2 = "+ (b >>> 2));
}
}
Salida:
a<<2 = 20
a>>2 = 1
b>>>2 = 1073741821
Operador de Instancia (instanceof)
El operador de instancia se usa para verificar el tipo. Se puede usar para probar si un objeto es una instancia de una clase, una subclase o una interfaz.
Formato general:  
Ejemplo:
// Programa Java para ilustrar
// instancia de operador
class operators 
{
public static void main(String[] args) 
{
Person obj1 = new Person();
Person obj2 = new Boy();
// Como obj1 es de tipo Person, no es una
// instancia de Boy o interfaz
System.out.println("obj1 instanceof Person: " + 
(obj1 instanceof Person));
System.out.println("obj1 instanceof Boy: " + 
(obj1 instanceof Boy));
System.out.println("obj1 instanceof MyInterface: " + 
(obj1 instanceof MyInterface));
// Dado que obj2 es de tipo Boy, cuya clase padre es
// Person e implementa la interfaz Myinterface
// es una instancia de todas estas clases
System.out.println("obj2 instanceof Person: " + 
(obj2 instanceof Person));
System.out.println("obj2 instanceof Boy: " + 
(obj2 instanceof Boy));
System.out.println("obj2 instanceof MyInterface: " + 
(obj2 instanceof MyInterface));
}
}
class Person 
{
}
class Boy extends Person implements MyInterface 
{
}
interface MyInterface 
{
}
Salida:
obj1 instanceof Person: true
obj1 instanceof Boy: false
obj1 instanceof MyInterface: false
obj2 instanceof Person: true
obj2 instanceof Boy: true
obj2 instanceof MyInterface: true
Precedencia de Operadores
La precedencia y las reglas asociativas se usan cuando se trata de ecuaciones híbridas que involucran a más de un tipo de operador. En tales casos, estas reglas determinan qué parte de la ecuación considerar primero, ya que puede haber muchas valoraciones diferentes para la misma ecuación. La siguiente tabla muestra la precedencia de los operadores en orden decreciente como magnitud, con la parte superior representando la precedencia más alta y la inferior con la prioridad más baja.
	Tabla de Precedencia y asociatividad de los operadores en Java.
	Operador
	Aociatividad
	++ —
	De derecha a izquierda
	++ — + – !
	De derecha a izquierda
	* / %
	De derecha a izquierda
	+ –
	De derecha a izquierda
	< <= > >=
	De derecha a izquierda
	== !=
	De derecha a izquierda
	&
	De derecha a izquierda
	^
	De derecha a izquierda
	|
	De derecha a izquierda
	&&
	De derecha a izquierda
	||
	De derecha a izquierda
	?:
	De derecha a izquierda
	= += -= *= /= %=
	De derecha a izquierda
Extra: Secuencias de Escape en Java
Los valores numéricos y de texto en los programas de Java se conocen como “literales”; no representan nada, pero son, literalmente, lo que ves.
Los literales normalmente se desprenden de las palabras clave del lenguaje Java, pero cuando se requieren comillas dobles o comillas simples dentro de un valor de String, es necesario indicar que el carácter de cita debe tratarse LITERALMENTE para evitar terminar prematuramente el String. Esto se logra fácilmente mediante el prefijo inmediato de cada carácter de comillas anidado con el operador de escape \.
Me explico mejor con el siguiente ejemplo:
String cita = " \"Java debe ser un territorio neutral, la Suiza de la tecnología informática.\"dijo James Gosling";
Además, el operador de escape \ ofrece una variedad de secuencias de escape muy útiles como son los siguientes:
	Tabla de Secuencias de Escape en Java.
	Escape
	Descripción
	\n
	Nueva Linea.
	\t
	Tabulador.
	\b
	Backspace
	\r
	Retorno del carro.
	\f
	Form feed.
	\\
	Barra invertida (\)
	\’
	Comilla simple
	\”
	Comilla doble
×Nota: Tanto \r como \f son caracteres de control de terminal o impresora y no tienen ningún significado en Java.
Ejemplo de Escape:
class Escape {
public static void main( String[] args ) {
String cabecera = "\n\tPRONOSTICO DE CLIMA:\n" ;
cabecera += "\n\tDia\t\tMañana\tNoche\tCondiciones\n" ;
cabecera += "\t---\t\t-------\t----\t-----------\n" ;
String pronostico = "\tDomingo\t25C\t\t23C\t\tSoleado\n";
pronostico += "\tLunes\t24C\t\t19C\t\tSoleado\n";
pronostico += "\tMartes\t26C\t\t15C\t\tNublado\n";
System.out.print(cabecera+pronostico) ;
}
}
Salida:
1.2.4. Tipos de datos, variables, expresiones.
Tipos de datos
Tipos de datos primitivos
Java cuenta con un pequeño conjunto de tipos de datos primitivos. Podríamos considerarlos fundamentales, ya que la mayor parte de los demás tipos, los tipos estructurados o complejos, son composiciones a partir de estos más básicos. Estos tipos de datos primitivos sirven para gestionar los tipos de información más básicos, como números de diversas clases o datos de tipo verdadero/falso (también conocidos como "valores booleanos" o simplemente "booleanos").
De estos tipos primitivos, ocho en total, seis de ellos están destinados a facilitar el trabajo con números. Podemos agruparlos en dos categorías: tipos numéricos enteros y tipos numéricos en punto flotante. Los primeros permiten operar exclusivamente con números enteros, sin parte decimal, mientras que el segundo grupo contempla también números racionales o con parte decimal.
Tipos numéricos enteros
En Java existen cuatro tipos destinados a almacenar números enteros. La única diferencia entre ellos es el número de bytes usados para su almacenamiento y, en consecuencia, el rango de valores que es posible representar con ellos. Todos ellos emplean una representación que permite el almacenamiento de números negativos y positivos. El nombre y características de estos tipos son los siguientes:
· byte: como su propio nombre denota, emplea un solo byte (8 bits) de almacenamiento. Esto permite almacenar valores en el rango [-128, 127].
· short: usa el doble de almacenamiento que el anterior, lo cual hace posible representar cualquier valor en el rango [-32.768, 32.767].
· int: emplea 4 bytes de almacenamiento y es el tipo de dato entero más empleado. El rango de valores que puede representar va de -231 a 231-1.
· long: es el tipo entero de mayor tamaño, 8 bytes (64 bits), con un rango de valores desde -263 a 263-1.
Tipos numéricos en punto flotante
Los tipos numéricos en punto flotante permiten representar números tanto muy grandes como muy pequeños además de números decimales. Java dispone de 2 tipos concretos en esta categoría:
· float: conocido como tipo de precisión simple, emplea un total de 32 bits. Con este tipo de datos es posible representar números en el rango de 1.4x10-45 a 3.4028235x1038.
· double: sigue un esquemade almacenamiento similar al anterior, pero usando 64 bits en lugar de 32. Esto le permite representar valores en el rango de 4.9x10-324 a 1.7976931348623157x10308.
Booleanos y caracteres
Aparte de los 6 tipos de datos que acabamos de ver, destinados a trabajar con números en distintos rangos, Java define otros dos tipos primitivos más:
· boolean: tiene la finalidad de facilitar el trabajo con valores "verdadero/falso" (booleanos), resultantes por regla general de evaluar expresiones. Los dos valores posibles de este tipo son true y false.
· char: se utiliza para almacenar caracteres individuales (letras, para entendernos). En realidad, está considerado también un tipo numérico, si bien su representación habitual es la del carácter cuyo código almacena. Utiliza 16 bits y se usa la codificación UTF-16 de Unicode.
Tipos de datos estructurados.
Los tipos de datos primitivos que acabamos de ver se caracterizan por poder almacenar un único valor. Salvo este reducido conjunto de tipos de datos primitivos, que facilitan el trabajo con números, caracteres y valores booleanos, todos los demás tipos de Java son objetos, también llamados tipos estructurados o "Clases".
Los tipos de datos estructurados se denominan así porque en su mayor parte están destinados a contener múltiples valores de tipos más simples, primitivos. También se les llama muchas veces "tipos objeto" porque se usan para representar objetos. Puede que te suene más ese nombre.
Cadenas de caracteres
Aunque las cadenas de caracteres no son un tipo simple en Java, sino una instancia de la clase String, el lenguaje otorga un tratamiento bastante especial a este tipo de dato, lo cual provoca que, en ocasiones, nos parezca estar trabajando con un tipo primitivo.
Aunque cuando declaramos una cadena estamos creando un objeto, su declaración no se diferencia de la de una variable de tipo primitivo de las que acabamos de ver:
String nombreCurso = "Iniciación a Java";
Y esto puede confundir al principio. Recuerda: Las cadenas en Java son un objeto de la clase String, aunque se declaren de este modo.
Las cadenas de caracteres se delimitan entre comillas dobles, en lugar de simples como los caracteres individuales. En la declaración, sin embargo, no se indica explícitamente que se quiere crear un nuevo objeto de tipo String, esto es algo que infiere automáticamente el compilador.
Las cadenas, por tanto, son objetos que disponen de métodos que permiten operar sobre la información almacenada en dicha cadena. Así, encontraremos métodos para buscar una subcadena dentro de la cadena, sustituirla por otra, dividirla en varias cadenas atendiendo a un cierto separador, convertir a mayúsculas o minúsculas, etc.
Vectores o arrays
Los vectores son colecciones de datos de un mismo tipo. También son conocidos popularmente como arrays e incluso como "arreglos" (aunque se desaconseja esta última denominación por ser una mala adaptación del inglés).
Un vector es una estructura de datos en la que a cada elemento le corresponde una posición identificada por uno o más índices numéricos enteros.
También es habitual llamar matrices a los vectores que trabajan con dos dimensiones.
Los elementos de un vector o array se empiezan a numerar en el 0, y permiten gestionar desde una sola variable múltiples datos del mismo tipo.
Por ejemplo, si tenemos que almacenar una lista de 10 números enteros, declararíamos un vector de tamaño 10 y de tipo entero, y no tendríamos que declarar 10 variables separadas de tipo entero, una para cada número.
Tipos definidos por el usuario
Además de los tipos estructurados básicos que acabamos de ver (cadenas y vectores) en Java existen infinidad de clases en la plataforma, y de terceros, para realizar casi cualquier operación o tarea que se pueda ocurrir: leer y escribir archivos, enviar correos electrónicos, ejecutar otras aplicaciones o crear cadenas de texto más especializadas, entre un millón de cosas más.
Todas esas clases son tipos estructurados también.
Y por supuesto puedes crear tus propias clases para hacer todo tipo de tareas o almacenar información. Serían tipos estructurados definidos por el usuario.
Tipos envoltorio o wrapper
Java cuenta con tipos de datos estructurados equivalentes a cada uno de los tipos primitivos que hemos visto.
Así, por ejemplo, para representar un entero de 32 bits (int) de los que hemos visto al principio, Java define una clase llamada Integer que representa y "envuelve" al mismo dato, pero le añade ciertos métodos y propiedades útiles por encima.
Además, otra de las finalidades de estos tipos "envoltorio" es facilitar el uso de esta clase de valores allí donde se espera un dato por referencia (un objeto) en lugar de un dato por valor (para entender la diferencia entre tipos por valor y tipos por referencia lee este artículo. Aunque está escrito para C#, todo lo explicado es igualmente válido para Java).
Estos tipos equivalentes a los primitivos, pero en forma de objetos son: Byte, Short, Integer, Long, Float, Double, Boolean y Character (8 igualmente).
A continuación, te dejamos un esquema resumen de todo lo anterior para facilitarte que lo "digieras" viéndolo ya ordenado:
Variables
¿Qué es una Variable?
Una variable es el nombre dado a una ubicación de memoria. Es la unidad básica de almacenamiento en un programa. El valor almacenado en una variable se puede cambiar durante la ejecución del programa.
En Java, todas las variables deben declararse antes de que puedan ser utilizadas.
×El valor almacenado puede cambiarse (variar) a medida que el programa ejecuta sus instrucciones, de ahí el término “variable“.
¿Cómo declarar variables?
Podemos declarar las variables en Java de la siguiente manera:
Cómo declarar variables en Java
· tipo de dato: tipo de datos que se pueden almacenar en esta variable.
· nombre_variable: nombre dado a la variable.
· valor: es el valor inicial almacenado en la variable.
Ejemplos:
float simpleInterest; //Declarando variable float
int time = 10, speed = 20; //Declarando e Inicializando la variable integer
char var = 'h'; // Declarando e Inicializando la variable character
Por ejemplo, el tipo de dato String se puede especificar para permitir que una variable llamada “mensaje” contenga texto con esta declaración:
String mensaje;
class PrimeraVariable
{
public static void main ( String[] args ) { 
String mensaje = "Valor inicial";
System.out.println(mensaje);
mensaje = "Valor modificado" ;
System.out.println(mensaje);
}
}
Salida:
Valor inicial
Valor modificado
Los nombres de variables también deben evitar las palabras clave de Java, ya que tienen un significado especial en el lenguaje Java.
· Lista de palabras reservadas en Java
Tipos de variables
Hay tres tipos de variables en Java:
· Variables locales
· Variables de instancia
· Variables estáticas
Sirven para referirse tanto a objetos como a tipos primitivos.
Tienen que declararse antes de usarse:
tipo identificador;
int posicion;
Se puede inicializar mediante una asignación:
tipo identificador = valor;
int posicion = 0;
Definición de constantes: 
			static final float PI = 3.14159f;
Ahora aprendamos sobre cada una de estas variables en detalle.
Variables locales
Una variable definida dentro de un bloque, método o constructor se llama variable local.
· Estas variables se crean cuando el bloque ingresado o método se llama y destruye después de salir del bloque o cuando la llamada regresa del método.
· El alcance de estas variables solo existe dentro del bloque en el que se declara la variable, es decir, podemos acceder a estas variables solo dentro de ese bloque.
Ejemplo 1:
public class StudentDetails
{
public void StudentAge() 
{ //variable local age
int age = 0;
age = age + 5;
System.out.println("La edad del estudiante es : " + age);
}
public static void main(String args[])
{
StudentDetails obj = new StudentDetails();
obj.StudentAge();
}
}
Salida:
La edad del estudiante es: 5
En el programa anterior, la variable age (edad) es una variable local para el método. Si usamos la variable agefuera del método, el compilador producirá un error como se muestra a continuación en el programa.
Ejemplo 2:
public class StudentDetails
{
public void StudentAge() 
{ //variable local age
int age = 0;
age = age + 5;
}
public static void main(String args[]) 
{ 
//utilizando la variable local age fuera de su alcance
System.out.println("La edad del estudiante es : " + age);
}
Salida:
error: cannot find symbol
 " + age);
Variables de instancia
Las variables de instancia son variables no estáticas y se declaran en una clase fuera de cualquier método, constructor o bloque.
· Como las variables de instancia se declaran en una clase, estas variables se crean cuando un objeto de la clase se crea y se destruye cuando se destruye el objeto.
· A diferencia de las variables locales, podemos usar especificadores de acceso para variables de instancia. Si no especificamos ningún especificador de acceso, se utilizará el especificador de acceso predeterminado.
Ejemplo:
import java.io.*;
class Points
{ 
//Estas variables son variables de instancia.
//Estas variables están en una clase y no están dentro de ninguna función/método
int engPoints;
int mathsPoints;
int phyPoints;
}
class PointsDemo
{
public static void main(String args[])
{ //primer objeto
Points obj1 = new Points();
obj1.engPoints = 50;
obj1.mathsPoints = 80;
obj1.phyPoints = 90;
//segundo objeto
Points obj2 = new Points();
obj2.engPoints = 80;
obj2.mathsPoints = 60;
obj2.phyPoints = 85;
//mostrando puntos para el primer objeto
System.out.println("Puntos para el primer objeto:");
System.out.println(obj1.engPoints);
System.out.println(obj1.mathsPoints);
System.out.println(obj1.phyPoints);
//mostrando puntos para el segundo objeto
System.out.println("Puntos para el segundo objeto:");
System.out.println(obj2.engPoints);
System.out.println(obj2.mathsPoints);
System.out.println(obj2.phyPoints);
}
}
Salida:
Puntos para el primer objeto:
50
80
90
Puntos para el segundo objeto:
80
60
85
Como puede ver en el programa anterior, las variables engPoints, mathsPoints, phyPoints; son variables de instancia. En caso de que tengamos varios objetos como en el programa anterior, cada objeto tendrá sus propias copias de variables de instancia. Del resultado anterior se desprende que cada objeto tendrá su propia copia de la variable de instancia.
Variables estáticas
Las variables estáticas también se conocen como variables de clase. 
· Estas variables se declaran de forma similar a las variables de instancia, la diferencia es que las variables estáticas se declaran utilizando la palabra clave dentro de una clase fuera de cualquier constructor o bloque de métodos.
· A diferencia de las variables de instancia, solo podemos tener una copia de una variable estática por clase, independientemente de cuántos objetos creemos.
· Las variables estáticas se crean al inicio de la ejecución del programa y se destruyen automáticamente cuando finaliza la ejecución.
Para acceder a variables estáticas, no necesitamos crear ningún objeto de esa clase, simplemente podemos acceder a la variable como:
nombre_clase.nombre_variable;
Ejemplo:
import java.io.*;
class Emp {
// salario como variable estatica
public static double salary;
public static String name = "Alex";
}
public class EmpDemo
{
public static void main(String args[]) {
//acceder a la variable estatica sin objeto 
Emp.salary = 1000;
System.out.println(Emp.name + " tiene un salario promedio de: " + Emp.salary);
}
}
Salida:
Alex tiene un salario promedio de: 1000.0
Variable de instancia vs Variable estática
· Cada objeto tendrá su propia copia de la variable de instancia, mientras que solo podemos tener una copia de una variable estática por clase, independientemente de cuántos objetos creemos.
· Los cambios realizados en una variable de instancia utilizando un objeto no se reflejarán en otros objetos, ya que cada objeto tiene su propia copia de la variable de instancia. En caso de estática, los cambios se reflejarán en otros objetos ya que las variables estáticas son comunes a todos los objetos de una clase.
· Podemos acceder a variables de instancia a través de referencias de objetos y se puede acceder directamente a las variables estáticas usando el nombre de clase.
En resumen, la sintaxis para variables estáticas y de instancia es:
class Example
{
static int a; //variable estatica
int b; //variable de instancia
}
Creando constantes
La palabra clave “final” es un modificador que se puede usar al declarar variables para evitar cualquier cambio posterior en los valores que inicialmente se les asignaron.
Esto es útil cuando se almacena un valor fijo en un programa para evitar que se altere accidentalmente.
Las variables creadas para almacenar valores fijos de esta manera se conocen como “constantes“, y es convencional nombrar constantes con todos los caracteres en mayúsculas, para distinguirlas de las variables regulares. Los programas que intentan cambiar un valor constante no se compilarán, y el compilador javac generará un mensaje de error.
Ejemplo:
class Constants
{
public static void main ( String[] args ) { 
//inicializamos tres constantes enteras
final int CONSTANTE1 = 6 ;
final int CONSTANTE2 = 1 ;
final int CONSTANTE3 = 3 ;
//declaramos variables regulares del tipo int
int td,pat,fg,total;
//Inicializamos las variables regulares
td = 4*CONSTANTE1;
pat = 3*CONSTANTE2;
fg = 2*CONSTANTE3; 
total = (td+pat+fg) ;
System.out.println("Resultado: " + total);
}
}
Salida:
Resultado: 33
×Nota: El carácter * significa una multiplicación. No se preocupe de momento, a continuación, en este enlace, conocerá todos los Operadores en Java.
Expresiones
Una expresión es un conjunto de variables, operadores e invocaciones de métodos que se construyen para poder ser evaluadas retornando un resultado.
Ejemplos de expresiones son:
int valor = 1;
if (valor 1 > valor2) { ... }
Cuando tengamos expresiones de evaluación complejas es recomendable que utilicemos paréntesis para saber cual es el orden de ejecución de operaciones.
Ya que si tenemos una expresión como
2 + 10 / 5
No será la misma si ponemos
(2 + 10) / 5
ó
2 + (10 / 5)
En el caso de no utilizar paréntesis se ejecutará el orden de preferencia de operadores. En este caso la división tiene más preferencia que la suma.
Sentencias
Una sentencia es la unidad mínima de ejecución de un programa. Un programa se compone de conjunto de sentencias que acaban resolviendo un problema. Al final de cada una de las sentencias encontraremos un punto y coma (;).
Tenemos los siguientes tipos de sentencias.
Sentencias de declaración
int valor = 2;
Sentencias de asignación
valor = 2;
Sentencias de incremento o decremento
valor++;
Invocaciones a métodos
System.out.println("Hola Mundo");
Creaciones de objetos
Circulo miCirculo = new Circulo(2,3);
Sentencias de control de flujo
if (valor>1) { … }
Bloques
Un bloque es un conjunto de sentencias los cuales están delimitados por llaves.
if (expresion) {
 // Bloque 1
} else {
 // Bloque 2
}
Tema 5. Definición de una clase: atributos y métodos.
Concepto de Clase
Casi todo lo que nos rodea o que conocemos puede formar parte de una Clase. Una Clase agrupa una serie de características y acciones comunes de un determinado elemento u objeto de aplicación. El molde para hacer jarrones seria una Clase y un jarrón hecho con ese molde sería un objeto. Un tipo de marca de coche seria la clase y un coche de esa marca seria el objeto. Cuando hablemos de los objetos, se entenderá mejor el concepto de clase, aún así es un concepto que no entraña demasiada dificultad de entender.
 	
Definición de una clase.
Para definir una clase se antepone la palabra reservada class seguida del nombre de la misma que por convención a de tener  la primera letra del nombre en Mayúscula. Una clase se define atendiendo al siguiente modelo:
class MiPrimeraClase {
 // Variables miembro de la Clase.(Variables, constantes, etc)
 // Método o métodos constructores. 
 // Otros métodos 
}
 En esta definición se puede apreciar que una clase engloba todos sus componentes y miembros entre corchetes.En la declaración o encabezado de la clase se ha omitido el tipo de modificador de acceso que antepone a la palabra class, así como otros conceptos que explicaremos de forma breve en el siguiente apartado. Como adelanto decir que Java asigna el modificador public por defecto cuando este lo hemos omitido en nuestra declaración de la clase.
Componentes de una Clase.
Una clase consta en su cabecera de la palabra class que indica que se esta definiendo una clase, del nombre de la clase a definir atendiendo a las convenciones o nomenclatura anteriormente señalada y tal como hemos adelantado en el apartado anterior también tenemos modificadores de acceso que explicaremos a continuación y otras palabras reservadas que se utilizan para indicar si la clase hereda de otra clase (superclase o clase Madre), si implementa algún tipo de interfaz, si es una clase Abstracta, etc.
De momento para seguir un sistema de aprendizaje progresivo y fácil de asimilar solo hablaremos de los tipos de modificadores, de las variables miembro de la clase, de las variables locales y de los métodos de la clase que podemos encontrar.
Modificadores de acceso: public, private, protected.
Un modificador de acceso tal y como se puede intuir por su propio nombre, regulan el acceso a los distintos campos o miembros de una clase, así como a la misma clase que contenga dicho modificador en su definición. Dicho esto, tenemos que:
· El modificador public es de ámbito público, es decir se puede acceder a un miembro de la clase (atributo, método) con dicho modificador desde cualquier clase.
· El modificador private al contrario que el anterior es de ámbito privado, es decir solo se puede acceder a un miembro de la clase desde la misma clase.
· El modificador protected es de ámbito de paquete, es decir se puede acceder a un miembro de la clase (atributo, método) con dicho modificador desde cualquier clase del mismo paquete.
Ejemplo con modificadores:
package A;
 public class Clase_A {
 public String nombre; 
 private String telefono; 
 protected String ciudad;
 public static void main(String[] args) {
 System.out.println("Nombre: "+nombre);
 System.out.println("telefono: "+telefono);
 System.out.println("Ciudad: "+ciudad);
 }
 }
-----------------------------------------------------------
package A;
 public class Clase_B {
 public static void main(String[] args) {
 System.out.println("Nombre: "+nombre);
 System.out.println("Ciudad: "+ciudad);
 }
 }
---------------------------------------------------------
package B;
 public class Clase_C {
 public static void main(String[] args) {
 System.out.println("Nombre: "+nombre);
 }
 }
 Según el ejemplo, vemos que en la clase «Clase_A» del paquete «A» se declaran los atributos nombre, telefono y ciudad. De acuerdo a las caracteristicas de cada modificador, desde esta clase se puede acceder a todos los atributos.
Desde la clase «Class_B» del mismo paquete «A» solo podemos acceder al atributo public «nombre» y al atributo protected «ciudad».
Y por último desde la clase «Class_C» del paquete «B» tan solo tendriamos acceso al atributo público «nombre», siempre y cuando hubiésemos importado la clase «Clase_A» al paquete B utilizando la sentencia import que veremos cuando realicemos algún programa en el entorno de desarrollo elegido ya sea NETBEANS o ECLIPSE.
Atributos o miembros de Clase.
En el cuerpo de una Clase podemos encontrar principalmente atributos, campos o variables de clase, también llamadas estas últimas variables globales. Sobre las variables ya comentamos bastante en la primera parte del curso Java básico y que podéis repasar en estas dos páginas tipos primitivos y declaración de variables. Solamente vuelvo a recordar la diferencia entre variables globales o de clase y las variables locales cuyo ámbito seria el cuerpo de un método en particular.
package A;
  public class Clase_A {  
            public String nombre; //Atributo Global
      public static void main(String[] args) { 
           String nombre; //Atributo local. 
                         // Al ser local no se añade modificador.
                  System.out.println("Nombre: "+nombre);
     }     
  }
 Aparte de variables globales y locales una clase puede tener declaración o instancias de clase (Objetos), que en definitiva es la pieza principal del lenguaje Java. Sobre los Objetos hablaremos a continuación.
1.2.5. Modificadores de acceso.
Los modificadores de acceso de clases, propiedades y métodos en Java
Uno de los principios básicos de los lenguajes orientados a objetos es la encapsulación, mediante la cual se garantiza que los datos de una clase solo son modificados por las operaciones apropiadas implementadas en los métodos de sus clases para preservar su invariante, las reglas que define la clase y el estado consistente de su estado.
El acceso a las propiedades y métodos se determina mediante las palabras reservadas de los modificadores de acceso, en Java hay cuatro modificadores de acceso que definen ámbitos de visibilidad de más restrictivos a menos restrictivos:
· private: únicamente la clase puede acceder a la propiedad o método.
· 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.
· protected: las clases del mismo paquete y que heredan de la clase pueden acceder a la propiedad o método.
· public: la propiedad o método es accesible desde cualquier método de otra clase.
Las clases tienen uno de los modificadores de acceso public o package private con el mismo significado que en las propiedades y métodos, visibles desde cualquier otro paquete y solo visible desde su propio paquete.
Los modificadores de acceso son una palabra reservada del lenguaje y se colocan delante de la propiedad o método, el modificador de acceso package private no tiene palabra reservada se aplica en caso de que no se especifique un modificador de acceso explícitamente.
package io.github.picodotdev.blogbitix;
public class Foo {
 private String property1;
 String property2;
 protected String property3;
 public property4;
 public String getProperty1() {
 return this.format;
 }
 String getProperty2() {
 return property2;
 }
 protected String getProperty3() {
 return property3;
 }
 private String getProperty4() {
 return property4;
 }
}
Los ámbitos de visibilidad según el modificador de acceso y el origen de acceso a la propiedad o método son los siguientes.
	Modificador de acceso
	Misma clase o anidada
	Clase en el mismo paquete
	Clase que hereda en otro paquete
	Clase que no hereda en otro paquete
	private
	Sí
	No
	No
	No
	default (package private)
	Sí
	Sí
	No
	No
	protected
	Sí
	Sí
	Sí
	No
	public
	Sí
	Sí
	Sí
	Sí
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. En esencia es la misma información de la tabla, pero representada de forma gráfica.
Un detalle a tener en cuenta es que los modificadores afectan a las clases, una propiedad privada de una clase es accesible para todas las instancias de esa clase. En concreto, este código es válido y el resultado es two, bar1 puede acceder a la propiedad thing de la instancia bar2 aún siendo privada en la clase.
package io.github.picodotdev.blogbitix;
public class Bar {
 private String thing;
 public void Bar(String thing) {
 this.thing = thing;
 }
 public String getOtherThing(Bar other) {
 return other.thing;
 }
 public static void main(String[] args) {
 Bar bar1 = new Bar("one");
 Bar bar2 = new Bar("two");
 String thing = bar1.getOtherThing(bar2);System.out.println(thing);
 }
}
No hay encapsulación entre las instancias de la misma clase, la encapsulación es para la clase accedida desde otras clases según los modificadores de acceso. 
1.2.6. Alcance de las variables.
Los parámetros de un método en una clase son conocidos como variables temporales. El valor y el nombre de estas variables expiran cuando el método llamado regresa el control al código que lo invocó. Cualquier variable definida en la lista de parámetros del método o dentro del cuerpo del método permanecen en memoria sólo lo que dura en ejecutarse el método llamado.
En java existen cuatro tipos de variables:
· Variables de Instancia (Campos No-Estáticos). Los objetos almacenan su estado individual en campos no-estáticos. Son declarados sin la palabra clave static. Sus valores son únicos para cada instancia u objeto.
· Variables de Clase (Campos Estáticos). Son campos declarados con el modificador static. Hay sólo una copia de esta variable para todas las instancias de la clase.
· Variables Locales. Es en donde los métodos de los objetos almacenan su estado temporal. Se declaran parecido a los campos. No existe una palabra clave para especificar que una variable es local, sino que depende donde la variable es declarada: dentro de los corchetes que definen un método. Son accesibles sólo dentro del método que las declaró y no son accesibles del resto de la clase.
· Parámetros. Son las variables que conforman la firma de un método. Son siempre clasificados como variables y no como campos. También se encuentran en otras construcciones que aceptan parámetros como los son los constructores y manipuladores de excepciones.
Llamaremos campos a las variables de instancia y de clase. Llamaremos variables a las anteriores más las locales y parámetros. Un campo o field está disponible en memoria el tiempo que el objeto que la contiene permanezca en memoria. En java una variable local debe de ser declarada antes de ser usada.
El alcance de los parámetros en un método, es todo el método completo. Las variables declaradas en la parte inicial de un ciclo for es el ciclo entero. Se puede declarar varias veces una variable local con el mismo nombre dentro de bloques no anidados dentro de un mismo método, pero es inválido declarar la variable local en bloques anidados.
1.2.7. Constructores.
Qué es un constructor en Java
Un constructor inicializa un objeto cuando se crea. Tiene el mismo nombre que su clase y es sintácticamente similar a un método. Sin embargo, los constructores no tienen un tipo de devolución explícito. Normalmente, usará un constructor para dar valores iniciales a las variables de instancia definidas por la clase, o para realizar cualquier otro procedimiento de inicio requerido para crear un objeto completamente formado.
Todas las clases tienen constructores, ya sea que usted defina uno o no, porque Java proporciona automáticamente un constructor predeterminado. En este caso, las variables de miembro no inicializadas tienen sus valores predeterminados, que son cero, null y false, para tipos numéricos, tipos de referencia y booleanos, respectivamente. Una vez que defines tu propio constructor, el constructor predeterminado ya no se usa.
Aquí hay un ejemplo simple que usa un constructor:
//Un ejemplo siemple de constructor
class MiClase {
int x;
MiClase(){
x=10;
}
}
class ConstructorDemo {
public static void main(String[] args) {
MiClase t1= new MiClase();
MiClase t2= new MiClase();
System.out.println(t1.x + " - "+t2.x);
}
}
En este ejemplo, el constructor de MiClase es:
MiClase(){
 x=10;
 }
Este constructor asigna a la variable de instancia x de MiClase el valor de 10. Este constructor es llamado por new cuando se crea un objeto. Por ejemplo, en la línea:
MiClase t1= new MiClase();
El constructor MiClase() es llamado en el objeto t1, dando a t1.x el valor de 10. Lo mismo es cierto para t2. Después de la construcción, t2.x tiene el valor de 10. Por lo tanto, el resultado del programa es:
Salida:
10 - 10
Constructores parametrizados
En el ejemplo anterior, se utilizó un constructor sin parámetros. Aunque esto está bien para algunas situaciones, la mayoría de las veces necesitará un constructor que acepte uno o más parámetros.
Los parámetros se agregan a un constructor de la misma manera que se agregan a un método: simplemente declararlos dentro del paréntesis después del nombre del constructor. Por ejemplo, aquí, MiClase tiene un constructor parametrizado:
//Un ejemplo de constructor parametrizado
class MiClase {
int x;
MiClase(int i){
x=i;
}
}
class ConstructorDemo {
public static void main(String[] args) {
MiClase t1= new MiClase(15);
MiClase t2= new MiClase(28);
System.out.println(t1.x + " - "+t2.x);
}
}
La salida de este programa es:
15 - 28
En esta versión del programa, el constructor MiClase() define un parámetro llamado i, que se usa para inicializar la variable de instancia, x. Por lo tanto, cuando la línea:
MiClase t1= new MiClase(15);
se ejecuta, el valor 10 pasa a i, que luego se asigna a x.
Ejemplo de Constructor en Java
Siguiendo nuestro ejemplo anterior, vamos a agregar un constructor a la clase Vehiculo:
//Un ejemplo de constructor
class Vehiculo {
int pasajeros; //números de pasajeros
int capacidad; //capacidad del combustible en galones
int mpg; //combustible consumido en miles por galon
//Esto es un constructor para Vehiculo
Vehiculo (int p, int c, int m) {
pasajeros=p;
capacidad=c;
mpg=m;
}
//Retornando el rango
int rango(){
return mpg*capacidad;
}
//Calcular el combustible necesario para una distancia dada
double capacidadnueva(int miles){
return (double)miles/mpg;
}
}
class DemoVehiculo {
public static void main(String[] args) {
Vehiculo minivan = new Vehiculo(9,15,20);
Vehiculo sportscar = new Vehiculo(10,25,30);
double galones;
int distancia = 250;
galones=minivan.capacidadnueva(distancia);
System.out.println("Para ir a "+distancia+" en minivan, se necesita "+galones+" galones");
galones=sportscar.capacidadnueva(distancia);
System.out.println("Para ir a "+distancia+" en sportscar, se necesita "+galones+" galones");
}
}
Salida:
Para ir a 250 en minivan, se necesita 12.5 galones
Para ir a 250 en sportscar, se necesita 8.333333333333334 galones
Ambos, minivan y sportscar, son inicializados por el constructor Vehiculo() cuando se crean. Cada objeto se inicializa como se especifica en los parámetros para el constructor. Por ejemplo, en la siguiente línea,
Vehiculo minivan = new Vehiculo(9,15,20);
los valores 9,15,20 se pasan al constructor Vehiculo() cuando new crea el objeto. Por lo tanto, la copia de pasajeros, capacidad y mpg de minivan contendrá los valores 9,15,20, respectivamente. El resultado de este programa es el mismo que la versión anterior.
1.2.8. Librerias
Uso de librerías en Java. 
Importar librerías estándar de Java y librerías propias. Importar paquetes
Librerías en Java. Importar paquetes y librerías, crea tus propios paquetes y aprende a importarlos fácilmente. Uso de import en java. En Java y en varios lenguajes de programación más, existe el concepto de librerías. Una librería en Java se puede entender como un conjunto de clases, que poseen una serie de métodos y atributos. Lo realmente interesante de estas librerías para Java es que facilitan muchas operaciones. De una forma más completa, las librerías en Java nos permiten reutilizar código, es decir que podemos hacer uso de los métodos, clases y atributos que componen la librería evitando así tener que implementar nosotros mismos esas funcionalidades.
Imaginemos cómo hacer un código para conseguir que nuestra aplicación imprima algo por pantalla o conseguir que nuestra aplicación pueda hacer uso de arreglos dinámicos con cualquier tipo de dato. Por medio de librerías, para imprimir texto en pantalla en Java basta con usar System.out.print() y se puede hacer uso de ArrayList, para tener arreglos dinámicos y demás, en Java, esto es así de fácil y todo es gracias a las librerías, la clase System que pertenece a la librería java.lang (ésta es la librería estándar de Java y no es necesarioimportarla). Ocurre de la misma forma con el ArralyList, no podríamos hacer uso de éste si no existiera la librería java.util. Cabe mencionar que estas librerías no solo poseen estas clases, sino que poseen una gran cantidad de clases Java adicionales que nos permiten llevar a cabo operaciones muy complejas con gran facilidad.
Lo más interesante de las librerías en Java, es que nosotros también podemos crearlas y hacer uso de ellas al interior de nuestros proyectos. Básicamente un paquete en Java puede ser una librería, sin embargo una librería Java completa puede estar conformada por muchos paquetes más. Al importar un paquete podemos hacer uso de las clases, métodos y atributos que lo conforman, así que eso de las librerías no es solo trabajo de otros sino que podemos crear nuestras propias librerías y usarlas, incluso podemos hacer uso de un proyecto completo nuestro al interior de otro (así de genial es esto).
Import en Java (importar librerías en Java)
Hacer uso de librerías tanto propias como externas, o librerías propias de Java, es bastante fácil. Básicamente lo único que debemos saber es que para importar librerías en Java se usa la palabra clave import seguido de la "ruta" del paquete o clase que deseamos agregar al proyecto. Cabe resaltar que el import permite agregar a nuestro proyecto una o varias clases (paquete) según lo necesitemos. Para comprender y usar correctamente el import de Java, retomaremos los ejemplos dados en la sección de paquetes.
Ejemplo de import en Java
Vamos a suponer que al interior de nuestro proyecto hemos creado cuatro clases diferentes en paquetes diferentes, cada clase se llamará "Clase_1", "Clase_2", "Clase_3" y "Clase_4" respectivamente.
En la imagen de abajo se puede apreciar la estructura de los paquetes de cada una de las cuatro clases de Java. Veamos con detalle esto para quedar claros.
La clase número uno fue declarada en un el paquete "mis_clases.clases_publicas.clase_1" por lo tanto quedará al interior de una carpeta llamada "clase_1" la cual estará al interior de otra carpeta llamada "clases_publicas" y esta a su vez estará dentro de la carpeta llamada "mis_clases". La clase número dos se le declaró el paquete "mis_clases.clase_2" por lo tanto ha quedado al interior de una carpeta llamada "clase_2" la cual a su vez está al interior de la carpeta "mis_clases". A la clase número tres se le impuso el paquete "mis_clases", esto indica que esta estará al interior de la carpeta "mis_clases". Por último, la clase número cuatro no tiene declarado ningún paquete por lo tanto el paquete asignado será el paquete por defecto, en otras palabras, esta clase se mantendrá siempre en la carpeta raíz del proyecto (en netbeans y eclipse la carpeta raíz se llama src).
Antes de importar en Java...
Al igual que sucede con la declaración de los paquetes, realizar el import en Java también tiene una localización especifica al interior del archivo java. La importación de librerías y demás siempre debe ir después de la declaración del paquete, si la clase no posee alguna declaración de paquete (pertenece al paquete por defecto), entonces los import deberán estar en las primeras líneas del archivo.
Ejemplo 1: Sintaxis para import en Java
package paquete.mipaquete;
import paquete2.otropaquete.*;
class Ejemplo1{}
En el código anterior básicamente estamos diciendo que la clase contenida en el archivo Java, estará en el paquete "paquete/mipaquete", es decir, esa será la ruta de acceso a esa clase en el proyecto. En la siguiente línea hemos realizado el import de un paquete. Por medio del "*" hemos indicado a Java que queremos importar todas las clases pertenecientes a dicho paquete, puede ser una o más.
Ejemplo 2: Sintaxis para import en Java
package paquete.mipaquete;
import paquete3.otropaquete2.MiClase;
class Ejemplo2{}
En el código anterior hemos usado el mismo paquete para la clase pero hay una pequeña diferencia al momento del import, en esta ocasión hemos importado una clase directamente (MiClase), es decir, como no usamos el "*" no hemos importado todas las clases pertenecientes al paquete "paquete3.otropaquete2" sino que solo hemos importado a "MiClase"
Ejemplo 3: Sintaxis para import en Java
import paquete.mipaquete.*;
class Ejemplo3{}
En esta ocasión se puede apreciar que no hemos declarado paquete alguno para nuestra clase y que únicamente hemos realizado el import, sin embargo este import como tal es algo particular para nosotros, pues hemos importado TODAS las clases pertenecientes al paquete "paquete.mipaquete" que es el paquete al cual pertenecen las clases del ejemplo 1 y 2, esto quiere decir que al interior de la clase Ejemplo3, podemos usar las clases Ejemplo1 y Ejemplo2.
Importando clases de Java
Importar clases propias de Java es prácticamente igual que importar clases de nuestros propios paquetes, sin embargo, ¿cuáles son esas clases?, ¿cómo conocerlas?, ¿cuál es el paquete al que pertenecen?, pues bien, de una vez te comento que Java está conformado por una enorme cantidad de clases y paquetes y desde mi punto de vista creo que es bastante complejo conocerlas todas, aunque si es importante conocer las más comunes y útiles, básicamente lo que debes hacer es ingresar a la API de Java y allí encontrarás todas las clases que componen el lenguaje, el paquete al que pertenecen, los métodos que poseen, los atributos y una breve explicación de cada uno de estos. Si ingresas a la documentación de Java verás que por ejemplo existe una clase llamada ArrayList, ésta pertenece al paquete java.util, esto quiere decir que para importarla debemos usar esa dirección, veamos:
Ejemplo 4: Importando clases de Java
import java.util.ArrayList;
class Ejemplo4{}
Aquí hemos importado la clase ArrayList y podremos hacer uso de sus componentes, siempre y cuando sean públicos (más adelante hablaremos de esto). Hay otra forma de hacerlo, pero posee ciertos inconvenientes:
Ejemplo 5: Importando clases de Java
import java.util.*;
class Ejemplo5{}
Aqui hemos importado TODAS las clases pertenecientes al paquete "java.util" lo cual incluye la clase ArrayList y por lo tanto es funcional y válido, sin embargo esto es bastante ineficiente, pues estamos importando todas las clases que son aproximadamente 50 y que seguramente no usaremos. Veamos entonces cómo importar algunas clases propias de Java.
Ejemplo 6: Importando clases de Java
import java.util.ArrayList;
import java.io.* //importando clases para entrada y salida (IN OUT)
import java.math.* //clases utiles para operaciones y valores matematicos
class Ejemplo6{}
Como podrás ver, existen muchas librerías muy útiles y es bastante sencillo hacer uso de ellas cuando sea necesario y así ahorrarnos mucho tiempo, trabajo y esfuerzo.
Muy bien, hasta ahora hemos aprendido todo lo necesario acerca del import en Java, sabemos cómo importar nuestra propia clase, importar todas las clases de un paquete, también vimos que Java posee una API y que está conformada por una enorme cantidad de Clases, interfaces, excepciones, etc. y que en cualquier momento podemos hacer uso de cualquiera de estas.
1.2.9. Encapsulamiento: métodos getters y setters.
En encapsulamiento es un principio del lenguaje Java cuya filosofía es hacer que los atributos de las clases se puedan editar sólo a través de métodos. De manera general, se hace teniendo las propiedades como privadas y métodos que la controlan públicos. Comúnmente, se crean un grupo de métodos llamados getters (se encargan de obtener el valor de la propiedad) y setters (se encargan de setearla).
Mantener las clases con el principio de encapsulamiento nos permite controlar el cambio de valor que pueda producirse en ellas añadiendo validaciones. De cualquier manera, es una convención dentro de la programación orientada a objetos, aunque no se esté realizando una operación adicional al cambio de valor. Veamos un ejemplo:
public class Gato {
 public String nombre;
 public int patas;
}
 
//Mi método main...
Gato g = new Gato();
g.nombre = "Nemo";
g.patas = 4;
System.out.println("Mi gato se llama:" + g.nombre);
System.out.println("El número de patas de mi gato es: " + g.patas);
En este caso, no se ha aplicado el principio de encapsulamiento, por lo que cualquier otro desarrollador con visibilidad de nuestra clase, puede cambiar las propiedades del mismo tan sólo con acceder a ellas, de manera muy simple.
Veamos la misma clase, con el principio de encapsulamiento
public class Gato {
 private String nombre;
 private int patas;
 public getNombre(){ return nombre;}
 public getPatas(){ return patas;}
 public setNombre(String nuevoNombre){ nombre = nuevoNombre;}
 public setPatas(int numeroPatas){ patas = numeroPatas;}
}
//Mi método main...
Gato g = new Gato();
g.setNombre("Nemo");
g.setPatas(3);
System.out.println("Mi gato se llama: " + g.getNombre());
System.out.println("El número de patas de mi gato es: " + g.getPatas());
Tras aplicar el principio de encapsulamiento, ya no tenemos acceso a las propiedades directamente, por lo que tenemos que usar los métodos (que son públicos y sí tenemos acceso a ellos) para poder acceder a las variables, tanto para modificarlas como para obtenerlas. El comportamiento es el mismo, aunque lleve un código adicional
¿Por qué debemos aplicar el principio de encapsulamiento?
Por mantenibilidad, estabilidad y seguridad principalmente. Un segundo equipo va a usar nuestra aplicación y por tanto nuestras clases. Nosotros conocemos perfectamente la funcionalidad, y entre todas las cosas que sabemos y asumimos, una de ellas es que los gatos no tienen más de 4 patas (o menos de 0). Pero sin embargo, según la estructura del lenguaje Java, no hay nada que no impida a un desarrollador hacer esto (No con nuestra clase actual):
	
g.setPatas(10);
g.setPatas(-50); 
Por lo tanto, se nos ocurre, actualizar el método «setPatas» de nuestra clase Gato para que quede así:
public void setPatas(int numeroPatas){
 if(numeroPatas>=0 && numeroPatas<5){
 patas = numeroPatas;
 } else {
 throw new IllegalArgumentException("Número de patas no válido");
 }
}
Con esta actualización del método, el segundo (tercer, cuarto, quinto..) equipo que use nuestra clase gato, no va a variar su código (estabilidad) , seguirá llamando al método setPatas (mantenibilidad), y nosotros controlaremos que el número sea entre 0 y 4 (seguridad). Si volvemos a la primera versión de la clase, no nos permitiría añadir este tipo de controles a posteriori sin hacer cambiar todos los usos de nuestra clase.
Get y set
Los métodos get y set, son simples métodos que usamos en las clases para mostrar (get) o modificar (set) el valor de un atributo. El nombre del método siempre sera get o set y a continuación el nombre del atributo, su modificador siempre es public ya que queremos mostrar o modificar desde fuera la clase. Por ejemplo, getNombre o setNombre.
Esta es la sintaxis de cada uno:
public tipo_dato_atributo getAtributo (){
 return atributo;
}
public void setAtributo (tipo_dato_atributo variable){
 this.atributo = variable;
}
Si usamos Eclipse tenemos una manera aún mas sencilla de generarlos automáticamente. Pinchamos en Source -> Generate Getters and Setters, nos aparecerá una ventana donde elegiremos que atributos generar su get o set, al pinchar en OK nos lo generara automáticamente estos métodos.
Veamos un ejemplo:
Clase
//Clase Empleado
public class Empleado {
 //Atributos
 private String nombre;
 private String apellido;
 private int edad;
 private double salario;
 
 //Metodos publicos
 public String getNombre() {
 return nombre;
 }
 //Modifica el nombre de un empleado
 public void setNombre(String nombre) {
 this.nombre = nombre;
 }
 
 //Devuelve la edad de un empleado
 public int getEdad() {
 return edad;
 }
 
 //Modifica la edad de un empleado
 public void setEdad(int edad) {
 this.edad = edad;
 }
 
 //Devuelve el salario de un empleado
 public double getSalario() {
 return salario;
 }
 
 //Suma un plus al salario del empleado si el empleado tiene mas de 40 años
 public boolean plus (double sueldoPlus){
 boolean aumento=false;
 if (edad>40 && compruebaNombre()){
 salario+=sueldoPlus;
 aumento=true;
 }
 return aumento;
 }
 
 //Metodos privados
 private boolean compruebaNombre(){
 if(nombre.equals("")){
 return false;
 }
 return true;
 }
 //Constructor
 public Empleado(){
 this.nombre="";
 this.apellido="";
 this.edad=0;
 this.salario=0;
 }
 
 //Constructor con 4 parametros
 public Empleado(String nombre, String apellido, int edad, double salario){
 this.nombre=nombre;
 this.apellido=apellido;
 this.edad=edad;
 this.salario=salario;
 }
} 
Clase ejecutable
public class EmpleadoApp {
 public static void main(String[] args) {
 Empleado empleado1=new Empleado ("Fernando", "Ureña", 23, 800);
 Empleado empleado2=new Empleado ("", "Lopez", 50 ,1800);
 //Mostramos el valor actual del salario del empleado1
 System.out.println("El salario del empleado1 es "+empleado1.getSalario());
 
 //Modificamos la edad del empleado1
 empleado1.setEdad(43);
 empleado1.plus(100);
 //Mostramos el salario de nuevo, ahora tendra 100 mas
 System.out.println("El salario actual del empleado1 es "+empleado1.getSalario());
 
 //Modificamos el nombre del empleado2
 empleado2.setNombre("Antonio");
 empleado2.plus(100);
 //Mostramos el salario de nuevo, ahora tendra 100 mas
 System.out.println("El salario del empleado2 es "+empleado2.getSalario());
 }
 }
1.3. Guía Practica
a) Tema de guía: Constructores
Creación de atributos de la clase coche
b) Recursos:
· Internet
· Computadora
· Netbeans
c) Metodologia: 
Intenta definir una clase que represente un coche. En la definición debe incluir:
· el modelo,
· el color,
· si la pintura es metalizada o no,
· la matrícula,
· el tipo de coche, que puede ser MINI, UTILITARIO, FAMILIAR o DEPORTIVO,
· modalidad del seguro, que puede ser a TERCEROS o a TODO RIESGO.
d) Desarrollo o procedimiento:
Como puede hacerse
Al diseñar una clase, debes prestar atención a los atributos que se incluyen y sus tipos. Para los atributos hay que elegir nombres significativos, por ejemplo, modelo es un buen nombre para el atributo que representa el modelo del coche. Al elegir el tipo de un atributo, se debe pensar tanto en los valores que puede tomar, como en las operaciones que se van a a aplicar.
Para el modelo, el color y la matrícula, se elige el tipo String. Para determinar condiciones que se pueden cumplir o no, se debe elegir un boolean, como es el caso de si la pintura es metalizada o no.
Cuando un atributo puede tomar una serie de valores, lo más adecuado es utilizar un tipo enumerado, eligiendo los nombres adecuados para los diferentes valores.
Para el año de fabricación, se usa un número entero. Para los valores no legales o absurdos, queda a cargo del programador/a comprobarlo (no os preocupéis, que lo veremos en su momento).
e) Resultados:
Solución
enum Tipo_Coche {MINI, UTILITARIO, FAMILIAR,DEPORTIVO}
enum Seguro {A_TODO_RIESGO, CONTRA_TERCEROS}
public class Coche {
    String modelo;
    String color;
    Tipo_Coche tipo;
    boolean esMetalizado;
    String matricula;
    int anioFabricacion;
    Seguro seguro;
}
1.4. Evaluación 
¿Cuál es la descripción que crees que define mejor el concepto 'clase' en la programación orientada a objetos?
a) Es un concepto similar al de 'array'
b) Es un tipo particular de variable
c) Es un modelo o plantilla a partir de la cual creamos objetos
d) Es una categoria de datos ordenada secuencialmente
¿Qué significa instanciar una clase?
a) Duplicar una clase
b) Eliminar una clase
c) Crear un objeto a partir de la clase
d) Conectar dos clases entre sí
¿Qué elementos crees que definen a un objeto?
a) Sus cardinalidad y su tipo
b) Sus atributos y sus