Programación I programación Orientada a Objetos



Descargar 36,14 Kb.
Fecha de conversión24.03.2017
Tamaño36,14 Kb.
  • Programación I
  • Programación Orientada a Objetos
  • Presentación
  • Herencia
  • Programación I
  • La idea básica consiste en que las clases nuevas se construyen a partir de las clases ya existentes. Es decir, las clases nuevas heredan la vida de las más antiguas.
  • La herencia es la característica clave de los sistemas orientados a objetos para propiciar la reusabilidad.
  • La herencia implementa las relaciones es-un (type-of) o es-una-clase-de (instanceof).
  • Herencia
  • Programación I
  • Ejemplo:
  • Herencia
  • Programación I
  • Fútbol es una clase de Pelota. Fútbol tiene todos los atributos y operaciones de Pelota.
  • No obstante, la clase Fútbol ha ocultado (hecho privada) la operación desinflar (sacándola de la interfaz pública) y sobrecargó el método lanzar con una implementación apropiada para el Fútbol.
  • La clase Pelota es la clase padre (superclase) en la jerarquía.
  • Herencia
  • Programación I
  • La herencia es una forma de especialización en donde las clases hijas son refinadas para tener el comportamiento y atributos adecuados para la aplicación de que se trate.
  • Al poder las clases derivadas añadir, redefinir y ocultar miembros, la herencia se convierte en reusabilidad programable.
  • Cuando se crea una clase es posible que sea útil para la creación de futuras clases. De modo que, cuando se esté haciendo un programa distinto y se necesite esa clase, ésta se pueda incluir en el código de ese nuevo programa.
  • Herencia por Composición
  • Programación I
  • También es posible, que se utilice una clase para crear instancias de la misma en nuevas clases. A eso se le llama Composición.
  • Representa una relación “tiene un”, es decir, si tenemos una clase Rueda y una clase Auto, es de esperar que la clase Auto tenga cuatro instancias de Rueda ó un vector de 4 posiciones, por ejemplo:
  • Herencia por Composición
  • Programación I
  • public class Rueda{
  • private int tamanho;
  • private String marca;
  • public Rueda(){
  • }
  • }
  • public class Auto{
  • private String Placa;
  • private Rueda rueda1, rueda2, rueda3, rueda4;
  • private Rueda [] ruedas=new Rueda[4];
  • public Auto(){
  • rueda1=new Rueda(); //A todos los obj ruedas
  • for (int i=0; i
  • ruedas[i]=new Rueda();
  • }
  • }
  • Herencia por Composición
  • Programación I
  • public class Circulo{
  • Punto centro;
  • int radio;
  • public float superficie() {
  • return 3.14*radio*radio;
  • }
  • }
  • Es la técnica en la que una clase se compone o contiene instancias de otras clases. Es una técnica muy habitual cuando se diseñan clases. En el ejemplo diríamos que un Circulo tiene un punto (centro) y un radio.
  • Ejemplo:
  • Herencia por Extensión
  • Programación I
  • Pero, además de ésta técnica de Composición es posible pensar en casos en los que una clase es una extensión de otra. Es decir, una clase es como otra y además tiene algún tipo de característica propia que la distingue.
  • Herencia por Extensión
  • Programación I
  • Aves
  • Persona
  • Insectos
  • Mamíferos
  • Hombre
  • Mujer
  • Animal
  • Herencia por Extensión
  • Programación I
  • Es el proceso por el cual un objeto puede adquirir las propiedades y métodos de otro objeto.
  • La herencia supone una clase base y una jerarquía de clases que contiene las clases derivadas de la clase base.
  • Además, es una forma de reutilización de software, en la cual se crean las clases nuevas a partir de las clases existentes, mediante la absorción de sus atributos y comportamientos.
  • Herencia por Extensión: Tipos
  • Programación I
  • La herencia simple es aquella donde las clases derivadas toman atributos y comportamientos de una sola clase base.
  • La herencia múltiple es aquella donde las clases derivadas toman los atributos y comportamientos de varias clases base.
  • Herencia por Extensión: Tipos
  • Programación I
  • Clase
  • Clase Base
  • Clase Padre
  • Clase
  • Clase Base
  • Clase Padre
  • Sub-Clase
  • Clase Derivada
  • Clase Hija
  • Herencia Simple Herencia Múltiple
  • Programación I
  • Ejemplo:
  • class Empleado {     protected String nombre;     protected int sueldo;     Empleado(String nombre, int sueldo) {
  •     this.nombre = nombre;         this.sueldo = sueldo; }     public void aumentarSueldo(int porcentaje) {
  • sueldo += (int)(sueldo * porcentaje / 100); }     public void mostrar() { System.out.println (“nombre: ” + nombre);
  • System.out.println (“Sueldo: ” + sueldo); } }
  • class Ejecutivo extends Empleado {     public int presupuesto;     void asignarPresupuesto(int p) {         presupuesto = p; } }
  • nombre
  • sueldo
  • Empleado(String,int)
  • aumentarSueldo(int)
  • mostrar()
  • ObjEmpleado
  • nombre
  • sueldo
  • presupuesto
  • aumentarSueldo(int)
  • mostrar()
  • asignarPresupuesto(int)
  • ObjEjecutivo
  • Herencia por Extensión
  • Programación I
  • Un Ejecutivo “ES UN” Empleado, pero lo contrario no es cierto. Por ejemplo, si escribimos:
  • Se producirá un error de compilación, pués en la clase Empleado no existe ningún método llamado asignarPresupuesto.
  • Empleado objEmp= new Empleado ("Esteban Comex Plota" , 100) ; objEmp.asignarPresupuesto(5000);  // error
  • Herencia por Extensión
  • Criterios de Accesibilidad
  • Programación I
  • Modificador
  • Misma class
  • Mismo package
  • Subclases
  • Universo
  • private
  • Si
  • default
  • Si
  • Si
  • Si
  • Si
  • Si
  • public
  • Si
  • Si
  • Si
  • Si
  • SobreEscritura de Métodos
  • Programación I
  • Una subclase puede modificar las características heredadas de una clase padre.
  • Una subclase puede crear un método con funcionalidad diferente al método de la clase padre pero con igual:
  • - Nombre,
  • - Tipo de dato de retorno,
  • - Lista de argumentos.
  • A este método se le dice que sobreescribe al método de la clase padre.
  • Ejemplo de SobreEscritura de Métodos
  • Programación I
  • public class Empleado {
  • protected String nombre;
  • protected int sueldo;
  • public void mostrar() {
  • System.out.println(“nombre: ” + nombre);
  • System.out.println(“Sueldo: ” + sueldo);
  • }
  • }
  • public class Ejecutivo extends Empleado{
  • public int presupuesto;
  • public void mostrar() {
  • System.out.println(“nombre: ” + nombre);
  • System.out.println(“Sueldo: ” + sueldo);
  • System.out.println(“Presupuesto: ” + presupuesto);
  • }
  • }
  • Palabra Reservada “super”
  • Programación I
  • super es usado en una subclase, para referirse a su clase padre, tanto atributos como a los métodos.
  • Las características invocadas no tienen que ser solo las de la superclase inmediata, pueden ser las de una superclase en la cadena de jerarquía.
  • Frecuentemente, es usado en la sobreescritura de métodos, debido a que por lo general no se reemplaza toda la funcionalidad del método heredado sino que se le añaden características.
  • Ejemplo de super
  • Programación I
  • public class Empleado {
  • protected String nombre;
  • protected float sueldo;
  • public void mostrar() {
  • System.out.println(“nombre: ” + nombre);
  • System.out.println(“Sueldo: ” + sueldo);
  • }
  • }
  • public class Ejecutivo extends Empleado{
  • public int presupuesto;
  • public void mostrar() {
  • //Se invoca al método del padre
  • super.mostrar();
  • System.out.println(“Presupuesto: ” + presupuesto);
  • }
  • }
  • Los Constructores no se heredan
  • Programación I
  • Una subclase hereda todos los atributos y métodos de la superclase (clase padre).
  • Una subclase no hereda el constructor de la superclase.
  • Hay dos formas de incluir el constructor:
  • - Usar el constructor por defecto. (sin parámetros)
  • - Escribir uno o mas constructores explícitos.
  • El constructor de la clase padre es llamado en el constructor de la clase hija.
  • Invocar Constructores de la Clase Padre
  • Programación I
  • Para invocar al constructor del padre, se debe usar la llamada super en la primera línea del constructor de la clase hija.
  • La especificación del constructor se específica en los argumentos que se usan en la llamada super.
  • Si una clase hija, no incluye una llamada this o super, el compilador añade implícitamente una llamada super() que llama al constructor por defecto de la clase padre.
  • Si la clase padre define constructores, pero no tiene un constructor por defecto, el compilador arrojará un mensaje de error.
  • Ejemplo de SobreEscritura de Métodos
  • Programación I
  • public class Empleado {
  • protected String nombre;
  • protected int sueldo;
  • public Empleado(String n, int s) {
  • nombre = n;
  • sueldo = s;
  • }
  • public Empleado(String n) {
  • nombre = n;
  • }
  • //Otras def. de métodos
  • }
  • Observemos la clase Padre Empleado y los constructores que ella posee:
  • Ejemplo de SobreEscritura de Métodos
  • Programación I
  • public class Ejecutivo extends Empleado {
  • private int presupuesto;
  • public Ejecutivo(String xnom, int xsueldo, int xpres) {
  • super(xnom,xsueldo);
  • presupuesto=xpres;
  • }
  • public Ejecutivo(String xnom, int xpres) {
  • super(xnom);
  • presupuesto=xpres;
  • }
  • public Ejecutivo(int xpres) {
  • presupuesto=xpres; //Como no hay llamada a un constructor de la clase Padre, el compilador incorpora una llamada super(); lo que genera ERROR porque en la clase Padre no hay
  • constructor por defecto.
  • }
  • //Otras def. de métodos
  • }
  • Herencia
  • Programación I
  • package Relacion_clases;
  • public class Punto {
  • protected int x,y;
  • public Punto() {}
  • public Punto(int a, int b){
  • this.SetPunto(a,b); }
  • public void SetPunto(int a, int b){
  • this.x=a;
  • this.y=b; }
  • public int getX(){ return this.x;}
  • public int getY(){ return this.y;}
  • }
  • package Relacion_clases;
  • public class Circulo extends Punto{
  • public double radio;
  • public Circulo () {
  • super(0,0);
  • this.setRadio (0); }
  • public Circulo (int a, int b, double r ) {
  • super(a,b);
  • this.setRadio (r); }
  • public void setRadio(double r) {
  • this.radio=(r>=0.0?r:0.0);}
  • public double GetRadio(){
  • return this.radio;}
  • public double area() {
  • return 3.1416*this.radio*this.radio; }
  • }
  • package Relacion_clases;
  • public class Implementacion {
  • public static void main(String[] args) {
  • Punto p=new Punto(3,5);
  • Circulo c=new Circulo(6,3,2.3);
  • System.out.println(p.getX()+ "," + p.getY());
  • System.out.println(c.getX()+ "," + c.getY()); }
  • }
  • Programación I
  • Las clases abstractas se utilizan como superclases en situaciones de herencia, por eso son llamadas superclases abstractas.
  • La finalidad de una clase abstracta es proveer una superclase apropiada de la cual otras clases puedan heredar una interfaz o una implementación.
  • Clases Abstractas
  • Programación I
  • Hacemos abstracta una clase declarándola con la palabra reservada abstract
  • Para que una clase sea declarada abstracta debe contener al menos un método sin implementación relativa a la clase, esto es, un método sin código. Éstos son llamados métodos abstractos. La implementación de éstos métodos se realiza en las subclases.
  • Clases Abstractas
  • Programación I
  • Las clases abstractas pueden tener atributos, métodos concretos y constructores, además de métodos abstractos.
  • Es recomendable declarar los atributos y métodos de estas clases protected o private en vez de public porque sólo podrán ser accedidos o invocados por las subclases de la clase abstracta.
  • Clases Abstractas
  • Programación I
  • public abstract class figura {
  • protected double x;
  • protected double y;
  • public figura(double i, double j)
  • { x = i; y = j; }
  • public abstract void mostrar_area();
  • }
  • public class triangulo extends figura {
  • public void mostrar_area()
  • { System.out.println(“Area de triangulo=”+(x*y*0.5)); }
  • }
  • public class rectangulo extends figura {
  • public void mostrar_area()
  • { System.out.println(“Area de rectangulo=”+(x*y)); }
  • }
  • Clases Abstractas
  • Programación I
  • No todos los métodos de una clase abstracta tienen que estar sin implementación, pero con que solamente exista un método abstracto, la clase debe declararse abstracta.
  • public abstract class Figura {
  • public Figura() { }
  • public double area() { return 0.0; }
  • public double volumen() { return 0.0; }
  • public abstract String devolverNombre();
  • }
  • Clases Abstractas
  • Programación I
  • Las clases abstractas tienen una característica importante: No se permite instanciar objetos de una clase abstracta.
  • Figura x = new Figura(); //Error
  • La única forma de utilizar una clase abstracta es creando clases hijas que hereden de ella y éstas se encarguen de implementar sus métodos abstractos.
  • Clases Abstractas
  • Programación I
  • Las subclases de una clase abstracta deben:
  • No se pueden definir constructores abstractos o métodos estáticos abstractos.
    • Sobreescribir todos los métodos abstractos de la superclase, o bien
    • Ser declaradas como clases abstractas
  • Interfaces
  • Programación I
  • Una interface Java declara solo el contrato y no la implementación, parecido a una clase abstracta que difiere la implementación de sus métodos y los hace abstractos.
  • Captura similitudes entre clases que no poseen relación de herencia y declara métodos útiles para ellas.
  • Interfaces
  • Programación I
  • Una interface contiene una colección de métodos que se implementan en otro lugar y también puede incluir constantes.
  • Muchas clases pueden implementar la misma interface. Éstas clases no necesitan compartir la misma jerarquía de herencia.
  • Otro beneficio de las interfaces es que permiten que una clase puede implementar mas de una interface.
  • Interfaces
  • Programación I
  • [public] interface NombredeInterface [extends
  • listadeSuperInterfaces]
  • {
  • //Declaración de constantes
  • //Declaración de métodos
  • }
  • Interfaces
  • Programación I
  • Restricciones con las declaraciones de atributos:
  • No se pueden utilizar los especificadores private y protected.
  • Por defecto, las variables miembro son public, static y final.
  • Interfaces
  • Programación I
  • Restricciones con las declaraciones de los métodos:
  • Sólo declaran comportamiento, no lo implementan.
  • Por defecto, las definiciones de los métodos miembro son públicos y abstractos.
  • No se pueden utilizar los especificadores private, protected, static, native, final y synchronized.
  • Interfaces
  • Programación I
  • [public] interface NombredeInterface [extends
  • listadeSuperInterfaces]
  • { //Constantes
  • [public] tipo_dato final NOMBRECONSTANTE1 = valor;
  • [public] tipo_dato NOMBRECONSTANTE2 = valor; …
  • //Métodos
  • [public] abstract tipoRetorno nomMetodo1(Parámetros Formales);
  • [public] tipoRetorno nomMetodo2(Parámetros Formales);
  • }
  • Interfaces
  • Programación I
  • public interface Control{
  • final int CantCanales = 32;
  • /* Permite Encender ó Apagar el televisor */
  • void EncenderApagar( );
  • /* Permite cambiar el canal activo */
  • void CambiarCanal( );
  • /* Permite ajustar el volumen actual */
  • void AjustarVolumen( );
  • }
  • Interfaces
  • Programación I
  • Para que una clase pueda usar una interface, se utiliza la palabra clave implements y el nombre de la interface en la línea de declaración de la clase.
  • La clase debe implementar todos los métodos de la interface.
  • Si la clase no proporciona la implementación para todos los métodos de la interface debe ser declarada como abstracta.
  • ¿Cómo usar una interfaz?
  • Interfaces
  • Programación I
  • public class Televisor implements Control {
  • private String marca;
  • private float costo;
  • void EncenderApagar( ){
  • //código
  • }
  • void CambiarCanal( ){
  • //código
  • }
  • void AjustarVolumen( ){
  • //código
  • }
  • public void mostrar(){
  • System.out.println(marca+” ”+costo);
  • }
  • }
  • Interfaces
  • Programación I
  • Imagine un grupo de objetos que comparten una misma habilidad: Volar, se podría implementar una interface que soporte las tres operaciones: despegar, aterrizar y volar.
  • <>
  • Volar
  • Despegar()
  • Volar()
  • Aterrizar()
  • Avion
  • Despegar()
  • Volar()
  • Aterrizar()
  • HacerManiobras()
  • Interfaces
  • Programación I
  • public interface Volar{
  • void despegar();
  • void volar();
  • void aterrizar();
  • }
  • public class Avion implements Volar {
  • void despegar(){
  • //acelera hasta despegar
  • }
  • void volar(){
  • //mantener el vuelo
  • }
  • void aterrizar(){
  • //bajar hacia la tierra hasta tocarla y desacelerar
  • }
  • void HacerManiobras(){
  • //Hacer maniobras
  • }
  • }
  • Interfaces
  • Programación I
  • Puede darse el caso, que múltiples clases implementen la interface Volar.
  • <>
  • Volar
  • Despegar()
  • Volar()
  • Aterrizar()
  • Pajaro
  • Despegar()
  • Volar()
  • Aterrizar()
  • HacerNido()
  • PonerHuevos()
  • Avion
  • Despegar()
  • Volar()
  • Aterrizar()
  • HacerManiobras()
  • Superman
  • Despegar()
  • Volar()
  • Aterrizar()
  • SaltarEdificios()
  • PararBalas()
  • Interfaces
  • Programación I
  • Un Avión es un Vehículo y puede volar. Un pájaro es un animal y puede volar. Esto muestra que una clase puede heredar de una clase pero también puede implementar algunas interfaces.
  • <>
  • Volar
  • Despegar()
  • Volar()
  • Aterrizar()
  • Pajaro
  • Despegar()
  • Volar()
  • Aterrizar()
  • HacerNido()
  • PonerHuevos()
  • Avion
  • Despegar()
  • Volar()
  • Aterrizar()
  • HecerManiobras()
  • Superman
  • Despegar()
  • Volar()
  • Aterrizar()
  • SaltarEdificios()
  • PararBalas()
  • Animal
  • Vehiculo
  • HomoSapien
  • public class HomoSapien extends Animal { … }
  • public class Avion extends Vehiculo implements Volar { …}
  • public class Pajaro extends Animal implements Volar { …}
  • public class Superman extends HomoSapien implements Volar { … }
  • Avion
  • Pajaro
  • Superman
  • Interfaces
  • Programación I
  • public interface Contador {
  • int MAX_INT = 2147483647;
  • void avanzar();
  • int obtenerValor(); }
  • public class ContadorSegundos implements Contador {
  • int valor; ContadorSegundos(){ valor = 0; } public void avanzar(){
  • valor++;
  • if (valor>60) valor = 0; } public int obtenerValor(){ return valor; } }
  • public class ContadorInverso implements Contador { int valor; ContadorInverso(){valor=MAX_INT;} public void avanzar(){
  • valor--;
  • if (valor<0) valor = MAX_INT; } public int obtenerValor(){ return valor; } }
  • Otro Ejemplo de Interface.
  • Interfaces
  • Programación I
  • Una clase puede implementar más de una interface.
  • interface1
  • interface2
  • superClase
  • Clase
  • public class Clase extends superClase implements interface1, interface2 {…}
  • :: Prof. Yeniffer Peña
  • Programación I
  • Programación Orientada a Objetos
  • Finalización
  • Continuará . . .


La base de datos está protegida por derechos de autor ©absta.info 2016
enviar mensaje

    Página principal