USO DE LAS CLASES
ABSTRACTAS
Algunas veces pretenderá crear
una superclase que defina solo una forma generalizada que será compartida por
todas sus subclases, permitiendo a cada subclase completar los detalles. Cada clase
determina la naturaleza de los métodos que las subclases deben implementar,
pero en sí misma no proporciona una implementación de uno o más de esos métodos.
Una manera como esta situación puede ocurrir es cuando una superclase es
incapaz de crear una implementación significativa para un método.
METODO ABSTRACTO
Un método abstracto se crea
especificando el modificador tipo abstrac.
Un método abstracto no contiene cuerpo, y por tanto no es implementado por la
superclase. Así, una subclase debe sobrescribirlo, no puede utilizar
simplemente la versión definida en la superclase.
Para declarar un método abstracto
se utiliza el siguiente formato.
abstract tipo nombre (lista de parámetros);
Como puede ver, el cuerpo del método
no está presente. El modificador y/o especificador abstract puede ser utilizado solamente en métodos normales. No puede
ser aplicado a métodos static ni a
constructores.
Una clase que contenga uno o más métodos
abstractos también debe ser declarada abstracta, precediendo su declaración Class con el especificador abstract. Cuando una subclase hereda
una clase abstracta, debe implementar todos los métodos abstractos en la
superclase. Si no es así, entonces la subclase también debe ser especificada
como abstract.
EJEMPLO DE UNA CLASE
ABSTRACTA E INTERFACE
Una tienda de informática vende
dos tipos de artículos (software y hardware) ambos caracterizados por su código
(de tipo char) y su descripción. Además, en los productos software hay que
indicar el tipo de producto (con una cadena), y en los hardware se debe indicar
si es un periférico o no. Para saber el precio de un artículo utilice una
interface que indique que para un artículo cuyo código es A el precio es 100.0
euros, si el código es B el precio es 50.3; para un artículo con código C el
precio es 150.50 euros. En el caso de ser un producto hardware, los artículos
sólo serán A O B y si es un periférico el precio se incrementará en un 10%. Los
productos sofware serán exclusivamente B ó C incrementándose el precio del
artículo en un 5% si el sofware es de tipo ProgramaJuegos. Nota: la interface
debe tener un método abstracto.
a) Implemente las clases y la
interfaz.
b) Realice un programa principal
donde cree un objeto software y otro hardware y muestre el precio y demás
características del objeto.
Lo primero que haremos es crear
una clase abstracta llamada artículos la cual contiene dos atributos que
caracterizan al hardware y al software que son el código de tipo char y descripción
de tipo String.
public abstract class Articulos {
private char codigo;
private String descripcion;
public Articulos(char codigo, String descripcion) {
this.codigo = codigo;
this.descripcion =
descripcion;
}
public char getCodigo() {
return codigo;
}
public void setCodigo(char codigo) {
this.codigo = codigo;
}
public String getDescripcion() {
return descripcion;
}
public void setDescripcion(String descripcion) {
this.descripcion =
descripcion;
}
public abstract String DameDescripcion();// método abstracto
}
Ahora crearemos una interfaz llamada Precio la cual contendrá
los precios constantes para los diferentes códigos de los productos, y además un
método abstracto para calcular el precio el cual tendrán que implementar las
clases hardware y software.
public interface Precio {
public static final
double A = 100.0;
public static final
double B = 50.3;
public static final
double C = 150.50;
public abstract double
CalcularPrecio();
}
Seguiremos con la clase hardware la cual heredara de la clase Artículo
e implementara la interface Precio, y además tendrá un nuevo atributo llamado periférico.
public class Hardware extends Articulos implements Precio {
private String
periferico;
public Hardware(char
codigo, String descripcion, String periferico) {
super(codigo,
descripcion);
this.periferico =
periferico;
}
public String
getPeriferico() {
return
periferico;
}
public void
setPeriferico(String periferico) {
this.periferico =
periferico;
}
@Override
// método heredado de la clase Articulo
public String
DameDescripcion() {
return
"codigo:" + super.getCodigo() + "\n" + "descripcion:
"
+
super.getDescripcion() + "\n" + "periferico: "
+
getPeriferico() + "\n" + "precio: " + CalcularPrecio();
}
// método implementado de la interface Precio
@Override
public double
CalcularPrecio() {
// TODO
Auto-generated method stub
double aumento,
aumento2;
if
(super.getCodigo() == 'A') {
if
(getPeriferico() == "si") {
aumento
= A * 0.10;
return
A + aumento;
} else {
return
A;
}
}
if
(super.getCodigo() == 'B') {
if
(getPeriferico() == "si") {
aumento2
= B * 0.10;
return
B + aumento2;
} else {
return
B;
}
}
return 0;
}
}
Igualmente crearemos la clase software que heredará de la clase Artículo
e implementara la interface Precio, y además tendrá un nuevo atributo llamado tipo.
public class Software extends Articulos implements Precio {
private String tipo;
public Software(char
codigo, String descripcion, String tipo) {
super(codigo,
descripcion);
this.tipo = tipo;
}
public String
getTipo() {
return tipo;
}
public void
setTipo(String tipo) {
this.tipo = tipo;
}
// método heredado de la clase Articulo
@Override
public String
DameDescripcion() {
// TODO
Auto-generated method stub
return
"codigo:" + super.getCodigo() + "\n" + "descripcion:
"
+
super.getDescripcion() + "\n" + "tipo: " + getTipo() +
"\n"
+
"precio: " + CalcularPrecio();
}
// método implementado de la interface Precio
@Override
public double
CalcularPrecio() {
// TODO
Auto-generated method stub
double aumento,
aumento2;
if
(super.getCodigo() == 'B') {
if
(getTipo() == "ProgramaJuegos") {
aumento
= B * 0.05;
return
B + aumento;
} else {
return
B;
}
}
if
(super.getCodigo() == 'C') {
if
(getTipo() == "ProgramaJuegos") {
aumento2
= C * 0.05;
return
C + aumento2;
} else {
return
C;
}
}
return 0;
}
}
Bueno ya creadas estas clases crearemos un programa principal
donde crearemos un objeto software y otro hardware el cual mostrara el precio y
demás características del objeto.
public class Main {
public static void
main(String[] args) {
// TODO Auto-generated
method stub
Articulos[]
articulo = new Articulos[4];
articulo[0] = new
Software('B', "software Portable", "ProgramaJuegos");
articulo[1] = new
Software('C', "software Aplicacion","ProgramaAplicacion");
articulo[2] = new
Hardware('A', "pantalla", "si");
articulo[3] = new
Hardware('B', "teclado", "no");
System.out.println("PRODUCTOS");
for (Articulos a
: articulo) {
System.out.println(a.DameDescripcion());
System.out.println("");
}
}
}
Al ejecutar este programa el resultado sería el siguiente.
PRODUCTOS
codigo:B
descripcion: software Portable
tipo: ProgramaJuegos
precio: 52.815
codigo:C
descripcion: software Aplicacion
tipo: ProgramaAplicacion
precio: 150.5
codigo:A
descripcion: pantalla
periferico: si
precio: 110.0
codigo:B
descripcion: teclado
periferico: no
precio: 50.3
El proyecto lo pueden descargar AQUI
ConversionConversion EmoticonEmoticon