NOTAS DE JAVA EN NETBEANS
Atajos de teclado en Netbeans para Java
Desplazar lineas seleccionadas……………………. Shift + Alt + (↑ o ↓)
Copiar lineas seleccionadas……………………. Ctrl + Shift + (↑ o ↓)
Zoom………………………………………………. Alt + Scroll
Sugerencias de autocompletado en Netbeans…….. Ctrl + Esp
Editar múltiples palabras a la vez…. SeleccionarPalabra + Ctrl + Shift + seleccionarPalabras
Comentarios
Comentar una linea o parte: Apartir de // (lo que viene despues) está comentado y no se ejecutará.
Comentar un bloque de lineas: Se abre con /* y a partir de aca todas las lineas siguientes estarán
comentadas …
… hasta que se cierre con */
Editar nombre de todas las variables con el mismo nombre:
Puedo ir donde declaré la variable, la selecciono, abro menú y elijo “Refactor”, “Rename”, cambio
el nombre y presiono “Refactor”.
Definir variables en Java
sintaxis:
tipo de dato nombreDeLaVariable;
; El punto y coma se usa como separador de linea en Java.
ej:
int edad;
double salario;
String nombreDeUsuario;
boolean esDeNoche;
Es posible declarar más de una variable de un mismo tipo en la misma linea:
tipo de dato var1, var2, …, varN;
ej:
String nombre, apellido;
Por convencion de nombres de variables se usa notacion lowerCamelCase (en minusculas y si hay
más de una palabra, se escriben sin espacios y todas empiezan con mayuscula excepto la primer
palabra)
Asignar valor a variable
sintaxis:
variable = valor;
Se puede declarar y luego por separado asignar un valor
int edad;
edad = 18;
Se puede declarar una variable e inicializarla en la misma linea de código.
int edad = 18;
Imprimir por pantalla en Java
Escribir sout y luego presionar la tecla tabulador, luego aparece
System.out.println(""); //Dentro de un bucle imprimirá con saltos de linea.
dentro del parentesis irá lo que ha de salir por pantalla (variables, texto entre comillas)
System.out.print(""); Dentro de un bucle imprimirá sin hacer saltos de linea.
Leer datos desde la consola
Para leer datos desde la consola en Java, se hace a través de un objeto Scanner.
Crear objeto de tipo Scanner:
Scanner input = new Scanner(System.in);
Para que funcione debo importar el paquete que trae la clase Scanner de Java. Para esto puedo hacer
clic en la lamparita que sale ai inicio de la linea y de ahi “add import for Java_util_Scanner”; o bien
puedo escribir al principio del fichero la siguiente linea
import java.util.Scanner;
ej.:
package nombreDelPackage;
import java.util.Scanner;
public class nombreDeLaClasePrincipal {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
int edad;
double estatura, salario;
}
}
int edad;
edad = input.nextInt();
// el metodo nextInt() permite leer un dato de tipo entero de la consola y devolverlo como entero.
double salario;
salario = input.nextDouble();
// el metodo nextDouble() permite leer un dato de tipo double de la consola y devolverlo como tipo
double.
boolean tieneHijos;
tieneHijos = input.nextBoolean();
// el metodo nextBoolean() permite leer un dato de tipo boolean de la consola y devolverlo como
tipo boolean.
String nombre;
nombre = input.nextLine();
//el metodo nextLine() permite leer un dato de tipo String de la consola y devolverlo como un
String.
char letra;
letra = input.nextLine(charAt(0));
// este metodo permite devolver el primer carácter como char.
Si el metodo nextLine() es usado después de un input.nextInt() o de un input.nextDouble(), debo
colocar un input.nextLine() en una linea previa.
double estatura;
estatura = Double.parseDouble(input.nextLine());
// lee una cadena de caracteres y la convierte en un double.
int edad;
edad = Integer.parseInt(input.nextLine()); //lee una cadena de caracteres y la convierte en double
Caracteres de escape
La barra invertida \ se usa para casos de ambigüedad.
Si quiero imprimir por pantalla la siguiente cita: Descartes dijo: “pienso, luego existo”.
Si escribo la cita dentro de las comillas quedaria del siguiente modo:
System.out.println("Descartes dijo: ”pienso, luego existo”.”);
System.out.println("Descartes dijo: \“pienso, luego existo\”.”);
La barra invertida lo que dice es que el carácter siguiente es de escape y no debe ser tenido en
cuenta por el código.
System.out.println("C:\Users\fulanito”);
System.out.println("C:\\Users\\fulanito”);
Puedo usar caracteres de escape para controlar el flujo de salida, por ej:
si ponemos:
System.out.println("UnoDosTres”);
Lo que se vería al correr el programa sería:
>UnoDosTres
\n provoca un salto de linea en el flujo de salida.
System.out.println("Uno\nDos\nTres”);
Lo que se vería al correr el programa sería:
>Uno
>Dos
>Tres
\t provoca un salto de tabulación.
Si escribimos:
System.out.println("Uno\tDos\tTres”);
Lo que se vería al correr el programa sería:
>Uno >Dos >Tres
\r
“harcodear” (Hard Code – Código duro) usar código duro, ej:
anioActual = 2024
Definir una constante
package nombreDelPackage;
import java.util.Scanner;
public class nombreDeLaClasePrincipal {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
int edad;
double estatura, salario;
}
}
Tema 1: Programación orientada a objetos en Java 1.Clases de objetos 2.Protección de miembros
3.Protección de clases 4.Inicialización y finalización 5.Creación de objetos 6.Trabajando con
objetos 7.Relaciones entre objetos 8.Clases anidadas e interiores 9.Autoreferencias 10.Aplicaciones
orientadas a objetos 11.Herencia 12.Adición, redefinición y anulación 13.Protección y herencia
14.Herencia múltiple 15.Polimorfismo 16.Ligadura dinámica 17.Información de clases en tiempo de
ejecución 18.Otros temas de interés en Java
Clases de objetos
Las clases de objetos representan conceptos o entidades significativos en un problema determinado.
Una clase describe las características comunes de un conjunto de objetos, mediante dos elementos:
• Atributos (o variables miembro, variables de clase). Describen el estado interno de cada
objeto
• Operaciones (o métodos, funciones miembro). Describen lo que se puede hacer con el
objeto, los servicios que proporciona
Durante la ejecución de la aplicación se producirá la instanciación de la clase, es decir, la creación
de los objetos que representan cada uno de los individuos con sus características propias, es decir,
valores específicos para sus atributos
La implementación de esta clase en Java se realizaría en un fichero con nombre Cuenta.java, y su
contenido sería el siguiente:
Los atributos pueden ser de cualquiera de los tipos básicos de Java: boolean, char, byte, short, int,
long, float y double, referencias a otros objetos o arrays de elementos de alguno de los tipos citados
En Java la implementación de las operaciones se realiza en el interior de la definición de la clase,
justo tras su declaración:
El acceso a los atributos de la clase desde la implementación de las operaciones se realiza de forma
directa
Los atributos u operaciones estáticas (static) son aquellos que pertenecen a la clase en sí, y no a los
objetos
De un atributo estático no se genera una copia por cada objeto que se crea. Existe una única copia
compartida por todos los objetos de la clase
Una operación estática únicamente puede acceder a miembros estáticos
El atributo nOp mantiene una cuenta global del número de operaciones realizadas en las cuentas del
banco, para la realización de estadísticas. La operación leerNOperaciones() permite leer este
contado
La operación eurosAPesetas() es una operación auxiliar de la clase Cuenta para ser usada cuando
sea necesaria una conversión de moneda
Protección de miembros de la clase
El principio de ocultación de información se plasma en los lenguajes OO en diversos mecanismos
de protección de los miembros de la clase.
UML permite asociar tres niveles de protección diferentes a cada miembro de la clase:
• Miembros públicos (+). Sin ningún tipo de protección especial
• Miembros privados (-). Inaccesibles desde el exterior de la clase
• Miembros protegidos (#). Similares a los privados aunque se permite su acceso desde las
clases descendientes
Las veremos más adelante, al estudiar el mecanismo de la herencia
En Java un miembro se etiqueta como público colocando el identificador public delante de su
declaración.
Para los miembros privados utilizaremos el identificador private
Los miembros no etiquetados son accesibles por parte de clases amigas.
En C++ y otros lenguajes OO las clases amigas a una dada pueden indicarse explícitamente.
En Java se consideran amigas todas aquellas que forman parte del mismo paquete.
Un fichero fuente java forma en sí un paquete y por tanto todas las clases incluidas en él son
amigas.
Las clases incluidas en varios ficheros fuente pueden agruparse en un único paquete indicando el
nombre de paquete al principio de cada fichero mediante el indicador package.
En este ejemplo, las clases Cuenta y Banco son amigas al pertenecer al mismo fichero fuente. El
acceso a los atributos de los objetos de la clase Cuenta almacenados en el vector interno de Banco
queda así garantizado. El atributo saldo puede mantenerse como privado puesto que existe una
operación que permite obtener su valor:
Atención: todas las clases que no se declaren como pertenecientes a ningún paquete de forma
explícita, pertenecen a un paquete “por defecto” y por tanto son amigas.
Un paquete crea un espacio de nombres propios. Esto significa que la clase pasa a tener como
prefijo el propio nombre del paquete. A la hora de utilizarla tenemos tres opciones:
• Utilizar su nombre completo: prueba.A
• Importar esa clase, para poder utilizarla sin el prefijo. Esto se indica al principio del código
fuente mediante import prueba.A
• Importar directamente todas las clases del paquete, que se usarían sin prefijo: import
prueba.*
Un paquete puede estar situado dentro de otro paquete formando estructuras jerárquicas.
Ejemplo:
miapp.prueba.A Java obliga a que exista una correspondencia entre la estructura de paquetes de una
clase y la estructura de directorios donde está situada.
La raiz de la estructura de directorios debe estar incluida en el classpath de Java (parámetro cp )
Las clases miapp.prueba.A, miapp.prueba.B y miapp.C deben estar en la siguiente estructura de
directorios:
Protección de clases
Por protección de clases entendemos un nivel superior de la ocultación de información, a nivel de
clases. Es decir, se trata de especificar que clases pueden ser utilizadas y cuales no, y por quién.
Dentro de un paquete, las clases son amigas y por tanto no existen restricciones respecto a la
utilización de una clase por las otras.
Sin embargo, desde el punto de vista del exterior, únicamente podrán ser utilizadas las clases
públicas del paquete, es decir, aquellas con el identificador public situado delante de su declaración
Atención: Java sólo permite una clase pública por fichero fuente, y el nombre de la clase y el
fichero deben coincidir obligatoriamente.
En nuestro ejemplo, si queremos que la clase Cuenta pueda ser utilizada desde el exterior del
fichero Cuenta.java deberemos declararla como pública.
Inicialización y finalización
La iniciación de los atributos de la clase se realiza en Java, al igual que en C++, mediante el uso de
constructores cuyo nombre coincide con el de la clase.
Java permite la sobrecarga de operaciones, por tanto se pueden definir varios constructores
posible para una clase siempre que se diferencien en la lista de argumentos
Si no se proporciona ningún constructor, Java proporciona automáticamente un constructor por
defecto, que no recibe argumentos y realiza una inicialización por defecto de los atributos.
Una vez implementado un constructor propio por parte del programador, Java elimina dicho
constructor, aunque puede ser definido nuevamente de manera explícita.
Naturalmente los constructores pueden ser marcados como públicos, privados, protegidos o con
acceso a nivel de paquete, lo que especificará quien puede crear objetos de esta clase y de que
manera.
Cuando finaliza el uso de un objeto, es frecuente la realización de ciertas tareas antes de su
destrucción, principalmente la liberación de la memoria solicitada durante su ejecución. Esto se
realiza en C++ y otros lenguajes OO en los denominados destructores.
Estos destructores son operaciones invocadas automáticamente justo antes de la destrucción del
objeto.
Sin embargo, en Java la liberación de memoria se realiza de manera automática por parte del
recolector de basura, por tanto la necesidad de este tipo de operaciones no existe en la mayor parte
de los casos.
Sin embargo sí puede ser necesario realizar alguna tarea no relacionada con la liberación de
memoria antes de la destrucción del objeto, como por ejemplo salvar el estado de la clase en un
fichero o base de datos.
Java permite introducir código para este fin implementando una operación pública especial
denominada finalize. Esta operación es invocada automáticamente antes de la destrucción del
objeto por parte del recolector de basura.
Siguiendo nuestro ejemplo, vamos asegurarnos de que el estado de una cuenta queda salvado en
disco antes de su destrucción, para poder ser recuperada posteriormente. Para ello introducimos el
código de escritura en fichero en la operación finalize de la clase Cuenta
Problema: no es posible saber con seguridad en que momento será invocada finalize, puesto que el
recolector de basura puede decidir su eliminación en un momento indeterminado, e incluso no ser
eliminado hasta el final de la ejecución de la aplicación.
Una posible solución es ordenar al recolector de basura que realice una limpieza de memoria
inmediata, para asegurar la finalización de los objetos. Esto se realiza mediante
Runtime.getRuntime().gc().
Por motivos de eficiencia, lo anterior es poco recomendable, sobre todo si se hace con frecuencia.
Una mejor opción es definir una operación ordinaria con este mismo propósito, a llamar de manera
explícita cuando haya finalizado el uso del objeto.
Introduciremos en la clase Cuenta una operación pública salvar en lugar de finalize, con la misma
implementación. Tras finalizar las operaciones sobre la cuenta, invocaremos a salvar para guardar
los cambios realizados
Creación de objetos
En Java los objetos se crean únicamente de forma dinámica. Para ello se utiliza el operador new, de
manera similar a C++.
Los objetos en Java se utilizan siempre a través de referencias. Las referencias son similares a los
punteros de C/C++, aunque su uso es mucho más sencillo.
Por tanto los pasos a seguir en la creación de un objeto son:
• Declarar una referencia a la clase
• Crear un objeto mediante el operador new invocando al constructor adecuado
• Conectar el objeto con la referencia
Casting o promocion de tipos
UpCasting o Generalizacion
Permite tener objetos de un determinado tipo pero tratarlos como si fueran de un tipo más alto en la
jerarquía de herencia.
Evita la repeticion de codigo redundante, ademas, abre el espectro para que esta clase más general
pueda tener el dia de manana muchas mas subclases sin tener que cambiar tanto codigo.
Consecuencias negativas: se ocultan las propiedades de los objetos que no están en todas las clases
que abarca la clase más general de las dadas. Es posible hacer el paso inverso (downcasting) para
“recuperar” lo especifico.
POLIMORFISMO
I. Ad-hoc
A. por sobrecarga
B. por coerción
II. Universal
A. …
B. por herencia
recorrer una coleccion:
1. mediante ciclo While
2. mediante ciclo for: necesito que el tipo de colección tenga metodos como size() o get(), que
permitan obtener un elemento por indice
ej.
for (int i = 0; i < listaTareas.size(); i++) {
System.out.println(listaTareas.get(i));
}
3. mediante ciclo for-each. No necesitamos conocer la estructura de la colección. Util en
colecciones que no permiten obtener un elemento por indice (como por ej HashSet).
Recorre todos los elementos de la colección y lo hace de uno en uno y de adelante atrás.
Desventajas: no se puede usar para recorrer de a dos en dos o de atrás para adelante.
for (Tarea tarea : listaTareas) {
System.out.println(tarea);
}
// declara temporalmente una variable llamada tarea de tipo Tarea que guarda una tarea y se
va actualizando de tarea a medida que recorre la coleccion listaTareas. Es decir, por cada
tarea (que va a guardar en la variable tarea de tipo Tarea declarada temporalmente) de la
coleccion listaTareas, hacer lo que esté dentro del bucle.
for (Object element : colection) {
……..
}
4. Mediante iterator.
Iteradores…. iterator
A la hora de trabajar con los ArrayList usamos los "Iteradores" (Iterator).
Sirven para recorrer los ArrayList y poder trabajar con ellos.
Los Iteradores solo tienen tres métodos que son
1. el "hasNext()" para comprobar que siguen quedando elementos en el iterador,
2. el "next()" para que nos de el siguiente elemento del iterador;
3. y el "remove()" que sirve para eliminar el elemento del ArrayList.
Previo importar:
import java.util.Iterator;
NombreClaseIterador<ClaseContenidaEnListaAIterar> nombreIterador = listaAIterar.iterator();
video: Polimorfismo en Java. Sobre escritura de métodos
Redefinir un método implicará que ante un mismo mensaje, haya un comportamiento diferente al
declarado en la superclase. Es decir, que ante un mismo mensaje, los objetos respondan de modos
diferentes.
Los objetos nacen en tiempo de ejecución por lo que el compilador no sabe aun hacia donde apunta
el parámetro ‘v’.
Recién en tiempo de ejecución es que Java enlazará el llamado al método y su definición respectiva.
Java deduce en tiempo de ejecución que ‘v’ apunta a una bicicleta eléctrica y por eso invoca al
encender de tal clase.
Para considerar a un método como sobrescrito debe respetar la firma tal como se declaró en la
superclase.
Override es una anotación que previene errores accidentales al sobrescribir.
Para que se pueda sobrescribir el metodo tiene que ser public.
INSTANCEOF (“… es una instancia de …”)
el operador instanceof devuelve un boolean
ej.
Auto a instanceof Vehiculo;
Cada vez que usamos el ‘instanceof’ estamos generando una relacion de dependencia con otra clase.
CLASE ABSTRACTA
Las clases abstractas no se pueden instanciar.
Cuando se define un metodo abstracto, se escribe solo su firma.
Un metodo abstracto no puede ser privado.
Si una clase define o hereda al menos un metodo abstracto, entonces deberá ser abstracta.
Una clase puede ser abstracta sin la necesidad de que contenga o herede métodos abstractos.
Si una clase no abstracta hereda un metodo abstracto, para que pueda compilar, debo o hacer
abstracta esta clase o bien sobrescribir el metodo abstracto heredado de la superclase siguiendo la
linea de jereaquia. Es decir, para que una clase no abstracta herede de una clase abstracta, sin tener
que volverla abstracta, debo sobrescribir los metodos abstractos heredados de la superclase
abstracta.
Plantear un metodo abstracto obliga a las subclases a que lo sobrescriban, es decir implementar el
metodo abstracto.Un metodo abstracto no puede ser final.
En UML las clases abstractas se escriben en itálica, y los metodos abstractos también van en itálica
pero toda la linea del metodo incluyendo.
Una clase abstracta no puede ser clase final, pues una clase final no puede tener herencia y la clase
abstracta es para plantear una generalizacion y que luego haya herencia.
FINAL
4 contextos de uso, la palabra final a nivel de
1. CONSTANTES
agregar la palabra final a una variable local
no permite ser modificado
final int MAX_VALOR = 10; //debo inicializar constante en la declaracion.
2. ATRIBUTOS
private final int numero; //se puede inicializar aquí o bien llega por parametro en el
constructor
no permite setter
3. CLASES
public final class Vehiculo {
Una clase declarada como final no puede ser una superclase, es decir, no puede tener hijos.
Una clase abstracta no puede ser final.
4. METODOS
Un metodo final no puede ser sobrescrito.
public final String getRepresentacion();
Año actual
import java.time.LocalDate;
public class Name {
int anioIngreso;
Name() {
this.anioIngreso = anioIngreso;
}
public int antiguedadEnAnios() {
int anioActual = LocalDate.now().getYear();
return anioActual – anioIngreso;
}
HERENCIA MULTIPLE
Java soporta herencia simple entre clases. No soportada herencia multiple. Para saldar esto, Java
utiliza el mecanismo de interface para emular la herencia multiple.
INTERFACE
Es un mecanismo de Java que permite emular la herencia multiple.
Es como una clase abstracta.
No se puede instanciar.
En una interfaz solo pueden haber metodos abstractos (recordar que los metodos abstractos deben
ser publicos para poder sobrescribirse). Tambien constantes pero solo estaticas y publicas.
Las realizaciones de interfaces cumplen conceptualmente con el tipo ‘es un/a’
public interface NombreDeInterface {
ej.
public interface EnviadorDeMensaje {
void enviarMensaje(String mensaje); //no hace falta poner la palabra public abstract porque la
interface puede tener metodos solo abstractos y estos deben ser publicos para poder sobrescribirlos),
Java lo tiene implicito pero si lo ponemos es indistinto. (public abstract void enviarMensaje(String
mensaje);)
Una clase puede implementar una o más interfaces y eso se hace colocando la palabra implements
antes del nombre de la interface. Si la clase implementa más de una interface, estas se separan por
“,”.
Ej. la clase PalomaMensajera hereda de la clase Ave e implementa la interface EnviadorDeMensaje.
Esto se coloca en codigo de la siguiente manera:
public class PalomaMensajera extends Ave implements EnviadorDeMensaje { //una paloma
mensajera es un ave pero tambien es un enviador de mensaje.
public class Dron extends Vehiculo implements Volador, Recargable { //una clase Dron que hereda
de la clase Vehiculo y que implementa las interfaces Volador y Recargable.
En UML la implementacion es con una flecha cuya punta es como la de herencia, con punta de
triangulo sin relleno pero la linea es punteada.
¿CLASE ABSTRACTA O INTERFACE?
Usualmente usamos una clase abstracta cuando necesito tener algun atributo o (incluyente) algun
metodo no abstracto, de lo contrario, usamos una interface.
HERENCIA ENTRE INTERFACES
Una interface puede heredar de una o más de una interface, es decir, en Java se permite la herencia
multiple entre interfaces.
En UML es con flecha de herencia.
En codigo, luego del nombre de la interface se usa la palabra extends y a continuacion el nombre de
las interfaces
public interface VehiculoRecargable extends Recargable, Vehiculo {
En este ejemplo la interface VehiculoRecargable hereda los metodos abstractos de las interface
Recargable y Vehiculo. Asi, un vechiculo recargable es aquel que cumpla el contrato de ser
recargable y de ser vehiculo. Le puedo agregar otros metodos a la interface VehiculoRecargable.
