CLASES ABSTRACTOS

El sentido está en que una superclase permite unificar campos y métodos de las subclases, evitando la repetición de código y unificando procesos. Ahora bien, una clase de la que no se tiene intención de crear objetos, sino que únicamente sirve para unificar datos u operaciones de subclases, puede declararse de forma especial en Java: como clase abstracta. La declaración de que una clase es abstracta se hace con la sintaxis public abstract class NombreDeLaClase { … }. Por ejemplo public abstract class Profesor. Cuando utilizamos esta sintaxis, no resulta posible instanciar la clase, es decir, no resulta posible crear objetos de ese tipo. Sin embargo, sigue funcionando como superclase de forma similar a como lo haría una superclase “normal”. La diferencia principal radica en que no se pueden crear objetos de esta clase.

Declarar una clase abstracta es distinto a tener una clase de la que no se crean objetos. En una clase abstracta, no existe la posibilidad. En una clase normal, existe la posibilidad de crearlos aunque no lo hagamos. El hecho de que no creemos instancias de una clase no es suficiente para que Java considere que una clase es abstracta. Para lograr esto hemos de declarar explícitamente la clase como abstracta mediante la sintaxis que hemos indicado. Si una clase no se declara usando abstract se cataloga como “clase concreta”. En inglés abstract significa “resumen”, por eso en algunos textos en castellano a las clases abstractas se les llama resúmenes. Una clase abstracta para Java es una clase de la que nunca se van a crear instancias: simplemente va a servir como superclase a otras clases. No se puede usar la palabra clave new aplicada a clases abstractas. En el menú contextual de la clase en BlueJ simplemente no aparece, y si intentamos crear objetos en el código nos saltará un error.

INTERFAZ

Una interfaz en Java es una colección de métodos abstractos y propiedades constantes.

En las interfaces se especifica qué se debe hacer pero no su implementación. Serán las clases que implementen estas interfaces las que describan la lógica del comportamiento de los métodos.

La principal diferencia entre interface y abstract es que un interface proporciona un mecanismo de encapsulación de los protocolos de los métodos sin forzar al usuario a utilizar la herencia.

VENTAJAS:

El uso de las interfaces Java proporciona las siguientes ventajas:

• Organizar la programación.
• permiten declarar constantes que van a estar disponibles para todas las clases que queramos (implementando esa interfaz)
• Obligar a que ciertas clases utilicen los mismos métodos (nombres y parámetros).
• Establecer relaciones entre clases que no estén relacionadas.            

COMO SE UTILIZA:

Java proporciona dos palabras reservadas para trabajar con interfaces: interface e implements.

Para declarar una interfaz se utiliza:

    modificador_acceso interface NombreInterfaz {
        ....
    }

modificador_acceso puede ser una clase de objetos que nos permite utilizar herencia en abstracción constante en las clases en las que se implemente.

Para implementarla en una clase, se utiliza la forma:

    modificador_acceso class NombreClase implements NombreInterfaz1 [, NombreInterfaz2]

Una clase puede implementar varias interfaces de los paquetes que se han importado dentro del programa, separando los nombres por comas.

Ejemplo

• Definición de una interfaz:

    interface Nave {
        public abstract moverPosicion (int x, int y);
        public abstract disparar();
        .....
    }

• Uso de la interfaz definida:

    public class NaveJugador implements Nave {
        public void moverPosicion (int x, int y) {
            //Implementación del método
            posActualx = posActualx - x;
            posActualy = posActualy - y;
        }

        public void disparar() {
            //Implementación del método
        }

        ... 

}                                     

HERENCIA MULTIPLE

Todos sabemos que la herencia es un mecanismo propio de la programación orientada a objetos POO. Nos permite crear clases a partir de otra, las cuales las unen vínculos sumamente estrechos, casi de familia. Es por ello que se llama herencia.

Si buscamos modelar nuestras clases u objetos como propios de la realidad, todos los conceptos de la orientación a objetos nos serán muy fácil de implementar mientras programamos.

Implementando herencia tenemos las siguientes ventajas:

• Modelado de la realidad
• Evitar redundancias en el código
• Facilita la reutilización del código, así como reduce el número de líneas a escribir
• Sirve como el soporte o la base para el polimorfismo

Conclusión: ¿Se debe utilizar la herencia múltiple? A mi forma de pensar, si no está implementada nativa mente, se debería de evitar el uso de una simulación que va en contra de la naturaleza del lenguaje. Además pienso que todo problema que o esquema de clases se pueden llegar a plantear de forma que solamente utilicemos la herencia simple, ya que es más sencilla y es más natural que se herede de un solo padre.

SEGUNDO EXAMEN PARCIAL HOSPITAL

se crea la clase hotel:

package examen_2;

/**
 *
 * @author IVAN CT
 */
public abstract class hotel {
    String nombre;
    String Apellido;
    String numCuartos;
    public hotel() {
    }
    public hotel(String nombre, String Apellido, String numCuartos) {
        this.nombre = nombre;
        this.Apellido = Apellido;
        this.numCuartos = numCuartos;
    }
    public String getNombre() {
        return nombre;
    }
    public void setNombre(String nombre) {
        this.nombre = nombre;
    }
    public String getApellido() {
        return Apellido;
    }
    public void setApellido(String Apellido) {
        this.Apellido = Apellido;
    }
    public String getNumCuartos() {
        return numCuartos;
    }
    public void setNumCuartos(String numCuartos) {
        this.numCuartos = numCuartos;
    }
}

luego la clase hospedante:
package examen_2;
import java.util.Scanner;

/**
 *
 * @author IVAN CT
 */
public final class hospedante extends hotel{
      private String pabellon_hotel;
    public hospedante() {
        this.ingresarDatos();
        this.mostrarDatos();
    }
    public void ingresarDatos() {
        Scanner sc = new Scanner(System.in);
        System.out.println("ingresa nombre del hotel");
        pabellon_hotel = sc.next();
        System.out.println("ingrese nombre del hospedante");
        nombre = sc.next();
        System.out.println("ingrese el apellido del hospedante");
        Apellido = sc.next();
        System.out.println("ingrese el numero de cuarto");
        numCuartos = sc.next();
    }
    public void mostrarDatos() {
        System.out.println("nombre: " + this.getNombre());
        System.out.println("apellidos: " + this.getApellido());
        System.out.println(" Numero de cuarto " + this.getNumCuartos());
    }
}

luego la clase numero_cuartos:

package examen_2;

import java.util.Scanner;

/**
 *
 * @author IVAN CT
 */
public final class numero_cuarto extends hotel{
     int cantCuarto;
    public numero_cuarto() {
        this.ingresarDAto();
        this.mostrarDato();
    }
    public void ingresarDAto() {
        Scanner sc = new Scanner(System.in);
        System.out.println("ingresa nombre: ");
        nombre=sc.next();
        System.out.println("ingresar apellido");
        Apellido=sc.next();
    }
    public void mostrarDato() {
        System.out.println("nombre: "+this.nombre);
        System.out.println("apellido: "+this.Apellido);
        System.out.println("numero de cuarto"+this.numCuartos);
    }
   

}

luego la clase lugar:

package examen_2;

import java.util.Scanner;

/**
 *
 * @author IVAN CT
 */
public final class lugar extends hotel{
     String nombrePabellon;
    public lugar() {
        this.ingresarDato();
        this.mostrarDato();
    }
    public  void ingresarDato (){
        Scanner sc=new Scanner(System.in);
        System.out.println("ingresar nombre;");
        nombre=sc.next();
        System.out.println("ingresa apellido");
        Apellido=sc.next();
        System.out.println("ingrese numero de cuarto");
        numCuartos=sc.next();
    }
    public void mostrarDato(){
        System.out.println("nombre: "+this.nombre);
        System.out.println("apellido: "+this.Apellido);
        System.out.println("numero de cuato: "+this.numCuartos);
    }
   

}

y finalmente la clase main_hotel:

ackage examen_2;

import java.util.ArrayList;

import java.util.Scanner;

import java.util.Iterator;

/**

 *

 * @author IVAN CT

 */

public class main_hotel {

     hospedante aa = new hospedante();

    lugar p = new lugar();

    public void Mennu() {

        int opc = 0;

        Scanner sp = new Scanner(System.in);

        do {

            System.out.println("****************************************");

            System.out.println("(1) Ingresar                            ");

            System.out.println("(2) Mostrar                             ");

            System.out.println("(3) Salir                               ");

            System.out.println("****************************************");

            System.out.println("Elija una opcion: ");

            opc = sp.nextInt();

            switch (opc) {

                case 1:

                    System.out.println("numero de piso");

                    String pabellon = sp.next();

                    System.out.println("imgresa nombre del hospedante");

                    String nombre = sp.next();

                    System.out.println("imgrese apellido del hospedantre");

                    String apellido = sp.next();

                    System.out.println("ingrese dni del hospedante");

                    String dni = sp.next();

                    break;

                case 2:

                    System.out.println("mostrar");

                    aa.mostrarDatos();

                    break;

            }

        } while (opc != 3);

    }

    public static void main(String[] args) {

        hospedante aa = new hospedante();

        lugar p = new lugar();

        ArrayList lista = new ArrayList();

        ingresar(lista);

        mostrar(lista);

    }

    

    static void ingresar(ArrayList lista) {

        System.out.println("LISTA DE HOTELES");

        lista.add("oro verde");

        lista.add("madera verde");

        lista.add("villa llenifer");

    }

     static void mostrar(ArrayList lista) {

        Iterator i = lista.iterator();

        while (i.hasNext()) {

            System.out.println(i.next());

        }

    }

}

  

TIPOS DE POLIMORFISMO

sobre carga de métodos

sobre escritura de métodos

variables polimorficas

POLIMORFISMO

POLIMORFISMO

El polimorfismo en una característica y un de los cuatro pilares junto con abstracción,encapsulamiento y herencia de la POO .
Se refiere hacer los mismo pero en distintas clases ,para entender mejor un breve ejemplo.

Ejemplo:

Nos creamos una clase Animal

Luego una clase León que heredara la clase Animal y donde veremos que tiene el mismo método de la clase animal pero en su propia clase

Luego aremos una clase Vaca que heredara Animal y donde veremos que tiene el mismo método de la clase animal pero en su propia clase

Luego nos crearemos nuestra clase Animal_Principal para que nos corra los métodos

HERENCIA

La herencia es un mecanismo que permite la definición de una clase a partir de la definición de otra ya existente. La herencia permite compartir automáticamente métodos y datos entre clases, subclases y objetos.

La herencia está fuertemente ligada a la reutilización del código en la OOP. Esto es, el código de cualquiera de las clases puede ser utilizado sin más que crear una clase derivada de ella, o bien una subclase. 

Hay dos tipos de herencia: Herencia Simple y Herencia Múltiple. La primera indica que se pueden definir nuevas clases solamente a partir de una clase inicial mientras que la segunda indica que se pueden definir nuevas clases a partir de dos o más clases iniciales.

Mapa conceptual:

 

CÓDIGO:

Clase Padre Base Alumno:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46

public class Alumno {   public String getNombre() { return nombre; }   public String getClases() { return clases; }   public String getGrado() { return grado; }   public String getGrupo() { return grupo; }   public void setNombre(String nombre) { this.nombre = nombre; }   public void setClases(String clases) { this.clases = clases; }   public void setGrado(String grado) { this.grado = grado; }   public void setGrupo(String grupo) { this.grupo = grupo; } private String nombre; private String clases; private String grado; private String grupo;   protected void ir_a_clase(){   }   protected void estudiar(){   } }

Clase Hija Alumno Regular:

1 2 3 4 5 6 7 8 9 10 11 12 13 14

public class Regular extends Alumno{   public Regular(){   }   protected void pagar_inscripcion(){   }   protected void matricularse(){   } }

Clase Hija Alumno Becario:

1 2 3 4 5 6 7 8 9 10

public class Becario extends Alumno{   public Becario(){   }   protected void pagar_inscripcion(){   } }

Clase Hija Alumno Intercambio:

1 2 3 4 5 6 7 8 9 10 11 12 13

public class Intercambio extends Alumno{   public Intercambio(String nombre,String clases,String grado,String grupo){ super.setNombre(nombre); super.setClases(clases); super.setGrado(grado); super.setGrupo(grupo); }   protected void matricularse(){   } }

Clase Principal Main:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

public class Main { public static void main(String args[]){ Regular pepe = new Regular(); pepe.setNombre("Pepe"); pepe.setClases("Biologia,matematicas"); pepe.setGrado("2"); pepe.setGrupo("G"); pepe.ir_a_clase();   Intercambio luis = new Intercambio("Luis","Fisica,Ecologia","3","B"); luis.ir_a_clase(); luis.estudiar(); luis.matricularse(); } }