Polimorfizm, interfejsy i klasy wewnętrzne

1. Metody wirtualne i polimorfizm

Car c = new Car(...); // utworzymy nowy obiekt klasy Car
Vehicle v = c;        // dokonamy obiektowej konwersji rozszerzającej

v.start();
System.out.println(v.toString());

• uzyskanie tablicy wszystkich startujących w wyścigu pojazdów (np. getAllVehiclesToStart()),
• przebiegnięcie przez wszystkie elementy tablicy i posłanie do każdego z obiektów, przez nie reprezentowanych,  komunikatu start()

1. kompilator wie tylko, że start() jest komunikatem do obiektu typu Vehicle,
2. powinien więc związać odwołanie v.start() z definicją metody start() z klasy Vehicle

public static void main(String args[]) {
    Car c = new Car(...);
    Rydwan r = new Rydwan(...);
    Vehicle v;
    if (args[0].equals("Rydwan")) v = r;
    else v = c;
    v.start();
}

2. Znaczenie polimorfizmu

class Zwierz {
  String name = "bez imienia";
  Zwierz() { }
  Zwierz(String s) { name = s; }
  String getTyp()      { return "Jakis zwierz"; }
  String getName()     { return  name;   }
  String getVoice()    { return "?"; }

  // Metoda speak symuluje wydanie głosu poprzez wypisanie odpowiedniego komunikatu
  void speak()  {
    System.out.println(getTyp()+" "+getName()+" mówi "+getVoice());
  }
}

class Pies extends Zwierz {
  Pies()         { }
  Pies(String s) { super(s); }
  String getTyp()      { return "Pies";   }
  String getVoice()    { return "HAU, HAU!"; }
}

class Kot extends Zwierz {
  Kot()         { }
  Kot(String s) { super(s); }
  String getTyp()      { return "Kot";        }
  String getVoice()    { return "Miauuuu..."; }
}

public class Main {
  public static void main(String[] arg) {
    Zwierz z1 = new Zwierz(),
           z2 = new Zwierz();
    Pies pies = new Pies(),
         kuba = new Pies("Kuba"),
         reksio = new Pies("Reksio");
    Kot kot = new Kot();

    animalDialog(z1, z2);
    animalDialog(kuba, reksio);
    animalDialog(kuba, kot);
    animalDialog(reksio, pies);
  }

  static void animalDialog(Zwierz z1, Zwierz z2) {
    z1.speak();
    z2.speak();
    System.out.println("----------------------------------------");
   }
}

W klasie String:

    public static String valueOf(Object obj) {
	return (obj == null) ? "null" : obj.toString();
    }

W klasie PrintStream (lub PrintWriter): 

    public void println(Object obj) {
        String txt = String.valueOf(x);
        // wypisanie tekstu txt
    } 

package tostring;

public class TestToString {

  public static void main(String[] args) {
    Object[] elts = { new Para(3, 5),
                      new Vehicle(
                          new Person("Stefan", "65021123456"),
                          100, 100, 100, 100 
                      ),
                      new Car("AA7897", 
                              new Person("Janek", "78011222457"),
                              100, 100, 100, 500, 50
                      ),
                      new MojaKlasa(), new Bicycle() };
    // Iterujemy po tablicy obiektów
    // dla każdego zostanie wywołana metoda toString() z jego klasy
    // albo z pierwszej jego nadklasy, która ją definiuje 
    // (w ostateczności z klasy Object)
    for (Object elt : elts) {
      System.out.println(elt);
    }
  }

}

class A {
  String toString() {
    return "Obiekt klasy A";
  }
}

package tostring;

class A {
  public String ToString() {
    return "Obiekt klasy A";
  }
}

class B {
  public String toString() {
    return "Obiekt klasy B";
  }
}

class C extends B {
  public String toString(String ... myMsg) {
    String s = "Obiekt klasy C";
    if (myMsg.length == 1) s += myMsg[0]; 
    return s;
  }    
}

public class UseOverride {
  public static void main(String[] args) {
    Object[] arr = { new A(), new B(), new C() };
    for (Object o : arr) {
      System.out.println(o);
    }
  }
}

class Liczba {
  
  private Number n;
  
  public Liczba() {
  }
  
  public Liczba(Integer i) {
    n = i;
  }
  
  public Liczba(Double d) {
    n = d;
  }
  
  public Number getNumber() { 
    return n; 
  }

}

class Cala extends Liczba {
  
  public Cala(int n) {
    super(n);
  }
  
  public Integer getNumber() {
    return super.getNumber().intValue();
  }

}

class Rzecz extends Liczba {
  
  public Rzecz(double n) {
    super(n);
  }
  
  public Double getNumber() {
    return super.getNumber().doubleValue();
  }

}

  public static void main(String[] args) {
    Liczba[] liczby = { new Cala(1), new Rzecz(2.1), new Rzecz(3.1), new Cala(3) };
    for (Liczba l : liczby) {
      System.out.println(l.getNumber());
    }
  }

3. Metody i klasy abstrakcyjne

abstract class SomeClass {
  int n;
  abstract int getSomething();
  void say() { System.out.println("Coś tam");
} 

abstract class Zwierz {
   String name = "bez imienia";
   Zwierz() { }
   Zwierz(String s) { name = s; }
   String getTyp()      { return "Jakis zwierz"; }
   String getName()     { return  name;   }
   String getVoice()    { return "?"; }
   void speak()  {
     System.out.println(getTyp()+" "+getName()+" mówi "+getVoice());
   }
}

abstract class Zwierz {
   String name = "bez imienia";
   Zwierz() {}
   Zwierz(String s) { name = s; }
   abstract String getTyp();
   abstract String getVoice();
   String getName() { return  name; }
   void speak()  {
    System.out.println(getTyp()+" "+getName()+" mówi "+getVoice());
   }
}

class Pies extends Zwierz {
   Pies() { }
   Pies(String s) { super(s); }
   String getTyp()      { return "Pies";   }
   String getVoice()    { return "HAU, HAU!"; }
}

class Kot extends Zwierz {
   Kot() { }
   Kot(String s) { super(s); }
   String getTyp()      { return "Kot";        }
   String getVoice()    { return "Miauuuu..."; }
}

4. Interfejsy

public interface Speakable {

  int QUIET = 0;              // <- publiczne stałe statyczne
  int LOUD  = 1;              // domyślnie public static final

  String getVoice(int voice); // <- metoda abstrakcyjna;
                              // ponieważ w interfejsie mogą być
                              // tylko publiczne metody abstrakcyjne,
                              // specyfikatory public i abstract niepotrzebne
}

public class Wodospad implements Speakable {

  public String getVoice(int voice) { // metody interfejsu są zawsze publiczne! 

    if (voice == LOUD) return "SZSZSZSZSZSZ....";
    else if (voice == QUIET) return "szszszszszsz....";
         else return "?"
  }
}

public interface Moveable {
   void start();
   void stop();
}

• Pies jest Zwierzem,
• Pies  potrafi mówić,
• Pies może się poruszać.

public abstract class Zwierz {

  private String name = "bez imienia";

  public Zwierz() {}

  public Zwierz(String s) {
    name = s;
  }

  public abstract String getTyp();

  public String getName() {
    return name;
  }
  
}

public class Pies extends Zwierz implements Speakable, Moveable {

  public Pies() {
  }

  public Pies(String s) {
    super(s);
  }

  public String getTyp() {
    return "Pies";
  }

  public String getVoice(int voice) {
    if (voice == LOUD)
      return "HAU... HAU... HAU... ";
    else
      return "hau... hau...";
  }

  public void start() {
    System.out.println("Pies " + getName() + " biegnie");
  }

  public void stop() {
    System.out.println("Pies " + getName() + " stanął");
  }

}

     Pies kuba = new Pies("Kuba");
     kuba.start();
     System.out.println(kuba.getVoice(Speakable.LOUD));
     kuba.stop();

1. klasa Pies dziedziczy klasę Zwierz - zatem kuba jest typu Zwierz,
2. klasa Pies implementuje interfejs Speakable - zatem kuba jest typu Speakable,
3. klasa Pies implementuje interfejs Moveable - zatem kuba jest typu Moveable

public class Wyscig {
  
  static void wyscig(Moveable ... moveables) {
    for (Moveable m : moveables) {
      m.start();
      if (m instanceof Vehicle) System.out.println(m);
    }
  }

  public static void main(String[] args) {
    wyscig(new Pies("Kuba"), 
           new Car("WB4545", new Person("Janek", "9012102567"),100, 100, 100, 100, 100), 
           new Kot("Mruczek"), 
           new Bicycle(new Person("Ala", "7011122347"),100, 100, 100, 100)
           ); 
  }
}

void merda() { System.out.println("Merda ogonem"); )

static void info(Zwierz z) {
   say(z.getTyp() + z.getName());   // say własna metoda =  System.out.println
   if (z instanceof Speakable) {
      Speakable zs = (Speakable) z;
      say(zs.getVoice(Speakable.LOUD));
   }
   if (z instanceof Pies)  ((Pies) z).merda();
}

1. Przy przekazywaniu argumentu następuje konwersja: Kot -> Zwierz,.
2. Polimorficznie jest wołana metoda getTyp() (z jest Zwierz, ale Java wie, że w tym Zwierzu siedzi Kot).
3. Ponieważ w z siedzi Kot, który implementuje interfejs Speakable, można zrobić konwersję do typu Speakable i odwołać się polimorficznie do getVoice().
4. Ponieważ Kot nie jest Psem - nie merda. ogonem.

void run(Moveable m) {
   m.start();
   if (m instanceof Pies) {
      System.out.println(" ...  i  .... " );
      ((Pies) m).merda();
      }
  }

1. Konwersję Psa do typu Moveable (w górę),
2. Polimorficzne wywołanie metody start() na rzecz obiektu oznaczanego przez m (formalnego typu Moveable, który jednak faktycznie jest typu Pies),
3. I jeżeli m odnosi się do Psa (a odnosi się), to po jawnej konwersji z typu Moveable do Psa możemy na rzecz przekształconego m wywołać "indywidualną" metodę merda z klasy Pies.

  void speak()  {
    System.out.println(getTyp()+" "+getName()+" mówi "+getVoice());
  }

  void speak()  {
    System.out.println(getTyp()+" "+getName()+" mówi "+((Speakable) this).getVoice(Speakable.QUIET));
  }

public abstract class Zwierz {

  // ...  

  public void speak(int ... v) {
    int vol = Speakable.QUIET; 
    if (v.length == 1) vol = v[0];  
    String voice;  
    if (this instanceof Speakable) voice = ((Speakable) this).getVoice(vol);
    else voice = "... (cisza) ...";
    System.out.println(getTyp()+" "+getName()+ " mówi " + voice);
  }
  
} 

public class Dialog {
  public static void main(String[] arg) {
    Pies kuba = new Pies("Kuba"), reksio = new Pies("Reksio");
    Kot kot = new Kot("Mruczek");
    Ryba ryba = new Ryba();

    animalDialog(kuba, reksio);
    animalDialog(kuba, kot);
    animalDialog(reksio, ryba);
  }

  static void animalDialog(Zwierz z1, Zwierz z2) {
    z1.speak();
    z2.speak();
    System.out.println("--------------------------------------");
   }
}

5. Użyteczność interfejsów: przykłady "for-each" i formatowania

public class CalendarForEach {

  public static void main(String[] args) {
 
    Calendar from, to;
    (from = Calendar.getInstance()).set(2008, 9, 1);; // 1 października
    (to = Calendar.getInstance()).set(2008, 9, 10);   // 10 pażdziernika 
    
    FromTo timeInterval = new FromTo(from, to);

    for (Calendar day : timeInterval) {
      System.out.printf("%tF%n", day);
    }
  }

}

import java.util.*;

public class FromTo implements Iterable<Calendar> {

   private Calendar from = Calendar.getInstance(),
                    to = Calendar.getInstance();


   public FromTo(Calendar f, Calendar t) {
      from.setTime(f.getTime());
      to.setTime(t.getTime());
   }

   public Iterator<Calendar> iterator() {
     return new CalendarIterator(from, to);
   }

}

import java.util.*;
import static java.util.Calendar.*;

public class CalendarIterator implements Iterator<Calendar> {

  private Calendar to;                                // data końca
  private Calendar current = Calendar.getInstance();  // bieżąca data iteratora

  CalendarIterator(Calendar from, Calendar to) {
    current.setTime(from.getTime());
    current.add(DATE, -1);                            // ustawiamy iterator przed początkiem zakresu 
    this.to = to;                                     // koniec zakresu 
  }

  public boolean hasNext() {
    return current.before(to);
  }

  public Calendar next() {
    if (!hasNext()) throw new NoSuchElementException();
    current.add(DATE, 1);
    return current;
  }

  // Metoda remove() nic nie robi,
  // ale musi być bo implementujemy interfejs Iterator
  public void remove() {
  }
}

1. wywoływana jest metoda formatTo z klasy obiektu,
2. metodzie formatTo jest przekazywany formator (jako parametr formatter), flagi formatowania (parametr flags), szerokość pola (parametr width) i precyzja (parametr precision),
3. w metodzie formatTo możemy sprawdzić wartości przekazanych informacji (np. locale formatora, flagi, szerokość precyzje) i na tej podstawie podjąć odpowiednie działania przetwarzające obiekt do wynikowego napisu,
4. przed zwróceniem sterowania z metody formatTo wywołujemy metodę format przekazanego formatora,
5. sformatowany napis będzie przez formator zapisany do odpowiedniej destynacji (np. wyprowadzony na standardowe wyjście).

• ALTERNATE - oznacza, że należy użyć alternatywnej formy sformatowania obiektu (w formacie użyto znaku #),
• LEFT_JUSTIFY - sformatowany napis będzie wyrównany w polu do lewej (w formacie użyto znaku -),
• UPPERCASE - zamiana liter na duże (użyto wielkiej litery w symbolu konwersji np. S, zamiast s).

import java.util.*;
import static java.util.FormattableFlags.*;

public class Person implements Formattable{
  
  private String fname;
  private String lname;

  public Person(String fname, String lname) {
    this.fname = fname;
    this.lname = lname;
  }

  @Override
  public void formatTo(Formatter formatter, int flags, int width, int precision) {
    String txt = lname;
    if ((flags & ALTERNATE) == ALTERNATE) txt += ' ' + fname;
    String fs = "%";
    if ((flags & LEFT_JUSTIFY) == LEFT_JUSTIFY) fs += '-';
    if (width >= 0) fs += width;
    if (precision >= 0) fs += "."+precision;
    fs += ((flags & UPPERCASE) == UPPERCASE) ?  "S" : "s";
    formatter.format(fs, txt);
  }


  public static void main(String[] args) {
    Person e =  new Person("Jan", "Kowalski");
    System.out.printf("%#s\n", e);
    System.out.printf("%20s\n", e);
    System.out.printf("%#30S\n", e);
    System.out.printf("%#.10S\n", e);
  }

}

6. Klasy wewnętrzne

6.1. Pojęcie klasy wewnętrznej

• Klasy wewnętrzne mogą być ukryte przed innymi klasami pakietu (względy bezpieczeństwa).
• Klasy wewnętrzne pozwalają unikać kolizji nazw (np. klasa wewnętrzna nazwana Vector nie koliduje nazwą z klasą zewnętrzną o tej samej nazwie).
• Klasy wewnętrzne pozwalają (czasami) na lepszą, bardziej klarowną strukturyzację kodu, bo można odwoływać się z nich do składowych (nawet prywatnych) klasy otaczającej, a przy tym zlokalizować pewne działania.
• Klasy wewnętrzne (w szczególności anonimowe) są intensywnie używane przy implementacji standardowych interfejsów Javy.
• Anonimowe klasy wewnętrzne pozwalają na traktowanie fragmentów kodu do wykonania (ściślej: metod przedefiniowywanych w tych klasach) jak obiektów, a wobec tego np. umieszczanie ich w tablicach, kolekcjach, czy przekazywanie innym meteodom jako argumentów. Można to traktować jako bardzo częściową ( ograniczoną co do semantyki i nieco żmudną w składni) realizację koncepcji domknięć (closures).

import javax.swing.*;
import java.awt.event.*;

public class Car extends Vehicle  {

  private String nrRej;
  private int tankCapacity;
  private int fuel;

  // Klasa wewnętrzna. Prywatna - nie możemy jej użyć poza klasą Car
  // Dostarcza definicji metody actionPerformed(...), wywoływanej przez Timer

   private class FuelConsume implements ActionListener {

     public void actionPerformed(ActionEvent e)  {
       if (getState() != MOVING) fuelTimer.stop();  // nie zużywaj paliwa, gdy nie jedziesz 
       else  {                                      
         fuel -= 1;               // odwolanie do pryw. składowej klasy otaczajĄcej
         if (fuel == 0) stop();
       }
     }
   }

  // Timer będzie co sekundę wywoływać metodę actionPerformed(...)
  // z klasy obiektu podanego jako drugi argument konstruktora
  // ( obiekt klasy FuelConsume)
  // w rezultacie co sekunde czasu komputerowego bedzie zuzywany 1 l paliwa

    private Timer fuelTimer = new Timer(1000, new FuelConsume());

    public Car(String nr, Person owner, int w, int h, int l,
               int weight, int tankCap)  {
        super(owner, w, h, l, weight);
        nrRej = nr;
        tankCapacity = tankCap;
    }

    public void fill(int amount)  {
      if (getState() == MOVING)
          System.out.println("Nie moge tankowac w ruchu");
      else  {
        fuel += amount;
        if (fuel > tankCapacity) fuel = tankCapacity;
      }
    }

    public void start()  {
      if (fuel > 0)   {
          super.start();
          fuelTimer.start();     // start Timera
      }
      else System.out.println("Brak benzyny");
    }

    public void stop()  {
      super.stop();
      fuelTimer.stop();          // zatrzymanie Timera
    }

    public String toString()  {
       return "Samochód nr rej " + nrRej + " - " + getState(getState());
    }
}

  public static void main(String[] args) throws InterruptedException {
    Car c = new Car("aaa", new Person("x", "c"), 100, 100, 100, 100, 100);
    c.fill(7);
    c.start();
    for (int i = 1; i <= 9; i++) {
      Thread.sleep(1000);
      System.out.println("Po " + i + " sek. - " + c);
    }
  }

Car.FuelConsume cfc =    new Car().new FuelConsume();

6.2. Anonimowe klasy wewnętrzne

Record jakisRekord;
//....
db.add(jakisRekord);

class Car  extends Vehicle {

 private ActionListener fuelConsumer  = new ActionListener()    {
       public void actionPerformed(ActionEvent e)  {
          if (getState() != MOVING) fuelTimer.stop();
          else  {
            fuel -= 1;
            System.out.println("Fuel "+ fuel);
            if (fuel == 0) stop();
          }
       }
    };

private Timer fuelTimer = new Timer(1000, fuelConsumer);
....
}

class Car  extends Vehicle {

private Timer fuelTimer = new Timer(1000,  new ActionListener() {

       public void actionPerformed(ActionEvent e)  {
          if (getState() != MOVING) fuelTimer.stop();
          else  {
            fuel -= 1;
           if (fuel == 0) stop();
          }
       }

    }   // nawias zamykający definicję klasy wewnętrznek
);      // nawias zamykający  new Timer(...),
        // i średnik kończący instrukcję deklaracyjną

...
}

• anonimowe klasy wewnętrzne nie mogą mieć konstruktorów (bo nie mają nazwy),
• za pomocą anonimowej klasy wewnętrznej można stworzyć tylko jeden obiekt, bo definicja klasy podana jest w wyrażeniu new czyli przy tworzeniu obiektu, a nie mając nazwy klasy nie możemy potem tworzyć innych obiektów; jeśli jednak to wyrażenie new umieścimy np. w pętli – to oczywiście stworzone zostanie tyle obiektów ile razy wykona się pętla,
• definiowanie klas wewnętrznych implementujących interfejsy stanowi jedyny dopuszczalny przypadek użycia nazwy interfejsu w wyrażeniu new  (nie wolno na przykład pisać ActionListener al = new ActionListener();, ale możemy użyć new ActionListener() wtedy, gdy zaraz potem następuje definicja anonimowej klasy wewnętrznej implementującej interfejs ActionListener),
• anonimowe klasy wewnętrzne są kompilowane do plików .class o nazwach automatycznie nadawanych przez kompilator (nazwa składa się z nazwy klasy otaczającej i jakiegoś automatycznie nadawanego identyfikatora np. Car$1.class)

6.3. Wewnętrzne klasy lokalne

import static java.util.Calendar.*;

public class FromTo implements Iterable<Calendar> {

   private Calendar from = Calendar.getInstance(),
                    to = Calendar.getInstance();


   public FromTo(Calendar f, Calendar t) {
      from.setTime(f.getTime());
      to.setTime(t.getTime());
   }
   
   @Override
   public Iterator<Calendar> iterator() {
     
     // użycie lokalnej anonimowej klasy wewnętrznej
     return new Iterator<Calendar>() {
       
      Calendar current = Calendar.getInstance();
      
      // Przydatność bloku inicjacyjnego
      {
        current.setTime(from.getTime());
        current.add(DATE,-1);
      }

      @Override
      public boolean hasNext() {
        return current.before(to);
      }

      @Override
      public Calendar next() {
        if (!hasNext()) throw new NoSuchElementException();
        current.add(DATE,1);
        return current;
      }

      @Override
      public void remove() {
      }
       
     };
   }

}

• w definicji klasy wewnętrznej możemy wprowadzać deklaracje i inicjacje pól, ale jeśli klasa jest anonimowa, to nie możemy podać konstruktora; dlatego przydatny do inicjacji obiektu takiej klasy może okazać się niestatyczny blok inicjacyjny,
• zastosowanie lokalnej anonimowej klasy wewnętrznej w klasie FromTo pozwoliło na zmniejszenie liczby klas w programie i długości kodu (wewnętrzna klasa iteratora ma dostęp do pól from i to z klasy otaczającej).

void listJavaFiles(String dirName)  {    // argument - nazwa katalogu

   File dir = new File(dirName);         // katalog jako obiekt typu File

   // listowanie z filtrowaniem nazw
   // kryteria wyboru nazw podajemy za pomocę
   // implementacji metody accept
   // w lokalnej anonimowej klasie

   String[] fnames = dir.list( new FilenameFilter()  {

         public boolean accept(File directory, String fname)  {
            return fname.endsWith(".java");

         }
   });

   for (int i=0; i < fnames.length; i++)  {  // lista -> stdout
      System.out.println(fnames[i]);
   }

}

// Metoda listuje pliki z rozszerzeniem podanym jako drugi argument,
// z podanego jako  pierwszy argument katalogu

void listFilesWithExt(String dirName, final String ext )  {
      File dir = new File(dirName);
      String[] fnames = dir.list( new FilenameFilter()  {
         public boolean accept(File dir, String fname)  {
            return fname.endsWith(ext);
         }
      });
      for (int i=0; i < fnames.length; i++)  {
          System.out.println(fnames[i]);
      }
   }

6.4. Anonimowe klasy wewnętrzne a domknięcia i tablice funkcji

	  String[] napisy = ["Ala", "ma", "kota", "i", "psa" ];
	  napisy.each { txt -> if (txt.size() > 2) println(txt) };
	  napisy.each { txt -> println(txt.toUpperCase()); };

interface StringOp {
  void execute(String s);
}

class MyStringList extends ArrayList<String> {
  
  public MyStringList(String ...args) {
    for(String s : args) this.add(s);
  }
  
  public void each(StringOp func) {
    for(String s : this) {
      func.execute(s);
    }
  }
}

public class QuasiClosures {

  public static void main(String[] args) {
    
    MyStringList list = new MyStringList("Ala", "ma ", "kota", "i", "psa");
    
    list.each( new StringOp() {  // kod do wykonania podajemy jako obiekt anonimowej klasy wewnętrznej

      @Override
      public void execute(String s) {
        if (s.length() > 2) System.out.println(s);
      }
    });
    

    list.each( new StringOp() {  // a tu inny kod, stworzony ad hoc

      @Override
      public void execute(String s) {
        System.out.println(s.toUpperCase());
      }
    });
    
    

  }

public class FuncTab {
  
  interface Func {
     void func();
  }

  
  private void testFuncTab() {

    // Tablica funkcji
    Func[] tabfunc = {
        new Func() {
          public void func() {
            System.out.println("Funkcja 1");
          }
        },
        new Func() {
          public void func() {
            System.out.println("Funkcja 2");
          }
        },
        new Func() {
          public void func() {
            System.out.println("Funkcja 3");
          }
        },
    };
    
    // Wywołanie funkcji z tablicy
    tabfunc[0].func();
    tabfunc[1].func();
    tabfunc[2].func();
  
  }
  
  public static void main(String[] args) {
    new FuncTab().testFuncTab();
  }

}

7. Zaawansowane użycie wyliczeń (enum)

• można dodawać dowolną niemal funkcjonalność do enum - to jest klasa i może mieć dodatkowe pola, konstruktory, metody,
• w definicji enum  ze stałymi można wiązać  wywołania metod poprzez niejawne użycie anonimowych klas wewnętrznych i przedefiniowanie w nich metod,
• istnieją efektywne implementacje zbioru elementów wyliczeniowych (EnumSet) i mapy, w której kluczami są elementy enumeracji (EnumMap); implemementacje te są realizowane jako wektory bitowe (na  typie long) albo tablice typu int[] i w większości przypadków dają dużą poprawę efektywności wobec normalnych zbiorów i map (w których zresztą też możemy używać elementów enumeracji)

package kiosk1;

public enum Gazety {

  Głos(1), Polityka(4.5), Gazeta(2.5);

  Gazety(double p) { price = p; }

  public double getPrice() { return price; }

  private final double price;

}

package kiosk1;
import java.util.*;
import static kiosk1.Gazety.*; // musi być nazwany pakiet!
import static java.lang.System.out;


public class Kiosk {

  // Mapa gazet dostępnych w kiosku: klucz - gazeta, wartość - liczba egzemplarzy
  private EnumMap<Gazety, Integer> map =
                                  new EnumMap<Gazety, Integer>(Gazety.class);

 public Kiosk() {
   supply(Głos, 20);
   supply(Polityka, 20);
   supply(Gazeta, 20);

   // co jest w kiosku:
   // Jak łatwo i elegancko!!!
   for (Gazety g : Gazety.values())
     out.println(g + " - liczba egzemplarzy " + map.get(g));

   // Sprzedajemy trochę
   double income = 0;
   income += sale(Głos, 2);
   income += sale(Polityka, 10);
   income += sale(Gazeta, 5);
   income += sale(Głos, 2);
   // Teraz w kiosku zostało
   for (Gazety g : Gazety.values())
     out.println(g + " - liczba egzemplarzy " + map.get(g));
   // a uzyskany dochód ze sprzedaży
   out.println("Dochód: " + income);
 }

   /**
   * Dostawa q sztuk gazety g
   * @param g - konkretna gazeta
   * @param q - liczba sztuk w dostawie
   */
   public void supply(Gazety g, int q) {
     // metoda containsKey() zwraca true jesli w mapie jest podany klucz
     if (map.containsKey(g)) q += map.get(g);  
     map.put(g, q);
   }

   /**
   * sprzedaż q sztuk gazety g
   * @param g - sprzedawana gazeta
   * @param q - liczba sprzedanych sztuk
   * @return wartość transakcji
   */
   public double sale(Gazety g, int q) {
     if (!map.containsKey(g)) return 0;
     int n = map.get(g);
     if (q > n) q = n;
     map.put(g, n-q);
     return q*g.getPrice();
   }

   public static void main(String[] args) {
     new Kiosk();
   }

}

package kiosk2;

public enum Gazety {

  // W konstruktorze użyjemy dwóch parametrów
  // Ze stałymi wyliczenia zwiążemy przedefiniowane metody toString
  // tak, by wydruk był ładniejszy nieco

  Głos(0.75, 1) {
    public String toString() { return "Tygodnik \"Głos\""; }
  },

  Polityka(4, 4.5) {
    public String toString() { return "Tygodnik \"Polityka\""; }
  },

  Gazeta(2, 2.5) {
    public String toString() { return "\"Gazeta Wyborcza\""; }
  };

  Gazety(double wp, double rp) {
    wholesalePrice = wp;
    retailPrice = rp;
  }

  public double getRetailPrice() { return retailPrice; }
  public double getWholesalePrice() { return wholesalePrice; }

  private final double wholesalePrice;
  private final double retailPrice;

}

package kiosk2;
import java.util.*;

// Dosyć funkcjonalna enumeracja
// opisuje możliwe transakcje (dostawa, sprzedaż gazet)
// a zarazem prowadzi rejestr magazynu i rejestr sprzedanych gazet

public enum Transaction {

   // Elementy wyliczenia (konkretne operacje)
   // Wiązemy z nimi ciała podklas, w których
   // implementujemy metodę perform,
   // która jest zadeklarowana na końcu jako abstrakcyjna
   // Uwaga: w klasach enum elementy wyliczenia winny
   // poprzedzać wszelkie rozszerzenia funkcjonalności

   SUPPLY {
     public void perform(Gazety g, int n) {
       if (volume.containsKey(g)) n += volume.get(g);
       volume.put(g, n);
     }
   },

   SALE {
     public void perform(Gazety g, int n) {
       if (!volume.containsKey(g)) return;
       int k = volume.get(g);
       if (n > k) n = k;
       volume.put(g, k-n);
       sold.put(g, n);
     }
     
   };


   public static int getVolume(Gazety g) {
     if (!volume.containsKey(g)) return 0;
     return volume.get(g);
   }

   public static int getSold(Gazety g) { 
     if (!sold.containsKey(g)) return 0;
     return sold.get(g);
   }

   // Gazety - stan magazynowy   
   private static final EnumMap<Gazety, Integer> volume =
     new  EnumMap<Gazety, Integer>(Gazety.class);
   // Gazety - sprzedane
   private static final EnumMap<Gazety, Integer> sold =
     new  EnumMap<Gazety, Integer>(Gazety.class);


   // Metoda perform musi być zsdeklarowana jako abstrakcyjna
   // ona własnie jest w różny sposób implemetowana w ciałach podklas
   // przypisanych stałym wyliczenia

   public abstract void perform(Gazety g, int n);

}

package kiosk2;
import static kiosk2.Gazety.*;
import static kiosk2.Transaction.*;
import static java.lang.System.out;


public class Kiosk {

  public Kiosk() {

    // Sprowadzamy gazety
    // możemy użyć dalej zdefiniowanej metody trans (może coś jeszcze będzie robić)
    trans(SUPPLY, Głos, 20);
    trans(SUPPLY, Polityka, 20);
    trans(SUPPLY, Gazeta, 20);

    // ale możemy też pisać tak:
    SUPPLY.perform(Gazeta, 10);
    SUPPLY.perform(Polityka, 10);

    // co jest w kiosku i ile wydano na sprowadzenie gazet:
    out.println("Po dostawie w kiosku są następujące gazety:");
    double cost = 0;
    for (Gazety g : Gazety.values()) {
      int n = getVolume(g);
      cost += g.getWholesalePrice() * n;
      out.println(g + " - liczba egzemplarzy " + n );
    }
    out.println("Wydano: " + cost);

    // Sprzedajemy trochę
    SALE.perform(Polityka, 15);
    SALE.perform(Głos, 10);
    SALE.perform(Gazeta, 20);

    // Co sprzedano i ile uzyskano?
    out.println("Sprzedano gazety: ");
    double income = 0;
    for (Gazety g : Gazety.values()) {
      int n = getSold(g);
      income += g.getRetailPrice() * n;
      out.println(g + " - liczba egzemplarzy " + n );
    }
    out.println("Dochód " + income);
    out.println("Zarobek : " + (income - cost));

    out.println("Zostały do sprzedaży:");
    for(Gazety g : Gazety.values())
      out.println(g + " - liczba egzemplarzy: " + getVolume(g));


  }

  /**
   * Ew. można taką metodę sobie dodac
   *   Transakcja - zakup gazet do kiosku lub ich sprzedaż
   *   @param t - rodzaj transakcji (SUPPLY lub SALE)
   *   @param g - jaka gazeta
   *   @param n - ile sztuk
   */

  public void trans(Transaction t, Gazety g, int n) {
    t.perform(g, n);
  }


  public static void main(String[] args) {
    new Kiosk();
  }

}