Semana 11

 Herencia.
Al crear una clase, en vez de declarar miembros completamente nuevos, el programador puede designar que la nueva clase herede los miembros de una clase existente, la cual se conoce como superclase, mientras que la clase nueva se conoce como subclase.
Una subclase puede agregar sus propios campos y métodos. Por lo tanto, una subclase es más específica que su superclase y representa a un grupo más especializado de objetos. La subclase exhibe los comportamientos de su superclase y puede modificarlos, de modo que operen en forma apropiada para la subclase. Es por ello que a la herencia se le conoce algunas veces como especialización.

Es necesario hacer una diferencia entre la relación es un y la relación tiene un. La relación es un representa a la herencia. En este tipo de relación, un objeto de una subclase puede tratarse también como un objeto de su superclase. Por ejemplo, un auto es un vehículo. En contraste, la relación tiene un representa la composición.
En este tipo de relación, un objeto contiene referencias a otros objetos como miembros. Por ejemplo, un auto tiene un volante de dirección (y un objeto auto tiene una referencia a un objeto volante de dirección).

Como todo objeto de una subclase es un objeto de su superclase, y como una superclase puede tener muchas subclases, el conjunto de objetos representados por una superclase es a menudo más grande que el de objetos representado por cualquiera de sus subclases. Por ejemplo, la superclase Vehiculo representa a todos los vehículos, entre ellos autos, camiones, barcos, bicicletas, etcétera. En contraste, la subclase Auto representa a un subconjunto más pequeño y específico de los vehículos.


Es posible tratar a los objetos de superclases y a los de subclases de manera similar; sus similitudes se expresan en los miembros de la superclase. Los objetos de todas las clases que se extienden a una superclase común pueden tratarse como objetos de esa superclase. Dichos objetos tienen una relación (es-un) con la superclase.

Una subclase puede personalizar los métodos que hereda de su superclase. Para hacer esto, la subclase sobrescribe (redefine) el método de la superclase con una implementación apropiada.

Miembros protected.
Los miembros public de una clase son accesibles en cualquier parte en donde el programa tenga una referencia a un objeto de esa clase, o una de sus subclases. Los miembros private de una clase son accesibles sólo dentro de la misma clase. En esta sección presentaremos el modificador de acceso protected. El uso del acceso protected ofrece un nivel intermedio de acceso entre public y private. Los miembros protected de una superclase pueden ser utilizados por los miembros de esa superclase, por los de sus subclases y por los de otras clases en el mismo paquete; es decir, los miembros protected también tienen acceso a nivel de paquete.

Todos los miembros public y protected de una superclase conservan su modificador de acceso original cuando se convierten en miembros de la subclase (por ejemplo, los miembros public de la superclase se convierten en miembros public de la subclase, y los miembros protected de la superclase se vuelven miembros protected de la subclase). Los miembros private de una superclase no pueden utilizarse fuera de la propia clase. En cambio, están ocultos en sus subclases y se pueden utilizar sólo a través de los métodos public o protected heredados de la superclase.

Los métodos de una subclase pueden referirse a los miembros public y protected que se hereden de la superclase con sólo utilizar los nombres de los miembros. Cuando un método de la subclasesobrescribe al método heredado de la superclase, este último puede utilizarse desde la subclase si se antepone a su nombre la palabra clave super y un punto (.) como separador.

Otro error común de sobrescritura es declarar el número incorrecto de tipos de parámetros en la lista de parámetros. Esto crea una sobrecarga no intencional del método de la superclase, en vez de sobrescribir el método existente. Si más tarde tratamos de llamar al método (con el número y tipos de parámetros correctos) en un objeto de la subclase, se invoca la versión de la superclase, lo cual puede provocar ligeros errores lógicos. Cuando el compilador encuentra un método declarado con @Override, compara la firma del método con las firmas del método de la superclase. Si no hay una coincidencia exacta, el compilador emite un mensaje de error, del tipo “el método no sobrescribe o implementa a un método de un supertipo”. Lo que sigue es corregir la firma del método para que coincida con la del método de la superclase.

El constructor de cada subclase debe llamar en forma implícita o explícita al constructor de su superclase para inicializar las variables de instancia heredadas de la superclase.

El uso de variables de instancia protected crea varios problemas potenciales. En primer lugar, el objeto de la subclase puede establecer de manera directa el valor de una variable heredada, sin utilizar un método establecer. Por lo tanto, un objeto de la subclase puede asignar un valor inválido a la variable, con lo cual el objeto puede quedar en un estado inconsistente.

Otro problema con el uso de variables de instancia protected es que hay más probabilidad de que los métodos de la subclase se escriban de manera que dependan de la implementación de datos de la superclase. En la práctica, las subclases sólo deben depender de los servicios de la superclase (es decir, de los métodos que no sean private) y no de la implementación de datos de la misma. Si hay variables de instancia protected en la superclase, probablemente tendríamos que modificar todas las subclases de esa superclase si cambia la implementación de ésta. Por ejemplo, si por alguna razón tuviéramos que cambiar los nombres de las variables de instancia primerNombre y apellidoPaterno por nombre y apellido, entonces tendríamos que hacerlo para todas las ocurrencias en las que una subclase haga referencia directa a las variables de instancia primerNombre y apellidoPaterno de la superclase. En tal caso, se dice que la clase es frágil o quebradiza, ya que un pequeño cambio en la superclase puede “quebrar” la implementación de la subclase. Es conveniente que el programador pueda modificar la implementación de la superclase sin dejar de proporcionar los mismos servicios a las subclases. Desde luego que, si cambian los servicios de la superclase, debemos volver a implementar nuestras subclases. Un tercer problema es que los miembros protected de una clase son visibles para todas las clases que se encuentren en el mismo paquete que la clase que contiene los miembros protected; esto no siempre es conveniente.

Ejemplos

1)

Clase padre
package ej_herencia;
import java.util.Scanner;
/**
 *
 * @author angel
 */
public class Ej_Herencia {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        // TODO code application logic here
        Scanner ingreso=new Scanner (System.in);
        double l, h, c=0;
        System.out.println("Ingrese lado ");
        l=ingreso.nextDouble();
        Cuadrado calcular=new Cuadrado(l,c);
        calcular.calcular1();
        calcular.imprimir();
        
        System.out.println("Inrese altura ");
        h=ingreso.nextDouble();
        Rectangulo calcular1=new Rectangulo (l,c,h);
        calcular1.calcular2();
        calcular1.imprimir();
    }
    
}

Clase Hijas
package ej_herencia;

/**
 *
 * @author angel
 */
public class Figura {
    protected double l;
    protected double a;

    public Figura(double l, double a) {
        this.l = l;
        this.a = a;
    }

    public double getL() {
        return l;
    }

    public double getA() {
        return a;
    }
    
    
    public void imprimir(){
        System.out.println("Lado "+l + " \t Area "+a);
    }

    
    
}

Rectangulo

package ej_herencia;

/**
 *
 * @author angel
 */
public class Rectangulo extends Figura {
    protected double h;
    public Rectangulo (double l, double a, double h){
        super(l, a);
        this.h=h;
    }
    public void calcular2(){
        a=l*h;
    }
}

Cuadrado

package ej_herencia;

/**
 *
 * @author angel
 */
public class Cuadrado extends Figura {
    public Cuadrado (double l, double a){
        super(l, a);
    }
    
    public void calcular1(){
        a=Math.pow(l, 2);
    }
}

2)

Principal

package ej2_herencia;
import java.util.Scanner;
/**
 *
 * @author angel
 */
public class Ej2_Herencia {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        // Principal
        Scanner in=new Scanner (System.in);
        double r, re=0;
        System.out.println("Ingrese radio ");
        r=in.nextDouble();
        
        Volumen calc=new Volumen(r,re);
        calc.calcular();
        calc.imprimir();
        
        Superficie cal=new Superficie(r, re);
        cal.calcular();
        cal.imprimir();
    }
    
}

Esfera
package ej2_herencia;

/**
 *
 * @author angel
 */
public class Esfera {
    protected double r;
    protected double re;

    public Esfera(double r, double re) {
        this.r = r;
        this.re = re;
    }

    public double getR() {
        return r;
    }

    public double getRe() {
        return re;
    }
    public void imprimir(){
        System.out.println("El resultado es  "+re);
    }
            
}

Superficie

package ej2_herencia;

/**
 *
 * @author angel
 */
public class Superficie extends Esfera {
    public Superficie(double r, double re){
        super(r, re);
    }
    public void calcular(){
        re=4 * Math.PI * Math .pow(r, 2);
    }
}

Volumen
package ej2_herencia;

/**
 *
 * @author angel
 */
public class Volumen extends Esfera {
    public Volumen(double r, double re){
        super(r, re);
    }
    public void calcular(){
        re=1.3333 * Math.PI * Math.pow(r, 3);
        
    }
}

3)

package ej3_herencia;
import java.util.Scanner;
/**
 *
 * @author angel
 */
public class Ej3_Herencia {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
       //Principal
       Scanner in=new Scanner(System.in);
       double v, r=0, p;
        System.out.println("Ingrese valor ");
        v=in.nextDouble();
        System.out.println("Ingrese porcentaje ");
        p=in.nextDouble();
        
        Descuento op=new Descuento(v,r,p);
        op.calculad();
        System.out.println("Descuento");
        op.imprimir();
        
        Aumento op1=new Aumento(v,p,r);
        
    }
    
}

Descuento
package ej3_herencia;

/**
 *
 * @author angel
 */
public class Descuento  extends Porcentaje {
    public Descuento (double valor, double resultado, double porc){
        super(valor, resultado, porc);
    }
    public void calculad(){
        resultado= valor-(valor*(porc/100));
    }
    
}

Porcentaje
package ej3_herencia;

/**
 *
 * @author angel
 */
public class Porcentaje {
    protected double valor;
    protected double resultado;
    protected double porc;

    public Porcentaje(double valor, double resultado, double porc) {
        this.valor = valor;
        this.resultado = resultado;
        this.porc = porc;
    }

    public double getValor() {
        return valor;
    }

    public double getResultado() {
        return resultado;
    }

    public double getPorc() {
        return porc;
    }
    
    public void imprimir(){
        System.out.println("El resultado es : "+ resultado);
    }
}

Aumento 
package ej3_herencia;

/**
 *
 * @author angel
 */
public class Aumento extends Porcentaje  {
    public Aumento (double valor, double resultado, double porc){
        super(valor, resultado, porc);
    }
    public void calcula(){
        resultado= valor +(valor*(porc/100));
    }
}



Video Como Referencia


Comentarios

Publicar un comentario

Entradas populares de este blog

Semana 6.

Imagen
 Estructuras repetetitivas. Los ciclos o también conocidos como bucles, son una estructura de  control de total importancia para el proceso de creación de un programa. Un ciclo en Java o bucle en Java permite repetir una o varias instrucciones cuantas veces lo necesitemos o sea necesario, ya que nos ayuda a llevar a cabo una tarea repetitiva en una  cantidad de líneas muy pequeña y de forma prácticamente  automática. Existen diferentes tipos de ciclos o bucles en Java, cada uno tiene una utilidad para casos específicos y depende de nuestra habilidad y conocimientos poder determinar en qué momento es bueno usar alguno de ellos. Tenemos entonces a nuestra disposición los siguientes tipos de ciclos en Java: • Ciclo for en Java • Ciclo while en Java • Ciclo do-while en Java. Ciclo For. Son una estructuras de control cíclica, nos permiten ejecutar una o variaslíneas de código de forma iterativa (o repetitiva), pero teniendo cierto control y conocimiento sobre las iteracio...
Leer más

Semana No. 4

Imagen
Estructuras condicionales. La instrucción condicional simple permite tomar decisiones empleando una variable booleana: La condición: expresiónbooleana (lógica o relacional). Se evalúa la condición y si ésta se cumple se ejecuta una determinada acción o grupo de acciones. Instrucción condicional simple. También se puede escribir como instrucción simple, aunque  es menos recomendable (por ser menos visible el comienzo y final ): Ejemplo: poner un texto aprobado o suspenso según la nota. Instrucción condicional doble. Se evalúa la condición y si ésta se cumple se ejecuta una determinada instrucción o grupo de instrucciones. Si no se cumple se ejecuta otra instrucción o grupo de instrucciones. Instrucciones condicionales anidadas Las instrucciones if también se pueden anidar:  • El else se asocia al if anterior más próximo que no tenga else, siempre que esté en el mismo bloque que el else. Ejemplo. Poner "cum laude" en el ejemplo anterior si nota>=9 Expresiones condic...
Leer más

Semana No. 1

 PROGAMACION POR LAAPLICACION DE JAVA Y DE NETBENS En la mayoría de los entornos de desarrollo el proceso es bastante similar, pero aquí explicaré los detalles relevantes de esto, para que al momento de crear un proyecto tú mismo, sepamos qué cosas se pueden cambiar cuándo y para qué. Su ámbito de aplicación es tan amplio que Java  se utiliza tanto en móviles como en electrodomésticos . Muchos programadores también utilizan este lenguaje para crear pequeñas aplicaciones que se insertan en el codigo HTML  de una página para que pueda ser ejecutada desde un navegador. Java es un sistema de programación versátil y, como puedes ver, con multitud de aplicaciones. Vamos a ver ahora algunos conceptos que se pueden relacionar con Java, lo que es y para que sirve. NetBeans es un entorno de desarrollo muy completo y profesional. Contiene muchas funcionalidades, para distintos tipos de aplicaciones y para facilitar al máximo la programación, la prueba y la depuración de las apl...
Leer más