• Lokální vnitřní třídy
• Anonymní třídy

public interface Info {
  public void kdoJsem();
}

public interface Trojrozmerny {
  public double getObjem();
  public double getPovrch();
}

public class Usecka implements Info {

  int delka;

  Usecka(int delka) { this.delka = delka; }

  @Override
  public void kdoJsem() {
    System.out.println("Usecka");
  }
}

public class Koule implements Info, Trojrozmerny {
  
  int polomer;
  
  Koule(int polomer) { this.polomer = polomer; }

  @Override
  public void kdoJsem() {
    System.out.println("Koule");
  }

  @Override  
  public double objem() {
    return 4 / 3 * Math.PI * Math.pow(polomer, 3);
  }

  @Override
  public double getPovrch() {
    return 4 * Math.PI * Math.pow(polomer,2);
  }
}

public class TestKoule {

  public static void main(String[] args) {
    Usecka u = new Usecka(5);
    Koule  k = new Koule(3);
    u.kdoJsem();
    k.kdoJsem();
    System.out.println("Objem koule: " + k.objem());
    System.out.println("Povrch koule: " + k.getPovrch());
  }
}

interface Zobrazitelny {
    void zobraz(int x, int y);
    void presun(int offsetX, int offsetY);
    void zmiz();
}

class UkazkovaTrida
    void ukazkovaMetoda(Zobrazitelny o) {
        o.zobraz(5, 8);
        o.presun(3, 14);
        o.zmiz();
    }
}

• může být obtížné, protože by byl evidentně vykonstruovaný, nebo
• může být nemožné, pokud naše třídy vznikly děděním z knihovních (tedy námi neovlivnitelných) tříd.

class Rodic{...}  
interface MojeRozhrani{...}
class Potomek extends Rodic implements MojeRozhrani{...}
...
Rodic r = new Rodic();
Rodic p = new Potomek();  

• které jsou deklarovány jako soukromé (private),
• pokud je nadtřída (rodič) z jiného balíku a tyto proměnné a metody nejsou veřejné (public) nebo chráněné (protected),
• které mají v potomkovi stejné jméno (u metod i typy parametrů ve stejném pořadí) jako v rodičovské třídě. Tyto členské proměnné a metody jsou předefinovány – hovoří se o zastínění (hiding) proměnných a překrytí (overriding) metod.

• boolean equals(Object obj)

• String toString()

• int hashCode()

class Osoba {

    private String adresa;
    private int rodneCislo;  // Rodné číslo není příliš vhodné ukládat jako číslo, ale to nyní pro jednoduchost ignorujme.

    public void setAdresa(String adresa) {
        this.adresa = adresa;
    }

    public void setCislo(int rodneCislo) {
        this.rodneCislo = rodneCislo;
    }
    
    @Override // tato anotace vyznačuje překrytí
    public boolean equals(Object obj) {
        if (obj instanceof Osoba) {
            Osoba b = (Osoba) obj;
            return (this.rodneCislo == b.rodneCislo);
        }
        return false;
    }
    
    public static void main(String[] args) {
        Osoba o1 = new Osoba();
        Osoba o2 = new Osoba();
        Osoba o3 = new Osoba();
        o1.setAdresa("Praha");
        o2.setAdresa("Brno");
        o3.setAdresa("Ostrava");
        
        o1.setCislo(9154185425);
        o2.setCislo(9154185425);
        o3.setCislo(8609065146);
        
        System.out.println(o1.equals(o2)); // vypíše TRUE
        System.out.println(o1.equals(o3)); // vypíše FALSE
    }
}
	

• musí být reflexivní, tj. x.equals(x) == true,
• musí být symetrická, tj. x.equals(y) == true právě tehdy, když y.equals(x) == true,
• musí být tranzitivní, tj. když x.equals(y) == true a y.equals(z) == true, tak x.equals(z) musí vrátit také true.
• musí být konzistentní, tj. pro nezměněné instance vrací vždy stejnou hodnotu,
• pro parametr null musí vracet hodnotu false, tj. x.equals(null) vrátí false.

• Pro tentýž objekt musí hashCode() vracet vždy stejný hešovací kód.
• Rozhodla-li equals(), že jsou si dva objekty rovny, musí hashCode() vrátit stejný hešovací kód. Je tedy nutné počítat hodnotu hashcode přesně z těch hodnot, které porovnáváme v metodě equals(). Naopak dva různé objekty by měly generovat dva různé hash kódy.
• Nejsou-li si objekty rovny podle equals(), mohou mít stejný hešovací kód.

• Když překrýváte equals, vždy překryjte také hashCode

abstract void vykresli();

public interface Rozhrani {
    int max(int a, int b);
    int min(int a, int b);
}

public abstract class CastecneImplementujiciRozhrani implements Rozhrani {
    @Override
    public int min(int a, int b) {
        return a < b ? a : b;
    }
}

• Obě podtřídy pak musí implementovat metodu vykresli(), která však bude kruh vykreslovat samozřejmě jinak, než obdélník.
• Přestože nelze vytvořit instanci abstraktní třídy GrafickyObjekt, lze deklarovat proměnnou tohoto objektového typu. Do této proměnné lze pak umístit odkaz jak na instanci třídy Kruh, tak i Obdelnik, např.:

  GrafickyObjekt o = new Obdelnik(10, 10, 3, 4);
  GrafickyObjekt o = new Kruh(12, 15, 5);
  

• Abstraktní třídu GrafickyObjekt lze použít i jako návratový typ metody nebo typ parametru metody. Ve skutečnosti se pak bude opět pracovat s instancemi tříd Kruh nebo Obdelnik.

GrafickyObjekt o;
...
if (a > b)
   o = new Kruh(5, 8, 3);
else
   o = new Obdelnik(6, 7, 3, 2);
o.vykresli();

public class A {
  public class B {
    public class C {
    }
  }
}

A a = new A();
A.B b = a.new B();
A.B.C c = b.new C();

public class A {
  private int a = 1;
 
  public class B {
    private int b = a;
 
    public class C {
      private int c1 = a;
      private int c2 = b;
    }
  }
}

public class A {
 
  public String metoda() {
    return "A";
  }
 
  public class B {
    public String metoda() {
      return "B";
    }
 
    public class C {
      public String metoda() {
        return "C";
      }
 
      public void volani() {
        System.out.println("C = " + metoda());
        System.out.println("B = " + B.this.metoda());
        System.out.println("A = " + A.this.metoda());
      }
    }
  }
}

• Logické seskupení tříd, které jsou využity v jednom místě aplikace.
  Když je třída B využita pouze ve třídě A, je logické ji do třídy A vnořit. Mj. se tím omezí počet souborů aplikace (přehlednost).
• Řešení problému zapouzdření.
  Uvažujme dvě samostatné třídy A a B, kde B potřebuje přístup k prvkům třídy A, které by jinak byly soukromé (private). Vnořením třídy B do A mohou být prvky třídy (statické metody + proměnné) deklarovány jako soukromé a třída B k nim má přesto přístup. Navíc, třída B může být skryta před vnějším světem.
• Vnitřní třídy mohou vést k přehlednějšímu a lépe udržovatelnému kódu.
  Vnořováním jednoduchých tříd do jiných tříd lze umístit kód blíže k místu jeho použití.

new TridaNeboInterface() { 
  ... implementace anonymni tridy ...
}

public static void main(String[] args) {
  class ReagujeNaTlacitko implements java.awt.event.ActionListener {

    public void actionPerformed(java.awt.event.ActionEvent e) {
      // zpracování stisku tlačítka;
    }
  }

  javax.swing.JButton tlacitko = new javax.swing.JButton("OK");
  tlacitko.addActionListener(new ReagujeNaTlacitko());
}

public static void main(String[] args) {
  javax.swing.JButton tlacitko = new javax.swing.JButton("OK");
  tlacitko.addActionListener(new java.awt.event.ActionListener() {
     public void actionPerformed(java.awt.event.ActionEvent e) {
        // zpracování stisku tlačítka;
     }
  });
}

final int POCITADLO = 1;
 
ActionListener posluchac = new ActionListener() {
  public void actionPerformed(ActionEvent e) {
    System.out.println("Pocitadlo = " + POCITADLO);
  }
};

• @Deprecated – touto anotací máme možnost označit element jako deprecated (zavržený), tzn. že by neměl být už dále používán. Elementem se rozumí třída, metoda, field (proměnná), konstruktor nebo interface. Při použití takového prvku v programu vypisuje překladač varovné hlášení.
  Takto označený eleemnt by měl být v JavaDoc dokumentaci opatřen vysvětlením, proč je zavržen a co má být použito místo něho.
  Příklad:

  /**
    * @deprecated
    * Metoda je zavržena, protože... Použijte místo ní metodu...
    */
  @Deprecated
  static void deprecatedMethod() { }
  

• @Override – tato anotace říká kompilátoru, že daný element je překrytím elementu z nadřazené třídy (rodiče). Kompilátor provádí kontrolu, zda překrytí proběhlo v pořádku (zda nejde např. o přetížení u metod).
  Příklad:

  @Override
  public String toString() {
      return "Kruh o poloměru " + r + ".";
  }
  

• @SupressWarning – pomocí této anotace můžeme kompilátoru říci, že pro daný element nemá generovat specifický warning. Můžeme tak např. potlačit vygenerování varování o tom, že používáme metodu nebo třídu, která je označena jako deprecated.
  Příklad:

  @SuppressWarnings("deprecation")
  void useDeprecatedMethod() {
      objectOne.deprecatedMethod(); // Jinak by zde překladač vypisoval varování.
  }
  

• @SafeVarargs – ujištění, že metoda používající proměnný počet parametrů neobsahuje potenciálně nebezpečné operace. Používá se od verze 7 jazyka Java.
  
• @FunctionalInterface – anotace označující funkční rozhraní, což je rozhraní obsahující pouze jednu hlavičku metody. Používá se od verze 8 jazyka Java.