(2) Accès aux variables d'instance définies dans les classes externes

Outer.java

public class Outer {
    private int foo;

    public class Inner {
        public int bar;
        private void method() {
            this.foo = Outer.this.bar;   // OK
        }
    }

    private void method() {
        this.foo = bar;                  // NG
    }
}

En outre, la priorité d'instance des classes internes non statiques est

• Variable locale de l'appelant

• Variable d'instance de classe interne
• Variables d'instance de classe externes

Outer.java

public class Outer {
	String foo = "outerclass-a";
	String bar = "outerclass-b";
	String baz = "outerclass-c";

	public class Inner {
		String foo = "innerclass-a";
		String bar = "innerclass-b";

		public void thread() {
			String foo = "thread-c";

			System.out.println(foo);
			System.out.println(bar);
			System.out.println(baz);

			System.out.println(this.foo);
			System.out.println(Outer.this.foo);
		}
	}

	public static void main(String... args) {
		new Outer().new Inner().thread();
	}
}

Résultat d'exécution.java

thread-c
innerclass-b
outerclass-c
innerclass-a
outerclass-a

Classe anonyme (classe anonyme, classe interne anonyme)

Lors de l'utilisation d'une classe imbriquée, elle peut être utilisée comme classe sans nom Ces classes imbriquées sont appelées "classes anonymes"

Principalement utilisé aux fins suivantes

• ① Lorsque la réutilisabilité du traitement est faible et qu'il n'est nécessaire que sur place
• ② Lorsque le code de traitement est court mais qu'il y a beaucoup de personnalisation

Classe anonyme-Syntaxe 1.text

nouveau nom de type() {
Implémentation de méthodes abstraites
}

Classe anonyme-Syntaxe 2.text

Nom du type Nom de l'instance=nouveau nom de type() {
Implémentation de méthodes abstraites
}

Tout d'abord, implémentez la méthode abstraite de l'interface sans utiliser la classe anonyme.

Sample.java

interface FooInterface {                           //interface
	void method();                                 //abstract method
}

class BarClazz implements FooInterface {           //implemented class
	public void method() {
		System.out.println("Did Implementation");  //implemented abstract method
	}
}

public class Sample{                               //runner
	public static void main(String... args) {
		new BarClazz().method();                   //new instance
	}
}

Lors de l'implémentation d'une méthode abstraite à l'aide d'une classe anonyme

Sample.java

interface FooInterface {
	void method();
}
                                                            //nothing inplemented class
public class Sample {
	public static void main(String... args) {
		FooInterface foo = new FooInterface() {				//anonymous class
			public void method() {
				System.out.println("Did Implementation");	//implemented abstract method
			}
		};													//semi-coron
		foo.method();										//instance.method()
	}
}

Résultat d'exécution.java

Did Implementation

Exemple pratique de classe anonyme

Prenons un exemple pratique de classe anonyme

① Lorsque la réutilisabilité du traitement est faible et qu'il n'est nécessaire que sur place

Définir une classe qui gère les informations client

ManagementClientInformation.java

public class ManagementClientInformation {
	public static class Client {
		private int id;
		private String name;

		Client(int id, String name) {
			this.id = id;
			this.name = name;
		}

		public int getId() {
			return this.id;
		}

		public String getName() {
			return this.name;
		}
	}

	public static void main(String... args) {
		List<Client> clientList = new ArrayList<>();
		clientList.add(new Client(1, "matsuda"));
		clientList.add(new Client(2, "tanaka"));
		clientList.add(new Client(3, "neko"));
		clientList.stream()
				.forEach(x -> System.out.println(x.getId() + " " + x.getName()));
	}
}

Résultat d'exécution.java

1 matsuda
2 tanaka
3 neko

Considérez les événements suivants

Vous êtes ingénieur système Il y avait une demande d'un client lors de la maintenance / réparation Il y a une demande pour trier un certain écran dans l'ordre inverse de l'identifiant client De plus, il est interdit de modifier la classe Client en raison de problèmes d'impact sur le système et de ballonnement.

⇒ Utiliser une classe anonyme

ManagementClientInformation.java

public class ManagementClientInformation {
	public static class Client {
		private int id;
		private String name;

		Client(int id, String name) {
			this.id = id;
			this.name = name;
		}

		public int getId() {
			return this.id;
		}

		public String getName() {
			return this.name;
		}
	}

	public static void main(String... args) {
		List<Client> clientList = new ArrayList<>();
		clientList.add(new Client(1, "matsuda"));
		clientList.add(new Client(2, "tanaka"));
		clientList.add(new Client(3, "neko"));

		Collections.sort(clientList, new Comparator<Client>() {
			public int compare(Client c1, Client c2) {
				return Integer.compare(c2.getId(), c1.getId());
			}
		});

		clientList.stream()
				.forEach(x -> System.out.println(x.getId() + " " + x.getName()));
	}
}

Résultat d'exécution.java

3 neko
2 tanaka
1 matsuda

À la fin

Quand j'ai touché l'API Stream pour la première fois, je ne comprenais pas du tout le contenu. Pendant que je le faisais, j'ai progressivement approfondi ma compréhension en apprenant la méthode de référence ⇒ expression lambda ⇒ conception générique dans l'ordre inverse. Je voudrais l'appliquer après avoir bien compris la partie de base.