dare de seama2 java
DESCRIPTION
Dare de seama pentru lab2TRANSCRIPT
Ministerul Educaţiei al Republicii MoldovaUniversitatea de Stat din Moldova
Facultatea de Matematică şi InformaticăDepartamentul “Informatica »
Dare de seamă la „Java”
Lucrare de laborator № 2
Tema : „ Mostenirea în Java ”
Varianta : № 7
Clasa de baza : „Peste”
Efectuat: studenta grupei IA21
numele, prenumele: Purice Cristina
Verificat: lect.univers., magistru in
inform.
Epifanova Irina .
Chişinău 2015
Formularea problemei:
Ierbivor Peștilor de aurDe descries în limbajul Java ierarhia de clase Pește
Prădător
De descris clasa de bază(Pește) ca o clasă abstractă, declarând în ea una sau mai multe funcții abstracte.
De descris interfața. De a preciza în ea funcția abstractă de afișare la ecran a tuturor câmpurilor clasei, și funcțiile care vă pot veni în cap :). De implementat interfața în cîteva clase din ierarhie.
Câmpurile obligatorii:- câmp de tip șir de caractere, care păstreaza numele Peștelui.- câmp de tip real, care indică greutatea Peștelui- câmp de tip întreg, care arată viteza Peștelui- câmp de tip întreg, care indică numărul de dinți ai Prădătorului- câmp de tip real al voracității, care indică câtă carne poate sa mănânce Prădătorul- câmp de tip întreg, care indică numărul de cicatrici ai Ierbivorului- câmp de tip real, final, care indică coeficientul de accelerare al Ierbivorului când apare un Prădător- câmp de tip șir de caractere, care indică naționalitatea Peștișorului de aur- câmp de tip întreg, care indică numărul de dorințe pe care Peștișorul de aur este gata să înfăptuiască fiind prinsă.
Câmpurile neobligatorii: toate care Vă pot trece prin cap :)...De descris pentru fiecare clasă din ierarhie următoarele:
- Câțiva constructori - Funcțiile de acces la câmpurile clasei, și funcțiile de setare a lor.
În clasa Peștișorul de aur de descris funcția ”prăjeală”, care mărește cu 50% numărul dorințelor pe care Peștișorul dat este gata să le înfăptuiască.
În clasa Ierbivor de descris funcția în care pe obiectul care a apelat funcția se ațâță un Prădător(în calitate de parametru), și care returnează viteza fugarului vegetarian în dependență de coeficientul de accelerare și numărul dinților al atacantului, și care adaugă Ierbivorului curent atâtea cicatrici, câți dinți are atacantul.
În clasa Prădător de descris funcția logica care află dacă el se va sătura de la consumul Ierbivor transmis ca parametru(se compară voracitatea Prădătorului cu greutatea Ierbivorului).
Pentru clasa Ierbivor de descris funcția, de tip final, de încrucișare (adunare) a două obiecte, și care returnează un Ierbivor nou(rezultatul se salvează în obiect nou), cu caracteristicile calculate din media aritmetica a câmpurilor operanzilor.
Pentru clasa Prădător de descris o funcție de coliziune a doi pești, care în dependență de la viteza totală, dezbate fiecărei un număr oarecare de dinți.
În funcția main() de creat vectorul dinamic cu exemplarele tuturor peștișorilor descriși mai sus , dând ca tipul de bază – clasa origine, și de inițializat aceste elemente cu obiectele tuturor claselor moștenite. După – de afișat la ecran printr-un ciclu câmpurile tuturor obiectelor create. Pe urmă de a prăji un peștișor de aur. De a ațâța un Prădător asupra unui Ierbivor. Rezultatele de afișat la ecran. De a afla satisfacția Prădătorului de la consumul unui ierbivor. De a îcnrucișa câțiva Ierbivor supraviețuiți. De a coliziona(fără colaider) doi Prădători(preferabil flămânzi). Rezultatul de afișat la ecran și de a-l salva în fișier textual.După ce totul a fost terminat fără greșeli — de spus “URRRRRRAAAAAAA ! ! !” și de prezintat profesorului al doilea laborator. :)
În lucrare de laborator (obligatoriu !) trebuie sa fie prezent apelul constructorului clasei-părinte(celui implicit și cu parametri), apelul funcției simple clasei-părinte (nu a constructorului), macară unul dintre elementele unuia dintre clase trebuie să fie declarat ca final, și macară una dintre variabilile clasei trebuie sa fie constantă(statică)
Exemplul lucrării practice (listingul programului)
Clasa Peste
public abstract class Peste implements Afisare {
String nume;float greutate; int viteza;
Peste() //constructor fara parametri{
nume="Nemo";greutate=6.5f;viteza=80;
}
Peste (String n, float g, int v) //constructor cu 3 parametri{
nume=n;greutate=g;viteza=v;
}
Peste (String n) //constructor cu un parametru{
nume=n;greutate=7f;viteza=99;
}//***************** implementarea metodei de afisare din interfata ********************// public void afis(){
System.out.println("\n");System.out.println("Nume: "+nume);System.out.println("Greutate: "+greutate);System.out.println("Viteza: "+viteza);
}//************************* metoda get de acces la cimpuri ********************// public String get_nume() // accesul la cimpul clasei nume
{return nume; // return this.nume
} public float get_greutate()
{return greutate;
} public int get_viteza()
{return viteza;
}//************************* metoda set de setare a cimpurilor ********************// public void set_nume(String n) //seteaza cimpului clasei nume valoarea noua a parametrului n
{nume = n; // this.nume = n;
} public void set_greutate(float g) //seteaza cimpului clasei greutate valoarea noua a
parametrului g{
greutate = g; // this.greutate = g;}
public void set_viteza(int v) //seteaza cimpului clasei viteza valoarea noua a parametrului v
{viteza=v; // this.viteza = v;
}
}
Clasa Ierbivor
public class Ierbivor extends Peste {int cicatrici;final float accelerare=2f; //coeficient de accelerare
Ierbivor() //constructor fara parametri{
super();cicatrici=5;
}
Ierbivor(String s, int c) //constructor cu 4 parametri{
super(s);cicatrici=c;
}
Ierbivor(String s, float g, int v, int c){super(s,g,v);cicatrici=c;}
//***************** implementarea metodei de afisare din interfata ********************// public void afis()
{ super.afis();System.out.println("Cicatrici: "+cicatrici);
} //************************* metoda get de acces la cimpuri ********************// public int get_cicatrici()
{return cicatrici;
}//************************* metoda set de setare a cimpurilor ********************// public void set_cicatrici(int c)
{cicatrici=c;
} public void aninare(Ierbivor I, Pradator P) {
System.out.println("\n"); System.out.println("Atentie, "+I.nume+" a fost atacat de "+P.nume+"!!!"); I.viteza=(int)(I.viteza*accelerare+P.dinti); I.cicatrici+=P.dinti;
} public final void incrucisare (Ierbivor I1, Ierbivor I2, String new_name) {
System.out.println("\n"); System.out.println("Mama: \n"); I1.afis(); System.out.println("\n TaTa: \n"); I2.afis(); int v=(I1.viteza+I2.viteza)/2; float g=(float)(I1.greutate+I2.greutate)/2; int c=(I1.cicatrici+I2.cicatrici)/2; Ierbivor I3=new Ierbivor(new_name, g, v, c); System.out.println("\nCopilul: \n"); I3.afis();
}
}
Clasa Pradator
public class Pradator extends Peste{int dinti;float carne; //cita carne poate minca pradatorul
Pradator(){super();dinti=42;carne=15.5f;}
Pradator (String n, float g, int v, int d) //constructor cu 4 parametri{
super(n,g,v); //apelam constructorul cu 3 parametri din clasa de baza
dinti=d;}//***************** implementarea metodei de afisare din interfata ********************// public void afis(){ super.afis();
System.out.println("Dinti: "+dinti);System.out.println("Carne mincata: "+carne);
} //************************* metoda get de acces la cimpuri ********************// public int get_dinti()
{return dinti;
} public float get_carne()
{return carne;
}//************************* metoda set de setare a cimpurilor ********************// public void set_dinti(int d)
{dinti=d;
} public void set_carne(float c)
{carne=c;
} public void satul(Ierbivor I) {
float cmp; System.out.println("\n"); System.out.println("Voracitatea "+this.nume+" este: "+this.carne+"kg"); System.out.println("Greutatea "+I.nume+" este: "+I.greutate+"kg"); if (this.carne>=I.greutate) {
cmp=this.carne-I.greutate; System.out.println("Pradatorul "+this.nume+"nu s-a saturat la consumarea
"+I.nume+"cu un deficit de "+cmp+"kg de carne"); } else {
cmp=I.greutate-this.carne;
System.out.println("Pradatorul "+this.nume+"s-a saturat la consumarea "+I.nume+"si a mincat cu "+cmp+"kg mai multa carne");
}
} public static void accident(Pradator P1, Pradator P2) {
System.out.println("\n"); System.out.println("Viteza"+P1.nume+" este: "+P1.viteza+"km/h si are "+P1.dinti+" dinti"); System.out.println("Viteza"+P2.nume+" este: "+P2.viteza+"km/h si are "+P2.dinti+" dinti"); P1.dinti=P1.dinti-((P1.viteza+P2.viteza)/10); P2.dinti=P2.dinti-((P1.viteza+P2.viteza)/10); System.out.println("Dupa accident, primul are "+P1.dinti+", iar al doilea "+P2.dinti);
} public void aninare(Ierbivor P1, Pradator P2) {
}
}
Clasa Pestisor_de_aur
public class Pestisor_de_aur extends Ierbivor {
String nationalitate;int dorinte;
Pestisor_de_aur() //constructor fara parametri{
nationalitate="australian";dorinte=3;
}
Pestisor_de_aur(String s, int c, String n, int d) //constructor cu 4 parametri{
super(s,c);nationalitate=n;dorinte=d;
}//***************** implementarea metodei de afisare din interfata ********************//public void afis()
{ super.afis();System.out.println("Nationalitate "+nationalitate);System.out.println("Dorinte indeplinite: "+dorinte);
} //************************* metoda get de acces la cimpuri ********************// public int get_dorinte()
{return dorinte;
} public String get_nationalitate()
{return nationalitate;
} //************************* metoda set de setare a cimpurilor ********************// public void set_nationalitate(String n)
{nationalitate=n;
} public void set_dorinte(int d)
{dorinte=d;
} public void prajeala() {
dorinte= (int)(Math.round(dorinte/2+dorinte)); }
}
Interfata Afisare
public interface Afisare {
public abstract void afis();
}
Metoda Main
import java.io.*;public class Main {
public static void main(String[] args) {// TODO Auto-generated method stub
Peste plancton[]=new Peste[6];
plancton[0]=new Pestisor_de_aur("Mimi", 2, "american",5);plancton[1]=new Ierbivor("Kust", 57, 120,3);
plancton[2]=new Ierbivor("Brocoli", 13);plancton[3]=new Pradator("Zliuka",90,90,53);plancton[4]=new Pradator("Cruela", 70, 130, 32);plancton[5]=new Ierbivor();
for (int i=0;i<6;i++)plancton[i].afis();
/*for (int i=0;i<6;i++)if(plancton[i] instanceof Pestisor_de_aur)
((Pestisor_de_aur)plancton[i]).prajeala();*/
((Pestisor_de_aur)plancton[0]).prajeala();plancton[0].afis();((Ierbivor)plancton[1]).aninare((Ierbivor) plancton[1],(Pradator) plancton[4]);plancton[1].afis();((Pradator)plancton[4]).satul((Ierbivor) plancton[2]);((Ierbivor)plancton[1]).incrucisare((Ierbivor) plancton[1], (Ierbivor) plancton[5], "Bibi");Pradator.accident((Pradator) plancton[3], (Pradator) plancton[4]);
try {File file = new File("Accident.txt");BufferedWriter output = new BufferedWriter(new FileWriter(file));output.write("Dupa accident");output.newLine();output.write("Viteza "+plancton[3].get_nume()+" este: "+plancton[3].get_viteza()
+"km/h si are "+((Pradator)plancton[3]).get_dinti()+" dinti");output.newLine();output.write("Viteza "+plancton[4].get_nume()+" este: "+plancton[4].get_viteza()
+"km/h si are "+((Pradator)plancton[4]).get_dinti()+" dinti");output.close();
}catch ( IOException e ) {
e.printStackTrace();}
}
}
Exemplul rulării programului:
Nume: MimiGreutate: 7.0Viteza: 99Cicatrici: 2Nationalitate americanDorinte indeplinite: 5
Nume: KustGreutate: 57.0Viteza: 120Cicatrici: 3
Nume: BrocoliGreutate: 7.0Viteza: 99Cicatrici: 13
Nume: ZliukaGreutate: 90.0
Viteza: 90Dinti: 53Carne mincata: 0.0
Nume: CruelaGreutate: 70.0Viteza: 130Dinti: 32Carne mincata: 0.0
Nume: NemoGreutate: 6.5Viteza: 80Cicatrici: 5
Nume: MimiGreutate: 7.0Viteza: 99Cicatrici: 2Nationalitate americanDorinte indeplinite: 7
Atentie, Kust a fost atacat de Cruela!!!
Nume: KustGreutate: 57.0Viteza: 272Cicatrici: 35
Voracitatea Cruela este: 0.0kgGreutatea Brocoli este: 7.0kgPradatorul Cruelas-a saturat la consumarea Brocolisi a mincat cu 7.0kg mai multa carne
Mama:
Nume: KustGreutate: 57.0Viteza: 272Cicatrici: 35
TaTa:
Nume: NemoGreutate: 6.5Viteza: 80Cicatrici: 5
Copilul:
Nume: BibiGreutate: 31.75Viteza: 176
Cicatrici: 20
VitezaZliuka este: 90km/h si are 53 dintiVitezaCruela este: 130km/h si are 32 dintiDupa accident, primul are 31, iar al doilea 10
Concluzie:
Efectuind aceasta lucrare de laborator am reusit sa insusesc principiul de mostenire a claselor in Java si modul de implementare a interfetelor. Am reusit sa observ ca in Java mostenire multipla nu exista, iar apelarea la functiile descries in clasele mostenite difera de apelul functiilor din clasa de baza. Cu ajutorul claselor abstracte, mostenirii si interfetelor, crearea obiectelor si lucrul cu ele devine mult mai simplu si mai usor de inteles.