Klasy wewnętrzne i zagnieżdżone

/* Test1.java */

// Obiekty klasy InnerClass zagnieżdżonej w klasie otaczającej
// Test1 można tworzyć w zawartości obiektowej klasy otaczającej 
// Test1 tak jak obiekty zwykłych klas.

// Klasy zagnieżdżone nie mogą mieć zawartości statycznej.

public class Test1
{
  InnerClass inner = new InnerClass();
  
  void createInner()
  {
    new InnerClass();
  }
  
  class InnerClass
  {
    InnerClass()
    {
      System.out.println("Test1.InnerClass()");
    }
  }
  
  public static void main(String[] args)
  {
    new Test1().createInner();
  }
}

Test1.InnerClass()
Test1.InnerClass()
Press any key to continue...

/* Test2.java */

// Obiekty klasy InnerClass zagnieżdżonej w klasie otaczającej
// Test2 można tworzyć poza zawartością obiektową klasy
// otaczającej Test2 jedynie przez referencję do obiektu
// klasy otaczającej.

public class Test2
{
  Test2()
  {
    System.out.println("Test2()");
  }
  
  class InnerClass
  {
    InnerClass()
    {
      System.out.println("Test2.InnerClass()");
    }
  }
  
  public static void main(String[] args)
  {
    Test2 outer = new Test2();
    Test2.InnerClass inner = outer.new InnerClass();
  }
}

Test2()
Test2.InnerClass()
Press any key to continue...

/* Test3.java */

// Klasa InnerClass zagnieżdzona w klasie otaczającej
// Outer ma bezpośredni dostęp do metod i zmiennych
// klasy otaczającej Outer.

class Outer
{
  private int a = 1;
  private static int b = 2;
  
  private void printA()
  {
    System.out.println("a = " + a);
  }
  
  private static void printB()
  {
    System.out.println("b = " + b);
  }
  
  class InnerClass
  { 
    int x = a;
    int y = b;
    
    InnerClass()
    {
      printA();
      printB();
      System.out.println("x = " + x);
      System.out.println("y = " + y);
    }
  }
}

public class Test3
{
  public static void main(String[] args)
  {
    Outer outer = new Outer();
    Outer.InnerClass inner = outer.new InnerClass();
  }
}

a = 1
b = 2
x = 1
y = 2
Press any key to continue...

/* Test4 */

// Z obiektu klasy InnerClass zagnieżdzonej w klasie Outer
// możemy się dostać do obiektu klasy otaczającej Outer
// przez referencję Outer.this

class Outer
{
  int a = 1;
  
  class InnerClass
  {
    int a = 2;
    
    void info()
    {
      System.out.println("outer.a = " + Outer.this.a);
      System.out.println("inner.a = " + this.a); // lub samo a
    }
  }
}

public class Test4
{
  public static void main(String[] args)
  {
    Outer outer = new Outer();
    Outer.InnerClass inner = outer.new InnerClass();
    inner.info();
  }
}

outer.a = 1
inner.a = 2
Press any key to continue...

/* Test5.java */

// Z obiektu klasy InnerClass zagnieżdzonej w klasie Outer
// możemy się dostać do zmiennych i metod określonych w klasie
// bazowej Ojciec klasy Outer przez referencję Outer.super
// lub ((Ojciec)Outer.this)

class Ojciec
{
  int a = 1;
}

class Outer extends Ojciec
{
  int a = 2;
  
  class InnerClass
  {
    int a = 3;
    
    void info()
    {
      System.out.println("ojciec.a = " + Outer.super.a);
      System.out.println("ojciec.a = " + ((Ojciec)Outer.this).a);
      
      System.out.println("outer.a = " + Outer.this.a);
      System.out.println("inner.a = " + this.a); // lub a
    }
  }
}

public class Test5
{
  public static void main(String[] args)
  {
    Outer outer = new Outer();
    Outer.InnerClass inner = outer.new InnerClass();
    inner.info();   
  }
}

ojciec.a = 1
ojciec.a = 1
outer.a = 2
inner.a = 3
Press any key to continue...

/* Test6.java */

// Przykład klasy Test6, której metoda zwraca obiekt klasy 
// InnerClass zagnieżdżonej w klasie otaczającej Test6.

public class Test6
{
  class InnerClass
  {
    InnerClass()
    {
      System.out.println("Test6.InnerClass()");
    }
  }
  
  InnerClass getInner()
  {
    return new InnerClass();
  }
  
  public static void main(String[] args)
  {
    Test6 outer = new Test6();
    Test6.InnerClass inner = outer.getInner();
  }
}

Test6.InnerClass()
Press any key to continue...

/* Test7.java */

// Dziedziczenie po klasie zagnieżdzonej 1

// Jeśli klasa Test7 dziedziczy po klasie InnerClass
// zagnieżdzonej w klasie Ojciec, to obiekt klasy Test7
// musi zostać połączony z obiektem klasy Ojciec, która 
// otacza klasę zagnieżdzoną InnerClass.

class Ojciec
{
  class InnerClass
  {
    InnerClass()
    {
      System.out.println("Ojciec.InnerClass()");
    }
  }
}

public class Test7 extends Ojciec.InnerClass
{
  Test7(Ojciec dad)
  { 
    dad.super(); // połączenie z obiektem klasy Ojciec
    System.out.println("Test7(Ojciec dad)");
  }
  
  public static void main(String[] args)
  {
    Ojciec dad = new Ojciec();
    new Test7(dad);
  }
}

Ojciec.InnerClass()
Test7(Ojciec dad)
Press any key to continue...

/* Test8.java */

// Dziedziczenie po klasie zagnieżdzonej 2

// Jeśli klasa LowerInnerClass zagnieżdżona w klasie Test8
// dziedziczy po klasie UpperInnerClass zagnieżdżonej 
// w klasie bazowej Ojciec klasy Test8, to obiekt klasy
// LowerInnerClass zagnieżdżonej w klasie Test8 jest 
// automatycznie łączony z obiektem klasy bazowej 
// Ojciec klasy Test8.

class Ojciec
{
  class UpperInnerClass
  {
    UpperInnerClass()
    {
      System.out.println("Ojciec.UpperInnerClass()");
    }
  }
}

public class Test8 extends Ojciec
{
  class LowerInnerClass extends Ojciec.UpperInnerClass
  {
    LowerInnerClass()
    {
      System.out.println("Test8.LowerInnerClass()");
    }
  }
  
  public static void main(String[] args)
  {
    new Test8().new LowerInnerClass();
  }
}

Ojciec.UpperInnerClass()
Test8.LowerInnerClass()
Press any key to continue...

/* Test9.java */

// Klasy zagnieżdzone pozwalają na realizację
// wielokrotnego dziedziczenia.

class Ojciec
{
  void metodaOjca()
  {
    System.out.println("Ojciec.metodaOjca()");
  }
}

class Matka
{
  void metodaMatki()
  {
    System.out.println("Matka.metodaMatki()");
  }
}

public class Test9 extends Ojciec
{
  class InnerClass extends Matka
  {
    
  }

  public static void main(String[] args)
  {
    Test9 outer = new Test9();
    Test9.InnerClass inner = outer.new InnerClass();
    outer.metodaOjca();
    inner.metodaMatki();
    ((Ojciec)outer).metodaOjca();
    ((Matka)inner).metodaMatki();
  }
}

Ojciec.metodaOjca()
Matka.metodaMatki()
Ojciec.metodaOjca()
Matka.metodaMatki()
Press any key to continue...

/* Test10.java */

// Ten sam program, ale zrealizowany przy
// pomocy anonimowych klas zagnieżdzonych.

class Ojciec
{
  void metodaOjca()
  {
    System.out.println("Ojciec.metodaOjca()");
  }
}

class Matka
{
  void metodaMatki()
  {
    System.out.println("Matka.metodaMatki()");
  }
}

public class Test10 extends Ojciec
{
  Matka getMatka()
  {
    return new Matka() {};
  }

  public static void main(String[] args)
  {
    Test10 outer = new Test10();
    outer.metodaOjca();
    outer.getMatka().metodaMatki();
    ((Ojciec)outer).metodaOjca();
    ((Matka)outer.getMatka()).metodaMatki();
  }
}

Ojciec.metodaOjca()
Matka.metodaMatki()
Ojciec.metodaOjca()
Matka.metodaMatki()
Press any key to continue...

/* Test11.java */

// Przykład zagnieżdzonej klasy anonimowej, 
// która dziedziczy po interfejsie Interface.

interface Interface
{
  void metoda();
}

public class Test11
{
  Interface createInner()
  {
    return new Interface()
    {
      public void metoda()
      {
        System.out.println("Interface.metoda()");
      }
    };
  }
  
  public static void main(String[] args)
  {
    Test11 outer = new Test11();
    Interface inner = outer.createInner();
    inner.metoda();
  }
}

Interface.metoda()
Press any key to continue...

/* Test12.java */

// Przykład zagnieżdzonej klasy anonimowej,
// która dziedziczy po klasie Ojciec.

class Ojciec
{
  void metoda()
  {
    System.out.println("Ojciec.metoda()");
  }
}

public class Test12
{
  Ojciec createInner()
  {
    return new Ojciec()
    {
      
    };
  }
  
  public static void main(String[] args)
  {
    Test12 outer = new Test12();
    Ojciec inner = outer.createInner();
    inner.metoda();
  }
}

Ojciec.metoda()
Press any key to continue...

/* Test13.java */

// Inny przykład zagnieżdzonej klasy anonimowej, 
// która dziedziczy po klasie Ojciec.

class Ojciec
{
  Ojciec(int x)
  {
    System.out.println("Ojciec(" + x + ")");
  }
}

public class Test13
{
  Ojciec createInner(int x)
  {
    return new Ojciec(x)
    {
      
    };
  }
  
  public static void main(String[] args)
  {
    Test13 outer = new Test13();
    Ojciec inner = outer.createInner(1);
  }
}

Ojciec(1)
Press any key to continue...

/* Test14.java */

// Przykład zagnieżdżonej klasy anonimowej,
// która inicjuje zmienne obiektowe wartościami
// zmiennych lokalnych.

// Jeśli zmienne obiektowe klasy anonimowej
// inicjowane są zmiennymi lokalnymi,
// to zmienne lokalne muszą być ustalone.

class Ojciec
{
  
}

public class Test14
{
  Ojciec createInner(final int x)
  {
    return new Ojciec()
    {
      int a = x;
    };
  }
  
  public static void main(String[] args)
  {
    Test14 outer = new Test14();
    Ojciec inner = outer.createInner(1);
  }
}

Press any key to continue...

/* Test15.java */

// Przykład zagnieżdżonej klasy anonimowej z pseudokonstruktorem.

class Ojciec
{
  
}

public class Test15
{
  Ojciec createInner(final int x)
  {
    return new Ojciec()
    {
      int a;
      {
        if (x != 0) a = x;
        System.out.println("a = " + a);
      }
    };
  }
  
  public static void main(String[] args)
  {
    Test15 outer = new Test15();
    Ojciec inner = outer.createInner(1);
  }
}

a = 1
Press any key to continue...

/* Test16.java */

// Klasa StaticClass wewnętrzna w klasie otaczającej Test16
// ma bezpośredni dostęp do metod i zmiennych statycznych
// klasy otaczającej Test16.

// Klasy wewnętrzne mogą mieć zawartość statyczną, ale nie mają
// dostępu do zmiennych i metod obiektowych klasy otaczającej.

public class Test16
{
  private static int a = 1;
  private static int b = 2;
  
  private static void metodaStatyczna()
  {
    System.out.println("a = " + a);
    System.out.println("b = " + b);
  }
  
  static class StaticClass // klasa wewnętrzna
  {
    int x = a;
    static int y = b;
    
    StaticClass()
    {
      metodaStatyczna();
      System.out.println("x = " + x);
      System.out.println("y = " + y);
    }
  }
  
  public static void main(String[] args)
  {
    new StaticClass();
  }
}

a = 1
b = 2
x = 1
y = 2
Press any key to continue...

Strona główna