RSS

Archivos Mensuales: junio 2011

Deberes – Orientación a objetos (II)

En Orientación a objetos (II) hablamos del Polimorfismo, de las colecciones hetereogéneas y de la Sobrecarga de métodos.

Vamos a practicar y a resolver ejercicios relacionados con estos temas.

  • Ejercicio 1: Crear las siguientes clases.

Realizar constructores por defecto y constructor con parámetros.
Sobrescribir el método mostrar() en las subclases para que muestren sus atributos específicos.
Razonar qué instrucciones serían correctas y cuales serían los resultados en la siguiente clase principal. Comprobar ejecutando.

public class MainProducto {

  public static void cartel(Producto p){
    System.out.println("¡¡Los mejores productos!!");
  }

  public static void cartel(Ordenador o){
    System.out.println("Oferta HP 620 T4500 - solo 378€");
  }

  public static void cartel(Mp3 m){
    System.out.println("Oferta MP3 Creative Zen 8GB 80.20€");
  }

  public static void cartel(DiscoDuro d){
    System.out.println("Oferta Western Digital 1 Tera 45.30€");
  }

  public static void main(String[] args) {
      Producto p1 = new Ordenador();
      Ordenador o1 = new Producto();
      Mp3 m1 = new Producto();
      Ordenador o2 = new DiscoDuro();
      Producto p2 = new DiscoDuro();
      Producto p3 = new Mp3();

      p1.mostrar();
      p2.mostrar();
      p3.mostrar();

      cartel(p1);
      cartel(p2);
      cartel(p3);

}

}
  • Ejercicio 2: Crear una clase principal que cree varios objetos de las clases anteriores, tanto de Producto como de DiscoDuro, MP3 y Ordenador. Crear un array de Producto para guardarlos. Rebajar el precio de todos los productos en 10.50 y mostrar el resultado.

Si te gusta esta entrada, vótala en Bitácoras.com votar

¿Cómo ves esta entrada o el blog? Deja un comentario!

 
1 comentario

Publicado por en 29 junio, 2011 en Deberes

 

Etiquetas: , , , , , ,

Reservar fecha y pago Examen – OCP Java Programmer (antiguo SCJP)

Desde principios de Junio de este año tanto la inscripción al examen como el pago se hace a través de Pearson Vue.

Lo primero que debemos hacer es registrarnos en la web. Nos pedirán datos como nuestro nombre, email, telefono, dirección, y nombre de usuario.

Una vez que nos hemos registrado nos aparece el botón ‘Schedule your exam’ donde podemos elegir el examen, el centro y la fecha.

Os dejo unas capturas (hacer click para ver mejor) :

1. Selección del Examen: (Aparece una lista para escoger el idioma, yo escogí Spanish-Modern)

2. Buscamos los centros de examen más cercanos y podemos chequear hasta cuatro para ver la disponibilidad de fechas que tienen y así elegir la que más nos convenga.

En la captura aparecen los centros más cercanos a Sevilla.

3. Elegir fecha y hora del examen. Para cada centro podemos ver las fechas que tienen disponibles. Podemos hacer click en los días señalados que nos aparece en el calendario y nos apareceran las horas disponibles. También podemos hacer click en la flecha que aparece a la izquierda y nos saca todas las citas disponibles de la semana.

En la captura nos aparecen las horas de los días 6 y 8 de Septiembre de 2011 en el centro ANFORA FORMACION.

Solo tendríamos que seleccionar el día y hora que queramos y pulsar Next.
Los pasos posteriores son la revisión de los datos, pago, confirmación  y recibo.

 

Actualizacion a 17/04/2012:

El precio del examen son 238 € más 42.84€ de impuestos, 280.84€ en total.
Si tenéis un Voucher, existe un cuadro de texto para informarlo y al actualizar el importe será de 0€.

 

Espero que os sea de ayuda. El proceso es muy sencillo y rápido.

Enlaces:

Java Certificacion Exams and Their Move to Pearson VUE.

Ayuda de Pearson Vue

Localizador de Centros de Examen

Si te gusta esta entrada, vótala en Bitácoras.com votar

¿Cómo ves esta entrada o el blog? Deja un comentario!

 
15 comentarios

Publicado por en 28 junio, 2011 en Examen

 

Etiquetas: , , , ,

Solucion – Deberes Orientacion Objetos (I)

Pongo la solución a los ejercicios anteriores en esta nueva entrada para no hacer excesivamente larga la anterior.

Ejercicio 1: Veamos las clases y qué debemos cambiar.

La clase Concurso tiene sus atributos públicos y de esta forma se puede acceder a ellos directamente en la clase mainConcurso e incluso darles valores incorrectos a los atributos.

Deberíamos hacer estos atributos privados y proveer métodos getters y setters que tengan en cuenta las condiciones que vemos para los atributos en el constructor.

En la clase mainConcurso se deben usar los métodos getters y setters de la clase Concurso.

Modificaciones clase Concurso:

import java.util.*;
import java.text.*;
public class Concurso{

    //1. Ponemos privados los atributos
     private int codConcurso;
     private int codOrgano;
     private String titulo;
     private int tipo;
     private Date fechaResolucion;

    //2. Creamos métodos getters y setters para los atributos.
     public void setCodConcurso(int codConcurso){
         if(codConcurso>0){
             this.codConcurso = codConcurso;
         }
     }

     public int getCodConcurso(){
         return codConcurso;
     }

     public void setCodOrgano(int codOrgano){
         this.codOrgano = codOrgano;
     }
     public int getCodOrgano(){
         return codOrgano;
     }

     public void setTitulo(String titulo){
         this.titulo = titulo;
     }
     public String getTitulo(){
         return titulo;
     }

     public void setTipo(int tipo){
        if(tipo>0 && tipo<4){
            this.tipo = tipo;
        }
        else {
            System.out.println("Fecha incorrecta");
        }
    }
    public int getTipo(){
       return tipo;
    }

    public void setFechaResolucion(String fechaResolucion){
       DateFormat df = new SimpleDateFormat("dd/MM/yyyy")<wbr>;
       try {
           this.fechaResolucion = df.parse(fechaResolucion);
       }
       catch (ParseException e){
           System.out.println("Fecha incorrecta");
       }
    }

 //Aunque se guarde internamente como Date para los que
 //usen la clase vamos a devolver un string formateado.
   public String getFechaResolucion(){
       SimpleDateFormat sdf = new SimpleDateFormat ("dd/MM/yyyy");
       String fecha = sdf.format(fechaResolucion);
       return fecha;
  }

 public Concurso(int codConcurso, int codOrgano, String titulo, int tipo, String fechaResolucion){
     if (codConcurso > 0){
         this.codConcurso = codConcurso;
     }
     else
     {
         this.codConcurso = -1;
     }

     this.codOrgano = codOrgano;
     this.titulo = titulo;

     if (tipo>0 && tipo <4)
     {  this.tipo = tipo;}
     else
     {  this.tipo = -1; }

     DateFormat df = new SimpleDateFormat("dd/MM/yyyy")<wbr>;
     try {
         this.fechaResolucion = df.parse(fechaResolucion);
     }
     catch (ParseException e){
         e.printStackTrace();
     }
 }

Modificamos la clase principal MainConcurso:

public class mainConcurso{

    public static void main(String[] args) {

    Concurso c = new Concurso(100, 105082, "Adjudicación suministro licencias SW.",1, "20/06/2011");

    //Modificamos los atributos con setters.
    c.setCodConcurso(-199);
    c.setTipo(5);

    //Para mostrar los datos utilizamos los getters.
    //Como getFechaResolucion devuelve ahora un String la salida es más
    //amigable.
    System.out.println("Concurso " + c.getCodConcurso() + ": " + c.getTitulo()
+ "\n Tipo: " + c.getTipo() + " Fecha Res: " + c.getFechaResolucion());

    }
}

Ejercicio 2: Creamos la jerarquía de clases.

Primero la clase Persona:

public class Persona{
    private String codPersona;
    private String nombre;
    private int edad;
    private String telContacto;

    //Constructor
    public Persona(String codPersona, String nombre, int edad, String telContacto){
        this.codPersona = codPersona;
        this.nombre = nombre;
        this.edad = edad;
        this.telContacto = telContacto;
    }

    //Getters y Setters
    public String getCodPersona(){
        return codPersona;
    }
    public void setCodPersona(String codPersona){
        this.codPersona = codPersona;
    }
    public String getNombre(){
        return nombre;
    }
    public void setNombre(String nombre){
        this.nombre = nombre;
    }
    public int getEdad(){
        return edad;
    }
    public void setEdad(int edad){
        this.edad = edad;
    }
    public String getTelContacto(){
        return telContacto;
    }
    public void setTelContacto(String telContacto){
        this.telContacto = telContacto;
    }

    //Métodos
    public void mostrar(){
         System.out.println("Persona: " + codPersona + "-" + nombre + "\n Edad: " + edad + "\n TelContacto: " + telContacto + "\n");
    }
}

La clase Alumno:
Para poder mostrar bien el atributo asignaturas, que es un array de String, hemos creado una función AsignaturasToString que se utiliza en el método a sobrescribir mostrar().

public class Alumno extends Persona{
    private int curso;
    private String[] asignaturas;

    //Constructor
    public Alumno(String codPersona, String nombre, int edad, String telContacto,int curso, String[]asignaturas){
        super(codPersona, nombre, edad, telContacto);
        this.curso = curso;
        this.asignaturas = asignaturas;
    }

    //Getters y Setters
    public int getCurso(){
        return curso;
    }

    public void setCurso(int curso){
        this.curso = curso;
    }
    public String[] getAsignaturas(){
        return asignaturas;
    }
    public String AsignaturasToString(){
        String resultado = "Asignaturas: ";
        for (int i=0; i<asignaturas.length; i ++)
        {
             if (i == 0){
                 resultado = resultado + asignaturas[i];
             }
             else {
                 resultado = resultado + ", " + asignaturas[i];
             }
        }
        return resultado;
    }

    public void setAsignaturas(String []asignaturas){
         this.asignaturas = asignaturas;
    }

    //Métodos
    public void mostrar(){
        System.out.println("Alumno: " + getNombre() + "\n Curso: " + curso + " " +  AsignaturasToString() + "\n");
    }
}

La clase Profesor:

public class Profesor extends Persona{

private float salario;
private String fecContratacion;

//Constructor
public Profesor(String codPersona, String nombre, int edad, String telContacto, float salario, String fecContratacion){
    super(codPersona, nombre, edad, telContacto);
    this.salario = salario;
    this.fecContratacion = fecContratacion;
}

//Getters y Setters
public float getSalario(){
    return salario;
}
public void setSalario(float salario){
    this.salario = salario;
}
public String getFecContratacion(){
    return fecContratacion;
}
public void setFecContratacion(String fecContratacion){
    this.fecContratacion = fecContratacion;
}

//Métodos
public void mostrar(){
    System.out.println("Profesor: " + getNombre() + "\n Salario: " + salario + "\n FecContratacion: " + fecContratacion + "\n");
}

}

Creamos una clase principal para ver los resultados:

public class MainPersonas {

public static void main(String[] args) {
    //Creamos una persona
    Persona p = new Persona("001", "Lola Gomez", 19, "600101010");

    //Creamos un alumno y lo mostramos.
    String[] asigA = {"IP1", "IP2", "IMD", "CI", "EST"};
    Alumno a = new Alumno("002", "Novatín Chiquitito", 20, "606514458", 2, asigA);
    a.mostrar();

    //Cambiamos las asignaturas del alumno y lo mostramos.
    String[] asigB = {"IP1","IP2","CI"};
    a.setAsignaturas(asigB);
    a.mostrar();

    //Creamos un profesor
    Profesor pro = new Profesor("003", "Amparo Osuna", 45, "615010250", 1500.50f, "12/03/1990" );

    //Mostramos la persona y el profesor.
    p.mostrar();
    pro.mostrar();
 }
}

Si te gusta esta entrada, vótala en Bitácoras.com votar

¿Cómo ves esta entrada o el blog? Deja un comentario!

 
1 comentario

Publicado por en 23 junio, 2011 en Deberes

 

Etiquetas: , , , , , ,

Deberes – Orientacion a Objetos (I)

En la entrada Orientación a Objetos(I)
hablamos de la encapsulación, la herencia y la sobrescritura de métodos.

Vamos a poner en práctica estos conceptos con algunos ejercicios:

  • Ejercicio1: Las siguientes clases no están aplicando la encapsulación. Modificar la clase Concurso y la clase mainConcurso para que la apliquen.
    import java.util.*;
    import java.text.*;
    public class Concurso{
        public int codConcurso;
        public int codOrgano;
        public String titulo;
        public int tipo;
        public Date fechaResolucion;

        public Concurso(int codConcurso, int codOrgano, String titulo, int tipo, String fechaResolucion){

            if (codConcurso > 0){
                this.codConcurso = codConcurso;
            }
            else
            {
                this.codConcurso = -1;
            }

            this.codOrgano = codOrgano;
            this.titulo = titulo;

            if (tipo>0 && tipo <4)
            {  this.tipo = tipo;}
            else
            {  this.tipo = -1; }

            DateFormat df = new SimpleDateFormat("dd/MM/yyyy")<wbr>;
            try {
              this.fechaResolucion = df.parse(fechaResolucion);
            }
            catch (ParseException e){
              e.printStackTrace();
            }
      }

}
 

La clase principal:

public class mainConcurso{

    public static void main(String[] args) {

    Concurso c = new Concurso(100, 105082, "Adjudicación suministro licencias SW.",1, "20/06/2011");

    c.codConcurso = -199;
    c.tipo = 5;

    System.out.println("Concurso " + c.codConcurso + ": " + c.titulo
    + "\n Tipo: " + c.tipo + " Fecha Res: " + c.fechaResolucion);

    }
}

La clase Concurso tiene un atributo fechaResolución de tipo Date.
Para más información sobre los tipos de fechas en Java, estos enlaces puede ser útiles: http://t.co/Y1XgxJL, http://t.co/RKrimEf

 

  • Ejercicio 2: Crear la clase Persona y las subclases Alumno y Profesor.La clase Persona puede tener los siguientes atributos: String codPersona, String nombre, int edad, String telContacto.

    La clase Alumno puede tener los siguientes atributos: int curso, String[] asignaturas. La clase Profesor puede tener los siguientes atributos: float salario, String fecContratacion.Sobrescribir el método void mostrar(), que se encargará de mostrar los atributos específicos de cada clase.

 
1 comentario

Publicado por en 22 junio, 2011 en Deberes

 

Etiquetas: , , , , , ,

Orientación a Objetos (VIII) – Acoplamiento y Cohesión

Uno de los objetivos más importantes del diseño orientado a objetos es conseguir una alta cohesión entre clases y un bajo acoplamiento.

¿Qué es la cohesión?
La medida que indica si una clase tiene una función bien definida dentro del sistema. El objetivo es enfocar de la forma más precisa posible el propósito de la clase. Cuanto más enfoquemos el propósito de la clase, mayor será su cohesión.

Una prueba fácil de cohesión consiste en examinar una clase y decidir si todo su contenido está directamente relacionado con el nombre de la clase y descrito por el mismo.

Una alta cohesión hace más fácil:

  • Entender qué hace una clase o método
  • Usar nombres descriptivos
  • Reutilizar clases o métodos

 

¿Qué es el acoplamiento?
El acoplamiento entre clases es una medida de la interconexión o dependencia entre esas clases.

El acoplamiento fuerte significa que las clases relacionadas necesitan saber detalles internos unas de otras, los cambios se propagan por el sistema y el sistema es posiblemente más difícil de entender.

Por ello deberemos siempre intentar que nuestras clases tengan un acoplamiento bajo. Cuantas menos cosas conozca la clase A sobre la clase B, menor será su acoplamiento.

Lo ideal es conseguir que la clase A sólo conozca de la clase B lo necesario para que pueda hacer uso de los métodos de la clase B, pero no conozca nada acerca de cómo estos métodos o sus atributos están implementados.

Los atributos de una clase deberán ser privados y la única forma de acceder a ellos debe ser a través de los métodos getter y setter.

Un bajo acoplamiento permite:

  • Entender una clase sin leer otras
  • Cambiar una clase sin afectar a otras
  • Mejora la mantenibilidad del código

Para saber más:
Msdn Magazine – Cohesión y acoplamiento
Cohesion and Coupling Metrics(1)
Cohesion and Coupling Metrics(2)

 
4 comentarios

Publicado por en 16 junio, 2011 en Estudio, Tema 2

 

Etiquetas: , , , , , ,

Orientación a Objetos (VII) – Miembros estáticos

Static

La palabra clave static declara miembros (atributos, métodos y clases anidadas) que están asociados a la clase en lugar de a una instancia de la clase.

Utilidad

A veces puede ser útil tener una variable compartida por todos los objetos de la clase (algo parecido a una variable global). En este caso marcaríamos esta variable como static.

Si una variable static no se marca como private, es posible acceder a ella desde fuera de la clase. Para hacerlo, no se necesita ningún objeto, se hace referencia a ella mediante el nombre de la clase.

Por ejemplo, un caso común es un contador de los objetos instanciados de una clase:

public class Leccion{
    public static int contador; //variable estática, asociada a la clase
    private int idLeccion;      //atributos, variables no estáticas
    private String desLeccion; //asociadas a los objetos

    public Leccion()
    {
        contador = contador + 1;  //podemos usar el contador para el id de cada objeto Leccion.
        idLeccion = contador;
        desLeccion = "Sin nombre";
    }
}

 

public class MainLeccion{
    public static void main (String[] args){
        System.out.println("Contador: " + Leccion.contador); //Muestra 0
        Leccion l1 = new Leccion();
        Leccion l2 = new Leccion();
        System.out.println("Contador: " + Leccion.contador); //Muestra 2
    }

}

O cuando necesitemos un método cuyo código no dependa de los atributos de un objeto de la clase. En este caso marcaríamos este método como static.

Por ejemplo, podríamos hacer la variable estática anterior privada y obtener el número de objetos Leccion creados mediante un método getContador().

public class Leccion{
    private static int contador; //variable estática, asociada a la clase
    public static int getContador(){ //método estático
         return contador;
    }

    private int idLeccion;     //atributos, variables no estáticas
    private String desLeccion; //asociadas a los objetos

    public Leccion()
    {
        contador = contador + 1;  //podemos usar el contador para el id de cada objeto Leccion.
        idLeccion = contador;
        desLeccion = "Sin nombre";
    }
}

En la clase principal ahora llamaríamos al método estático:

public class MainLeccion{
    public static void main (String[] args){
        System.out.println("Contador: " + Leccion.getContador()); //Muestra 0
        Leccion l1 = new Leccion();
        Leccion l2 = new Leccion();
        System.out.println("Contador: " + Leccion.getContador()); //Muestra 2
    }


Accediendo a Miembros Estáticos

Anteriormente hemos visto que para acceder a las variables y métodos estáticos hemos utilizado el nombre de la clase y el operador punto. Es lo más lógico dado que las variables y métodos estáticos pertenecen a la clase, pero Java permite también acceder a los miembros estáticos utilizando un objeto.

Java lo permite pero el compilador realmente lo sustituirá por el nombre de la clase.

En el ejemplo anterior podíamos haber escrito:

 System.out.println("Contador: " + l2.getContador());

Esto último solo lo podremos hacer si existe una instancia de la clase.

Redefinición en Métodos Estáticos

Los métodos estáticos no se pueden sobrescribir (override), sin embargo si es posible tener el mismo método en una subclase. Esto se denomina redefinición o ocultación.

Si se llama al método con una referencia de objeto, el método llamado será el correspondiente a la clase para la que se haya declarado la variable.

¿Qué diferencia existe entre la sobrescritura y la redefinición?

La sobrescritura (override) está íntimamente ligada al polimorfismo. Como los métodos estáticos están asociados a la clase en lugar de a los objetos, el polimorfismo en tiempo de ejecución no es posible y por lo tanto no es sobrescritura sino redefinición.

Veamos la diferencia. Creamos una clase Persona y una subclase Cliente. Creamos un método no estático, mostrar() y un método estático, mostrarStatic() en cada una de las clases.

public class Persona{
    private String nif;
    private String nombre;
    private int edad;

    public Persona(String nif, String nombre, int edad){
        this.nif = nif;
        this.nombre = nombre;
        this.edad = edad;
    }
    ... //getters, setters

    public void mostrar(){
        System.out.println("Persona " + nif + ":  \n Nombre: " + nombre + "\n Edad: " + edad);
    }
    public static void mostrarStatic(){
        System.out.println("Clase Persona");
    }
}

 

public class Cliente extends Persona{
    private int id;
    private int antiguedad;
    private int descuento;

    public Cliente(String nif, String nombre, int edad, int id, int antiguedad, int descuento) {
        super(nif, nombre, edad);
        this.id = id;
        this.antiguedad = antiguedad;
        this.descuento = descuento;
    }
    ... // getters, setters

    public void mostrar(){
        System.out.println("Cliente" + id + ":  \n Nombre: " + getNombre()
         + "\n Antigüedad: " + antiguedad + "\n Descuento: " + descuento);
    }
    public static void mostrarStatic(){
        System.out.println("Clase Cliente");
    }
}

Con esta definición de clases si creamos los siguientes objetos tendríamos los siguientes resultados:

  public class MainSobrescritura{
      public static void main(String[] args){
          Persona per = new Persona("18520147L", "Maria Victoria Rodriguez", 18);
          Cliente cli = new Cliente("20415789M", "Secundino Jimenez", 25, 504, 5, 1);
          Persona per2 = new Cliente("41605788R", "Luis Martin", 30, 905, 3, 2);

          per.mostrar(); //llama a mostrar() de Persona
          cli.mostrar(); //llama a mostrar() de Cliente
          per2.mostrar();//llama a mostrar() de Cliente
      }
  }

Ahora veamos lo que ocurre con un método estático:

public class MainRedefinicion{
    public static void main(String[] args){
       Persona per = new Persona("18520147L", "Maria Victoria Rodriguez", 18);
       Cliente cli = new Cliente("20415789M", "Secundino Jimenez", 25, 504, 5, 1);
       Persona per2 = new Cliente("41605788R", "Luis Martin", 30, 905, 3, 2);

        per.mostrarStatic(); //llama a mostrarStatic de Persona
        cli.mostrarStatic(); //llama a mostrarStatic de Cliente
        per2.mostrarStatic();//llama a mostrarStatic de Persona y no de Cliente como arriba.
    }
}

Vemos que en los métodos estáticos el método llamado será el de la clase declarada en tiempo de compilación y no en tiempo de ejecución como pasa con los métodos no estáticos sobrescritos.

Acceso en un método estático

Un método estático no puede acceder a ninguna variable salvo a las variables locales, los atributos static y sus parámetros. Cualquier intento de acceder a atributos que no sean estáticos directamente (sin crear un objeto) provoca un error de compilación.

Nota

El método main es también un método estático. Podemos comprobar que no creamos ningún objeto para ejecutarlo.Si necesita datos miembro se deben crear objetos dentro de main.

 
1 comentario

Publicado por en 10 junio, 2011 en Estudio, Tema 2

 

Etiquetas: , , , , ,

Orientación a Objetos (VI) – Constructores

Constructores

Los constructores son métodos especiales que se utilizan para inicializar un objeto de una clase.
Los constructores son la única forma de crear un objeto en Java.

El nombre del constructor debe ser idéntico al de la clase y no tendrá tipo de retorno. Los modificadores de acceso válidos para los constructores son: public, protected y private.

Una clase puede tener cualquier número de constructores. Todos tendrán el mismo nombre y al igual que otros métodos sobrecargados, los constructores se diferenciaran unos de otros en el número y en el tipo de sus parámetros.

La sintaxis será:
[modificador acceso] nombreClase ([listaParámetros]) {…}

Encadenamiento de Constructores

Para llamar al constructor utilizaremos la palabra clave new. Además, con esta palabra clave, no sólo estamos invocando al constructor de la clase de nuestro objeto, sino también a los constructores de las superclases.

Por ejemplo, imaginemos que tenemos la siguiente clase:

 public class Solicitante extends Persona extends Object {
 ...
 }
 

Al crear un objeto con new,

...
 Solicitante solAyuda1 = new Solicitante();
...

se llamará al constructor de Solicitante, que llamará al constructor de Persona, que llamará al constructor de Object. Después, terminará el constructor de Object, terminará el constructor de Persona inicializando los atributos que le correspondan, y terminará el constructor de Solicitante inicializando los atributos que le correspondan.

El Constructor es Obligatorio

Todas las clases deben tener un constructor, incluso las clases abstractas.

Si no escribimos un constructor para una clase el compilador añade uno por defecto.
En este caso, el constructor no tendrá parámetros, su cuerpo estará vacío y tendrá el mismo modificador de acceso que la clase.

Por ejemplo, para esta clase que no hemos escrito constructor:

public class Persona{
    private String id;
    private String nombre;
    private String movil;
}

El compilador insertaría:

public class Persona{
    private String id;
    private String nombre;
    private String movil;
    public Persona(){}
}

En el momento en que escribamos un constructor (con o sin parámetros) el constructor por defecto se perderá.

A Recordar

  • Cada constructor debe tener en su primera línea una llamada a otro constructor sobrecargado, (this) o una llamada al constructor de la superclase (super).
  • En el caso de que no escribamos la llamada a super, el compilador insertará automáticamente una llamada a super sin parámetros, super().
  • Sólo es posible llamar a a un constructor desde otro constructor.
  • Las interfaces no pueden tener constructores, ya que no son clases.
  • La llamada al constructor de la superclase mediante super puede ser con o sin parámetros.
  • Si el constructor de la superclase necesita parámetros y en el constructor de la subclase hacemos una llamada a super sin parámetros fallará.
  • Las clases abstractas también tienen constructores. Estos constructores serán llamados cuando se ejecute el constructor de las subclases que la concretan.

Ver También: Sobrecarga de Constructores

 
1 comentario

Publicado por en 8 junio, 2011 en Estudio, Tema 2

 

Etiquetas: , , , ,

 
A %d blogueros les gusta esto: