Introduccio al Java

INTRODUCCIÓ AL
JAVA

Algoritmos y Estructura de Datos

EL LENGUAJE JAVA
 Orientado a Objetos
 Tipos estrictos

 Clases estrictas

TIPOS PRIMITIVOS
 Tipos numéricos
 Tipos enteros:
 byte, enteros 8-bits con signo complemento a 2,
 short, enteros 16-bits con signo complemento a 2

 int, enteros 32-bits con signo complemento a 2

 long, enteros 64-bits con signo complemento a 2

 Tipos en coma flotante:
 float, real en coma flotante, 32-bits IEEE 754
 double, real en coma flotante, 64-bits IEEE 754

 Tipos no numéricos
 char, carácter 16-bits Unicode
 boolean, tipo lógico, cuyos valores son true (cierto) y false

(falso)

OPERADORES

 Igualdad y desigualdad: == , !=
 Comparación: <, <=, >, >=
 Suma y resta unarios: +, -
 Suma, multiplicación, división y módulo: +, -, *, /, %
 Incremento y decremento prefijos y posfijos: ++, --
 Desplazamiento con signo y sin signo: <<, >>, >>>
 Negación lógica unaria de bits: ~
 Lógica de bits: &, |, ^
 Lógica booleana: &&, ||

EXPRESIONES
 Grupos de Precedencia
 Grupo 0: ( )
 Grupo 1: ++, --, + (unario), - (unario)

 Grupo 2: *, /, %

 Grupo 3: +, -, + (concatenación)

 Funciones especiales:
 Seno x => Math.sin(x)
 x2 => Math.pow(x,2)
 Math.round(6.6) => 7

ASIGNACIÓN
 Utilización de operadores:
 var1 = var2 + var3; // asignar a var1 el valor de var2 + var3
 var1 = var2 - ver3; // asignar a var1 el valor de var2 - var3
 var1 = var2 * ver3; // asignar a var1 el valor de var2 * var3
 var1 = var2 / ver3; // asignar a var1 el valor de var2 / var3
 var1 = var2 % ver3; // asignar a var1 el valor de 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

DECLARACIÓN DE VARIABLES
 tipo nombre;
 tipo nombre1, nombre2, nombre3;
 tipo nombre = valor;

DECLARACIÓN DE CONSTANTES
static final tipo nombre = valor;

CONVERSIONES ENTRE TIPOS
 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

PAQUETES
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.*;

DECLARACIÓN DE CLASES

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

DECLARACIÓN DE OBJETOS
 nombreClase nombreObjeto;
 nombreClasenombreObjeto1,nombreObjeto2, nombreObjeto3;
 nombreClase nombreObjeto = nombreOtroObjeto;
 nombreClase nombreObjeto = new nombreClase();

Ejemplo:
clasePublica elObjeto;
clasePublica elObjeto1, elObjeto2, elObjeto3;
clasePublica elObjeto4 = elObjeto;
clasePublica elObjeto5 = new clasePublica();

DECLARACIONES DE CAMPOS

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

ACCESO A CAMPOS
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;

DECLARACIÓN DE MÉTODOS

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

EJEMPLO DE CLASE
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;
}
}

LLAMADAS A MÉTODOS

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();

DECLARACIÓN DE MÉTODOS
CONSTRUCTORES

modificadores nombreClase(<lista argumentos formales>) {
< cuerpo del método constructor >
}

Ejemplo:
public Clase() {
enteroPrivado = 0;
}
public Clase(int entero) {
}
}

LLAMADAS A MÉTODOS
CONSTRUCTORES

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);

MODELO DE UN PROGRAMA
public class nombrePrograma {
public static void main(String[] args)
{
< cuerpo del programa >
}
}

HERENCIA

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.

CAMBIO DE TIPO

 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;

SUPERCONSTRUCCIÓN

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.

EJEMPLO DE
SUPERCONSTRUCCIÓN
}
}

private double doblePrivado;
public ClaseExtendida(int entero, double doble) {
super(entero);
doblePrivado = doble;
}
}

VARIABLES ENMASCARADAS
public int dato;
}
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);

SOBREESCRITURA DE MÉTODOS
public int dato;
public estableceDato(int entero) {
dato = entero;
}
}

public int datoExtendido;
public estableceDato(int entero) {
super.estableceDato(entero);
datoExtendido = entero*2;
}

PAQUETES
package nombrePaquete;
< declaracion de la clase >
}

 Importante: Si deseamos que una clase sea
utilizada fuera de su paquete, deberemos
declararla como public.

ABSTRACCIÓN MEDIANTE
INTERFACES

modificador interface nombreInterfaz {
< especificaciones de los métodos >
}

modificador class nombreClase implements nombreInterfaz {
< implementación de los metodos de la interfaz >
< implementación de metodos y datos propios de la clase >
}

PROPIEDADES DE LOS OBJETOS
 Objetos nulos: null

 El identificador this

private int entero;
this.entero = entero;
}
}

OBJETOS VS VARIABLES
- 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.

LA SUPERCLASE OBJECT
 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.

IGUALDAD DE OBJETOS

public boolean equals() {
< instrucciones para comparar con los campos de obj >
return resultado de la comparacion;
}
}

Ejemplo:
private int entero;
public boolean equals(Clase c) {
return (c.entero==entero);
}
}

ASIGNACIÓN DE OBJETOS
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;
}
}

CONVERSIONES DE CLASE
 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();

ARRAYS
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();

SELECCIÓN CON IF-ELSE
if (condicion)
instrucción;
else instrucción;

if (velocidad>limite)
System.out.println("Multazo");
else System.out.println("Buen conductor");

SUCESIVOS ELSE-IF
if (condicion) instrucción;
else if (condicion) instrucción;
else if (condicion) instrucción;
....
else instrucción;

if (nota>=9) calificacion=’SB’;
else if (nota>=7) calificacion=’N’;
else if (nota>=5) calificacion=’A’;
else calificacion=’S’;

LA INSTRUCCIÓN SWITCH
switch (expresion) {
case valor: instrucción; break;
case valor: instrucción; break;
....
default: instrucción; break;
}

switch(nota) {
case 10:
case 9: calificacion = ‘SB’; break;
case 8:
case 7: calificacion = ‘N’; break;
case 6:
case 5: calificacion = ‘A’; break;
default: calificacion = ‘S’; break;
}

BUCLES FOR
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;
}

BUCLES FOR INDETERMINADOS
for(; ; ) {
if (condicion) break;
}

for(inicio; ; actualización) {
if (condicion) break;
}

BUCLES CONDICIONALES WHILE
<instrucciones para inicializar las condiciones>
while (condiciones) {
<instrucciones para llevar a cabo el bucle
y cambiar condiciones >
}

int i=0;
while(i<5) {
i++;
}

BUCLES CONDICIONALES DO WHILE
<instrucciones para inicializar las
condiciones>
do {
<instrucciones para llevar a cabo el bucle y
cambiar condiciones >
} while (condiciones);

int i=0;
do {
i++;
} while (i<5);

CADENAS DE CARACTERES
 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

CADENAS (CONTINUACIÓN)

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;

SALIDA POR PANTALLA
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;

EL MÉTODO TOSTRING

Cuando sobreescribimos el método toString de Object, esto nos
ofrece
un acceso automático al método println como sigue:
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"

ENTRADA DESDE TECLADO

import java.io.*;

BufferedReader in = new
BufferedReader(new InputStreamReader(System.in));

String cadena = in.readLine();

LECTURA DE NÚMEROS

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();

ENTRADA/SALIDA DESDE ARCHIVOS

BufferedReader fin = new BufferedReader(new FileReader(nombreArchivo));

PrintWriter fout = new PrintWriter(new FileWriter(nombreArchivo));
fout.close();

EXCEPCIONES
 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.

EJEMPLO

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");
}
}

EXCEPCIONES DEFINIDAS
POR EL USUARIO
public class nombre extends Exception {
public nombre() {}
public nombre(String s) { }

} throw new nombre(“mensaje”);

EJEMPLO

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;
}
}

Introduccio al Java

Recomendados

Recomendados

Más contenido relacionado

La actualidad más candente

La actualidad más candente (20)

Destacado

Destacado (20)

Similar a Introduccio al Java

Similar a Introduccio al Java (20)

Más de Marc Soler Camps

Más de Marc Soler Camps (7)

Introduccio al Java