Quels sont les objectifs de classes internes

Une utilisation classique pour un intérieur de classe est la mise en œuvre d'un itérateur à l'intérieur d'un conteneur (ArrayList, par exemple - look pour class Itr). Tous les conteneurs veut exposer au reste du monde est une Iterator. Cependant, il a de créer de quelques cas concrets de mise en œuvre de cet itérateur, probablement familier avec le fonctionnement interne du conteneur. À l'aide d'un intérieur de classe se cache la mise en œuvre, tout en le gardant près du conteneur de mise en œuvre. Et d'être intérieure (non statique), il est lié à une instance spécifique de ce conteneur, ce qui permet de l'accès privé conteneur membres.

Il y a quelques types de classes internes - non-statique de la classe imbriquée, classes locales et anonyme des classes. Chacun a un peu différente but, donc quand on parle d'un intérieur de classe, vous devez spécifier quel type êtes-vous en train de parler.

En supposant que vous faites référence à des non-statique à l'intérieur des classes, je dirais que la raison de leur utilisation est la même que l'utilisation des classes régulières (à savoir l'abstraction et de diviser le code en unités logiques), mais il n'y a aucune raison de faire usage de classes visibles par le reste du monde. Vous pouvez également faire des classes imbriquées public, bien sûr, dans ce cas, vous le rendrais imbriquée à la place des indépendants dans le but d'exprimer leur relation étroite avec l'extérieur de la classe.

En règle générale, objets devrait être conçu pour un seule responsabilité (Très cohérente). En d'autres termes, n'importe quel objet bien conçu, doit effectuer une unique et cohérent de tâches. Ce serait considéré comme une bonne pratique pour la conception orientée objet.

Parfois, cependant, un développeur peut concevoir une classe qui nécessite un séparé spécialisé classe pour travailler. Cette spécialisé classe pourrait être considéré comme un de la classe helper.

Si le helper classe est pas utilisé par une autre classe, alors il serait considéré comme un premier candidat comme un intérieur de la classe

Provoquée par des ncmathsadist ci-dessus, un exemple de l'intérieur de la classe serait dans la mise en œuvre de gestionnaires d'Événements.

Par exemple, dans la conception d'une interface utilisateur graphique (GUI), un développeur peut avoir créé un bouton que effectue un particulier tâche après que l'utilisateur appuie sur elle.

Le bouton aurait besoin d'un gestionnaire d'événement qui écoute pour quand ce bouton est pressé.

Dans ce cas, la création du gestionnaire d'événement pour le bouton comme intérieur de la classe serait meilleures pratiques comme l'intérieur de la classe ne serait pas être utilisé n'importe où d'autre que le bouton spécifique au sein de l'interface de la classe.

Si vous trouvez qu'il y a assez de code qui pourrait être fait de mieux en classe en tant que classe offre à nous préciser les stats et
comportement avec les champs et les méthodes, et vous ne voulez pas que cette classe doit être utilisée à l'extérieur de la classe englobante. vous devriez utiliser l'intérieur de la classe.

Ici l'intérieur de la classe est caché du monde extérieur.
Intérieur de la classe peuvent accéder au privé des membres de la classe englobante, ce qui nous donne de l'encapsulation.

Permettez-moi de donner l'exemple..
Supposons que vous voulez réglez la vitesse de cycle et vous avez une règle d'entreprise comme il y a seulement jusqu'à 6 rapports.
Ainsi, vous pouvez créer Intérieure de la Classe de Cycle qui aurait une méthode pour définir la vitesse.
Cette partie de la méthode de validation qui sont vérifiées avant le réglage de la vitesse.comme le cycle est en cours d'exécution...des engins de nombre est inférieur à 6...

meilleur exemple est la gestion des événements de code utilise les classes internes(parfois anonymes inner classes), de créer des événements et les écouteurs sans créer d'Événement distinct de l'Objet et de l'Écouteur d'Événement classes pour votre événement..

Disons que vous avez un type et sa classe, appelée OuterClass, dans un package nommé "com.la coutume.les classes".

Puis ici, c'est la façon dont vous commencez à avoir besoin d'un intérieur de classe ou de classe statique:

Cas 1:

1. vous avez besoin pour l'emballage d'un groupe de classes
2. mais aussi le type de besoin de certaines variables globales exposé à toutes ces classes à l'ensemble des
3. vous comprenez que vous ne peut pas faire ce genre de choses avec des paquets, mais de réaliser qu'il pouvait y arriver avec l'héritage, où les parents membres de la classe peuvent agir comme des variables globales qui deviennent disponibles pour l'ensemble de son enfant instances de classe.
4. mais vous n'aimez pas l'idée que vous avez besoin d'hériter de la classe parent et aussi que vous avez besoin d'instancier la classe enfant pour accéder aux variables globales. C'est comme demander à acheter un café pour prendre un café.
5. et si vous vous rendez compte que vous pouvez créer un OuterClass avec les membres statiques de maison et de toutes les classes dans ce OuterClass comme l'intérieur de la classe ou de classe statique comme il faut et voilà! Le OuterClass membres statiques disponibles en tant que variables globales pour ces classes imbriquées et vous pourriez même avoir accès sans l'instanciation d'eux.

Ce code doit mieux expliquer

public class InnerClassTester{
  public static void main(String []args){

    //without the need to instantiate any class
    //static class without instantiation
    System.out.println(OuterClass.NestedStaticClass1.incrGlobalNum()); //outputs 1

    //static class instantiated
    OuterClass.NestedStaticClass2 koolObj = new OuterClass.NestedStaticClass2();
    //works with instantiation as well
    System.out.println(koolObj.incrGlobalNum()); //outputs 2

    //inner classes always need to be instantiated
    //and they can only be instantiated from within an instance of outer class
    //think of them as instance member of outer class and this would make sense
    OuterClass.NestedInnerClass1 koolObj2 = new OuterClass().new NestedInnerClass1();
    //works with inner classes as well
    System.out.println(koolObj2.incrGlobalNum()); //outputs 3
 }
}

class OuterClass{
    //global variable thats only accessible for select classes (or nested classes)
    //we also learn a purpose for private static fields
    private static int privateGlobalValue = 0;

    //classes to be grouped
    //static class
    public static class NestedStaticClass1{
        //no need to instantiate this class to access/update the global value
        public static int incrGlobalNum(){
            return ++privateGlobalValue;
        }
    }

    public static class NestedStaticClass2{
        //instantiate and still manipulate the global value
        public int incrGlobalNum(){
            return ++privateGlobalValue;
        }
    }

    //inner class
    public class NestedInnerClass1{
        //instantiate and still manipulate the global value
        public int incrGlobalNum(){
            return ++privateGlobalValue;
        }
    }

}

Ne vous rappelle closures en Javascript ? 🙂

---

La plupart des applications de classes imbriquées voir ce qu'il s'applique sur la base de décisions de conception. Ce qui signifie que, tous les cas d'une classe imbriquée peut être remplacé par d'autres modèles.

Mais après avoir dit cela, il est également vrai que l'on peut aussi remplacer le modèle d'héritage avec la composition de motif (et il prend de l'ampleur ces derniers temps) bien qu'un modèle d'héritage est certainement mieux lorsque les dépendances entre les classes est tellement vrai que la composition de l'dépendances entièrement serait laid.

Cas 2:

1. vous avez besoin pour mettre en œuvre 2 interfaces, IShark et IMosquito, avec la même signature, un public morsure de la méthode, sur la OuterClass.
2. mais vous voulez afficher 2 messages différents depuis un requin de la morsure est un peu différente de celle d'un moustique.
3. cependant, vous savez que c'est pas possible, car une seule morsure méthode peut être mise en œuvre
4. vous savez que vous pouvez créer 2 classes différentes dans le même package que en œuvre des interfaces et également de mettre en œuvre distincte mordre les méthodes et les ont composé dans OuterClass.
5. mais vous avez voulu le faire à l'intérieur de OuterClass parce que c'était votre décision de conception pour encapsuler la morsure de comportement à l'intérieur d'elle, peut-être parce qu'il y a une dépendance sur une variable privée au sein de la classe.
6. dès que vous réalisez que vous pouvez mettre en œuvre à la fois les interfaces via statique privée les classes internes et de le faire apparaître sur le monde extérieur, comme si elle était composée.

Prendre un coup d'oeil à ce code:

//no additional classes in the package

public class InterfaceTester{

     public static void main(String []args){

        //same class returns 2 instances - both compliant to 
        //either interfaces and yet different output

        IShark shark = OuterClass.getSharkInstance();
        System.out.println(shark.bite()); //outputs "Die fast bosedk!"

        IMosquito mosquito = OuterClass.getMosquitoInstance();
        System.out.println(mosquito.bite()); //outputs "Die slow bosedk!"
     }

}

interface IShark{
    public String bite();
}

interface IMosquito{
    public String bite();
}

class OuterClass implements IShark{

    //dependency of inner class on private variable
    private static String dieSlow = "Die slow bosedk!";
    private static String dieFast = "Die fast bosedk!";

    private static OuterClass outerInst;
    private static InnerClass innerInst;

    //private constructor to stop regular instantiation
    private OuterClass(){}

    //get a shark !
    public static IShark getSharkInstance(){
        return outerInst != null ? outerInst : new OuterClass();
    }

    //get a mosquito !
    public static IMosquito getMosquitoInstance(){
        return innerInst != null ? innerInst : new InnerClass();
    }
    //an implementation of bite
    public String bite(){
        return dieFast;
    }

    //inner class that implements the second interface
    private static class InnerClass implements IMosquito{
        //different implementation of bite
        public String bite(){
            return dieSlow;
        }
    }

}

Ce genre de décision de conception, les cas sont nombreux et toutes les réponses ci-dessus une liste de plusieurs de ces cas. Donc, il ne serait pas faux de penser que cette fonctionnalité a été introduite plus comme un nouveau motif qu'en tant que fonction ou fonctionnalité.

Je voudrais juste considérer que c'est juste une caractéristique de la langue. Je recommande de ne pas l'utiliser si nous adoptons des CRUES et à obéir au principe SOLIDE.