Era Java il primo linguaggio di programmazione a supportare le classi interne?

La prima lingua con classi nidificate era Beta , un successore di Simula . Sono ulteriormente trasferiti nel successore di Beta, gBeta . Un linguaggio moderno che li porta piuttosto lontano è Newspeak . Il nesting di Scala funziona anche molto simile a quello di Beta.

Le classi interne di Java sono ispirate a quelle di Beta ma (almeno secondo alcune persone che conoscono bene Beta e sono state anche coinvolte nella progettazione di Java) non ne acquisiscono completamente tutte le funzionalità. (Sto citando abbastanza liberamente qui, penso che la citazione attuale fosse qualcosa di più simile a "le persone che hanno progettato Java hanno provato a copiare classi annidate senza comprenderle").

Nota che nella tua domanda, usi il termine "definizioni di classi annidate", che è ambiguo: può significare "definizioni nidificate di classi" o può significare "definizioni di classi annidate". Nella mia risposta, suppongo che tu intenda il secondo, dal momento che richiami esplicitamente le classi interne di Java, che sono definizioni di classi annidate (con alcune avvertenze).

Esistono molti linguaggi che consentono di annidare una definizione di classe all'interno di un'altra definizione di classe, ma solo in pochissimi di questi linguaggi questo produce effettivamente una classe nidificata. Ad esempio, in Ruby:

class Foo
  class Bar; end
end

non produce una classe nidificata. Non esiste alcuna relazione tra le due classi e / o tra la classe Bar e le istanze della classe Foo . L'unica cosa che fa è associare la classe Bar a una costante denominata Bar namespace all'interno di Foo . L'articolo di Wikipedia è semplicemente sbagliato in cui è incluso Ruby nell'elenco. In alto, l'articolo definisce il significato n. 1 sopra, ma l'elenco in realtà è lingue che supportano il significato n. 2.

Una classe nidificata appropriata ha le seguenti proprietà:

• La classe interna è una proprietà di istanze della classe esterna, cioè la classe "nested" non è effettivamente nidificata all'interno della classe esterna, è nidificata all'interno di istanze della classe esterna, che significa anche che ogni istanza della classe esterna ottiene la propria copia della classe interna (almeno semanticamente). Ciò significa che a.Inner e b.Inner (supponendo a e b sono istanze di Outer ) sono non della stessa classe! (E la classe Outer.Inner non esiste.)
• Allo stesso modo, le istanze della classe interna sono nidificate all'interno delle corrispondenti istanze della classe esterna, sono visibili solo a quel singolo oggetto (a meno che non sia esportato, cioè restituito da un metodo pubblico).

Come Konrad Rudolph ha sottolineato nel suo commento, essere in grado di annidare lessicamente le definizioni di classe è una cosa semplice e ovvia che non è interessante in alcun modo.

C ++ ha classi annidate, e praticamente dal primo giorno