Conceptos Básicos de Java

Conceptos Básicos de Java

Conceptos Básicos de Java Características de la Programación en Java • Sensible a mayúsculas/minúsculas. • Palabras reservadas. • Comentarios. • Lenguaje de formato libre. • Identificadores. • Variables y constantes. • Convenciones de nomenclatura. • Tipos de datos. • Operadores.

Conceptos Básicos de Java Características de la Programación en Java (2) Sensible a mayúsculas/minúsculas • Se distingue entre mayúsculas y minúsculas. • Los identificadores Cat, cat y CAT son diferentes. • Todas las palabras reservadas del lenguaje van en minúsculas. Palabras reservadas

Conceptos Básicos de Java Paquetes Paquetes: es un conjunto de clases e interfaces relacionadas que proveen acceso protegido y administración de nombres. • Las clases e interfaces que son parte de la Plataforma Java están agrupadas • en paquetes de acuerdo a su función: • java.applet : para manejo de Applets. • java.io: para manejo de entrada/salida. • java.awt: para manejo de la GUI. • El programador agrupa sus clases e interfaces en paquetes, anteponiendo la claúsula package NombreDel Paquete a las declaraciones de todas las clases e interfaces agrupadas. • La plataforma JAVA importa automáticamente los siguientes paquetes: el default package, el paquete java.lang y el paquete actual. • El alcance de la sentencia package es todo el archivo fuente. • Ejemplo:

Conceptos Básicos de Java Paquetes (2) Sentencia import: indicaal compilador dónde están ubicadas las clases que estamos importando. • Ejemplos: • Para importar sólo una clase de un paquete: import <nombre.paquete>.<NombreClase>; import java.lang.String; • Para importar todas las clases de un paquete: import <nombre.paquete>.*; • import java.lang.*;

Conceptos Básicos de Java Características de la Programación en Java (3) Comentarios. Existen tres formas de introducir comentarios: • Comentario en una línea // Comentario de una línea • Comentario en una o más líneas /* Comentario de más de una línea */ • Comentario de documentación. Se usa con javadoc /** Método XYZ: Realiza la labor X sobre los datos Y devolviendo Z */ javadoc Fichero.java > Fichero.html

Conceptos Básicos de Java Características de la Programación en Java (4) Lenguaje de formato libre. • La disposición de los elementos dentro del código es libre. • Sentencias: línea simple de código terminada en “;” total = a + b + c + d ; • Bloque de código: conjunto de sentencias agrupadas entre llaves { x = x + 1; y = y + 1; } • Java permite espacios en blanco entre elementos del código x1 = y * delta ; x2 = (y+1) * delta ;

Conceptos Básicos de Java Características de la Programación en Java (5) Identificadores • Son nombres de clases, variables o métodos. • No tienen longitud máxima. • El primer carácter del identificador debe ser: A-Z, a-z, _, $. • El resto: A-Z, a-z, _, $, 0-9. • No se permite utilizar palabras reservadas como identificador. Ejemplos válidos anioDeNacimiento2 _otra_variable NombreDeVariableMuyLargoNoImporta BotonPulsacion Ejemplos NO válidos Razón 3valores (número comoprimer carácter) Dia&mes & Dos más (espacio) Dos-valores –

Conceptos Básicos de Java Características de la Programación en Java (6) Variables y constantes • Variables:zona de memoria cuyos valores van a cambiar durante la ejecución <tipo> <identificador> ; ó <tipo> <identificador> , <identificador> ... ; ejemplo:int x, y, z ; • Constantes: zona de memoria cuyos valores no cambian final <tipo> <identificador> = <valor> ; ejemplo:final double PI = 3.14159265 ; • Asignación de Variables: se utiliza el operador asignación “=“ <variable> = <expresión> ; La parte izquierda siempre debe ser una variable. La parte derecha puede ser un literal, una variable, una expresión, una función o una combinación de todos. Se puede asignar un valor a una variable en el momento de declararla. ejemplo:int i = 0 ;

Conceptos Básicos de Java Características de la Programación en Java (7) Convenciones de nomenclatura • Los identificadores que proporciona Java siguen una convención según el elemento: Clases: primera letra en mayúscula de cada palabra ejemplo:Empleado, LibroDeCuentas, String Variables: primera letra en minúscula y la primera letra de cada palabra en mayúscula ejemplo:contador, numeroTotalAccesos, string Constantes: todo en mayúsculas, separando cada palabra por el carácter “_” ejemplo:PI, ANCHO_IMAGEN Métodos: siguen el mismo formato que las variables seguidas de paréntesis “(“ “)” ejemplo:sumar(), obtenerResultado() Estructuras de control: utilizar llaves englobando a todas las sentencias de una estructura de control, aunque sólo haya una sentencia ejemplo: if ( <condición> ) { // hacer algo }else{ // hacer otra cosa }

Características de la Programación en Java (8) Tipos de Datos • Los tipos primitivos son ocho agrupados en cuatro lógico: boolean texto: char entero: byte, short, int, long real: float, double Tipos Primitivos Tipo Lógico Tipos Numéricos Integrales Punto Flotante Caracteres Números Enteros boolean char byte short int long float double • Los tipos referencia son punteros a objetos Conceptos Básicos de Java

Conceptos Básicos de Java Características de la Programación en Java (9) Tipos de Datos • Tipos Primitivos

Conceptos Básicos de Java Características de la Programación en Java (10) Tipos de Datos • Tipos Referencia • Un tipo referencia guarda un puntero a la dirección donde se ubica el objeto • Sólo puede almacenar direcciones de objetos de su propio tipo • Todas las clases son de tipo referencia • El valor que toma por defecto una variable de tipo referencia es null

Conceptos Básicos de Java Características de la Programación en Java (11) Tipos de Datos Conversión de tipos • La conversión de tipos (casting) se debe realizar entre tipos de la misma naturaleza: numéricos o referencia • Al convertir un tipo a un tamaño más pequeño se puede perder la información de los bits de mayor peso • La sintaxis es: (<tipo>) <expresión> ejemplo:byte num8bits = (byte) 27 ; int num32bits = 27 ; num8bits = (byte) num32bits ;

Conceptos Básicos de Java Características de la Programación en Java (12) Operadores • Operadores unarios: +, - • Operadores aritméticos: +, -, *, /, % (resto de la división) • Operadores de asignación: =, +=, -=, *=, /=, %= <var> += <expr> => <var> = <var> + <expr> • Operadores incrementales: ++, -- siguiendo a la variable: <var>++, <var>-- ejemplo:i=6; j=i++; => j=i; i=i+1; // resultado i=7 , j=6 precediendo a la variable: ++<var>, --<var> ejemplo:i=6; j=++i; => i=i+1; j=i; // resultado i=7 , j=7 • Operadores relacionales: == (igual), != (distinto), >, <, >=, <=

Conceptos Básicos de Java Características de la Programación en Java (13) Operadores • Operadores lógicos: && (AND), || (OR), ! (NOT), & (AND), | (OR) && y || realizan evaluación perezosa: op1 && op2 => si op1 es false, no se evalúa op2 op1 || op2 => si op1 es true, no se evalúa op2 & y | siempre evalúan los dos operadores • Operador instanceof: <objeto> instanceof <clase> determina si un objeto pertenece a una clase • Operador condicional: ? : <exprBooleana> ? <valor1> : <valor2> Permite bifurcaciones condicionales sencillas • Operadores a nivel de bits: >>, <<, >>>, &, |, ^, ~

110 11 101 ^ es el XOR 6^3=5 110 con 11 =5 ~ es el complemento El cero pertenece a los naturales -3 -2 -1 0 1 2 3 ~2 = -3 ~-2 = 1

<< corrimiento a la izquierda >> corrimiento a la derecha 1 1 0 1 0 13<<1=26 1 1 0 13>>1=6 1 1 0 1 =13 27 26 25 24 23 22 21 20 128 64 3216 8 4 2 1 1 byte = 8 bits

Conceptos Básicos de Java Control de Flujo • Las sentencias de control del flujo de ejecución permiten tomar decisiones y realizar un proceso repetidas veces • Hay dos tipos principales de sentencias de control de flujo: Condicionales: if, switch Bucles: for, while, do while • Otras sentencias que permiten interrumpir el flujo normal de ejecución son break y continue

Control de Flujo (2) if if (cont == 0) System.out.println(“cont = cero”); ------------------------------------------------------------------------------- if (cont == 0) { System.out.println(“cont = cero”); System.out.println(“otra sentencia”); } ------------------------------------------------------------------------------- if (cont == 0) { System.out.println(“cont = cero”); }else{ System.out.println(“cont != cero”); } ------------------------------------------------------------------------------- if (nota<4) { System.out.println("Insuficiente"); }elseif (nota<6) { System.out.println("Suficiente"); }else{ System.out.println(“Muy Bien"); } if (<exprBooleana>) <sentencia> ; ------------------------------------------------------- if (<exprBooleana>) { <grupoSentencias>; } ------------------------------------------------------- if (<exprBooleana>) { <grupoSentencias>; }else{ <grupoSentencias>; } ------------------------------------------------------- if (<exprBooleana>) { <grupoSentencias>; }else if (<exprBooleana>){ <grupoSentencias>; }else{ <grupoSentencias>; } Conceptos Básicos de Java

Control de Flujo (3) switch switch ( <variable> ) { case literal1: [<grupoSentencias1>;] [break;] case literal2: [<grupoSentencias2>;] [break;] ... case literalN: [<grupoSentenciasN>;] [break;] [default:<grupoSentencias>;] } int día = 4; switch (día) { case 1: System.out.println("Lunes"); break; case 2: System.out.println("Martes"); break; case 3: System.out.println("Miércoles"); break; case 4: System.out.println("Jueves"); break; case 5: System.out.println("Viernes"); break; case 6: System.out.println("Sábado"); break; case 7: System.out.println("Domingo"); break; default: System.out.println(“Error"); } Conceptos Básicos de Java

Control de Flujo (4) for for ( <inicialización>; <exprBooleana>; <actualización> ) { <grupoSentencias>; } <inicialización> asignación del valor inicial de las variables que intervienen en la expresión <exprBooleana> condición booleana <actualización> nuevo valor de las variables en <inicialización> for ( int i = 0; i < 10; i++ ) { System.out.println(“valor del contador: “ + i ); } Conceptos Básicos de Java

Control de Flujo (5) while while (<exprBooleana>){ <grupoSentencias>; } int cont = 0; while (cont++ < 10) { System.out.println(“contador:“ + i ); } do while do{ <grupoSentencias>; }while (<exprBooleana>); int cont = 0; do{ System.out.println(“contador:“ + i ); } while (cont++ < 10); Conceptos Básicos de Java

Conceptos Básicos de Java Control de Flujo (6) Break La instrucción break sirve para abandonar una estructura de control, tanto de las alternativas (if-else y switch) como de las repetitivas o bucles (for, do-while y while). En el momento que se ejecuta la instrucción break, el control del programa sale de la estructura en la que se encuentra. int i; for (i=1; i<=4; i++) { if (i==3) break; System.out.println("Iteración: "+i); } resultado Iteración: 1 Iteración: 2 Continue La instrucción continue sirve para transferir el control del programa desde la instrucción continue directamente a la cabecera del bucle (for, do-while o while) donde se encuentra. int i; for (i=1; i<=4; i++) { if (i==3) continue; System.out.println("Iteración: "+i); } resultado Iteración: 1 Iteración: 2 Iteración: 4

Ejemplo de uso Array Declaración char s[]; Point p[]; char[] s; Point[] p; Un array es un objeto. Se crea con new public char[] createArray() { char[] s; s = new char[26]; for ( int i=0; i<26; i++ ) { s[i] = (char) (’A’ + i); } return s; } public void printElements(int[] list) { for (int i = 0; i < list.length; i++) { System.out.println(list[i]); } } Longitud del array

Ejemplo de uso Array Crear un Array con valores iniciales 1) String[] names; names = new String[3]; names[0] = "Georgianna"; names[1] = "Jen"; names[2] = "Simon"; 2) String[] names = { "Georgianna", "Jen", "Simon" }; 1) MyDate[] dates; dates = new MyDate[3]; dates[0] = new MyDate(22, 7, 1964); dates[1] = new MyDate(1, 1, 2000); dates[2] = new MyDate(22, 12, 1964); 2) MyDate[] dates = { new MyDate(22, 7, 1964), new MyDate(1, 1, 2000), new MyDate(22, 12, 1964) };

Ejemplo de uso Array Multidimensional (matrices) int[][] twoDim = new int[4][]; twoDim[0] = new int[5]; twoDim[1] = new int[5]; int[][] twoDim = new int[][4]; // illegal int[][] twoDim = new int[4][5]; String [][] ciudades={{"BsAs","Sao Pablo","Madrid"}, {"Argentina","Brasil","España"}}; for ( int i=0; i<ciudades.length; i++ ) { for (int j=0; j<ciudades[i].length; j++ ) { System.out.println(ciudades[i][j]) ; } }

Recorriendo Array public void printElements(int[] list) { for ( int element : list ) { System.out.println(element); } } Este FOR, puede ser leido como: Para cadaelemento enlist hacer.

Redimensionando un Array NO SE PUEDE HACER Qué hacemos entonces? Usamos ARRAYCOPY int[] myArray = { 1, 2, 3, 4, 5, 6 }; // nuevo array más grande int[] hold = { 10, 9, 8, 7, 6, 5, 4, 3, 2, 1 }; // copia todo lo de myArray al array hold System.arraycopy(myArray, 0, hold, 0, myArray.length);

public classFecha{ privateintdia; privateintmes; privateintanio; publicFecha(int vdia, int vmes, int vanio){ dia = vdia; mes = vmes; anio = vanio; } publicvoidmostrarFecha(){ System.out.println (dia+”/”+mes+”/”+anio); } publicstaticvoidmain(String[] args){ FechaMiFecha = newFecha(10, 08, 2003); } } Variable Constructor Método Método principal de la aplicación Creación de un objeto Conceptos Básicos de Java Clases

???? 0xFFFF0000 dia 10 mes 08 anio 2003 Conceptos Básicos de Java Clases (2) Creación de Objetos • Se utiliza la palabra reservada new <NombreClase> <refObjeto>; <refObjeto> = new <NombreClase>() ; ó <NombreClase> <refObjeto> = new <NombreClase>() ; ejemplo:Fecha MiFecha ; MiFecha MiFecha = new Fecha (10, 08, 2003) ; MiFecha

Conceptos Básicos de Java Clases (3) Modificadores de clase: son palabras reservadas que se anteponen a la declaración de clase. Sintaxis: modificador class NombreClase Los modificadores posibles son los siguientes: • public. Toda clase public debe ser declarada en un fichero fuente con el nombre de esa clase pública: NombreClase.java. De esta afirmación se deduce que en un fichero fuente puede haber más de una clase, pero sólo una con el modificador public. • abstract. Las clases abstractas no pueden ser instanciadas. Sirven únicamente para declarar subclases que deben redefinir aquellos métodos que han sido declarados abstract. • final. Una clase declarada final impide que pueda ser superclase de otras clases. Dicho de otra forma, ninguna clase puede heredar de una clase final.

Conceptos Básicos de Java Clases (4) Modificadores de Ámbito

Conceptos Básicos de Java Clases (9) Atributos: sirven para almacenar valores de los objetos que se instancian a partir de una clase. Sintaxis: [modifÁmbito][static][final][transient][volatile] tipo nombreAtributo Tipos de Atributos: • de Objeto: son variables u objetos que almacenan valores distintos para instancias distintas de la clase (para objetos distintos). • de Clase: son variables u objetos que almacenan el mismo valor para todos los objetos instanciados a partir de esa clase. Declaración de Atributos: • static. Mediante la palabra reservada static se declaran atributos de clase. • final. Sirve para declarar constantes, no se permite la modificación de su valor. • otros modificadores: transient, volatile. • modific. de ámbito: public, protected, private, (default)

Conceptos Básicos de Java Clases (10) Ámbito de una variable. En Java se dispone de tres tipos de variables: • Variables miembro pertenecientes a una clase • Argumentos de un método de la clase • Variables locales de un método de la clase ejemplo: class Ejemplo { int x ; // variable miembro void metodo ( int y ){ // argumento int z ; // variable local x = y + z ; } } • Las variables miembro son visibles desde cualquier parte de la clase • Los argumentos y variables locales sólo son visibles dentro del método al que pertenecen. Dejan de existir al finalizar el método.

Conceptos Básicos de Java Métodos Los Métodos son bloques de código (subprogramas) definidos dentro de una clase. Sintaxis: <tipoRetorno> <nombreMétodo> ( <listaArgumentos> ) donde <tipoRetorno> tipo devuelto por el método. <nombreMétodo> identificador válido en Java. <listaArgumentos> sucesión de pares tipo-valor separados por coma ejemplo: String darFormato (String dia, String mes, String anio) { String s ; s = dia + “/” + mes + “/” + anio ; return s ; } • Un método tiene acceso a todos los atributos de su clase. • Pueden ser llamados o invocados desde cualquier sitio. • Un método puede invocar a otros métodos. • En Java no se puede definir un método dentro de otro. • La ejecución de todos los programas se inician con el método main().

Conceptos Básicos de Java Métodos (2) Modificadores de métodos: Sintaxis: [ModificadorDeÁmbito] [static][abstract][final][native][synchronized] TipoDevuelto NombreMétodo ([ListaParámetros]) Los modificadores posibles son los siguientes: • static. Los métodos static son métodos de clase (no de objeto) y por tanto, no necesita instanciarse la clase (crear un objeto de esa clase) para poder llamar a ese método. • abstract. Se declaran en las clases abstract. Cuando se declara un método abstract, no se implementa el cuerpo del método, sólo su signatura. • final. Los métodos de una clase que se declaran de tipo final no pueden ser redefinidos por las subclases. • native. Los métodos native, son métodos que se encuentran escritos en otro lenguaje de programación distinto a Java (ej: C). • synchronized. Son métodos especiales para cuando varios threads (subprocesos) pueden acceder concurrentemente a los mismos datos y se desea que una sección crítica se proteja (bloquee) para que los threads accedan en exclusión mutua a la misma.

Conceptos Básicos de Java Conceptos Básicos de Java Métodos (3) Constructor: es un método especial de las clases que sirve para inicializar los objetos que se instancian como miembros de una clase. public classFecha{ privateintdia; privateintmes; privateintanio; publicFecha(int vdia, int vmes, int vanio){ dia = vdia; mes = vmes; anio = vanio; } publicvoidmostrarFecha() { System.out.println (dia+”/”+mes+”/”+anio); } publicstaticvoidmain(String[] args){ FechaMiFecha = newFecha(10, 08, 2003); } }

Conceptos Básicos de Java Referencia this this: es una palabra clave que hace referencia al objeto o instancia actual. Usos: • Cuando se hace referencia a una variable miembro cuyo identificador coincide con el identificador de un parámetro. public classFecha{ • privateintdia; • privateintmes; • privateintanio; • publicFecha(int dia, int mes, int anio){ • this.dia = dia; • this.mes = mes; • this.anio = anio; • } • publicvoidmostrarFecha() { • System.out.println (dia+”/”+mes+”/”+anio); • } • public static void main(String[] args) { • Fecha MiFecha = new Fecha(10, 08, 2003); • } • }

Conceptos Básicos de Java Referencia this (2) • Cuando se hace referencia al objeto actual en un método que devuelve un objeto del tipo de referencia. public classFecha{ • privateintdia; • privateintmes; • privateintanio; • publicFecha(int dia, int mes, int anio) { • this.dia = dia; • this.mes = mes; • this.anio = anio; • } • public Fecha getObjetoFecha() { • return this; • } • public static void main(String[] args) { • Fecha MiFecha = new Fecha(10, 08, 2003); • Fecha MiFecha2 = MiFecha.getObjetoFecha(); • } • }

Conceptos Básicos de Java Referencia this (3) • Cuando se invoca a otros constructores de la clase. public classFecha{ • privateintdia; • privateintmes; • privateintanio; • public Fecha(int dia, int mes, int anio) { • this.dia = dia; • this.mes = mes; • this.anio = anio; • } • public Fecha() { • this(01,01,1900); • } • public static void main(String[] args) { • Fecha MiFecha = new Fecha(10, 08, 2003); • Fecha MiFecha2 = new Fecha(); • } • }

Conceptos Básicos de Java Herencia Herencia: es el mecanismo por el que se crean nuevos objetos definidos en términos de objetoa ya existentes. Sintaxis: class NombreClaseHija extends NombreClasePadre class Padre { String variable; void metodo() { variable = “Padre”; } } class Hija extends Padre { String variable; void metodo() { variable = “Hija”; super.metodo(); System.out.println(variable); System.out.println(super.variable); } }

Herencia Simple public class Employee { public String name = ""; public double salary; public Date birthDate; public String getDetails() {...} } public class Manager extends Employee { public String department; }

Conceptos Básicos de Java Herencia (2)

Visibilidad o Acceso

Overriding de métodos en herencia public class Employee { protected String name; protected double salary; protected Date birthDate; public String getDetails() { return “Name: “ + name + “\n” + “Salary: “ + salary; } } public class Manager extends Employee { protected String department; public String getDetails() { return “Name: “ + name + “\n” + “Salary: “ + salary + "\n" + “Manager of: “ + department; } }

Conceptos Básicos de Java