Java #16: obiekty POJO i losowanie liczb

Obiekty POJO

Obiekty POJO (Plain Old Java Object) to nic innego jak zwykłe klasy zawierające jedynie pola, domyślny konstruktor (czyli taki, którego nie implementujemy, domyślnie jest tworzony przez kompilator) i akcesory (gettery i settery do każdego z pól). Pojęcie to powstało podczas rozwoju Java Enterprise Edition, gdzie istniały już pojęcia takie jak JavaBean, EntityBean czy SessionBean.

O to przykładowe POJO:

public class Cat {
    private String name;
    private int year;
    private String race;

    public String getName() {
      return name;
    }

    public void setName(String name) {
      this.name = name;
    }

    public int getYear() {
      return year;
    }

    public void setYear(int year) {
      this.year = year;
    }

    public String getRace() {
      return race;
    }

    public void setRace(String race) {
      this.race = race;
    }
}

Wygląda prosto, prawda? I takie powinno pozostać. W obiektach POJO nie umieszczamy:

• adnotacji, świadczących o rodzaju klasy (np. @Entity)
• implementacji interfejsu (słowo kluczowe implements)
• rozszerzenia o klasę nadrzędną (słowo kluczowe extends)

Taka klasa jest wygodna w dalszym użyciu.

Losowanie wartości

Napiszę teraz klasę o nazwie CatGenerator, która będzie w losowy sposób wypełniać tablicę kotów (obiektów POJO).

public class CatGenerator {

  public static Cat[] getCats(int catsNumberInArray) {
    Cat[] catArray = new Cat[catsNumberInArray];
    for (int i = 0; i < catArray.length; i++) {
      catArray[i] = randomCat();
    }
    
    return catArray;
  }

  public static Cat randomCat() {
    Cat randomCat = new Cat();
    randomCat.setName(randomName());
    randomCat.setRace(randomBreed());
    randomCat.setYear(randomYear());
    
    return randomCat;
  }

  private static String randomBreed() {
    return CatBreed.randomBreed().name();
  }

  private static int randomYear() {
    int maxLifeExpectancy = 20;
    int minLifeExpectancy = 1;
    
    return new Random().nextInt(maxLifeExpectancy) + minLifeExpectancy;
  }

  private static String randomName() {
    return CatName.randomName().toString();
  }

  private enum CatName {
    Ginger, Eiffel, Nikon;

    private static CatName randomName() {
      return values()[new Random().nextInt(CatName.values().length)];
    }
  }

  private enum CatBreed {
    Ragdoll, Persian, Abyssinian;

    private static CatBreed randomBreed() {
      return values()[new Random().nextInt(CatBreed.values().length)];
    }
  }
}

Klasa, którą napisałem, zawiera dwie metody publiczne, jedna służąca do generowania pojedynczego kota oraz druga, która generuje tablicę obiektów POJO o zadanej długości. W pierwszej metodzie losujące randomYear() użyty został obiekt klasy Random, który zawiera metodę losującą nextInt(int bound). Jak się domyślasz, jest to metoda, która losuje liczbę całkowitą o zadanym zakresie. Parametr bound oznacza górny zakres wartości, które możesz wylosować, przy czym dolną wartością będzie zawsze zero. Dlatego właśnie do rezultatu metody dodałem liczbę jeden (najmniejszy wiek kota może być właśnie taki).

Metoda values w enumie

Pierwsza linijka obu typów wyliczeniowych zawiera jakieś nazwy własne. Następnie w metodach randomBreed() oraz randomName() użyte są enumy: CatName i CatBreed, zawierające oprócz przykładowych wartości do losowania, metody losujące. Obie metody posiadają tajemniczy ciąg:

values()[new Random().nextInt(<EnumName>.values().length)]

gdzie <EnumName> to nazwa mojego typu wyliczeniowego. Metoda values() jest zawsze domyślnie zaimplementowana w każdym enumie i zwraca tablicę zawierającą wszystkie typy, które określiłeś w pierwszej linii kodu swojego enuma. Tutaj użyłem ją, aby pobrać po indeksie którąś z wartości. To co przesyłam w kwadratowych nawiasach to nic innego jak użycie tej samej metody nextInt z parametrem <EnumName>.values().length, co z kolei pozwala określić mi liczbę typów, które są w enumie (w moim przypadku będzie to liczba trzy i jak już wspomniałem, jest to maksymalna wartość po której metoda nextInt może losować).

Na koniec piszę implementację metody main, aby przetestować czy całość działa:

public class MainCats { 
   public static void main(String[] args) { 
      Cat[] cats = CatGenerator.getCats(1000); 
      for (Cat cat : cats) { 
         System.out.println(cat.getName() + " " + cat.getRace() + " " + cat.getYear()); 
      } 
   } 
}

Link do lekcji: https://github.com/developeronthego/java-basics/tree/main/src/main/java/basics/lesson16

Link do lekcji o enumach: https://developeronthego.pl/java-podstawy-14-typ-wyliczeniowy/