Clases y Herencia java

I N ST S T I TU T U T O S U PE P E R IO I O R TE T E C NO N O L G I CO C O P B L IC IC O “PAMPAS - TAYACAJA” F O R M R M A C I Ó N P R O R O F E S I O N A L T E C N O L Ó G I C A

SEMANAS 13, 14, 15

I UNIDAD Carrera Profesional: Computación e Informática Semestre: III Sección: Única

Docente: Ing. JUAN J. ARAUJO ROMO Asignatura: ESTRUCTURA DE LA INFORMACION Semestre Académico: 2010 - I

OBJETOS Y CLASES 1.

DEFINICION DE CLASE: Una clase es como una plantilla de la cual se pueden crear varios objetos con las mismas características y funciones. o

Una clase es un modelo (diseño) de objeto

o

Define los atributos y operaciones del objeto

o

La clase usan el encapsulamiento encapsulamiento para forzar la abstracción

Una clase es una representación de un objeto en particular, y define un nuevo tipo de dato. Las clases de utilizan para crear objetos de ese tipo de clase en particular

Ejemplo de una clase en notación UML

o

El nombre de toda clase debe comenzar con mayúsculas

o

El nombre de los objetos con minúsculas

� � � � � � �

��


2.

UNA CLASE EN JAVA Para crear una clase se utiliza la palabra reservada

class y a

continuación el nombre de la clase. La definición de la clase se pone entre las llaves de apertura y cierre. El nombre de la clase empieza con una letra mayúscula.

Sintaxis: class NombreClase { //miembros dato o datos miembro //funciones miembro }

Ejemplo 1: public class Empleado { Cuerpo de la clase }

3.

DEFINICIÓN DE OBJETO: Objeto es una instancia de la clase, los objetos tienen las siguientes cualidades (identidad – los objetos se distinguen del uno del otro, comportamiento – pueden realizar tareas, estado – almacena información que varía a través del tiempo).

4.

DECLARACION DE OBJETOS: Para crear un objeto o una instancia de esta clase tenemos dos alternativas, la primera en la misma línea de declaración, tal como se ilustra a continuación.

Sintaxis 1: NombreClase NombreVariable; NombreVariable = new NombreClase ( )

� � � � � � �

��


2.

UNA CLASE EN JAVA Para crear una clase se utiliza la palabra reservada

class y a

continuación el nombre de la clase. La definición de la clase se pone entre las llaves de apertura y cierre. El nombre de la clase empieza con una letra mayúscula.

Sintaxis: class NombreClase { //miembros dato o datos miembro //funciones miembro }

Ejemplo 1: public class Empleado { Cuerpo de la clase }

3.

DEFINICIÓN DE OBJETO: Objeto es una instancia de la clase, los objetos tienen las siguientes cualidades (identidad – los objetos se distinguen del uno del otro, comportamiento – pueden realizar tareas, estado – almacena información que varía a través del tiempo).

4.

DECLARACION DE OBJETOS: Para crear un objeto o una instancia de esta clase tenemos dos alternativas, la primera en la misma línea de declaración, tal como se ilustra a continuación.

Sintaxis 1: NombreClase NombreVariable; NombreVariable = new NombreClase ( )

� � � � � � �

��


Sintaxis 2: NombreClase NombreVariable = new NombreClase ( )

Ejemplo 2: Empleado A1 = new Empleado ();

5.

ASIGNACION DE OBJETOS Cuando creamos un objeto internamente existe un puntero, al que no tenemos acceso, pero cuando asignamos objetos lo que realmente estamos asignando son las direcciones de memoria donde están definidos los objetos.

Ejemplo 3: Empleado A1 = new Empleado (); Empleado A2 = A1;

� � � � � � �

��


6.

ATRIBUTOS Los atributos son las características individuales que diferencian un objeto de otro y determinan su apariencia, estado u otras cualidades. Los atributos se guardan en variables denominadas de instancia, instancia, y cada objeto particular puede tener valores distintos para estas variables.

Las variables de instancia también denominados miembros dato, son declaradas en la clase pero sus valores son fijados y cambiados en el objeto.

Sintaxis: [TipoAcceso] TipoNombre

Ejemplo 4: Como ejemplo definiremos la clase Artículo que tiene definido 3 atributos

Clase Articulo

La implementación de esta clase seria:

public class Articulo { public int codigo; public String nombre; public double precio; }

� � � � � � �

��


El siguiente programa ilustra cómo debe usarse la clase Articulo:

public class Articulo { public static void main(String[ ] args) { // Creación de dos objetos

Articulo art1 = new Articulo(); Articulo art2 = new Articulo(); Articulo art3;

// Asignación de datos

art1.codigo = 100; art1.nombre = "Televisor"; art1.precio = 500; art2.codigo = 200; art2.nombre = "Plancha"; art2.precio = 80; art3 = art1;

// Imprimir artículos System.out.println(art1.codigo + "-" + art1.nombre + "-" + art1.precio); System.out.println(art2.codigo + "-" + art2.nombre + "-" + art2.precio); System.out.println(art3.codigo + "-" + art3.nombre + "-" + art3.precio);

} }

Analice ahora Ud. cada línea del programa anterior y modifique para 5 artículos.

��

� � � � � � �

I N ST I TU T O S U PE R IO R TE C NO L G I CO P B L IC O “PAMPAS - TAYACAJA” F O R M R M A C I Ó N P R O R O F E S I O N A L T E C N O L Ó G I C A

7.

COMPORTAMIENTO – METODOS El comportamiento de los objetos de una clase se implementa mediante funciones miembro o métodos. Un método es un conjunto de instrucciones que realizan una determinada tarea y son similares a las funciones de los lenguajes estructurados. Del mismo modo que hay variables de instancia y de clase, también hay métodos de instancia y de clase. En el primer caso, un objeto llama a un método para realizar una determinada tarea, en el segundo, el método se llama desde la propia clase.

Sintaxis [modificador] tipo NombreMetodo(tipo parm1, tipo parm2, tipo parm3, . . .) { declaraciones de variables locales; //...sentencias [return[ (]expresión[ )]]; }

Ejemplo 5:

En el siguiente ejemplo se ilustra el uso de métodos, para

Calculadora que tiene definidos atributos públicos n1 y n2, dos operaciones suma() y producto(). eso se ha definido una clase de nombre

Clase Calculadora public class Calculadora { public int n1; public int n2;

� � � � � � �

��


public int suma() { return (n1 + n2); }

public int producto() { return (n1 * n2); } }

Para ilustrar el uso de la clase Calculadora, se crea el programa aplicacal.

public class aplicacal { public static void main(String[ ] args) { Calculadora obj = new Calculadora (); obj.n1 = 10; obj.n2 = 8;

System.out.println("n1 = " + obj.n1); System.out.println("n2 = " + obj.n2); System.out.println("Suma = " + obj.suma()); System.out.println("Producto = " + obj.producto());

} }

Ejemplo 6: En el siguiente ejemplo tenemos una segunda versión de la clase

Calculadora donde las operaciones tienen parámetros.

� � � � � � �

��


Clase Calculadora public class Calculadora { public int suma (int n1, int n2) { return (n1 + n2); } public int producto (int n1, int n2) { return (n1 * n2); } }

Para ilustrar el uso de la clase Calculadora, se crea el programa

aplicacalcu. public class aplicacalcu { public static void main(String[ ] args) { int a = 15; int b = 8; Calculadora obj = new Calculadora(); System.out.println("n1 = " + a); System.out.println("n2 = " + b); System.out.println("Suma = " + obj.suma(a,b)); System.out.println("Producto = " + obj.producto(a,b));

} }

� � � � � � �

��


Ejemplo 7:

Diseñe una clase

Empleado; cuyos atributos sean

nombre, apellido y edad , con Método u operaciones de registrar y mostrar.

Empleado

Notación UML: •

El nombre de toda clase debe comenzar con mayúsculas

•

El nombre de los objetos con minúsculas � � � � � � �

��


CLASE EMPLEADO public class Empleado { private String Nombre; private String Apellido; private int Edad; public void Registrar(String Nombre, String Apellido, int Edad) { this.Nombre = Nombre; this.Apellido= Apellido; this.Edad = Edad; } public void Mostrar() { System.out.println("Nombre "+ Nombre); System.out.println("Apellido"+ Apellido); System.out.println("Edad"+ Edad);

} }

CLASE PRINCIPAL public class principal { public static void main(String[ ] args) { Empleado A1= new Empleado(); A1.Registrar("Juan","Hurtado", 22);

A1.Mostrar(); } }

� � � � � � � �

��


8.

MODIFICADORES DE ACCESO A LOS MIEMBROS DE UNA CLASE Una faceta importante de los lenguajes de Programación Orientada a Objetos se denomina encapsulación. El acceso a los miembros de una clase está controlado. Para usar una clase, solamente necesitamos saber que funciones miembro se pueden llamar y a qué datos podemos acceder, no necesitamos saber cómo está hecha la clase, como son sus detalles internos. Una vez que la clase está depurada y probada, la clase es como una caja negra. Los objetos de dicha clase guardan unos datos, y están caracterizados por una determinada conducta.

Este ocultamiento de la información niega a las entidades exteriores el acceso a los miembros privados (private) de un objeto. De este modo, las entidades exteriores acceden a los datos de una manera controlada a través de alguna función miembro. Para acceder a un miembro público (public), sea dato o función basta escribir:

objeto_de_la_clase.miembro_público_no_estático clase.miembro_público_estático La

segunda

representación se

ampliará

cuando

veamos

miembros dato estático y métodos estáticos.

8.1. MIEMBROS PÚBLICOS: Los miembros públicos son aquellos que tienen delante la palabra

public, y se puede acceder a ellos sin ninguna restricción.

8.2. MIEMBROS PRIVADOS: Los miembros privados son aquellos que tienen delante la palabra

private, y se puede acceder a ellos solamente dentro del

ámbito de la clase.

� � � � � � � �

��


8.3. POR DEFECTO (A NIVEL DE PAQUETE) Cuando

no

se

pone

ningún

modificador

de

acceso

delante de los miembros, se dice que son accesibles dentro del mismo paquete (package).

Esto es lo que hemos utilizado en algunos de los ejemplos estudiados antes.

package es la primera sentencia que se pone en

un archivo .java. El nombre del paquete es el mismo que el nombre del subdirectorio que contiene los archivos .java. Cada archivo .java contiene habitualmente una clase. Si tiene más de una solamente una de ellas es pública. El nombre de dicha clase coincide con el nombre del archivo. El uso de paquetes se estudiará más adelante.

Como se habrá dado cuenta hay una correspondencia entre archivos y clases, entre paquetes y subdirectorios. El Entorno Integrado de Desarrollo (IDE) en el que creamos los programas facilita esta tarea sin que el usuario se aperciba de ello.

EJEMPLO 8: Uso de los modificadores de acceso package //archivo: Linea.java

import java.io.*; class Linea { //coordenada 1er punto, modificador de acceso:package int x1,y1; //coordenada 2do punto, modificador de acceso:package int x2,y2;

� � � � � � � �

��


void leer() //modificador de acceso:package { try { // Definir un flujo de caracteres de entrada: flujoE InputStreamReader isr = new InputStreamReader(System.in); BufferedReader flujoE = new BufferedReader(isr); String sdato; // variable para almacenar una línea de texto

//lectura System.out.println("Introduzca 1er punto: "); System.out.print("x1: "); sdato = flujoE.readLine(); // leer una línea de texto x1=Integer.parseInt(sdato);//convierte cadena System.out.print("y1: "); sdato = flujoE.readLine(); // leer una línea de texto y1=Integer.parseInt(sdato);//convierte cadena

System.out.println("Introduzca 2do punto: "); System.out.print("x2: "); sdato = flujoE.readLine(); // leer una línea de texto x2=Integer.parseInt(sdato);//convierte cadena System.out.print("y2: ");

sdato = flujoE.readLine(); // leer una línea de texto y2=Integer.parseInt(sdato);//convierte cadena } catch (IOException ignorada) { } }

��

� � � � � � � �


void escribir() //modificador de acceso:package { System.out.println("Puntos de la recta : "); System.out.println("x1="+x1+" y1="+y1); System.out.println("x2="+x2+" y2="+y2); } }

// Archivo LineaAppl.java import java.io.*; class LineaAppl { public static void main (String[] args) { //Creación de un objeto recta: r1 Linea r1 = new Linea();

// uso del objeto r1 como el modificador de acceso es package //y la clase Linea está en el mismo directorio entonces main() // puede utilizar los métodos leer() y escribir()

r1.leer(); r1.escribir(); }

} � � � � � � � �

��


EJEMPLO 9:

Uso del modificador de acceso privado (private). El

siguiente programa es similar al anterior salvo que los métodos de la clase Linea son private.

//archivo: Linea1.java import java.io.*;

class Linea1 { //coordenada 1er punto, modificador de acceso:package int x1,y1; //coordenada 2do punto, modificador de acceso:package int x2,y2;

private void leer( ) //modificador de acceso:privado { try { // Definir un flujo de caracteres de entrada:

flujoE InputStreamReader isr = new InputStreamReader(System.in); BufferedReader flujoE = new BufferedReader(isr);

String sdato; // variable para almacenar una línea de texto

//lectura System.out.println("Introduzca 1er punto: "); System.out.print("x1: "); sdato = flujoE.readLine(); // leer una línea de texto

� � � � � � � �

��


x1=Integer.parseInt(sdato);//convierte cadena System.out.print("y1: "); sdato = flujoE.readLine(); // leer una línea de texto y1=Integer.parseInt(sdato);//convierte cadena

System.out.println("Introduzca 2do punto: "); System.out.print("x2: "); sdato = flujoE.readLine(); // leer una línea de texto x2=Integer.parseInt(sdato);//convierte cadena System.out.print("y2: "); sdato = flujoE.readLine(); // leer una línea de texto y2=Integer.parseInt(sdato);//convierte cadena } catch (IOException ignorada) {} }

private void escribir( ) //modificador de acceso:privado { System.out.println("Puntos de la recta : "); System.out.println("x1="+x1+" y1="+y1); System.out.println("x2="+x2+" y2="+y2); } }

// Archivo Linea1Appl.java

import java.io.*; class Linea1Appl { public static void main (String[] args)

��

� � � � � � � �


{ //Creación de un objeto recta: r1 Linea1 r1=new Linea1();

// uso del objeto r1 //como el modificador de acceso de los metodos de la clase Linea es privado //entonces main() no puede utilizar los métodos leer() y escribir()

r1.leer(); r1.escribir(); } }

NOTA: Este programa no ejecuta porque el compilador protesta mostrando el siguiente mensaje:

EJEMPLO 10: Uso

del modificador private y public. Nótese como

la función main(), puede acceder a los métodos públicos de la clase Linea2.

//archivo: Linea2.java

import java.io.*;

class Linea2 { //coordenada 1er punto, modificador de acceso:privado private int x1,y1; //coordenada 2do punto, modificador de acceso:privado private int x2,y2; //los datos miembro solo serán accedidos por sus métodos por ser privados

��

� � � � � � � �


public void leer() //modificador de acceso:público { try { // Definir un flujo de caracteres de entrada: flujoE InputStreamReader isr = new InputStreamReader(System.in); BufferedReader flujoE = new BufferedReader(isr);

String sdato; // variable para almacenar una línea de texto //lectura System.out.println("Introduzca 1er punto: "); System.out.print("x1: "); sdato = flujoE.readLine(); // leer una línea de texto x1=Integer.parseInt(sdato);//convierte cadena

System.out.print("y1: "); sdato = flujoE.readLine(); // leer una línea de texto y1=Integer.parseInt(sdato);//convierte cadena

System.out.println("Introduzca 2do punto: "); System.out.print("x2: "); sdato = flujoE.readLine(); // leer una línea de texto x2=Integer.parseInt(sdato);//convierte cadena

System.out.print("y2: "); sdato = flujoE.readLine(); // leer una línea de texto y2=Integer.parseInt(sdato);//convierte cadena } catch (IOException ignorada) {} }

��

� � � � � � � �


public void escribir() //modificador de acceso:público { System.out.println("Puntos de la recta : "); System.out.println("x1="+x1+" y1="+y1); System.out.println("x2="+x2+" y2="+y2); } // Archivo Linea2Appl.java

import java.io.*; class Linea2Appl { public static void main (String[] args) { //Creación de un objeto recta: r1 Linea2 r1=new Linea2(); // uso del objeto r1 como el modificador de acceso de los métodos //de la clase Linea // es public entonces main() puede utilizar los métodos leer() y //escribir() r1.leer(); r1.escribir(); } }

9.

OCULTANDO DATOS Uno de los fundamentos de la programación orientada a objetos es que el usuario solo debe tener acceso a los datos que son de su interés y del modo que le corresponde, por ejemplo solo lectura, solo escritura o ambos.

��

� � � � � � � �


Para conseguir esto se debe implementar los atributos como privados y se debe implementar métodos para acceso a ellos, existe un estándar para definir este método. Por ejemplo; si el atributo es apellido los métodos serian:

setapellido : este método permite asignar un valor al atributo. getapellido : este método permite leer el valor del atributo. Como puede apreciar existen dos prefijos, el prefijo para asignar un valor al atributo y el prefijo

set que se utiliza

get para leer el valor del atributo,

de esta manera podemos seleccionar si se implementa el método set, get, o ambos, y restringir el novel de acceso nivel de acceso a los datos. Otra posibilidad que nos da la implementación de estos métodos es agregar funcionalidad que puede servir para verificar por ejemplo si el -2 se esta signando es correcto o no.

EJEMPLO 11: Realizar un programa que ilustra el uso de métodos para acceder a los campos de un objeto.

Clase Artículo en notación UML:

� � � � � � � �

��


Clase Articulo public class Articulo { private int codigo; private String nombre; private double preCosto; private double preVenta; public void setCodigo(int nCodigo) { codigo = nCodigo; } public void setNombre(String sNombre) { nombre = sNombre; } public void setPreCosto(double nPreCosto ) { preCosto = nPreCosto; preVenta = preCosto * 1.4; } public int getCodigo() { return codigo; } public String getNombre() { return nombre; } public double getPreCosto() { return preCosto; }

� � � � � � � �

��


public double getPreVenta() { return preVenta; } } Clase progprincipal public class progprincipal { public static void main(String[ ] args) { Articulo art1 = new Articulo(); art1.setCodigo( 1000 ); art1.setNombre( "Auto" ); art1.setPreCosto( 15000 ); System.out.println("Codigo = " + art1.getCodigo() ); System.out.println("Nombre = " + art1.getNombre() ); System.out.println("Precio Costo = " + art1.getPreCosto() ); System.out.println("Precio Venta = " + art1.getPreVenta() );

} }

Como se puede apreciar el precio de venta se calcula de manera automática cuando establecemos el precio de costo, esto debido a que utilizamos un método para asignar el precio de costo, por otro lado el precio de venta sólo puede ser leído (sólo lectura), más no existe manera alguna de cambiar su valor, a menos que cambiemos el precio de costo.

10. SOBRECARGA La sobrecarga permite definir dos ó más métodos que comparten el nombre, pero la declaración de sus parámetros debe ser diferente. Esta una de las características muy importante de la POO, y por lo tanto también de Java.

� � � � � � � �

��


Cuando se invoca a un método sobrecargado, Java utiliza el tipo y/o número parámetros como guía para determinar a qué versión del método sobrecargado debe llamar. Por lo tanto, los métodos sobrecargados deben ser diferente tipo y/o número de parámetros.

EJEMPLO 12:

En este ejemplo ilustraremos el uso de la sobrecarga,

para lo cual implementamos una clase que permita

convertir a String un

número, dependiendo el número se ejecutará el método que le corresponde.

Clase miconvertidor con una función sobrecargada

miconvertidor, tal como se aprecia en la figura, tenemos el método convert sobrecargado. La clase que se utilizara para esta demostración es

Clase miconvertidor public class miconvertidor { public String convert(int n) { return (Integer.toString(n)); } public String conver(long n) { return (Long.toString(n)); }

� � � � � � � �

��


public String convert(float n) { return (Float.toString(n)); } public String convert(double n) { return (Double.toString(n)); } }

El programa que ilustra el uso de esta clase es el siguiente:

Clase aplicaconvert

public class aplicaconvert { public static void main(String[] args) { miconvertidor obj = new miconvertidor(); int n1 = 500; long n2 = 100000; float n3 = 456.459834f; double n4 = 8934.42573485720;

System.out.println("n1 = " + obj.convert(n1)); System.out.println("n2 = " + obj.convert(n2)); System.out.println("n3 = " + obj.convert(n3)); System.out.println("n4 = " + obj.convert(n4)); } }

� � � � � � � �

��


11. CONSTRUCTORES permiten inicializar un objeto inmediatamente después de su creación, tienen el mismo nombre que la clase donde se encuentra y sintácticamente son similares de los Los

constructores

métodos.

Sintaxis public nombre_clase (lista_de_parámetros ) { // instrucciones } El constructor se invoca cuando creamos el objeto, junto con el operador

new. Sintaxis nombre_clase nombre_variable; nombre_variable = new nombre_clase( lista_de_argumentos ); Los constructores tienen el mismo nombre de la clase, y no tienen objetivo principal de un constructor es inicializar el estado interno del objeto. tipo, esto debido a que retornan el mismo tipo de la clase, el

EJEMPLO 13:

En

este ejemplo crearemos una clase de nombre

empleado, que tiene un constructor que inicializa sus atributos

Clase Empleado con un Constructor

� � � � � � � �

��


Clase Empleado public class Empleado { // Atributos: private String nombre; private double sueldo; private int edad; // Constructor: public Empleado() { nombre = "Claudia"; sueldo = 5000.00; edad = 22; } // Operaciones: public String getNombre() { return this.nombre; } public double getSueldo() { return this.sueldo; } public int getEdad() { return this.edad; } } � � � � � � � �

��


El programa que ilustra el uso de esta clase es el siguiente, puede notar que el constructor se invoca junto con el operador new.

Clase aplicaempleado public class aplicaempleado { public static void main(String[] args) { Empleado obj = new Empleado( ); System.out.println( "Nombre = " + obj.getNombre() ); System.out.println( "Sueldo = " + obj.getSueldo() ); System.out.println( "Edad = " + obj.getEdad() ); } }

12. CONSTRUCTORES CON PARÁMETROS útiles si tienen parámetros, en nuestro ejemplo de la clase Empleado, resulta que no todos los empleados se llaman claudia, el ejemplo siguiente ilustra el uso de Los

constructores

pueden

resultar

más

constructores con parámetros.

EJEMPLO 14:

El siguiente ejemplo ilustra el uso de constructores

con parámetros la clase utilizada es Empleado1.

Clase Empleado1 con un constructor con parámetros

��

� � � � � � � �


Clase Empleado1 public class Empleado1 { // Atributos: private String nombre; private double sueldo; private int edad; // Constructor: public Empleado1(String nombre, double sueldo, int edad) { this.nombre = nombre; this.sueldo = sueldo; this.edad = edad; } // Operaciones: public String getNombre() { return this.nombre; } public double getSueldo() { return this.sueldo; } public int getEdad() { return this.edad; } }

inicializar los objetos con diferentes datos, así podemos tener un objeto para empleado. El constructor de esta clase permite

��

� � � � � � � �


El programa que ilustra el uso de esta clase es el siguiente:

Clase aplicaempleado1 public class aplicaempleado1 { public static void main(String[] args) { Empleado1 obj = new Empleado1( "Angelica", 4000, 23 );

System.out.println( "Nombre = " + obj.getNombre() ); System.out.println( "Sueldo = " + obj.getSueldo() ); System.out.println( "Edad = " + obj.getEdad() ); } }

constructor se invoca junto con el operador new y es en esa instrucción que se le pasa los datos para que inicialice los objetos. Puede notar que el

13. SOBRECARGA DE CONSTRUCTORES Al igual que los métodos, los constructores también pueden ser sobrecargados, esto quiere decir, que podemos tener diferentes constructores dependiendo de los datos de los que disponemos.

EJEMPLO 15: En este ejemplo se ilustra cómo construir clases con constructores sobrecargados la clase que se utiliza es

Empleado2, en esta clase

tenemos cuatro versiones del constructor, tal como se aprecia en la Figura.

� � � � � � � �

��


Clase Empleado2 con constructor sobrecargado

Los datos de un empleado son: nombre, sueldo y edad, cunado falta el sueldo se asume un sueldo base que está definido en SUELDO_BASE y cuando falta la edad se asume cero.

Clase Empleado2

public class Empleado2 { // Atributos:

private String nombre; private double sueldo; private int edad; private static final double SUELDO_BASE = 5000.00; // Constructores:

public Empleado2(String nombre, double sueldo, int edad) { this.nombre = nombre; this.sueldo = sueldo; this.edad = edad; }

� � � � � � � �

��


public Empleado2(String nombre, double sueldo) { this( nombre, sueldo, 0 ); } public Empleado2(String nombre, int edad) { this( nombre, SUELDO_BASE, edad ); } public Empleado2(String nombre) { this( nombre, SUELDO_BASE ); } // Operaciones:

public String getNombre() { return nombre; } public double getSueldo() { return sueldo; } public int getEdad() { return edad; } } � � � � � � � �

��


El programa que ilustra el uso de esta clase es el siguiente: Clase aplicaempleado2 public class aplicaempleado2 { public static void main(String[] args) { Empleado2 emp1 = new Empleado2 ( "Gustavo", 15000.0, 30 ); Empleado2 emp2 = new Empleado2 ( "Ricardo", 27 ); Empleado2 emp3 = new Empleado2 ( "Sergio" ); System.out.println( "Empleado 1" ); System.out.println( "Nombre = " + emp1.getNombre() ); System.out.println( "Sueldo = " + emp1.getSueldo() ); System.out.println( "Edad = " + emp1.getEdad() ); System.out.println(); System.out.println( "Empleado 2" ); System.out.println( "Nombre = " + emp2.getNombre() ); System.out.println( "Sueldo = " + emp2.getSueldo() ); System.out.println( "Edad = " + emp2.getEdad() ); System.out.println(); System.out.println( "Empleado 3" ); System.out.println( "Nombre = " + emp3.getNombre() ); System.out.println( "Sueldo = " + emp3.getSueldo() ); System.out.println( "Edad = " + emp3.getEdad() ); System.out.println(); } }

Ricardo se le asignó el sueldo base debido que no se le especifico su sueldo al momento de crear el objeto, en el caso de Sergio solo se especificó su nombre, por lo tanto se le asignó el sueldo base y edad cero. Del resultado obtenido podemos deducir que a

��

� � � � � � � �


SEMANA 16

I UNIDAD Carrera Profesional: Computación e Informática Semestre: III Sección: Única

Docente: Ing. JUAN J. ARAUJO ROMO Asignatura: ESTRUCTURA DE LA INFORMACION Semestre Académico: 2010 - I

HERENCIA 1.

DEFINICION DE HERENCIA: La

herencia

es

la

característica

más

sobresaliente

de

la

programación orientada a objetos, porque permite definir una jerarquía de clases, y de esta manera reutilizar sus definiciones.

Mediante la herencia el programador puede crear una clase genérica que defina los rasgos comunes de un conjunto de objetos, luego esta clase puede ser heredada por otras clases más específicas, cada una de las cuales añadirá aquellos rasgos que la hacen única.

2.

FUNDAMENTOS Por si misma, la idea de objeto es una herramienta más que buena. Permite empaquetar datos y funcionalidad, de manera que es posible representar cualquier idea del universo del problema mediante clases.

Es posible utilizar clases ya definidas para crear a partir de estas nuevas clases (clase heredada), y luego agregarle funcionalidad adicional según necesidades de esta nueva clase.

En terminología de la POO, una clase heredada se llama superclase, y la clase que hereda se denomina subclase. Por lo tanto, una subclase es una versión especializada de la superclase, que hereda todas las definiciones de la superclase (atributo y métodos) ya añade su propia funcionalidad.

��

� � � � � � � �


Notación UML para representar la herencia.

La Figura nos representa la herencia utilizando notación UML, la flecha apunta a la

superclase, y

es

posible que existan muchas

subclases que hereden una superclase.

A la superclase también se le conoce como clase base, clase super, o clase padre; y a la subclase también se le conoce como clase derivada, heredada, o clase hija.

Ejemplo 16: de

aplicación

En este ejemplo veremos un caso básico, pero ilustrativo

de

herencia,

tenemos

una

clase

base

de

nombre

CalculadoraBase, y una subclase de nombre Calculadora1 que hereda de CalculadoraBase.

� � �

Ejemplo básico de aplicación de herencia. ��

� � � � �


En la Figura se puede apreciar que la subclase hereda los métodos suma y resta, he implementa los métodos factorial y esPrimo.

Una instancia de la clase métodos

suma

CalculadoraBase solo tendrá los

y resta, mientras que una instancia de la clase

Calculadora1 tendrá los métodos heredados suma y resta, y además sus métodos propios factorial y esPrimo.

A

continuación

tenemos

la

implementación

de

la

clase

alculadoraBase, usted puede apreciar claramente la implementación de los métodos suma y resta. Clase CalculadoraBase.java public class CalculadoraBase { public int suma(int n1, int n2) { return (n1+n2); }

public int resta(int n1, int n2) { return (n1 - n2); } }

A

continuación

tenemos

la

implementación

de

la

clase

Calculadora1, la palabra extends en !a definición de la clase indica que está heredando de la clase CalculadoraBase, y puede usted apreciar que solo se está implementando los nuevos métodos.

� � � � � � � �

��


Clase Calculadora1.java public class Calculadora1 extends CalculadoraBase { public int factorial(int n) { int f = 1; while(n>1) { f=f* n--;

} return f; }

public Boolean esPrimo(int n) { Boolean primo = true; int k = 1; while(++k
} } return primo; } }

� � � � � � � �

��


A continuación tenemos el programa ilustrativo del uso de la clase

Calculadora1 solo se está creando una instancia de esta clase (cal), y debido a la herencia tenemos acceso a los métodos suma y resta, que son los métodos heredados, y los métodos propios factorial y esPrimo.

Clase prog14

public class prog14 { public static void main(String[] args) { int n1 = 17, n2 = 6; Calculadora1 cal = new Calculadora1();

System.out.println( "n1 = " + n1 ); System.out.println( "n2 = " + n2 ); System.out.println( "Suma: " + cal.suma(n1,n2) ); System.out.println( "Resta: " + cal.resta(n1,n2) ); System.out.println( "Factorial de " + n2 + " es " + cal.factorial(n2) ); System.out.println( n1 + " es primo: " + cal.esPrimo(n1) ); } }

3.

IMPLEMENTANDO LA HERENCIA Palabra Clave: extends La palabra clave

extends permite implementar la herencia de clases.

En Java solo se puede heredar desde una clase, en otras palabras no existe la herencia múltiple.

� � � � � � � �

��


Sintaxis class nombre_subclase extends nombre_superclase { // implementación }

Ejemplo de herencia.

Por

ejemplo,

en

la

Figura

tenemos

una

clase

base

CuentaBancaria que define las características comunes a todas las cuentas, y a partir de esta se obtiene dos subclases CuentaAhorro y CuentaCorriente. A continuación tenemos código básico para la implementación de estas clases:

public class CuentaBancaria { //Implementación } public class CuentaAhorro extends CuentaBancaria { //Implementación } public class CuentaCorriente extends CuentaBancaria { //Implementación }

��

� � � � � � � �


4.

PALABRAS CLAVES this y super 4.1. Palabra Clave: this: Esta palabra clave hace referencia al objeto actual, y puede utilizarse dentro de cualquier método. Por ejemplo, si tenemos la clase Demo:

class Demo { private int n; public void setN( int n ) { this.n = n; } } En esta clase tenemos una variable privada n, y un método

setN para asignar un valor a la variable, pero resulta que el parámetro del método tiene el mismo nombre que la variable de la clase, por lo tanto, la única manera de hacer referencia a la variable de la clase es mediante la palabra clave

this, tal como se

ilustra en el script.

La palabra clave

this por si sola hace referencia al constructor

de la misma clase. � � � � � � � �

��


Ejemplo 17: En este ejemplo veremos la aplicación de la palabra clave

this, la clase que utilizaremos es Empleado.

Clase Empleado.java public class Empleado { // Atributos: private int codigo; private String nombre; private Double sueldo; // Constructores: public Empleado(int codigo, String nombre, Double sueldo) { this.codigo = codigo; this.nombre = nombre; this.sueldo = sueldo; } public Empleado(String nombre) { this( 1000, nombre, 3500.00 ); } // operaciones public String toString() { return codigo + " " + nombre + " " + sueldo; }

}

��

� � � � � � � �


Esta clase tiene tres campos privados: código, nombre y sueldo; tiene también dos constructores, el primero recibe tres datos (código, nombre y sueldo), mientras que el segundo recibe solo el nombre y asume los otros dos datos, tal como se puede apreciar en el script, pero invoca al primer constructor mediante la palabra clave

this; el otro método

(toString) retorna una cadena con los tres datos del empleado.

Programa ilustrativo para el uso de la clase

Empleado.

Clase prog15.java

public class prog15 { public static void main(String[ ] args) { Empleado emp1 = new Empleado ( 500, "Claudia", 4000.00 ); Empleado emp2 = new Empleado ( "Laura" ); System.out.println( "Empleado 1: " + emp1.toString() ); System.out.println( "Empleado 2: " + emp2.toString() ); } }

En el programa anterior podemos observar que la segunda instancia (emp2) se crea solo con el nombre del empleado (Laura), pero internamente se le asigna código 1000 y sueldo 3500.00, si revisamos la clase Empleado, esto se realiza a través del segundo constructor que invoca al primer constructor utilizando la palabra clase this.

� � � � � � � �

��


4.2. PALABRA CLAVE: super Permite a una subclase hacer referencia a la superclase inmediata superior. Esta palabra clave tiene dos formas generales: la primera es para llamar al constructor de la superclase y la segunda es para acceder a un miembro de la superclase que se ha ocultado por un miembro de la subclase.

Invocar Constructores de la Superclase Para invocar constructores de la

superclase, se deben

realizar desde el constructor de la subclase.

Sintaxis:

super(lista_de_parametros );

lista_de_parametros especifica cualquier parámetro que necesite el constructor en la superclase. super (lista_de_parametros) debe ser la primera sentencia que se ejecute En este caso,

dentro del constructor de la subclase.

Acceder a Miembros de la Superclase La palabra clave super actúa de manera similar a this, pero en este caso se hace referencia a la superclase.

Sintaxis: super, miembro

En este caso el miembro puede ser un método o una variable de instancia. Esta forma de usar la palabra clave super tiene mayor aplicación, sobre todo cuando miembros de la subclase ocultan miembros de igual nombre en la superclase.

� � � � � � � �

��


Ejemplo 18: clase

En este ejemplo veremos la aplicación de la palabra

super para invocar al constructor de la superclase.

Se trata de una superclase

Persona y dos subclases Trabajador y

Docente, desde estas subclases se invocará al constructor de la superclase.

Clase Persona.java public class Persona { // Atributos: private int codigo; private String nombre; private Double sueldo; // Constructores: public Persona(int codigo, String nombre, Double sueldo) { this.codigo = codigo; this.nombre = nombre; this.sueldo = sueldo; } // Operaciones: public String toString() { return ( codigo + " - " + nombre + " - " + sueldo ); } }

Esta clase tiene un constructor a través del cual se asigna los datos, y un método (toString) que retorna los datos de la persona concatenados y separados por un guión.

� � � � � � � �

��


Clase Trabajador.java public class Trabajador extends Persona { // Operaciones: public Trabajador (int codigo, String nombre, Double sueldo, Double bonificacion) { super( codigo, nombre, sueldo + bonificacion ); } public String toString() { return ( "Trabajador: " + super.toString() ); } }

El constructor de esta clase invoca al constructor de la clase través de la palabra

Persona a

super, se está pasando la suma del sueldo y la

bonificación como sueldo del trabajador.

toString, peor está invocando al método toString de la clase Persona a través de la palabra clave super, y a su resultado se le está concatenando la palabra Trabajador. También se está redefiniendo el método

Clase Docente.java public class Docente extends Persona { // Operaciones: public Docente(int codigo, String nombre, int horas, Double importePorHora) { super( codigo, nombre, horas * importePorHora ); } public String toString() { return ( "Docente: " + super.toString() ); } }

��

� � � � � � � �


En el constructor de esta clase también se está invocando al constructor de la clase

Persona, el sueldo se está calculado como el

producto de la cantidad de horas (horas) por el importe por hora (importePorHora).

toString y se está accediendo al método toString de la clase Persona a través de la palabra super, y a su resultado se le está concatenando la palabra Docente. De igual forma se está redefiniendo el método

A continuación tenemos el programa ilustrativo:

Clase prog16.java public class prog16 { public static void main(String[ ] args) { Trabajador tra = new Trabajador ( 500, "Julio Flores", 2000.00, 500.00 ); Docente doc = new Docente ( 501, "Gustavo Coronel", 150, 50.00 );

System.out.println(); System.out.println( tra.toString() + "\n" ); System.out.println( doc.toString() ); } }

En este programa estamos creando dos instancias, una de la clase

Empleado, luego estamos imprimiendo la cadena que retorna el método toString de cada una de ellas trabajador y otra de la clase

respectivamente.

��

� � � � � � � �


Ejemplo 19:

La clase base es

Figura, y de ella van a heredar las

Polígono y Circulo. A su vez, de Polígono heredarán las clases Cuadrado y Triangulo. El diagrama esquemático de clases es el clases

siguiente:

La clase base Figura solo tiene dos atributos:

nombre de la figura y

perímetro (longitud total de su borde exterior) y, aparte del constructor, un único método llamado imprimirInformacion que imprime por pantalla la información de la figura. Aquí está la clase Figura programada:

public class Figura { String nombre; double perimetro; public Figura(String nombre, double perimetro) { this.nombre = nombre; this.perimetro = perimetro; } public void imprimirInformacion() { System.out.println("Soy un "+nombre+" y mi perímetro es "+perimetro+" m"); } public static void main(String[] args) { Figura cuad= new Figura("cuadrado", 2*4); Figura circ= new Circulo(2); Figura tria= new Figura("triangulo", (3*3)); cuad.imprimirInformacion(); circ.imprimirInformacion(); tria.imprimirInformacion(); } }

��

� � � � � � � �


main, crea tres objetos y luego imprime la información de cada uno de ellos: un cuadrado de lado 2 metros, un círculo de radio 2 metros y un triángulo de lado 3 metros. En el método

Compila y ejecuta el programa. La salida por pantalla debería ser la siguiente:

Clase Círculo.java Ahora vas a programar la clase

Circulo, que hereda de la clase

Figura. Esta nueva clase tiene un atributo más (aparte de los heredados), de tipo double, que almacena el radio del círculo, que se le anterior

pasa en el constructor. El radio nos sirve para calcular el perímetro del círculo (2*pi*radio).

Además

esta

clase

sobrescribe

el

método

anterior

imprimirInformacion para añadir un mensaje más explicativo con el valor del radio. El código de la clase Circulo es el siguiente:

public class Circulo extends Figura { double radio;

public Circulo(double radio) { super("Circulo", 2*Math.PI*radio); this.radio = radio; } � � � � � � � �

��


public void imprimirInformacion() { System.out.println("Soy un circulo y mi radio es "+radio+ " m, con lo que mi perimetro es "+perimetro+" m"); }

public static void main(String[] args) { Figura c1= new Circulo(2); Figura c2= new Circulo(3); c1.imprimirInformacion(); c2.imprimirInformacion(); } }

main, se crea dos objetos de la clase Circulo, uno de radio 2 metros y otro de radio 3 metros, e imprime su información. El método

Tras compilar y ejecutar el programa, la salida por pantalla debería ser la siguiente:

Clase Polígono.java Ahora toca la clase

Polígono, muy parecida a la clase Circulo

anterior. La diferencia es que en vez de radio los atributos del polígono son el número de lados y la longitud de cada lado, con los que podemos calcular el valor del perímetro.

Polígono. En el método main crea dos polígonos, uno de 3 lados con longitud 3 (triángulo) y otro de 4 lados con longitud 4 (cuadrado). Este ejercicio consiste en programar la clase

� � � � � � � �

��


El código de la clase Poligono es el siguiente:

public class Poligono extends Figura { int numeroLados; double longitudLado;

public Poligono(String nombre, int numeroLados, double longitudLado) { super(nombre,(numeroLados*longitudLado)); this.numeroLados=numeroLados; this.longitudLado=longitudLado; }

public void imprimirInformacion() { System.out.println("Soy un polígono "+nombre+", tengo "+numeroLados+ " lados de longitud "+longitudLado+

" m, por lo que mi perímetro es "+perimetro+ " m"); }

public static void main(String[ ] args) { Figura c= new Poligono("Cuadrado",4,2); Figura t= new Poligono("Triángulo",3,2);

c.imprimirInformacion(); t.imprimirInformacion(); } }

� � � � � � � �

��


Clases Cuadrado.java y Triángulo.java Sólo quedan las clases

Cuadrado y Triangulo, que derivan de la clase

Poligono. Estas dos clases no tienen atributos nuevos y ni siquiera sobreescriben el método imprimirInformacion. Programa las dos clases. En cada una de ellas, añade un

main que cree

dos objetos.

Las clases son los siguientes:

Clase Cuadrado.java

public class Cuadrado extends Poligono { public Cuadrado(double longitudLado) { super("Cuadrado",4,longitudLado); }

public static void main(String[ ] args) { Figura c1= new Cuadrado(2.0); Figura c2= new Cuadrado(5.0);

c1.imprimirInformacion(); c2.imprimirInformacion(); } }

� � � � � � � �

��

Clases y Herencia java

Recommend Documents