Este documento proporciona una introducción a los conceptos básicos de Java, incluyendo tipos de datos primitivos, clases, objetos, herencia, paquetes, métodos y constructores. También explica operadores, declaración de variables, condicionales, bucles y cadenas de caracteres.

1. Conceptos Generales
Guido Ticona Hurtado
guidoti@gmail.com

2.  Orientado a Objetos
 Tipos estrictos
 Clases estrictas

3. Código Fuente
.java
javac
ByteCode
.class
JVM JVM JVM
java
“Write once,
run everywhere!”

4.  Tipos numéricos
◦ Tipos enteros:
 byte, enteros 8-bits
 short, enteros 16-bits
 int, enteros 32-bits
 long, enteros 64-bits
◦ Tipos en coma flotante:
 float, real en coma flotante, 32-bits
 double, real en coma flotante, 64-bits
 Tipos no numéricos
 char, carácter 16-bits
 boolean, tipo lógico, cuyos valores son true (cierto) y false
(falso)

5.  Igualdad y desigualdad: == , !=
 Comparación: <, <=, >, >=
 Suma, multiplicación, división y módulo: +, -,
*, /, %
 Incremento y decremento prefijos y posfijos: ++,
--
 Desplazamiento con signo y sin signo: <<, >>,
>>>
 Lógica booleana: &&, ||

6.  Grupos de Precedencia
 Grupo 0: ( )
 Grupo 1: ++, --
 Grupo 2: *, /, %
 Grupo 3: +, -, + (concatenación)
 Funciones especiales:
◦ Seno x => Math.sin(x)
◦ Cuadrado => Math.pow(x,2)
◦ Redondeo => Math.round(6.6) = 7

7.  Utilización de operadores:
◦ var1 = var2 + var3;
◦ var1 = var2 - var3;
◦ var1 = var2 * var3;
◦ var1 = var2 / var3;
◦ var1 = var2 % var3;
 Asignaciones de incremento decremento:
◦ variable++; // añadir uno a variable
◦ variable--; // restar uno a varibale
◦ variable += exp; // añadir exp a variable
◦ variable -= exp; // restar exp a variable

8. ◦ tipo nombre;
◦ tipo nombre1, nombre2, nombre3;
◦ tipo nombre = valor;
Declaración de Constantes:
static final tipo nombre = valor;

9.  Asignar una variable a otra cuyo tipo es mayor de
tamaño:
byte => short => int => long => float => double
 Para pasar de un tipo a otro menor en tamaño, tenemos
que hacer una conversión explícita de tipos:
(tipo)expresion

10. Paquetes Java más importantes:
- lang – para funciones del lenguaje;
- util – para utilidades adicionales;
- io – para entrada y salida;
- text – para formateo especializado;
- awt – para gráficos e interfaz gráfica de usuario
Para acceder a cualquiera de estos paquetes, excepto
lang que está siempre disponible, usamos el siguiente
modelo:
import java.nombrepaquete.*;

11.  Representación abstracta(modelo) de una entidad
del mundo
 Especifica los atributos (propiedades) y métodos
(comportamientos)
 Ejem. Casa, auto, libro, etc.

12.  Es una instancia de una clase (representación
real de la clase, no es abstracto)
 Los atributos del objeto tienen un valor
 Ej. Bolígrafo Pilot color azul, Auto toyota modelo
2012, etc.

13.  Un objeto no es un dato simpre, sino que puede
contener en su interior cierto número de atributos
bien estructurados
 Cada objeto no es un ente aislado, sino que forma
parte de una organización jerárquica o de otro tipo

14. ◦ Class SombreroMexicano{
 String propietario;
 String color;
 Int tamaño;
 Boolean nuevo;
◦ }
Instancias
Propietario: Jose
Color: rojo
Tamaño: 7
Nuevo: verdad
Propietario: Andres
Color: verde
Tamaño: 5
Nuevo: falso

15. Propietario: Jose
Color: rojo
Tamaño: 7
Nuevo: verdad
Propietario: Roberto
Color: rojo
Tamaño: 7
Nuevo: verdad
Propietario: Roberto
Color: rojo
Tamaño: 7
Nuevo: falso
cambiarPropietario
ponerUsado

16. modificador class nombreClase {
< declaración de campos >
< declaración de métodos >
}
 modificador puede ser public o nada; si la clase no pertenece a un
paquete, ambas definiciones son equivalentes; si la clase pertenece a un
paquete, entonces, si se declara public, la clase podrá utilizarse fuera del
paquete, pero si no se declara public, sólo podrá utilizarse dentro del
paquete

17.  Clases => mayuscula primera letra
 Objetos =>minuscula primera letra
 No usar caracter “_”, usar Mayuscula

18. ◦ nombreClase nombreObjeto;
◦ nombreClase nombreObjeto1, nombreObjeto2, nombreObjeto3;
◦ nombreClase nombreObjeto = nombreOtroObjeto;
◦ nombreClase nombreObjeto = new nombreClase();
Ejemplo:
clasePublica elObjeto;
clasePublica elObjeto1, elObjeto2, elObjeto3;
clasePublica elObjeto4 = elObjeto;
clasePublica elObjeto5 = new clasePublica();

19. modificadores tipo nombreCampo;
 modificador puede ser:
- private, accesible solo desde dentro de la propia clase
- protected, accesible solo desde la propia clase, clases del mismo paquete o
subclases
- public,accesible por todos
- package,si no se especifica nada, es el modo por defecto, accesible solo desde el
propio paquete; si la clase no se encuentra dentro de un paquete, es equivalente a
public.
 Otros modificadores que se pueden añadir son:
- static, indica que el campo pertenece a la clase, no a un objeto concreto
- final, indica que dicho campo no puede ser sobreescrito en una subclase
 tipo es el tipo del campo (tipo primitivo o clase del objeto)
 nombreCampo es el nombre del campo

20. objeto.campo; // si campo no es static
nombreClase.campo; // si campo es static
elObjeto.doblePublico = 5.0;
double doble = elObjeto.doblePublico;
Clase.doblePublicoEstatico = 7.0;
Double doble = Clase.doblePublicoEstatico;

21. modificador tipo nombreMetodo(<lista de parametros formales>) {
< cuerpo del método; campos e instrucciones >
return expresion; // solo métodos que devuelven resultado
}
<lista de parametros formales> = (tipo campo, tipo campo, ...)
modificador significa lo mismo que para los campos.
tipo es el tipo devuelto por el método, puede ser:
- void si el método no devuelve nada
- un tipo primitivo
- una clase
nombreMetodo es el nombre del método

22. public class Clase {
private int enteroPrivado;
static private int enteroEstaticoPrivado;
public void estableceEntero(int entero) {
enteroPrivado = entero;
}
public int recuperaEntero() {
return entero;
}
static public void estableceEnteroEstatico(int entero) {
enteroEstaticoPrivado = entero;
}
static public int recuperaEnteroEstatico() {
return enteroEstatico;
}
}

23. metodo(<lista parametros reales>); // metodos de la propia clase
objeto.metodo(<lista dparametros reales>); // metodos no estaticos
nombreclase.metodo(<lista parametros reales>); //metodos estaticos
Ejemplo:
elObjeto.estableceEntero(7);
int entero = elObjeto.recuperaEntero();
Clase.estableceEnteroEstatico(8);
int entero = Clase.recuperaEnteroEstatico();

24. modificadores nombreClase(<lista argumentos formales>) {
< cuerpo del método constructor >
}
Ejemplo:
public class Clase {
private int enteroPrivado;
public Clase() {
enteroPrivado = 0;
}
public Clase(int entero) {
enteroPrivado = entero;
}
}

25. nombreClase objeto = new nombreClase(<lista parametros reales>);
Ejemplo:
Clase elObjeto;
elObjeto = new Clase();
O en una sola línea:
Clase elObjeto = new Clase();
Clase elObjeto = new Clase(5);

26. public class nombrePrograma {
public static void main(String[] args) {
< cuerpo del programa >
}
}

27. modificadores class nombreClase extends nombreClaseQueExtiende {
}
 Ejemplo
public class ClaseExtendida extends Clase {
}
 Una clase que extiende otra, se llama subclase o clase hija,
mientras que la clase a la que extiende (la original) se llama
superclase o clase paterna.
 La subclase hereda los miembros (propiedades y métodos) de la
superclase.

28.  Cualquier objeto de una subclase puede ser asignado a
un objeto de su superclase.
 Cualquier objeto de una superclase puede ser asignado
a una subclase con una conversión explícita (cambio de
tipo).
ClaseExtendida elObjetoExtendido = new ClaseExtendida();
Clase elObjeto = laClaseExtendida;
ClaseExtendida elObjetoExtendido = (ClaseExtendida)elObjeto;

29. modificadores class nombreclase extends nombreClaseQueEstiende {
public nombreClase(<lista de parametros formales>) {
super(<lista de parametros reales>);
<instrucciones de inicializacion>
}
}
 Importante: La llamada al superconstructor debe
ser la primera instrucción de un constructor.

30. public class Clase {
private int enteroPrivado;
public Clase(int entero) {
enteroPrivado = entero;
}
}
public class ClaseExtendida extends Clase {
private double doblePrivado;
public ClaseExtendida(int entero, double doble) {
super(entero);
doblePrivado = doble;
}
}

31. public class Clase {
public int dato;
}
public class ClaseExtendida extends Clase {
public double dato;
public estableceDatos(int entero, double doble) {
super.dato = entero;
dato = doble;
}
Clase elObjeto = new Clase();
ClaseExtendida elObjetoExtendido = new ClaseExtendida();
elObjeto.dato = 5; // es un valor entero
elObjetoExtendido.dato = 6.4; // es un valor doble
elObjetoExtendido.estableceDatos(3,7.8);

32. public class Clase {
public int dato;
public estableceDato(int entero) {
dato = entero;
}
}
public class ClaseExtendida extends Clase {
public int datoExtendido;
public estableceDato(int entero) {
super.estableceDato(entero);
datoExtendido = entero*2;
}

33. package nombrePaquete;
modificador class nombreClase {
< declaracion de la clase >
}
 Importante: Si deseamos que una clase sea utilizada
fuera de su paquete, deberemos declararla como
public.

34.  Objetos nulos: null
 El identificador this
public class Clase {
private int entero;
public Clase(int entero) {
this.entero = entero;
}
}

35. - Una variable tiene memoria para un solo valor
y dispone de un conjunto predefinido de
operaciones según sea su tipo.
- Un objeto tiene memoria para un grupo de
varios valores, junto con un conjunto coherente
de métodos que operan sobre esos valores.
Tanto métodos como valores están
encapsulados en la clase de la que se ha
obtenido el objeto.

36.  En Java, todas las clases son subclases de una
clase especial llamada Object.
 Java alcanza la generalidad utilizando objetos de
diferentes clases en las mismas partes del
programa, pero todos ellos pertenecen a la clase
Object.

37. modificador class nombreClase {
public boolean equals() {
< instrucciones para comparar con los campos de obj >
return resultado de la comparacion;
}
}
Ejemplo:
public class Clase {
private int entero;
public boolean equals(Clase c) {
return (c.entero==entero);
}
}

38. modificador class nombreClase implements Cloneable {
public Object clone() {
nombreClase obj = new nombreClase(parametros);
< instrucciones para copiar los campos a obj >
return obj;
}
}
public class Clase implements Cloneable {
private int entero;
public Object clone() {
Clase c = new Clase();
c.entero = entero;
return c;
}
}

39.  El método clone invocado sobre clase2
devuelve un objeto de la clase Object. Esto
debe ser así, porque lo exige la interfaz
Cloneable. Para convertirlo de nuevo a Clase
necesitamos la conversión explícita de tipo.
Clase objeto1 =
(Clase)objeto2.clone();

40. Declaración e instanciación de un array de n enteros:
int miArray[];
miArray = new int[n];
Lo mismo en una sola línea:
int miArray[] = new int[n];
Declaración e instanciación de un array de n objetos:
MiClase miArray[] = new MiClase[n];
for(int i=0;i<n;i++) miArray[i] = new MiClase();

41. if (condicion)
instrucción;
else instrucción;
if (velocidad>limite)
System.out.println("Multa");
else System.out.println("Buen conductor");

42. if (condicion) instrucción;
else if (condicion) instrucción;
else if (condicion) instrucción;
....
else instrucción;
if (nota>=9) calificacion=’C’;
else if (nota>=7) calificacion=’D’;
else if (nota>=5) calificacion=’B’;
else calificacion=’A’;

43. switch (expresion) {
case valor: instrucción; break;
case valor: instrucción; break;
....
default: instrucción; break;
}
switch(nota) {
case 10:
case 9: calificacion = ‘D’; break;
case 8:
case 7: calificacion = ‘C’; break;
case 6:
case 5: calificacion = ‘B’; break;
default: calificacion = ‘A’; break;
}

44. for(inicio; prueba; actualización) {
< cuerpo del bucle for >
}
for(int i=0; i<5;i++)
System.out.println("hola");
for(int i=0; i<5;i++) {
cuenta += i;
System.out.println("hola");
}

45. for(; ; ) {
< cuerpo del bucle for >
if (condicion) break;
}
for(inicio; ; actualización) {
< cuerpo del bucle for >
if (condicion) break;
}

46. <instrucciones para inicializar las condiciones>
while (condiciones) {
<instrucciones para llevar a cabo el bucle y
cambiar condiciones >
}
int i=0;
while(i<5) {
System.out.println("hola");
i++;
}

47. <instrucciones para inicializar las condiciones>
do {
<instrucciones para llevar a cabo el bucle y
cambiar condiciones >
} while (condiciones);
int i=0;
do {
System.out.println("hola");
i++;
} while (i<5);

48.  La clase String
 Creación de una cadena:
String miCadena = "Esta es la cadena";
 Cadena Vacía vs Cadena Nula
String s1; // Cadena Nula, igual al valor null
String s2= ""; // Cadena Vacía

49.  Comparación de cadenas:
if (cadena1.equals(cadena2))
System.out.println("Las cadenas son iguales");
else System.out.println("Las cadenas no son
iguales");
 Concatenación de cadenas:
String c3 = c1+c2;

50. import java.io.*;
System.out.println(elementos);
System.out.println();
System.out.print(elementos);
System.out.println("hola"); // escribe "hola"
System.out.println(5); // escribe 5
int i = 5; System.out.println(i) ; // escribe 5;
double d=6.4; System.out.println(d); // escribe 6.4;
double d=6.4; System.out.println("d="+d); // escribe d=6.4;

51. Cuando sobreescribimos el método toString de Object, esto
nos ofrece
un acceso automático al método println como sigue:
public class Clase {
private int entero;
public Clase (int e) {
entero = e;
}
public String toString() {
return(""+e);
}
}
Clase miClase = new Clase(5);
System.out.println(miClase); // escribe "5"
System.out.println("clase="+miClase); // escribe "clase=5"

52. import java.io.*;
BufferedReader in = new
BufferedReader(new InputStreamReader(System.in));
String cadena = in.readLine();

53. int i=Integer.valueOf(in.readLine()).intValue();
double d=Double.valueOf(in.readLine()).doubleValue();
int i=Integer.valueOf(in.readLine().trim()).intValue();
double d=Double.valueOf(in.readLine().trim()).doubleValue();

54. BufferedReader fin = new BufferedReader(new FileReader(nombreArchivo));
PrintWriter fout = new PrintWriter(new FileWriter(nombreArchivo));
fout.close();

55.  Una excepción es un objeto que avisa que ha ocurrido alguna condición
inusual. Java tiene muchos objetos de excepción predefinidos y también
podemos crear los nuestros propios
 Para utilizar excepciones, tenemos que hacer cuatro cosas:
◦ Intentar: crear un bloquee alrededor de la instrucción donde puedan
ocurrir excepciones y precederlas con la palabra clave try
◦ Capturar: colocar a continuación de la instrucción try otro bloque
precedido por la palabra catch
◦ Lanzar: si no se trata la excepción, ésta pasará automáticamente al
método llamador; si la capturamos y la tratamos parcialmente, podemos
de todas formas pasarla con una instrucción throw.
◦ Declarar: mencionar en la declaración del método qué excepciones se
devolverán al método llamador.

56. public void leeArchivo(String nombre) throws IOException {
BufferedReader fin = new BufferedReader(new FileReader(nombre));
try {
while(true) {
cadena = fin.readLine();
System.out.println(cadena);
}
} catch (EOFException e) {
System.out.println("Fin del archivo");
}
}

57. public class nombre extends Exception {
public nombre() {}
public nombre(String s) { }
}
throw new nombre(“mensaje”);

58. public class DenominadorCeroException extends Exception {
public DenominadorCeroException() { super(); };
public DenominadorCeroException(String s) { super(s); };
}
public class Racional {
private int num, den;
public Racional(int n, int d) throws DenominadorCeroException {
if (d==0) throw new DenominadorCeroException("Denominador cero");
num = n;
den = d;
}
}

59.  Clase
Sombrero(color,marca,modelo,propietario)
 Subclase
SombreroMexicano(diametro)
 Subclase
SombreroCopa(altura,material)
Programa principal para mostrar 2
SombreroMexicano y 1 SombreroCopa

60. <tipo> variable[]=new <tipo>[n];
Se hace referencia con variable[0],variable[1]…
variable[n]

61. List<tipo> var=new ArrayList<tipo>();
var.add(valor);
for(<tipo> variable:lista){
}
Iterator i=lista.iterator();
While (i.hasNext())
i.next();

62.  Clases
◦ Ventana(alto,ancho,color fondo,color texto,titulo)
◦ Boton(texto,borde,color fondo)
 Subclases
◦ Mensaje(icono,mensaje)
◦ Dialogo(posicionx, posicion y)
◦ BotonRadio(activo)
 Crear un ventana Mensaje con botones(Aceptar,Cancelar)
 Crear un ventana Dialogo con boton
radio(lunes,martes,miercoles,jueves,viernes,sabado)
 Mostrar propiedades de las 2 ventanas.