Pourquoi java autorise la classe finale A {classe abstraite B {}}

En java, il est décidé qu'une classe avec une méthode abstraite sera toujours une classe abstraite (ou une interface). ** Cependant, une classe avec une classe interne abstraite peut être une classe concrète.

Par exemple, le code suivant est exécutable.

java

final class A
{
    static abstract class B{String str="hoge";}
}

public class Main
{
    public static void main(String...args)
    {
        System.out.println(new A_B().str);
      //System.out.println(new A.B(){}.str); (Classe anonyme)Mais c'est bien
    }
} 

class A_B extends A.B{}

Si la classe concrète n'a pas de classe interne abstraite

Bien que ce soit une hypothèse apparemment contradictoire, considérez le cas où vous ne voulez pas reconnaître la diversité dans le macro (tout), mais vous voulez reconnaître la diversité dans le micro (détails).

De telles hypothèses sont utiles lors de l'examen de la relation entre micro et macro, comme la dynamique statistique.

Par exemple, supposons que vous créez une classe ʻAir (air) et une classe Molecule` (molécule).

On peut dire que «l'air» a une «molécule []» parce que les molécules se rassemblent pour produire de l'air.

Diverses molécules telles que la molécule d'hydrogène, la molécule d'eau, la molécule de dioxyde de carbone, etc. peuvent être envisagées. Donc, H2 extends Molecule, H2O extends Molecule, CO2 extends Molecule En héritant et en l'utilisant comme ça, il n'y a pas de molécule appelée «simple molécule», donc je ne pense pas qu'elle sera utilisée sans en hériter. Ainsi, "Molecule" est probablement une classe abstraite.

D'un autre côté, je ne veux pas en faire une classe abstraite car il est difficile de penser à des concepts subordonnés dans ʻAir`.

Ici, si vous voulez définir une méthode dans ** Molecule que vous voulez seulement être appelée par ʻAir` ** et si?

Habituellement, cela peut être résolu en faisant de «Molecule» la classe interne de «Air». Si la classe concrète ʻAir n'a pas la classe abstraite Molecule` à l'intérieur, vous devrez probablement faire les choses fastidieuses suivantes:

1. Avoir la classe statique publique finale $ {private $ () {}} dans ʻAir`
2. Donnez à la méthode Something un argument ʻAir. $` Type

Réalisez avec.

Puisque le type ʻAir. $ Est public static et peut être vu depuis un autre que ʻAir, il peut être utilisé comme type d'argument formel pour les méthodes de classes autres que ʻAir. Cependant, puisque son constructeur est «privé», l'instanciation ne peut être effectuée qu'à partir de «Air». Autre que ʻAir, c'est-à-dire ʻAir. $ `Les arguments réels de type ne peuvent pas être passés.

Grâce à cela, "si une méthode a un type ʻAir. $ Comme argument formel, cette méthode ne peut être appelée qu'à partir de la classe ʻAir "est établie.

Un exemple est présenté ci-dessous.

python

public class Test2 {

	public static void main(String[] args) 
	{

        //new H2O.only_for_air(new Air.$());Est une erreur d'autorisation d'accès. En d'autres termes, uniquement depuis l'Air_for_Je ne peux pas appeler l'air
		new Air().molecule_caller(new H2O());//Peut être appelé depuis Air

	}

}



class Air
{
	final public static class ${private $(){}}//Finalisé car ce serait un problème même s'il était réécrit dans la classe enfant d'Air
	
	void molecule_caller(Molecule m)
	{
		new H2O().only_for_air(new Air.$());
	}
	
	
}

abstract class Molecule
{
	void only_for_air(Air.$ $)
	{
		System.out.println("succeeded");
	}
}


class H2O extends Molecule{}

Eh bien, je dois faire une chose si gênante.

Je me suis donc demandé si "une classe concrète avec une classe interne abstraite" serait possible en java.