Elektrotehnicki fakultet, Beograd  Ласло Краус ИР2ОО2
Други колоквијум
6. 7. 2007.

Аутори: Игор Тартаља и Ласло Краус

Задаци: 1 2 | Напоменe | Решења: 2

Поставка задатка 1 (укупно 30 поена) ( почетак)

Одговорити концизно (по једна или две реченице) и прецизно на следећа питaња:

а) (Java) Шта се догађа када се за нит у блокираном стању позове метод interrupt()?

б) (C#) Која су основне разлике наредбе switch у односу на исту у језику Јава?

в) (C#) Који све типови спадају у вредносне, а који у указане типове?

Поставка задатка 2 (70 поена) ( решење | почетак)

У пакету logika постоје следећи типови за рад са логичким елементима (ове типове није потребно реализовати):

Реализовати на језику Java следеће типове:


Напоменe ( почетак)


Решење задатка 2 ( поставка | почетак)


///////////////// Не припада решењу колоквијума ///////////////////////
// Elem.java                                                        ///
                                                                    ///
package logika;                                                     ///
                                                                    ///
public abstract class Elem {                                        ///
  private char ime;                                                 ///
                                                                    ///
  protected Elem[] ulazi;                                           ///
                                                                    ///
  public Elem (char iime, int brUl)                                 ///
    { ime=iime; if (brUl != 0) ulazi = new Elem[brUl]; }            ///
                                                                    ///
  public char ime () { return ime; }                                ///
                                                                    ///
  public abstract String vrsta ();                                  ///
                                                                    ///
  public abstract boolean vrednost ();                              ///
                                                                    ///
  public String toString ()                                         ///
    { return ime + " (" + (vrednost()?"T":"F") + ")"; }             ///
}                                                                   ///
                                                                    ///
// Izvor.java                                                       ///
                                                                    ///
package logika;                                                     ///
                                                                    ///
public class Izvor extends Elem {                                   ///
  private boolean vr;                                               ///
                                                                    ///
  public Izvor (char ime) { super (ime, 0); }                       ///
                                                                    ///
  public void postavi (boolean v) { vr = v; }                       ///
                                                                    ///
  public boolean vrednost () { return vr; }                         ///
                                                                    ///
  public String vrsta () { return "izvor"; }                        ///
}                                                                   ///
                                                                    ///
// Ne.java                                                          ///
                                                                    ///
package logika;                                                     ///
                                                                    ///
public class Ne extends Elem {                                      ///
  public Ne (char ime, Elem a) { super (ime, 1); ulazi[0] = a; }    ///
                                                                    ///
  public boolean vrednost () { return ! ulazi[0].vrednost (); }     ///
                                                                    ///
  public String vrsta () { return "ne"; }                           ///
}                                                                   ///
                                                                    ///
// I.java                                                           ///
                                                                    ///
package logika;                                                     ///
                                                                    ///
public class I extends Elem {                                       ///
  public I (char ime, Elem a, Elem b)                               ///
    { super(ime,2); ulazi[0]=a; ulazi[1]=b; }                       ///
                                                                    ///
  public boolean vrednost ()                                        ///
    { return ulazi[0].vrednost() && ulazi[1].vrednost(); }          ///
                                                                    ///
  public String vrsta () { return "i"; }                            ///
}                                                                   ///
                                                                    ///
// GIndeks.java                                                     ///
                                                                    ///
package logika;                                                     ///
                                                                    ///
public class GIndeks extends Exception {                            ///
  public String toString ()                                         ///
    { return "*** Indeks izvan opsega!"; }                          ///
}                                                                   ///
                                                                    ///
// GPocetak.java                                                    ///
                                                                    ///
package logika;                                                     ///
                                                                    ///
public class GPocetak extends Exception {                           ///
  public String toString ()                                         ///
    { return "*** Nedoszoljena pocetna vrednost!"; }                ///
}                                                                   ///
                                                                    ///
// Brojac.java                                                      ///
                                                                    ///
package logika;                                                     ///
                                                                    ///
public class Brojac {                                               ///
  private Izvor[] izlazi;                                           ///
  private int ciklus, vrednost;                                     ///
                                                                    ///
  public Brojac (int brIzl) {                                       ///
    izlazi = new Izvor [brIzl];                                     ///
    ciklus = 1 << brIzl;                                            ///
  }                                                                 ///
                                                                    ///
  public Brojac povezi (int ind, Izvor izv) throws GIndeks {        ///
    if (ind<0 || ind>=izlazi.length) throw new GIndeks ();          ///
    izlazi[ind] = izv; return this;                                 ///
  }                                                                 ///
                                                                    ///
  private void postaviIzlaze () {                                   ///
    int k = vrednost;                                               ///
    for (int i=izlazi.length-1; i>=0; i--) {                        ///
      if (izlazi[i] != null) izlazi[i].postavi ((k&1)==1);          ///
      k >>= 1;                                                      ///
    }                                                               ///
  }                                                                 ///
                                                                    ///
  public Brojac postavi (int k) throws GPocetak {                   ///
    if (k<0 || k>=ciklus) throw new GPocetak ();                    ///
    vrednost = k; postaviIzlaze ();                                 ///
    return this;                                                    ///
  }                                                                 ///
                                                                    ///
  public Brojac povecaj () {                                        ///
    vrednost = (vrednost == ciklus-1) ? 0 : vrednost+1;             ///
    postaviIzlaze (); return this;                                  ///
  }                                                                 ///
                                                                    ///
  public Brojac smanji () {                                         ///
    vrednost = (vrednost == 0) ? ciklus-1 : vrednost-1;             ///
    postaviIzlaze (); return this;                                  ///
  }                                                                 ///
}                                                                   ///
                                                                    ///
///////////////// Не припада решењу колоквијума ///////////////////////

// Analizator.java

package logika;

public class Analizator extends Thread {
  private Brojac brojac;
  private Elem elem;
  private boolean radi = false;
  private int dt = 300;

  public Analizator (Brojac br, Elem el) { brojac = br; elem = el; start (); }


  public Analizator postaviDt (int d) { dt = d; return this; }

  public void run () {
    try {
      while (! interrupted ()) {
        if(!radi) synchronized(this) {wait();}
        sleep (dt); brojac.povecaj ();
        elem.vrednost ();
      }
    } catch (InterruptedException g) {}
  }

  public synchronized void kreni () {
    try {
      brojac.postavi (0); elem.vrednost ();
      radi = true; notify ();
    } catch (GPocetak g) {}
  }

  public synchronized void stani () { radi = false; }

  public void zavrsi () { interrupt (); }
}

// GraElem.java

package logika;
import java.awt.Label;

public class GraElem extends Elem {
  private Elem elem;
  private Label natpis;

  private void prikazi () {
    if (natpis != null) {
      String s = elem + "   [ " + vrsta();
      if (elem.ulazi != null) {
        s += " : ";
        for (int i=0; i<elem.ulazi.length; i++) {
          if (i>0) s += ", ";
          s += elem.ulazi[i];
        }
      }
      natpis.setText (s + " ]");
    }
  }

  public GraElem (Elem el, Label ntp) {
    super (el.ime(), 0); elem = el;
    natpis = ntp; prikazi ();
  }

  public boolean vrednost () {
    boolean vr = elem.vrednost ();
    prikazi (); return vr;
  }

  public String vrsta () { return elem.vrsta (); }

  public String toString () { return elem.toString (); }
}

// Program.java

package logika;
import java.awt.*;
import java.awt.event.*;

public class Program extends Frame {
  private Label[] natpisi;
  private Analizator analiz;
  private Button dgmKreni=new Button("Kreni"),
                 dgmStani=new Button("Stani");

  private void napraviMrezu () {
    Brojac bro = new Brojac (3);
    Izvor p = new Izvor ('a');
    Izvor q = new Izvor ('b');
    Izvor r = new Izvor ('c');
    try {
      bro.povezi(0,p).povezi(1,q).povezi(2,r);
    } catch (GIndeks g) {}

    natpisi = new Label [6];
    for (int i=0; i<natpisi.length; natpisi[i++]=new Label());
    Elem a = new GraElem (p,               natpisi[0]);
    Elem b = new GraElem (q,               natpisi[1]);
    Elem c = new GraElem (r,               natpisi[2]);
    Elem d = new GraElem (new I ('d',a,b), natpisi[3]);
    Elem e = new GraElem (new Ne('e',c),   natpisi[4]);
    Elem f = new GraElem (new I ('f',d,e), natpisi[5]);
    analiz = new Analizator (bro, f);
  }

  private void omoguci (boolean da) {
    dgmKreni.setEnabled (da);
    dgmStani.setEnabled (! da);
    dgmKorak.setEnabled (da);
  }

  private void popuniProzor () {
    Panel plo = new Panel (new GridLayout (0,1));
    add (plo, "Center");
    for (int i=0; i<natpisi.length; plo.add(natpisi[i++]));

    add (plo = new Panel (), "South");
    plo.add (new Label ("dt", Label.CENTER));
    final TextField tksDt = new TextField ("300", 4);
    plo.add (tksDt);
    tksDt.addTextListener (new TextListener(){
      public void textValueChanged (TextEvent d) {
        try {
          analiz.postaviDt
          (Integer.parseInt(tksDt.getText()));
        } catch (NumberFormatException g) {}
      }
    });
    plo.add (dgmKreni);
    dgmKreni.addActionListener (new ActionListener () {
      public void actionPerformed (ActionEvent d)
        { omoguci (false); analiz.kreni (); }
    });
    plo.add (dgmStani);
    dgmStani.setEnabled (false);
    dgmStani.addActionListener (new ActionListener () {
      public void actionPerformed (ActionEvent d)
        { omoguci (true); analiz.stani (); }
    });
  }

  public Program () {
    super ("Kombinaciona mreza");
    setSize (240, 170);
    napraviMrezu ();
    popuniProzor();
    setVisible (true);
    addWindowListener (new WindowAdapter () {
      public void windowClosing(WindowEvent d)
        { analiz.zavrsi (); dispose (); }
    });
  }

  public static void main (String[] varg)
    { new Program (); }
}
( почетак)
         
Аутор: Ласло Краус
Е-пошта: kraus@etf.rs

Copyright © 2010, Laslo Kraus
Последња ревизија: 30.8.2010.