Download INTRODUCCION (32456)

INTRODUCCION
Los programas se crean a partir de
objetos, los cuales son instancias de clases.
Algunas clases están en la biblioteca de Java
y otras las escribe el programador,
buscamos clases útiles en la biblioteca y que
hemos escrito en el pasado. Con la herencia
podemos usar una clase existente como la
base para crear una clase modificada.
*PROTECTED
Cundo usamos la herencia, prívate es un término demasiado privado y posible es demasiado
pública. Si una clase necesitaba a sus clases acceso acierto variable o métodos especifico, pero
debe evitar que otra clase accedan a estos, puede etiquetarlas como protected.
Este método necesita acceso las variables X y Y postergación son inaccesibles y que se le
etiquetaron como prívate, para anticiarnos este posible uso en el.
public class Persona {
private String nombre; private String apellidos; private int edad;
public Persona() { nombre = ""; apellidos = ""; edad = 0; }
public Persona (String nombre, String apellidos, int edad) { this.nombre = nombre;
this.apellidos = apellidos; this.edad = edad; }
public String getNombre() { return nombre; }
public String getApellidos() { return apellidos; }
public int getEdad() { return edad; }
public String toString() { Integer datoEdad = edad;
return "-Nombre: ".concat(nombre).concat(" -Apellidos: ").concat(apellidos).concat(" Edad: ").concat(datoEdad.toString() ); }
} //Cierre de la clase
INTRODUCCION DE HERENCIA
Vamos a empezar con una clase similar a la que y hemos usado varias veces el libro. Es
una clase para poder presentar a una esfera. Una esfera tiene un radio y una posición en
el espacio, debe aparecer como un circulo (el método para mostrar una esfera
simplemente invoca el método de biblioteca drwOval).
Import java.awt.*;
Public class Esfera {
Protected int x = 100, y = 100
Public void setX (int nuevaX) {
X = nuevaX;
}
Public void setY (int nuevaY) {
Y = nuevaY;
}
Public void mostrar(Grphics papel) {
Papel.draeOval(x, y, 20, 20);
}
}
sUPER
Algunas veces una clase necesita llamar un método de su superclase inmediata.
No hay problema con esto, ya que los métodos de todas las clases en los niveles superiores
del árbol de herencia están disponibles, siempre y cuando estén etiquetados como public o
protected, hay un problema que puede sugerir es cuando e4l método deseado de la superclase tiene
el mismo nombre que un método de la clase actual.
Por ejemplo, para llamar al método mostrar de una superclase use lo siguiente:
//Código de la clase Persona ejemplo aprenderaprogramar.com
public class Persona {
private String nombre;
private String apellidos;
private int edad;
//Constructor
public Persona (String nombre, String apellidos, int edad) {
this.nombre = nombre;
this.apellidos = apellidos;
this.edad = edad;
}
//Métodos
public String getNombre () { return nombre;
}
public String getApellidos () { return apellidos;
public int getEdad () { return edad;
} //Cierre de la clase
}
}
FINAL
Los procesos de heredar y redefinir, se enfocan en cambiar el comportamiento de las clases
y los objetos. La herencia es muy poderosa, pero algunas veces es reconfortante que algunas cosas
estén fijas y no se puedan modificar, sqrt, que es lo que hace drawLine. POO siempre existe el
peligro de que alguien extienda las clases a las que estas pertenecen y en consecuencia cambie lo
que hace. Esto podría ser por error o en un intento inadvertido de ser útil, para evitar esto el
programador puede describir un método como final.
La mayoría de los métodos se describen como final.
Final doublé cmPerInch = 2.54;
//Ejemplo aprenderaprogramar.com
//Sintaxis: CaracterPublico/Privado static final TipoDeLaConstante =
valorDeLaConstante;
private static final float PI = 3.1416f; //Recordar f indica que se
trata de un float
private static double PI = 3.1416;
public static final String passwd = "jkl342lagg";
public static final int PRECIO_DEFAULT = 100;
ABSTRACTO
El sentido está en que una superclase permite unificar campos y métodos de las subclases, evitando
la repetición de código y unificando procesos. Ahora bien, una clase de la que no se tiene intención
de crear objetos, sino que únicamente sirve para unificar datos u operaciones de subclases, puede
declararse de forma especial en Java: como clase abstracta. La declaración de que una clase es
abstracta se hace con la sintaxis public abstract class NombreDeLaClase { … }. Por ejemplo
public abstract class Profesor. Cuando utilizamos esta sintaxis, no resulta posible instanciar la clase,
es decir, no resulta posible crear objetos de ese tipo. Sin embargo, sigue funcionando como
superclase de forma similar a como lo haría una superclase “normal”. La diferencia principal radica
en que no se pueden crear objetos de esta clase.
import java.util.*;
abstract class Instrumento {
public abstract void tocar();
public String tipo() {
return "Instrumento";
}
public abstract void afinar();
}
class Guitarra extends Instrumento {
public void tocar() {
System.out.println("Guitarra.tocar()");
}
public String tipo() { return "Guitarra"; }
public void afinar() {}
}
class Piano extends Instrumento {
public void tocar() {
System.out.println("Piano.tocar()");
}
public String tipo() { return "Piano"; }
public void afinar() {}
}
class Saxofon extends Instrumento {
public void tocar() {
System.out.println("Saxofon.tocar()");
}
public String tipo() { return "Saxofon"; }
public void afinar() {}
}
// Un tipo de Guitarra
class Guzla extends Guitarra {
public void tocar() {
System.out.println("Guzla.tocar()");
}
public void afinar() {
System.out.println("Guzla.afinar()");
}
}
// Un tipo de Guitarra
class Ukelele extends Guitarra {
public void tocar() {
System.out.println("Ukelele.tocar()");
}
public String tipo() { return "Ukelele"; }
}
public class Musica2 {
// No importa el tipo de Instrumento,
// seguirá funcionando debido a Polimorfismo:
static void afinar(Instrumento i) {
// ...
i.tocar();
}
static void afinarTodo(Instrumento[] e) {
for(int i = 0; i < e.length; i++)
afinar(e[i]);
}
public static void main(String[] args) {
// Declarar un Arreglo SIN INSTANCIAS es valido en Clases
Abstractas
Instrumento[] orquesta = new Instrumento[5];
// Generar una INSTANCIA de una la Clase Abstracta no es valido
// Instrumento nuevo = new Instrumento();
int i = 0;
// Up-casting al asignarse el Arreglo
orquesta[i++] = new Guitarra();
orquesta[i++] = new Piano();
orquesta[i++] = new Saxofon();
orquesta[i++] = new Guzla();
orquesta[i++] = new Ukelele();
afinarTodo(orquesta);
}
}