Campi a condivisione controllata con le inner-classes

Prima della versione 1.1 di Java, due oggetti appartenenti alla stessa classe avevano solo due possibilità rispetto alla condivisione di dati:

• Nessuna condivisione: campi istanza (public, private, protected o con visibilità package)
• Visibiltà globale per tutte le istanze della classe (campi static di classe)

 

public abstract class Shared{
    public abstract static void sharedMethod();
}

---

public class Class1{
  private Shared ref;
        ...
        public Class1(Shared ref){this.ref=ref;}
        public void method(){ref.sharedMethod();}
        ...
}

---

public class Class2{
  private Shared ref;
      ...
      public Class2(Shared ref){this.ref=ref;}
      public void method(){ref.sharedMethod();}
      ...
}

 

class Executor extends Shared{

public static void sharedMethod(){System.out.printf("Method of executor called!");}
}

...
Executor ex = new Executor();
Class1 c1 = new Class1(ex);
Class2 c2 = new Class2(ex);
...
c1.method();
c2.method();
...

• class (condiviso da tutti gli oggetti di una classe)
• instance (proprio del singolo oggetto)

• factory (proprio di tutti gli oggetti creati dalla stessa istanza di outer class).

• tutti i campi propri dell'oggetto factory
• tutti i campi statici della classe dell'oggetto factory.
• i metodi (statici e non) della particolare istanza della classe factory (o di una sua sottoclasse) con tutte le regole di polimorfismo applicate

Ogni outer class è, di fatto, una factory anche senza implementare un metodo come getGrouped: è infatti sufficiente vestire l'operatore new con il nome della outer class:
 

GroupFactory gf=new GroupFactory();
GroupFactory.Grouped = gf.new Grouped();

 

public class GroupFactory{
        int campo;
        …
        public class Grouped {
                int campo;

               public void m(){
       System.out.println("Inner: "+campo);
System.out.println("Outer: "+GroupFactory.this.campo);
                }
        }
}

• il metodo changeStatus() è comune a oggetti di classi diverse allocate nel contesto di una stessa istanza dell'Outer Class
• il metodo changeStatus() è diverso in oggetti appartenenti alla stessa classe creati da due istanze di Outer Class in rapporto di ereditarietà tra loro.

 

public class Factory {
    protected String SharedMethod(){
     return "Shared from 'Factory'";
    }

public class Inner1{
 String name;
  Inner1(String name){this.name=name;}
  public String getInnerName(){return "Inner1: '"+name+"'";}
  public final void method(){
    System.out.print(getInnerName());
    System.out.println(" - Behaviour: " + SharedMethod());
  }
}
 

public class Inner2{
  String name;
  Inner2(String name){this.name=name;}
  public String getInnerName(){return "Inner2: '"+name+"'";}
  public final void method(){

  System.out.print(getInnerName());
  System.out.println(" - Behaviour: " + SharedMethod());
}
}
}

In altre parole, potremmo definire polimorfismo incrociato (nel contesto di lunguaggi con ereditarietà singola), le capacita di istanziare:

• oggetti appartenenti alla stessa classe con comportamento parzialmente diversificato
• oggetti appartenenti a classi diverse con comportamento parzialmente condiviso.