Conceptos Básicos de Java



Descargar 59,97 Kb.
Fecha de conversión25.04.2017
Tamaño59,97 Kb.
  • 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: indica al compilador dónde están ubicadas las clases que estamos importando.
  • Ejemplos:
    • Para importar sólo una clase de un paquete:
    • import .;
    • import java.lang.String;
    • Para importar todas las clases de un paquete:
    • import .*;
  • 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 como primer 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
  • ;
  • ó , ... ;
  • ejemplo: int x, y, z ;
  • Constantes: zona de memoria cuyos valores no cambian
  • final = ;
  • ejemplo: final double PI = 3.14159265 ;
  • Asignación de Variables: se utiliza el operador asignació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 ( ) {
  • // 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: ()
  • 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: =, +=, -=, *=, /=, %=
      • += => = +
      • Operadores incrementales: ++, --
  • siguiendo a la variable: ++, --
  • ejemplo: i=6;
  • j=i++; => j=i; i=i+1;
  • // resultado i=7 , j=6
  • precediendo a la variable: ++, --
  • 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: instanceof determina si un objeto pertenece a una clase
      • Operador condicional: ? :
      • ? :
      • Permite bifurcaciones condicionales sencillas
      • Operadores a nivel de bits: >>, <<, >>>, &, |, ^, ~
  • xor
  • 0
  • 1
  • 0
  • 0
  • 1
  • 1
  • 1
  • 0
  • 6^3=5
  • 110 con 11
  • 110
  • 11
  • 101
  • =5
  • -3 -2 -1 0 1 2 3
  • El cero pertenece a los naturales
  • ~2 = -3
  • ~-2 = 1
  • ~ es el complemento
  • ^ es el XOR
  • << corrimiento a la izquierda
  • >> corrimiento a la derecha
  • 27 26 25 24
  • 23 22 21 20
  • 8 4 2 1
  • 128 64 32 16
  • 1 1 0 1
  • =13
  • 13>>1=6
  • 1 1 0
  • 1 1 0 1 0
  • 13<<1=26
  • 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
  • Conceptos Básicos de Java
  • Control de Flujo (2)
  • if
  • if ()
  • ;
  • -------------------------------------------------------
  • if () {
  • ;
  • }
  • -------------------------------------------------------
  • if () { ;
  • }else{
  • ;
  • }
  • -------------------------------------------------------
  • if () { ;
  • }else if (){
  • ;
  • }else{
  • ;
  • }
  • 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");
  • }else if (nota<6) {
  • System.out.println("Suficiente");
  • }else{
  • System.out.println(“Muy Bien");
  • }
  • Conceptos Básicos de Java
  • Control de Flujo (3)
  • switch
  • switch ( ) {
  • case literal1:
  • [;]
  • [break;]
  • case literal2:
  • [;]
  • [break;]
  • ...
  • case literalN:
  • [;]
  • [break;]
  • [default:;]
  • }
  • 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 ( ; ; ) {
  • ;
  • }
  • asignación del valor inicial de las variables que intervienen en la expresión
  • condición booleana
  • nuevo valor de las variables en
  • 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 (){
  • ;
  • }
  • int cont = 0;
  • while (cont++ < 10) {
  • System.out.println(“contador:“ + i );
  • }
  • do while
  • do{
  • ;
  • }while ();
  • int cont = 0;
  • do{
  • System.out.println(“contador:“ + i );
  • } while (cont++ < 10);
  • 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.
  • resultado
  • Iteración: 1
  • Iteración: 2
  • int i;
  • for (i=1; i<=4; i++) {
  • if (i==3) break;
  • System.out.println("Iteración: "+i);
  • }
  • 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.
  • resultado
  • Iteración: 1
  • Iteración: 2
  • Iteración: 4
  • int i;
  • for (i=1; i<=4; i++) {
  • if (i==3) continue;
  • System.out.println("Iteración: "+i);
  • }

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
  • for (int j=0; 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 cada elemento en list hacer.

Redimensionando un Array

  • Qué hacemos entonces?
  • Usamos ARRAYCOPY
  • NO SE PUEDE HACER
  • 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);
  • Conceptos Básicos de Java
  • Clases
  • public class Fecha {
  • private int dia;
  • private int mes;
  • private int anio;
  • public Fecha(int vdia, int vmes, int vanio) {
  • dia = vdia;
  • mes = vmes;
  • anio = vanio;
  • }
  • public void mostrarFecha() {
  • System.out.println (dia+”/”+mes+”/”+anio);
  • }
  • public static void main(String[] args) {
  • Fecha MiFecha = new Fecha(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 (2)
  • Creación de Objetos
  • Se utiliza la palabra reservada new
  • ;
  • = new () ;
  • ó = new () ;
  • ejemplo: Fecha MiFecha ;
  • MiFecha
  • MiFecha = new Fecha (10, 08, 2003) ;
  • MiFecha
  • 0xFFFF0000
  • ????
  • 2003
  • anio
  • 08
  • mes
  • 10
  • dia

  • 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 (5)
  • Modificadores de Ámbito
  • Conceptos Básicos de Java
  • Clases (6)
  • Modificadores de Ámbito
  • Conceptos Básicos de Java
  • Clases (7)
  • Modificadores de Ámbito
  • Conceptos Básicos de Java
  • Clases (8)
  • 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: ( )
  • donde tipo devuelto por el método.
  • identificador válido en Java.
  • 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 class Fecha {
  • private int dia;
  • private int mes;
  • private int anio;
  • public Fecha(int vdia, int vmes, int vanio) {
  • dia = vdia;
  • mes = vmes;
  • anio = vanio;
  • }
  • public void mostrarFecha() {
  • 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
  • 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 class Fecha {
  • private int dia;
  • private int mes;
  • private int anio;
  • public Fecha(int dia, int mes, int anio) {
  • this.dia = dia;
  • this.mes = mes;
  • this.anio = anio;
  • }
  • public void mostrarFecha() {
  • 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 class Fecha {
  • private int dia;
  • private int mes;
  • private int anio;
  • public Fecha(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 class Fecha {
  • private int dia;
  • private int mes;
  • private int anio;
  • 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;
  • }
  • }

Los métodos overridden NO PUEDEN ser menos accesibles

  • public class Parent {
  • public void doSomething() {}
  • }
  • public class Child extends Parent {
  • private void doSomething() {} // illegal
  • }
  • public class UseBoth {
  • public void doOtherThing() {
  • Parent p1 = new Parent();
  • Parent p2 = new Child();
  • p1.doSomething();
  • p2.doSomething();
  • }
  • }
  • Conceptos Básicos de Java
  • Referencia super
  • super: es una palabra clave que se utiliza para referenciar atributos o métodos de la superclase que han sido sobrescritos por la clase hija.
  • Usos:
    • Cuando se hace referencia a un atributo de la clase padre.
  • 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);
  • }
  • }
  • Conceptos Básicos de Java
  • Referencia super (2)
    • Cuando se hace referencia a un método de la clase padre.
  • 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);
  • }
  • }
  • Conceptos Básicos de Java
  • Referencia super (3)
    • Cuando se hace referencia a un constructor de la clase padre.
  • class Padre {
  • String variable;
  • public Padre(String nombrevar) {
  • variable = nombrevar;
  • }
  • }
  • class Hija extends Padre {
  • String variable;
  • public Hija() {
  • super(“Padre”);
  • variable = “Hija”;
  • }
  • }
  • Conceptos Básicos de Java
  • Super
  • public String getDetails() {
  • return super.getDetails() + “\nDepartment: " + department;
  • }
  • 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
  • Polimorfismo
  • Polimorfismo: indica “muchas formas”. Una clase sólo tiene una forma, pero una variable que hace referencia a la superclase de una jerarquía puede tener muchas formas (una por cada subclase).

Objetos Polimórficos

  • Employee [] staff = new Employee[1024];
  • staff[0] = new Manager();
  • staff[1] = new Employee();
  • staff[2] = new Engineer();
  • public class TaxService {
  • public void chargeTax(){
    • TaxService taxSvc = new TaxService();
    • Manager m = new Manager();
    • TaxRate t = taxSvc.findTaxRate(m);
  • }
  • public TaxRate findTaxRate(Employee e) { …}
  • }

Operador instanceof

  • public class Employee extends Object
  • public class Manager extends Employee
  • public class Engineer extends Employee
  • ----------------------------------------
  • public void doSomething(Employee e) {
  • if ( e instanceof Manager ) {
  • …..
  • } else if ( e instanceof Engineer ) {
  • …..
  • } else {
  • ……
  • }
  • }

Casting de objetos

  • public void doSomething(Employee e) {
  • if ( e instanceof Manager ) {
  • Manager m = (Manager) e;
  • System.out.println(“This is the manager of ” + m.getDepartment());
  • }
  • …..
  • }
  • Conceptos Básicos de Java
  • Clases Abstractas
  • Clases Abstractas: una clase abstracta representa un concepto abstracto.
  • Una clase abstracta sólo puede ser heredada, pero nunca puede ser instanciada.
  • Se declara anteponiendo el modificador abstract a la palabra clave class.
  • Una clase abstracta puede contener métodos abstractos y métodos con implementación.
  • Un método es abstracto si se declara con el modificador abstract (dentro de una clase abstracta), pero no se implementa.
  • Las subclases de una clase abstracta deben implementar los métodos abstractos que tenga definidos.
  • Sintaxis: abstract class NombreClase
  • Conceptos Básicos de Java
  • Clases Abstractas (2)
  • Ejemplo:

Conceptos Básicos de Java

  • public class Count {
  • private int serialNumber;
  • public static int counter = 0;
  • public Count() {
    • counter++;
    • serialNumber = counter;
  • }
  • }
  • static
  • Ejemplo para atributos:
  • public class OtherClass {
  • public void incrementNumber() {
  • Count.counter++;
  • }
  • }
  • llamando desde otra clase

Conceptos Básicos de Java

  • public class Count2 {
  • private int serialNumber;
  • private static int counter = 0;
  • public static int getTotalCount() {
  • return counter;
  • }
  • public Count2() {
  • counter++;
  • serialNumber = counter;
  • }
  • }
  • Static Ejemplo para métodos:
  • public class TestCounter {
  • public static void main(String[] args) {
  • System.out.println("Number of counter is "
  • + Count2.getTotalCount());
  • Count2 counter = new Count2();
  • System.out.println("Number of counter is "
  • + Count2.getTotalCount());
  • }
  • }
  • llamando desde otra clase
  • public class Count3 {
  • private int serialNumber;
  • private static int counter = 0;
  • public static int getSerialNumber() {
  • return serialNumber; // COMPILER ERROR!
  • }
  • }
  • Los métodos static no pueden ser accedidos como variables de instancia !!!!
  • Conceptos Básicos de Java
  • Static Ejemplo para métodos:
  • public class Count4 {
  • public static int counter;
  • static {
  • counter = Integer.getInteger("myApp.Count4.counter").intValue();
  • }
  • }
  • public class TestStaticInit {
  • public static void main(String[] args) {
  • System.out.println("counter = "+ Count4.counter);
  • }
  • }
  • Conceptos Básicos de Java
  • Inicializadores Static Ejemplo :
  • Interfaces
  • Interfaces: una interfaz es una colección de definiciones de métodos sin implementación y declaraciones de constantes, agrupadas bajo un nombre.
  • Define un protocolo de comportamiento que debe ser implementado por cualquier clase que pretenda utilizar ciertos servicios, con independencia de las relaciones jerárquicas.
  • Las interfaces sirven para:
    • Declarar métodos que serán implementados por una o más clases. Define un conjunto de métodos pero no los implementa.
    • Definir la interfaz de programación de un objeto, sin mostrar el cuerpo actual de la clase.
  • Una interfaz permite a objetos no relacionados interactuar.
  • Una clase que implementa una interfaz debe implementar cada uno de los métodos que ésta define.
  • Una interfaz puede extender múltiples interfaces. Por lo tanto, se tiene herencia múltiple de interfaces. Una interfaz sólo puede ser extendida por otra interfaz.
  • Una clase puede implementar varias interfaces.
  • Conceptos Básicos de Java
  • Conceptos Básicos de Java
  • Interfaces
  • Declaracion:
  • Conceptos Básicos de Java
  • Interfaces
  • Representación en UML:
  • public interface Flyer {
  • public void takeOff();
  • public void land();
  • public void fly();
  • }
  • public class Airplane implements Flyer {
  • public void takeOff() {…}
  • public void land() {….}
  • public void fly() {….}
  • }
  • Conceptos Básicos de Java
  • Interfaces
  • Representación en UML:

Control de Flujo de las instrucciones de

  • Selección :
    • if, if-else y switch.
  • Iteración :
    • while, do-while y for.
  • Transferencia :
    • break, continue, return, try-catch-finally y assert.

Ejemplo

Ejemplo mejorado

Try-catch, con múltiples catch

Usando finally

  • Siempre se ejecuta

Categorias de Exception

THROWS

  • Try - catch
  • Intentando atrapar ….
  • ?

THROWS

Ejemplo de Throws

Clase personal hija de Exception

Captura de nuestra Exception

Ejercicio

System Properties

  • Lo usamos para dialogar con las variables del entorno del sistema operativo
  • System.getProperties, devuelve un objeto Properties
  • System.getProperty, devuelve un String con el valor de determinada propiedad
  • El objeto Properties tiene un método propertiesNames() que se recorre con un Enumeration

Ejemplo

Consola I/O

  • System.out : salida estándar al monitor
  • System.in : entrada estándar del teclado
    • Genera un objeto de tipo InputStream
  • System.err : escribe un error estándar

Ejemplo para leer del teclado

Otro Ejemplo para leer del teclado

Files

  • File myFile;
  • myFile = new File("myfile.txt");
  • myFile = new File("MyDocs", "myfile.txt");
  • Import java.io

Leer y Escribir Files

  • Para Leer:
    • FileReader (lee caracteres)
    • BufferedReader (tiene declarado el método readLine)
  • Para Escribir:
    • FileWriter (escribe caracteres)
    • PrintWriter (tiene declarado los métodos print y println)

Ejemplo de Lectura de un File

Ejemplo de Escritura de un File

Collections

  • Un Collection es un objeto que representa un grupo de objetos conocidos como elementos
  • Colección ordenada
  • CON elementos duplicados

Ejemplo para SET

  • import java.util.*;
  • public class SetExample {
  • public static void main(String[] args) {
  • Set set = new HashSet();
  • set.add("one");
  • set.add("second");
  • set.add("3rd");
  • set.add(new Integer(4));
  • set.add(new Float(5.0F));
  • set.add("second"); // duplicate, not added
  • set.add(new Integer(4)); // duplicate, not added
  • System.out.println(set);
  • }
  • }
  • [one, second, 5.0, 3rd, 4]
  • Imprime:

Ejemplo para LIST

  • import java.util.*
  • public class ListExample {
  • public static void main(String[] args) {
  • List list = new ArrayList();
  • list.add("one");
  • list.add("second");
  • list.add("3rd");
  • list.add(new Integer(4));
  • list.add(new Float(5.0F));
  • list.add("second"); // duplicate, is added
  • list.add(new Integer(4)); // duplicate, is added
  • System.out.println(list);
  • }
  • }
  • [one, second, 3rd, 4, 5.0, second, 4]
  • Imprime:

Collections desde la versión 1.1

  • La clase Vector implementa la interface List.
  • La clase Stack es una subclase de Vector y soporta los métodos push, pop, y peek.
  • La clase Hashtable implementa la interface Map.
  • La interface Enumeration es una variación de la interface Iterator.
  • Un enumeration es devuelto en los métodos de Vector, Stack, y Hashtable.

Collections : Generics

  • • Elimina la necesidad de hacer casting
  • Antes de Generics
  • ArrayList list = new ArrayList();
  • list.add(0, new Integer(42));
  • int total = ((Integer)list.get(0)).intValue();
  • Después de Generics
  • ArrayList list = new ArrayList();
  • list.add(0, new Integer(42));
  • int total = list.get(0).intValue();

Iterators

  • • Iteration es el proceso de recuperar cada elemento en una collecion.
  • • Un Iterator de un Set está desordenado.
  • • Un ListIterator de un List puede ser escaneado hacia adelante (usando el método next ) o hacia atrás (usando el método previous).
  • Ejemplo:
  • List list = new ArrayList();
  • add some elements
  • Iterator elements = list.iterator();
  • while ( elements.hasNext() ) {
  • System.out.println(elements.next());
  • }

Jerarquía de Iterator en el API

FOR: para recorrer Collections

  • Usando FOR con iterators:
  • public void deleteAll(Collection c){
  • for ( Iterator i = c.iterator() ; i.hasNext() ; ){
  • NameList nl = i.next();
  • nl.deleteItem();
  • }
  • }
  • Usando FOR con Collecion:
  • public void deleteAll(Collection c){
  • for ( NameList nl : c ){
  • nl.deleteItem();
  • }
  • }

FOR: para recorrer Collections

  • Usando FOR con arrays:
  • public int sum(int[] array){
  • int result = 0;
  • for ( int element : array ) {
  • result += element;
  • }
  • return result;
  • }
  • Usando FOR anidados:
  • List subjects=...;
  • List teachers=...;
  • List courseList = new ArrayList();
  • for ( Subject subj : subjects ) {
  • for ( Teacher tchr : teachers ) {
  • courseList.add(new Course(subj, tchr));
  • }
  • }


La base de datos está protegida por derechos de autor ©absta.info 2016
enviar mensaje

    Página principal