|
Teniu una peixera on viuen animals i plantes. Hi trobeu
també objectes que serveixen per mantenir en equilibri aquest petit
ecosistema (la peixera, els termòmetres,les bombes, etc) . L'objectiu
d'aquest exercici és representar tots aquests diferents objectes,
animats i inanimats, en forma de classes de
Java i crear-ne alguna funcionalitat per a una botiga de peixos.
Construireu una superclasse
"Organisme" de la qual heretaran
les subclasses "Peix"
i "Planta". Objectes i plantes
són organismes, per tant, poden tenir una superclasse
comuna. Pel que fa referència als objectes inanimats, creareu la
classe "Complement".
L'aplicació que escriureu farà
un llistat amb les característiques dels peixos i plantes que teniu
a la botiga. Cada tipus de peix o planta té associat un fitxer
.properties (que us heu
de descarregar de la web) amb les característiques de nom,
família, tolerància a la llum, longitud, pH de l'aigua,
etc. Posareu la llista de peixos i plantes de la botiga en matrius i,
per a cada individu, en funció de si és peix, planta o complement
en treureu per consola les seves característiques:
|
|
- En primer lloc, heu de fer les peces del puzle. Necessiteu
escriure una classe Organisme,
una Peix, una Planta
i una Complement.
Bàsicament, el vostre objectiu és crear unes classes que:
- quan s'instancien, carreguen
la informació des d'un fitxer de propietats cap als
camps de la classe i
- saben formatar aquesta
informació per fer-la més llegible.
Quan les tingueu, escriureu el programa que fa la llista de característiques.
Escriviu, en primer lloc, una classe
Organisme i poseu-la
en el paquet d110.aquari.
Aquesta és la forma que ha de tenir, us passem
una llista de camps i mètodes i vosaltres els aneu afegint a
la classe. Els camps només cal declarar-los, els mètodes
els heu de declarar i escriure'n el contingut en funció de les
pistes que ara us donarem.
- Camps (fields):
- De tipus
string:
nom de l'animal o planta,
família a la qual pertany i
llum. Necessitats d'il·luminació
de l'animal o planta.
Si mireu els fitxers de propietats, la llum estarà codificada
amb tres lletres en funció de les necessitats de cada
organisme: "A" alta, mitjana
"M" i baixa "B".
Més avall, heu de fer un mètode que tradueixi
aquests codis al seu significat.
- De tipus
int:
temperaturamaxima i temperaturaminima
amb l'interval de tolerància tèrmica del peix
o planta i
existencies
amb el nombre d'exemplars disponibles a la botiga de peixos.
- De tipus
double:
phmaxim i phminim
amb l'interval de tolerància a l'acidesa del peix o planta,
i
preu.
- Mètodes:
- getPH(): retornarà
un string amb els marges d'acidesa de l'aigua acceptables
per l'espècie. Per exemple: 6-7.
Ha de recollir els valors de phmaxim
i phminim, i passar els enters a cadena
posant un guionet al mig.
- getTemperatures():
retornarà una cadena
(string) amb els marges
de temperatura acceptables per l'espècie. Per exemple:
10-20.
- getLlum(): traduirà
el codi de tipus de necessitats de llum a l'explicació
pertinent. Si és "A",
"Necessitats altes de llum",
etc. Podeu utilitzar un senzilla estructura if
per fer la traducció.
- setDadesespecie(string especie):
aquest mètode és molt important,
obtindrà les dades de l'espècie de peix o planta
que especifiqueu al paràmetre
especie. Les dades
són als fitxers *.properties
que us heu de
descarregar de la web. Heu de procedir de manera similar
a l'exercici de les altures del mòdul 3. Descomprimiu
els fitxers de propietats i deixeu-los a la mateixa carpeta
on esteu escrivint aquestes classes. Carregueu les dades del
fitxer aprofitant que el paràmetre especie
del mètode es correspon al nom del fitxer de propietats:
props=new
Properties();
in=new FileInputStream(especie+".properties");
props.load(in); |
Carregueu als camps temperaturamaxima,
temperaturaminima,
phmaxim,
phminim,
nom, familia
i llum les
corresponents propietats procedents del fitxer així:
String
<uncamp>=props.getProperty("<uncamp>");.
|
Heu de parar atenció amb la protecció
d'errors: errors d'inexistència
de fitxer, d'entrada-sortida,
de conversió
(la classe
java.util.Properties
només llegeix des de java.lang.String,
heu de fer conversions
a int i
double).
- Mètode constructor
Organisme(string especie). Aquest
mètode només
s'encarrega de cridar al mètode
setDadesespecies(string especie).
- Dins del mateix paquet,
d110.aquari, creareu
ara una classe "Peix"
filla d'"Organisme"
amb la següent informació. Atenció, no oblideu fer-la
filla!:
- Camps (fields):
- De tipus
string:
procedència, amb la procèdencia
geogràfica del peix,
dieta, tot codificant la dieta segons
aquesta escala ("A" algues,
"O" omnívor, "F"
fulles).
- De tipus
int:
longitud, amb la longitud en cm del
peix.
- Mètodes:
- getDieta(): retorna
una cadena traduint el codi de tipus de dieta a l'explicació
pertinent. Si és 'A',
"Algues", etc. Podeu utilitzar un bucle
for per fer la feina.
- setDadesPeix(string especie).
Carrega, del fitxer <especie>.properties,
les dades relatives a la procedència, dieta i longitud.
Heu de procedir igual que amb la classe Organisme.
Atenció un cop més amb les proteccions
d'excepcions! Fixeu-vos que carregueu
les dades des del fitxer de propietats en dos passos: Organisme
carrega els camps comuns a tots els éssers vius. Després,
si fa falta, cada subclasse carrega els camps que li són
propis.
- Mètode constructor
Peix(string especie).
Ha de:
- cridar al constructor
de la superclasse. Recordeu com es fa?
- cridar al mètode
setDadespeix(string especie).
Així, cada cop que instancieu un objecte de la classe
peix, el primer que farà la classe serà carregar
les seves dades.
- Creeu ara la classe "Planta"
en el mateix paquet, d110.aquari,
filla d'"Organisme"
i amb la següent informació:
- Camps (fields):
- De tipus
string:
tipus, codificant el tipus de planta ("T"
tija, "B" bulb, "A"
arrels).
- Mètodes:
- getTipus(): traduirà
el codi de tipus de planta a l'explicació pertinent.
Si és 'T',
"Tija", etc.
- Finalment, creeu la classe
"Complement", la que recull
tots els objectes inanimats de la botiga, amb les següents dades:
- Camps (fields):
- De tipus
string:
nom, descripcio,
codiinventari.
- De tipus
int:
existencies.
- De tipus
double:
preu.
- Mètodes:
- setDadescomplement(string complement):
carrega del fitxer <complement>.properties.
El procediment ja l'heu fet dues vegades, els camps que carrega
són el nom, la descripció i el codi d'inventari.
- Mètode constructor
Complement(string complement):
crida a setDadescomplement(string
complement)
- Ara que ja teniu les classes ben estructurades i que
ja saben treballar, verifiqueu el seu funcionament escrivint
i executant el programa següent, del qual us en donem el
codi font incomplet: li falta el mètode dadesOrganismes
que escriu a la consola el nom, la família, el pH, la temperatura
i la llum de cada espècie animal o vegetal. Observeu aquestes
crides del programa:
peix=new
Peix(peixos[n]);
dadesOrganismes(peix); |
i
planta=new
Planta(plantes[n]);
dadesOrganismes(planta); |
Heu d'escriure un mètode, precisament
dadesOrganismes, que us permetrà demostrar
que enteneu i sou capaços d'utilitzar
les capacitats de l'herència de Java.
Observeu que el paràmetre que
li passeués, en un cas, una instància
de la classe Peix, i en un altre, de
la classe Planta. Heu de resoldre,
doncs, dos problemes:
- L'encapçalament del mètode dadesOrganismes
té un paràmetre d'entrada que a vegades és
un peix i a vegades és una planta. De
quina classe ha de ser per incloure tant a peixos com a plantes?
- Un cop heu passat el paràmetre dins el mètode,
cal esbrinar de quina classe (Peix
o Planta) és el paràmetre
que acabeu de recollir? Ho necessitareu per imprimir coses diferents
en funció del tipus d'organisme?
Completeu el programa, tot escrivint
aquest mètode.
package d110.aquari;
import java.io.*;
public class Descripcions {
public Descripcions() { //
constructor
}
public static void main(String[] args)
throws
FileNotFoundException, IOException
{
Organisme organisme;
Peix peix;
Planta planta;
Complement complement;
String[] peixos={"escalar","plecostomus","vermell"
};
String[] plantes={"barteri","crassicaulis",
"hottoniiflora"};
String[] complements={"termometre","bomba","peixera"};
System.out.println("Organismes
de l'aquari:");
System.out.println("-----------------------");
System.out.println("Peixos:");
System.out.println("-----------------------");
for
(int n=0; n<peixos.length; n++) {
peix=new
Peix(peixos[n]);
dadesOrganismes(peix);
System.out.println("Longitud
------> "+
peix.longitud+
"
cm");
System.out.println("Dieta
---------> "+
peix.getDieta());
System.out.println("=========================\n");
}
System.out.println("Plantes:");
System.out.println("-----------------------");
for
(int n=0; n<plantes.length; n++) {
planta=new
Planta(plantes[n]);
dadesOrganismes(planta);
System.out.println("Tipus
---------> "+
planta.getTipus());
System.out.println("=========================\n");
}
System.out.println("Complements:");
System.out.println("-----------------------");
for
(int n=0; n<complements.length; n++) {
complement=new
Complement(complements[n]);
System.out.println("Nom
-----------> "+
complement.nom);
System.out.println("Descripció
---->"+
complement.descripcio);
System.out.println("Codi
----------> "+
complement.codiinventari);
System.out.println("=========================\n");
}
}
}
|
- La sortida ha de ser com aquesta:
|
|
Peixos i plantes d'una banda, i complements de l'altra, són objectes
que es poden trobar en una botiga especialitzada. Tot i no pertànyer
al mateix arbre d'herència (peixos
i plantes són organismes, els
complements no), al comerç rebran tot un grup d'accions comunes:
tindran un preu, es podran vendre, formaran part d'estocs, tindran pèrdues,
etc. Per resoldre aquests aspectes, podeu crear una interfície
compartida per tots els tipus d'objectes
o una nova classe que englobi les altres
dues. La primera forma l'heu estudiada a la pràctica
4. Per a la segona, hauríeu de crear una cosa similar a l'exemple
següent:
public class Objectebotiga
{
// Classes
que ens interessi aplegar
Organisme organisme;
Complement complement;
// Camps que
ens interessi compartir
double preu;
int existencies;
...
} |
Per fer l'exercici creareu una classe
Objectebotiga i fareu un petit programa de compravenda.
Necessitareu baixar-vos aquests fitxers
.properties. Un d'ells conté el preu
dels articles de la botiga i l'altre, les existències. Deixeu-los,
com abans, en el mateix directori on teniu els fitxers .class
del paquet d110.aquari.
- Creeu la classe Objectebotiga.
Ha de contenir un objecte organisme, un objecte complement i altres
camps específics, com el preu i les existències. Ha de
ser capaç de fer aquestes feines:
- Vendre un producte:
s'han de passar com a paràmetres
el nom de l'objecte i el nombre d'unitats a vendre. Les dades les
ha d'obtenir, per a lectura i escriptura, dels fitxers preus.properties
i existencies.properties. Aquest mètode
hauria de verificar les existències de l'objecte que intenteu
vendre. Si està disponible, s'hauria de llegir en el fitxer
preus.properties el preu del producte.
Si hi ha existències i el preu és superior a 0, el
mètode hauria de fer una
sortida a la consola indicant el nombre d'unitats venudes, el preu
per unitat, el preu total i el preu total + IVA. Finalment, hauria
d'actualitzar el fitxer existencies.properties,
restant el nombre d'unitats venudes.
- Comprar o reposar
les existències. S'hauria d'escriure un mètode
que, tot passant el nom del producte i el nombre d'unitats que en
voleu comprar, ho enregistrés al fitxer existencies.properties.
Atenció amb el control d'excepcions
perquè aquests mètodes
han d'estar protegits contra error d'entrada-sortida
i d'inexistència de fitxers!
També podríeu afegir-hi habilitats específiques
en funció del tipus d'objecte que veneu, tot aprofitant els camps
organisme i complement.
Podeu afegir-hi alguna cosa, al vostre gust.
Penseu que per escriure en un fitxer
.properties heu de fer:
File fitxerPropietats = new File("existencies.properties");
fitxerPropietats.createNewFile();
props.store(new FileOutputStream(fitxerPropietats), "");
|
- Escriviu un programa Vendes.java
que, en primer lloc, demani a l'usuari si vol fer una compra o una venda.
En segon lloc, demanarà el nom del producte que voleu comprar/vendre.
Després de teclejar-lo, si existeix el producte, us demanarà
la quantitat d'unitats a comprar/vendre. Si hi ha unitats suficients
en estoc, es farà la compravenda: s'actualitzarà
el fitxer existencies.properties, sumant
o restant, i s'informarà del cost econòmic de l'operació.
|