ZAD 3:
Dana jest klasa Procesor o poniższym interfejsie i działaniu. Wykorzystując tę klasę i mechanizm dziedziczenia napisz klasę CacheProcesor, posiadającą te same składowe co Procesor ale dodatkowo zapamiętującą 10 ostatnich wyników działań każdego rodzaju. Przy wywołaniu każdego działania, zanim wywoła meteodę klasy bazowej, sprawdza, czy wynik żądanego działania (te same argumenty) jest zapamiętany w pamięci podręcznej chache (np. lista, tablica, kolejka, ...) i jeśli tak jest - zwraca wynik działania bez wywoływania czasochłonnej operacji z klasy bazowej. Uwaga: dla ułatwienia możesz wymyślić (nie pisać - założyć, że jest) i użyć klasy listy/kolejki/... o dowolnym interfejsie.
class Procesor {
public Procesor(Date init); //inicjalizuje procesor
public double log10(double arg) throws ArithmeticExc; //oblicza logarytm
public double power(doublex, double y) throws ArithmeticExc; //oblicza potęgę
public void dispose(); //zwalnia zasoby
}
class CacheProcesor extends Procesor {
double [] log = new double[10];
double [][] pot = new double[10][10];
double arg;
double x,y;
int ktory_log=0;
int ktory_pot_x=0;
int ktory_pot_y=0;
public CacheProcesor(){
if(log10(double arg)==TRUE)
{
private double tmp = log10(double arg);
log[ktory_log] = tmp;
ktory_log++;
System.out.println(arg);
}
else System.out.println("Blad!");
if(pot(double x, double y)==TRUE)
{
double tmp_x = x;
double tmp_y = y;
pot[ktory_pot][0] = tmp_x;
pot[0][ktory_pot] = tmp_y;
System.out.println("X = "+tmp_x+"Y = "+tmp_y);
ktory_pot ++;
}
}
dispose();
}
public static void main(String[] args) {
CacheProcesor cp = new CacheProcesor();
try
{
cp();
cp.Procesor();
}
catch (throws ArithmeticExc){ System.out.println("Niepoprawne dane!"");
}
catch (IOException e) { System.out.println("Błąd odczytu danych");
}
}
To pierwsze przykładowe rozwiązanie zadania 3.
class ArithmeticExc extends Exception{
}
class Processor{
public Processor(Date init);
public double log10(double arg) throws ArithmeticExc;
public double power(double x, double y) throws ArithmeticExc;
public void dispose();
}
class log10Call
{
double arg, result;
}
class powerCall{
double x, y, result;
}
class CacheProcessor extends Processor{
LinkedList<log10Call> log10CallsList=new LinkedList<log10Call>();
LinkedList<powerCall> powerCallsList=new LinkedList<powerCall>();
public CacheProcessor(Date init){
super(init);
}
public double log10(double arg) throws ArithmeticExc{
for(log10Call call: log10CallsList){
if(call.arg==arg)
return call.result;
}
log10Call call=new log10Call();
call.arg=arg;
call.result=super.log10(arg);
if(log10CallsList.size()>=10)
log10CallsList.remove(0);
log10CallsList.add(call);
return call.result;
}
public double power(double x, double y) throws ArithmeticExc{
for(powerCall call: powerCallsList){
if(call.x==x && call.y==y)
return call.result;
}
powerCall call=new powerCall();
call.x=x;
call.y=y;
call.result=super.power(x, y);
if(powerCallsList.size()>=10)
log10CallsList.remove(0);
powerCallsList.add(call);
return call.result;
}
}
A to drugie przykładowe rozwiązanie 3.
ZAD 4:
Napisz klasę kolejki FIFO z typowymi operacjami (czytaj/pisz/usuń początek/koniec, sprawdzenie czy pusta) o skończonej pojemności (N - parametr konstruktora), która jednak przechowuje nie pojedyńcze wartości, ale pary (np. liczb). Niepoprawne operacje powinny wyrzucać wyjątki.
I przykładowe rozwiązanie:
class FIFO{
int ile =0;
int N = 1000;
public FIFO(){
int[][] tab = new tab[N][N]; //deklaracja tablicy w konstruktorze o parametrach N x N
}
int pisz(int a, int b){ // przekazuje dwie wartosci a i b
tab[ile][0] = a; // zapisuje a ( 0 odpowiada pierwszej kolumnie tablicy)
tab[ile][1] = b; // zapisuje b ( 1 odpowiada drugiej kolumnie tablicy)
ile++; // zwiększam ile + 1, ktory okresla ilosc dodanych PAR liczb
}
void czytaj_poczatek(){ // jest to kolejka FIFO, wiec czytam to co dodalem pierwsze
System.out.println("Na poczatku lezy : "+tab[0][0]+","+tab[0][1]);
}
void czytaj_koniec(){ // czytam ostatnio dodana pare liczb
System.out.println("Na koncu lezy : "+tab[ile][0]+","+tab[ile][1]);
}
void usun_poczatek(){
tab[0][0]=0; // zeruje zawartość pierwszego 'wózka' w kolejce
tab[0][1]=0;
for(int i=0;i<ile;i++){ //obracam w pętli zsuwając kolejkę tj : pierwszy przyjmuje wartość
tab[i][0] = tab[i+1][0];// znajdującego się za nim wózk i tak aż do końca kolejki
tab[i][1] = tab[i+1][1];// warunkiem pętli jest że interator "i" będzie mniejszy od liczby dodanych
} // tzn. jezeli dodalismy 10 elementow to ostatecznie zatrzyma sie na i = 9
// przypisze wózkowki nr 9 wartości z 10
tab[ile][0]=0; // a w tym miejscu je wyzeruje
tab[ile][1]=0;
ile--; // i zmniejszy ilość wózków
}
void usun_koniec(){ // usuwam koniec kolejki tj. ostatnio dodany obiekt, po prostu go zeruje
tab[ile][0]=0;
tab[ile][1]=0;
}
void czy_pusta(){ // zakładam , że jezeli pierwsza wartość w wózku jest NULLem to oznacza że tablica jest pusta
if(tab[0][0]==NULL) System.out.println("TABLICA JEST PUSTA!");
}
}
public static void main(String[] args) {
FIFO f = new FIFO(); // deklaruje obiekt f klasy FIFO
int licz=0; // pomocnicza zmienna dla pętli WHILE
Scanner odczyt = new Scanner(System.in); // do oczytu z klawiatury danych
while(licz<1000){
try { // wyłapując wyjątki wczytuję kolejno pierwszą i drugą wartość do zapamiętania
int a = odczyt.nextInt();
int b = odczyt.nextInt();
f.pisz(a,b);
licz++;
} catch(IOException e) { System.out.println("Błąd przy wprowadzaniu danych");} // jezeli cos pojdzie nie tak, wyrzuci wyjatek ;)
}
}
Piszę jako iż, jestem ciekaw, czy rozwiązanie owych zadań jest w miarę poprawne. Wszelkie komentarze mile widziane. :)