UNIVERSIDAD CENTRAL DEL ECUADOR

FACULTAD DE INGENIERA CIENCIAS FSICAS Y MATEMTICAS

INTREGANTES: CASTRO ADONIS
CHANGOLUISA CRISTIAN
PUCHA FELIPE
PROGRAMACIN ll
CLASE ABSTRACTA
Definicin: Clases definidas en la jerarqua que
simplemente recogen las caractersticas comunes
de
otra serie de clases (sus descendientes), pero que no se van a (o no se
deben) utilizar para crear ejemplares.
Caractersticas de una Clase abstracta: Modela el comportamiento
comn de sus clases derivadas. Establece mtodos que necesariamente
han de ser implementados por sus subclases (las clases derivadas)
METODOS ABSTRACTOS. Mtodos sin cdigo, se declaran pero no se
definen Deben definirse en alguna subclase Si una subclase no
implementa un mtodo abstracto heredado debe ser abstracta tambin Un
mtodo abstracto debe pertenecer a una clase abstracta
Implementa mtodos que son comunes a todas sus subclases (No
abstractos). La clase abstracta puede definir atributos comunes a sus
subclases. En el sistema no se crean ejemplares de la clase abstracta
porque no seran objetos con existencia propia en el mundo real. new A
()ERROR si A abstracta Los objetos que se crearn sern ejemplares de
las subclases (aquellas que no sean tambin abstractas).
CLASE BASE
Vamos a poner un ejemplo del segundo tipo, que simule la utilizacin de
liberas de clases para crear un interfaz grfico de usuario como Windows
3.1 o Windows 95.
Supongamos que tenemos una clase que describe la conducta de una
ventana muy simple, aquella que no dispone de ttulo en la parte superior,
por tanto no puede desplazarse, pero si cambiar de tamao actuando con el
ratn en los bordes derecho e inferior.
La clase Ventana tendr los siguientes miembros dato: la posicin x e y de
la ventana, de su esquina superior izquierda y las dimensiones de la
ventana: ancho y alto.
public class Ventana {
protected int x;
protected int y;
protected int ancho;
protected int alto;
public Ventana(int x, int y, int ancho, int alto) {
this.x=x;
this.y=y;
this.ancho=ancho;
this.alto=alto;
}
//...
}

Las funciones miembros, adems del constructor sern las siguientes: la

funcin mostrar que simula una ventana en un entorno grfico, aqu
solamente nos muestra la posicin y las dimensiones de la ventana.
public void mostrar(){
System.out.println("posicin : x="+x+", y="+y);
System.out.println("dimensiones : w="+ancho+", h="+alto);
}
La funcin cambiarDimensiones que simula el cambio en la anchura y altura
de la ventana.
public void cambiarDimensiones(int dw, int dh){
ancho+=dw;
alto+=dh;
}
El cdigo completo de la clase base Ventana, es el siguiente
package ventana;
public class Ventana {
protected int x;
protected int y;
protected int ancho;
protected int alto;
public Ventana(int x, int y, int ancho, int alto) {
this.x=x;
this.y=y;
this.ancho=ancho;
this.alto=alto;
}
public void mostrar(){
System.out.println("posicin : x="+x+", y="+y);
System.out.println("dimensiones : w="+ancho+", h="+alto);
}
public void cambiarDimensiones(int dw, int dh){
ancho+=dw;
alto+=dh;
}
}
Objetos de la clase base
Como vemos en el cdigo, el constructor de la clase base inicializa los
cuatro miembros dato. Llamamos al constructor creando un objeto de la
clase Ventana
Ventana ventana=new Ventana(0, 0, 20, 30);
Desde el objeto ventana podemos llamar a las funciones miembro pblicas
ventana.mostrar();
ventana.cambiarDimensiones(10, 10);
ventana.mostrar();

CLASE DERIVADA
La clase derivada heredar los miembros dato de la clase base y las
funciones miembro, y tendr un miembro dato ms, el ttulo de la ventana.
public class VentanaTitulo extends Ventana{
protected String titulo;
public VentanaTitulo(int x, int y, int w, int h, String nombre) {
super(x, y, w, h);
titulo=nombre;
}
extends es la palabra reservada que indica que la
clase VentanaTitulo deriva, o es una subclase, de la clase Ventana.
La primera sentencia del constructor de la clase derivada es una llamada al
constructor de la clase base mediante la palabra reservada super. La
llamada
super(x, y, w, h);
inicializa los cuatro miembros dato de la clase
base Ventana: x, y, ancho, alto. A continuacin, se inicializa los miembros
dato de la clase derivada, y se realizan las tareas de inicializacin que sean
necesarias. Si no se llama explcitamente al constructor de la clase base
Java lo realiza por nosotros, llamando al constructor por defecto si existe.
La funcin miembro denominada desplazar cambia la posicin de la
ventana, aadindoles el desplazamiento.
public void desplazar(int dx, int dy){
x+=dx;
y+=dy;
}
Redefine la funcin miembro mostrar para mostrar una ventana con un
ttulo.
public void mostrar(){
super.mostrar();
System.out.println("titulo
: "+titulo);
}
En la clase derivada se define una funcin que tiene el mismo nombre y los
mismos parmetros que la de la clase base. Se dice que redefinimos la
funcin mostrar en la clase derivada. La funcin miembromostrar de la clase
derivada VentanaTitulo hace una llamada a la funcin mostrar de la clase
base Ventana, mediante
super.mostrar();
De este modo aprovechamos el cdigo ya escrito, y le aadimos el cdigo
que describe la nueva funcionalidad de la ventana por ejemplo, que muestre
el ttulo.
Si nos olvidamos de poner la palabra reservada super llamando a la
funcin mostrar, tendramos una funcin recursiva. La
funcin mostrar llamara a mostrar indefinidamente.
public void mostrar(){ //ojo!, funcin recursiva
System.out.println("titulo
: "+titulo);
mostrar();
}
La definicin de la clase derivada VentanaTitulo, ser la siguiente.
package ventana;
public class VentanaTitulo extends Ventana{
protected String titulo;
public VentanaTitulo(int x, int y, int w, int h, String nombre) {
super(x, y, w, h);
titulo=nombre;
}

public void mostrar(){

super.mostrar();
System.out.println("titulo
: "+titulo);
}
public void desplazar(int dx, int dy){
x+=dx;
y+=dy;
}
}
Objetos de la clase derivada
Creamos un objeto ventana de la clase derivada VentanaTitulo
VentanaTitulo ventana=new VentanaTitulo(0, 0, 20, 30, "Principal");
Mostramos la ventana con su ttulo, llamando a la funcin mostrar,
redefinida en la clase derivada
ventana.mostrar();
Desde el objeto ventana de la clase derivada llamamos a las funciones
miembro definidas en dicha clase
ventana.desplazar(4, 3);
Desde el objeto ventana de la clase derivada podemos llamar a las
funciones miembro definidas en la clase base.
ventana.cambiarDimensiones(10, -5);
Para mostrar la nueva ventana desplazada y cambiada de tamao
escribimos
ventana.mostrar();
CONSTRUCTOR

Cuando se construye un objeto es necesario inicializar sus variables con

valores coherentes, imaginemos un objeto de la clase Persona cuyo
atributo color de pelo al nacer sea verde, un estado incorrecto tras
construir el objeto persona. La solucin en los lenguajes orientados a
objetos es emplear los constructores. Un constructor es un mtodo
perteneciente a la clase que posee unas caractersticas especiales:
Se llama igual que la clase.
No devuelve nada, ni siquiera void.
Pueden existir varios, pero siguiendo las reglas de la sobrecarga de
funciones.
De entre los que existan, tan slo uno se ejecutar al crear un objeto de la
clase.
Dentro del cdigo de un constructor generalmente suele existir
inicializaciones de variables y objetos, para conseguir que el objeto sea
creado con dichos valores iniciales.
Para definir los constructores se emplea la siguiente sintaxis:
[modifVisibilidad] nombreConstructor (listaParmetros) [throws
listaExcepciones]
{
}
Para modifVisibilidad se aplica las mismas normas que para atributos y
mtodos:
public: indica que es un mtodo accesible a travs de una instancia del
objeto.

private: indica que a travs de una instancia no es accesible el mtodo. Al

heredar el mtodo se convierte en inaccesible.
protected: indica que a travs de una instancia no es accesible el mtodo.
Al heredar si se puede usar desde la clase derivada.
Sin especificar: indica visibilidad de paquete, se puede acceder a travs de
una instancia, pero slo de clases que se encuentren en el mismo paquete.
nombreConstructor debe de coincidir con el nombre de la clase.
listaParmetros es la lista de los parmetros que tomar la funcin
separados por comas y definidos cada uno de ellos como:
tipo nombreParmetro
La clusula opcional throws es empleada para indicar que dentro del
mtodo se pueden generar errores en su ejecucin, y que debemos estar
preparados para tratarlos.
listaExcepciones es el nombre de todos esos posibles errores, su utilizacin
la veremos en el punto dedicado a la gestin de errores mediante try y
catch.
El constructor posee un par de llaves, dentro de las cuales estar el cdigo
que se ejecutar al ser llamada la funcin. Dicho cdigo estar formado
por instrucciones vlidas en el lenguaje, finalizadas generalmente por
punto y coma.
DECLARACINDE ACCESO
Los modificadores de acceso estan dividos en 2 categoras, estas son:
1. Modificadores de Acceso: public, protected y private.
2. Modificadores de No Acceso: strictfp, final y abstract.
Para las clases se aplican los siguientes modificadores:

De Acceso: Se refiere a la visibilidad de la clases, cuando una clase A

pueda ver la Clase B. Para este caso aplican los siguientes modificadores:
o

Acceso por defecto (default) : Cuando se dice que una clase

tiene un acceso por default es cuando la misma no tiene un
modificador precedente en la declaracin de la clase. Este nivel de
acceso tambien es llamado nivel de acceso por paquetes
( package-level access), por que una clase solo puede ser
accesada por clases que esten en el mismo paquete. Ejemplo:

1 package com.clubprogramador;
2 class ClasePorDefecto{}

Acceso pblico (public): Es cuando la palabra public precede

la declaracin de la clase, esto lo que indica es que la clases con

este modificador podran ser accesadas desde otros paquetes

incluido el propio. Ejemplo:
1 package com.clubprogramador;
2 public class ClasePublica{}

De no Acceso: Se refiere a aquellos modificadores de clase que

cambian la forma de declaracin. Para este caso aplican los siguientes
modificadores:
o

Clases Finales (final): cuando una clase usa el modificador final

indica que esta no podra ser Super Clase de otra (Ninguna otra
clase podra heredar de ella).

1 package com.clubprogramador;
2
3 public final class ClaseFinal {
4
5}

Clases Abstractas (abstract): una clase abstracta es aquella

que se define una estructura genrica sin implementacin de los
mtodos solo los define, cada subclase (clase que hereda) podr
ejecutar la implementacin.

1 package com.clubprogramador;
2
3 public abstract class ClaseAbstracta {
4
5 public abstract void getAbstracta();
6}

Cualquier clase que contenga uno o ms mtodos abstractos, debe de ser

declarada como abstracta y una clase abstracta puede nunca ser instanciada
ESPECIFICADORES DE ACCESO

Un especificador (modificador) de acceso o alcance es una palabra clave

(reservada) que nos permite controlar nivel de alcance que tiene cada
variable, mtodo o clase. Existen tres public, protected, private, static,
final.
public
establece un nivel de acceso total, es decir una clase public puede ser
usada por otras clases del mismo paquete y de otros paquetes no
relacionados, lo mismo para los mtodos y variables. public es el

especificador de acceso mas utilizado en estudiantes ya que no nos

enfrentamos a la dificultad (..?) de tener que determinar que se puede y
que no se puede utilizar en un clase.
private
establece un nivel restringido de acceso, En el cual los miembros
declarados como tal solo son accesibles dentro de la clase, aunque la clase
herede de esta ultima. las variable y mtodos private son usados cuando los
clientes de una clase no deben preocuparse (ni les debe importar) como
se efectan las acciones claves de un programa. establecer miembros
private establece el mayor nivel de seguridad.
protected
establece un nivel de acceso intermedio entre public y private en el que los
miembros solo son accesibles por clases y mtodos dentro del mismo
paquete.
static
el modificador static crea variables y metodos de clase (a esto es lo que nos
referimos cuando hablamos de variables de clase) estos objetos pueden ser
llamados desde cualquier parte de la clase modificando sus valores reales
de forma definitiva. la diferencia con una variable normal es que cuando
llamamos a una variable de instancia (normal) cambiamos su valor solo en
ese instancia (metodos, etc..) en cambia una variable estatica cambia de
valor definitivamente cada vez que se llama, en palabras simples
actualizamos su valor real desde cualquier parte del programa.
final
el modificador final, crea una constante, en realidad en java no existen las
constantes, pero final hace que las variables imiten su comportamiento.
Cualquier intento por modificar una variable final creara un error en tiempo
de ejecucion.
Un ejemplo de final, es la variable PI, de la clase Math
class Generalidades
{
public static void main(String[]agrs)
{
System.out.println("El valor de Pi es"+ Math.PI);
System.out.println("nuevo valor de Pi"+(Math.PI = 5));//intentamos
cambiar el valor de PI
}//fin del metodo main
}// Fin de la clase
Esta seria la salida del compilador.:
El valor de Pi es3.141592653589793
Exception in thread "main" java.lang.RuntimeException: Uncompilable
source code - cannot assign a value to final variable PI
at Ejemplo.Generalidades.main(Generalidades.java:12)
lo que esta en rojo es la descripcin del error cannot assign a value to final
variable PI (no se puede asignar un valor a la variable final PI)
FINAL, CLASE NO EXTENSIBLE

En el contexto de herencia, la palabra reservada final aplicada a una clase

se emplea
para impedir que la clase sea derivable; es decir, cuando se requiere que
una clase no
pueda extenderse, se declara con el modificador final; por ejemplo: se
define la clase
VideoConsola de tal forma que se evita crear subclases de ella en otras
estructuras:
public final class VideoConsola extends Consola
{
...
}
Con esa declaracin, todo intento de definir una subclase de VideoConsola
ser un
error de compilacin; el compilador producir un error en la siguiente
declaracin de la
clase OtraVideo:
class OtraVideo extends VideoConsola { ... }
En la extensa biblioteca de clases incorporada en los paquetes de Java se
encuentran
clases con el atributo final; por ejemplo, las clases que envuelven a los tipos
bsicos,
como Integer, Boolean, etctera, o la clase String, estn declaradas con
final; esa
proteccin asegura que una referencia a Intger es realmente a un objeto de
ese tipo y no
a un subtipo.

HERENCIA
La idea de la herencia es permitir la creacin de nuevas clases basadas en
clases existentes.
Cuando heredamos de una clase existente, reusamos (o heredamos)
mtodos y campos, y agregamos nuevos campos y mtodos para cumplir
con la situacin nueva.
Cada vez que encontremos la relacin "es-un" entre dos clases, estamos
ante la presencia de herencia.
La clase ya existente es llamada superclass, o clase base, o clase padre.
La clase nueva es llamada subclase, clase derivada, o clase hija.
A travs de la herencia podemos agregar nuevos campos, y podemos
agregar o sobre montar mtodos (override). Sobre montar un mtodo es
redefinirlo en la case heredada.
Estudio de ejemplos: ManagerTest.java
Destacar uso de super para invocar al constructor de la clase base y para
invocar a mtodos sobremontados.
Jerarqua de Herencia

HERENCIA MULTIPLE
Herencia mltiple
La herencia mltiple, consiste en la utilizacin de las propiedades de una
clase a varias clases ms, lo que significa que en esta propiedad una sola
clase padre puede heredarle atributos, u objetos de esta a varias clases hijo
sin ninguna limitacin entre ellas.
El nico problema de la herencia mltiple, es que es manejable en varias
plataformas para programar, pero en Java no existe el concepto de la
herencia mltiple, ose ase que Java no es capas de manejar algn mtodo
para poder heredar a ms de una clase hija.
HERENCIA SIMPLE
La herencia simple consiste en cuando una clase, hereda a una clase hijo, y
a solo una le hereda sus atributos, es igual al concepto general de herencia,
con la limitante de solo poder heredar de una clase padre a una clase hijo, y
solo a una clase hijo
Un ejemplo de herencia simple en Java es la siguiente:
Public class animal{
Public String ojos;
Public String color;
Public int patas;
Public void patas(){
...
}
}

REDEFINICION
La clase base Object de todas las clases en el lenguaje Java, tiene una
funcin miembro denominada clone, que se redefine en la clase derivada
para realizar una duplicacin de un objeto de dicha clase.
Sea la clase Punto ya estudiada en pginas anteriores. Para hacer una copia
de un objeto de esta clase, se ha de agregar a la misma el siguiente cdigo:
se ha de implementar el interface Cloneable
se ha de redefinir la funcin miembro clone de la clase base Object
public class Punto implements Cloneable{
private int x;
private int y;
//constructores ...

public Object clone(){

Object obj=null;
try{
obj=super.clone();
}catch(CloneNotSupportedException ex){
System.out.println(" no se puede duplicar");
}
return obj;
}
//otras funciones miembro
}
En la redefinicin de clone, se llama a la versin clone de la clase base
desde super. Esta llamada se ha de hacer forzosamente dentro de un
bloque try... catch, para capturar la
excepcinCloneNotSuportedException que nunca se producir si la clase
implementa el interface Cloneable. Como vemos la llamada a la
versin clone de la clase base devuelve un objeto de la clase base Object,
que es a su vez devuelto por la versin clone de la clase derivada.
Para crear un objeto pCopia que es una copia de otro objeto punto se
escribe.
Punto punto=new Punto(20, 30);
Punto pCopia=(Punto)punto.clone();
La promocin (casting) es necesaria ya que clone devuelve un objeto de la
clase base Object que ha de ser promocionado a la clase Punto.
Si hemos redefinido en la clase Punto la funcin miembro toString de la
clase base Object, podemos comprobar que los
objetos punto y pCopia guardan los mismos valores en sus miembros dato.
System.out.println("punto "+ punto);
System.out.println("copia "+ pCopia);

RELACION IS-A
La herencia se encuentra en cualquier lugar en Java. Es seguro decir que es
prcticamente imposible escribir el programa ms pequeo en Java sin usar
la herencia. Veamos el siguiente cdigo:
1
class Test {
2
public static void main(String[] args){
3
Test t1 = new Test();
4
Test t2 = new Test();
5
if (!t1.equals(t2))
6
System.out.println("No son iguales");
7
if (t1 instanceof Object)
8
System.out.println("T1 es un objeto");
9
}
10
}
11
Produce lo siguiente:
1
No son iguales
2
T1 es un objeto
3
Nos preguntamos algo, De dnde viene el mtodo equals?. La variable de
referencia t1 es del tipo Test, y no hay ningn mtodo equals en la clase
Test. El segundo test realizado con if pregunta si t1 es una instancia de la
clase Object, y como esto es as, el test es completado.

Esto pasa porque todas las clases en Java son subclases de la clase Object.
En otras palabras, todas las clases que usemos o escribamos heredarn de
la clase Object. Siempre tendremos un mtodo equals, un
mtodo clone, notify, wait, y otros, disponibles para su uso. All donde
creemos una clase, automticamente hereda todos los mtodos de la clase
Object.
SUPER
Si se necesita llamar al mtodo padre dentro de una clase que ha
reemplazado ese mtodo, se puede hacer referencia al mtodo padre con la
palabra clave super:
import MiClase;
public class MiNuevaClase extends MiClase {
public void Suma_a_i( int j ) {
i = i + ( j/2 );
super.Suma_a_i( j );
}
}
En el siguiente cdigo, el constructor establecer el valor de i a 10, despus
lo cambiar a 15 y finalmente el mtodo Suma_a_i() de la clase
padre MiClase lo dejar en 25:
MiNuevaClase mnc;
mnc = new MiNuevaClase();
mnc.Suma_a_i( 10 );
super es un concepto que no existe en C++, al menos no con una
implementacin similar a Java. Si un mtodo sobreescribe un mtodo de su
superclase, se puede utilizar la palabra clave super para eludir la versin
sobreescrita de la clase e invocar a la versin original del mtodo en la
supreclase. Del mismo modo, se puede utilizar super para acceder a
variables miembro de la superclase.
Bibliografa
http://www.unalmed.edu.co/~jaguzman/docencia_archivos/objetos/diapositiv
as/8-Clases%20abstractas.pdf
http://www.sc.ehu.es/sbweb/fisica/cursoJava/fundamentos/herencia/herencia
.htm#La clase base
http://www.mundojava.net/definicion-de-constructores-de-una-clase.html?
Pg=java_inicial_4_4_5.html
http://www.elclubdelprogramador.com/2011/08/28/java-declaracion-declases-y-modificadores-de-acceso/
http://chilejava.blogspot.com/2013/05/especificadores-de-acceso.html

Ejercicios y Problemas
Ejercicios
13.1 Implementar una clase Automvil dentro de una jerarqua de
herencia; considerar que adems de ser un vehculo, un automvil
es tambin una comodidad, un smbolo de estado social, un modo
de transporte, etctera.

package ejercicio1.3.;
import java.util.Scanner;
public class TestPrincipal {

return " Automovil\n"

+ "------------------------------------\n"
+ "placa=" + placa + "\n"
+ " marca=" + marca + "\n"
+ " nombrPropietario=" + nombrPropietario +"\n"
+ " pais de Origen= "+paisOrigen+ "\n"
+ "nmero de pasajero=s"+pasajeros+"\n"
+ "-------------------------------------\n";
*/
Automovil car;
Scanner sc= new Scanner(System.in);
System.out.println("Ingrese la placa del automvil");
String placa =sc.next();
System.out.println("Ingrese la marca del automvil");
String marca = sc.next();
System.out.println("Ingrese el nombre del propietario del automvil");
String prop=sc.next();
System.out.println("Igrese el pais de origen del automvil");
String paisOrig=sc.next();
System.out.println("Ingrese el nmero de pasajerps que su vejiculo
puede llevar");
String numPas=sc.next();
Integer numPas1=0;
boolean j= false;
while(j==false){
try {

numPas1=Integer.parseInt(numPas);
j=true;
} catch (Exception e) {
System.out.println("Ingrese el nmero de pasajerps que su
vejiculo puede llevar");
numPas=sc.next();
j=false;
}

}
car=new Automovil(placa, marca, prop, paisOrig, numPas1);
System.out.println(car);
}
}

13.2 Implementar una jerarqua de herencia de animales que

contenga al menos seis niveles de derivacin y 12 clases.
public class DEB2EJERC2 {
public static void main(String[] args) {
}

// CLASES BASE
class ANIMAL {
}
// PRIMERA DERIVADA
class AEREO extends ANIMAL {
}
class TERRESTRE extends ANIMAL {
}
class MARINO extends ANIMAL {
}
//SEGUNDA DERIVADA
class VIVIPARO extends TERRESTRE {
}
class OVIPARO extends AEREO {
}
//TERCERA DERIVADA
class AVES extends OVIPARO {
}
class MAMIFEROS extends VIVIPARO {
}
// CUARTA DERIVADA
class PLUMA extends AVES {
}
class PELO extends MAMIFEROS {
}
//QUINTA DERIVADA
class PERROS extends PELO {
}
class GOLONDRINA extends PLUMA {
}
// SEXTA DERIVADA
class PATAS extends PERROS {
}
class ALAS extends GOLONDRINA {
}
}

13.3 Deducir las clases necesarias para disear un programa con diferentes tipos de juegos de cartas.

13.4 Implementar una jerarqua de clases de los distintos tipos de

archivos; codificar en Java la cabecera de las clases y los
constructores.

public class DEB2EJERC4 {

public static void main(String[] args) {
}
public class TIPOSDEARCHIVO {
}
class entrada extends TIPOSDEARCHIVO {
public entrada (){
}
}
class salida extends TIPOSDEARCHIVO {
public salida (){
}
}
class situacion extends TIPOSDEARCHIVO {
public situacion (){
}
}

class constantes extends TIPOSDEARCHIVO {

public constantes (){
}
}
class historicos extends TIPOSDEARCHIVO {
public historicos (){
}
}
class movimiento extends TIPOSDEARCHIVO {
public movimiento (){
}
}
class ACIL extends TIPOSDEARCHIVO {
public ACIL (){
}
}
class BINARIO extends TIPOSDEARCHIVO {
public BINARIO (){
}
}
}

13.5 Describir las diversas utilizaciones de la referencia super.

Se usa para invocar constructores de la clase padre

Debe ser la primera sentencia del constructor de la clase hijo

Esta referencia tambin se usa para invocar cualquier mtodo del padre.

Si la superclase no tiene un constructor sin argumentos, se debers definir un

constructor en la subclase.

13.6 Qu diferencias se pueden encontrar entre this y super?

Se sabe que java soporta herencia, con lo cual una clase puede ser la hija
de otra, o dicho de otro modo, extenderla.
por ejemplo
class Padre {
public String getName() {
return "Jose";
}
}
class Hijo extends Padre {
public String getName() {
return "Pablo";

}
}
Utilizas super si desde la clase Hijo quieres hacer referencia a la clase Padre,
por ejemplo, si desde la clase hijo quisieras invocar el metodo "getName()"
de la clase padre para que te devuelva "Jose" deberias llamar anteponiendo
super (super.getName()), de otra forma siempre obtendrias "Pablo"
this es ms sencillo, pues, hace referencia a la instancia actual de la clase,
se utiliza en ciertos casos puntuales.

La palabra reservada this permite especificar que la variable que

seala (y la seala haciendo (this.nombreVariable) es de la misma
clase en la que se usa. tambin permite crear cdigo mucho ms fcil
de entender para aquel que lo lee (y por tanto, ms sencillo para
nosotros cuando lo tengamos que releer/modificar/mejorar).

La palabra reservada super sirve para indicar que una variable o un

mtodo es de la superclase
la superclase y la subclase tienen una variable y un mtodo que
tienen el mismo nombre, pero que hacen funciones diferentes, y los
distinguimos usando sper.

Problemas
13.1 Definir una clase base Persona que contenga informacin de
propsito general comn a toda la gente (nombre, direccin, fecha de
nacimiento, sexo, etc.); disear una jerarqua de clases que contemple
las siguientes: Estudiante, Empleado y EstudianteEmpleado; escribir
un programa que lea del dispositivo estndar de entrada los datos
para crear una lista de personas: a) general; b) estudiantes; c)
empleados; d) estudiantes empleados. El programa deber permitir
ordenar alfabticamente por el primer apellido.

package ejercicio13.pkg1;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Scanner;

/**
*
* @author Lili

*/
public class Main {
Scanner dato=new Scanner(System.in);

public Persona ingresarDatos1(){

System.out.println("Ingrese el nombre: ");

String nombre = dato.next();
System.out.println("Ingrese la direcin: ");
String direccion=dato.next();
System.out.println("Ingrese el sexo: ");
String sexo=dato.next();

return new Persona(nombre,direccion,sexo);

}

public Estudiante ingresarDatos2(){

Persona persona=ingresarDatos1();
System.out.println("Ingrese el nmero de carnet: ");
String carnet=dato.next();
return new
Estudiante( carnet,persona.getNombre(),persona.getDireccion(),
persona.getSexo());
}

public Empleado ingresarDatos3(){

Persona persona=ingresarDatos1();
System.out.println("Es mayor de edad?\n"
+ "1. Si\n"
+ "2. No");

String eleccion=dato.next();
boolean mayorDeEdad;
if (eleccion.equals("1")) {
mayorDeEdad=true;
}else{
mayorDeEdad=false;
}
return new
Empleado(mayorDeEdad,persona.getNombre(),persona.getDireccion(),perso
na.getSexo());
}
public EstudianteEmpleado ingresarDatos4(){
Empleado empleado=ingresarDatos3();
System.out.println("Ingrese el carnet");
String carnet=dato.next();
return new EstudianteEmpleado(carnet, empleado.isMayorDeEdad(),
empleado.getNombre(), empleado.getDireccion(), empleado.getSexo());
}
public static void main(String[] args) {
ArrayList<Persona> listA = new ArrayList();
Main menu=new Main();
System.out.println("\tPERSONA");
listA.add(menu.ingresarDatos1());
System.out.println("\tESTUDIANTE");
listA.add(menu.ingresarDatos2());
System.out.println("\tEMPLEADO");
listA.add(menu.ingresarDatos3());
System.out.println("\tESTUDIANTE-EMPLEADO");
listA.add(menu.ingresarDatos4());
System.out.println("Lista sin ordenar");
for (Persona persona : listA) {
int i=1;
System.out.println(i+".- "+persona.toString());

}
Collections.sort(listA);
System.out.println("Lista ordenada");
for (Persona persona : listA) {
int i=1;
System.out.println(i+".- "+persona.toString());
}
}

13.2 Implementar una jerarqua Librera que tenga al menos una

docena de clases; considerar una librera con colecciones de libros de
literatura, humanidades, tecnologa, etctera.

public class biblioteca {

public static void main(String[] args) {}
}
class libreria1 {
}
class
}
class
}
class
}
class
}
class
}

literatura extends libreria1 {

humanidades extends libreria1 {
tecnologia extends libreria1 {
cientificos extends libreria1 {
bibliograficos extends libreria1 {

class
}
class
}
class
}
class

pinocho extends literatura {

ElLimire extends humanidades {
microsoft extends tecnologia {
teoriaespectral extends cientificos {

}
class Socrates extends bibliograficos {
}
class Descartes extends bibliograficos {
}
class Pitagoras extends bibliograficos {
}
class ElonLagesLima extends bibliograficos {
}

13.4 Implementar una jerarqua Empleado de cualquier tipo de

empresa que le sea familiar; la jerarqua debe tener al menos tres
niveles, con herencia de miembros dato, y mtodos; stos debern
calcular salarios, despidos, promociones, altas, jubilaciones, etctera;
los mtodos tambin debern permitir calcular aumentos salariales y
primas para empleados de acuerdo con su categora y productividad;
la jerarqua de herencia podr utilizarse para proporcionar diferentes
tipos de acceso a empleados; por ejemplo: el tipo de acceso
garantizado al pblico diferir del proporcionado a un supervisor, al
departamento de nminas o al Ministerio de Hacienda.

public class Problema2deberes2 {

public static void main(String[] args) {
Scanner a = new Scanner(System.in);
System.out.println("ingrese su sueldo");
double sueldo = a.nextDouble();
System.out.println("ingrese la opcion que desea calcular");
int x = a.nextInt();
switch (x) {
case (1):
aumentosalarial au = new aumentosalarial();

System.out.println("su sueldo total es de " +

au.sueldototal(sueldo));
break;
case (2):
jubilaciones r = new jubilaciones();
System.out.println("su jubilacion total sera de " +
r.calculo1(sueldo));
break;
case (3):
promociones rt = new promociones();
System.out.println("su promocion en el sueldo total sera de " +
rt.prom(sueldo));
break;
case (4):
reduccion m = new reduccion ();
System.out.println("su sueldo con multas es de " +
m.reduc(sueldo));
break;
}
}
}
public class aumentosalarial extends Problema2deberes2{
Scanner a = new Scanner(System.in);
double sueldototal(double sueldo) {
System.out.println("EL AMUENTO SE DARA CON 5 AOS DE EMPLEO ");
System.out.println("cuantos aos trabaja en la empresa");
double aos = a.nextDouble();
if (aos >= 5) {
double sueldototal = sueldo + 150;
return sueldototal;
}
if (aos < 5) {
double sueldototal = sueldo;
return sueldototal;
}
return 0;
}
}
public class jubilaciones extends aumentosalarial {
Scanner a = new Scanner(System.in);
double calculo1 (double sueldo){
System.out.println("ingrese el numero de aos de empleo");
double f = a.nextDouble();
double total = 150*f;
return total;
}
public class promociones {

Scanner a = new Scanner(System.in);

double prom(double sueldo){
System.out.println("cuantas horas extras trabajo este mes ");
double c = a.nextDouble();
if (c>=10){
double t = sueldo +35 ;
return t;
}
else
return sueldo;
}
public class reduccion {
Scanner a = new Scanner(System.in);
double reduc (double sueldo){
System.out.println("ingrese el numero de sanciuones por atrasos");
double h = a.nextDouble();
System.out.println("ingrese el numero de faltas en el empleo");
double k = a.nextDouble();
double y = h*(0.50);
double u = 5*15;
double entero = sueldo -y-u ;
return entero;
}

13.7 El programa siguiente muestra las diferencias entre llamadas a un

mtodo redefinido y otro no.

public class Base {

public void f() {
System.out.println("f(): clase base !");
}
public void g() {
System.out.println("g(): clase base !");
}
}
public class Derivada1 extends Base {
public void f() {
System.out.println("f():clase Derivada !");
}
public void g(int k) {
System.out.println("g() :clase Derivada !" + k);
}

}
public class Derivada2 extends Derivada1 {
public void f() {
System.out.println("f() :clase Derivada2 !");
}
public void g() {
System.out.println("g() :clase Derivada2 !" );
}
}
public class Anula {
/**
* @param args the command line arguments
*/
public static void main(String[] args) {
Base b = new Base();
Derivada1 d1 = new Derivada1();
Derivada2 d2 = new Derivada2();
Base p = b;
p.f();
p.g();
p = d1;
p.f();
p.g();
p = d2;
p.f();
p.g();
}
}
Cul es el resultado de ejecutar este programa? Por qu?

Al ejecutar el main del programa, se hace el llamado a los constructores de

cada clase y por lo tanto se imprimen los tipos de clases, en base a la
herencia que se ha creado por eso sale el tipo de clase para cada parmetro
f y g respectivamente.