1. When using anonymous internal classes, we must inherit a class or implement an interface, but we can't have both. At the same time, we can only inherit a class or implement an interface.
2. Constructors cannot be defined in anonymous inner classes.
3. No static member variables or static methods can exist in an anonymous inner class.
4. Anonymous inner classes are local inner classes, so all restrictions on local inner classes also apply to anonymous inner classes.
5. Anonymous inner classes cannot be abstract. They must implement all abstract methods of inherited classes or implemented interfaces.
Define anonymous inner classes
public class HelloWorldAnonymousClasses {
/**
* HelloWorld interface with two methods
*/
interface HelloWorld {
public void greet();
public void greetSomeone(String someone);
}
public void sayHello() {
// 1. The local class EnglishGreeting implements the HelloWorld interface
class EnglishGreeting implements HelloWorld {
String name = "world";
public void greet() {
greetSomeone("world");
}
public void greetSomeone(String someone) {
name = someone;
System.out.println("Hello " + name);
}
}
HelloWorld englishGreeting = new EnglishGreeting();
// 2. Anonymous classes implement the HelloWorld interface
HelloWorld frenchGreeting = new HelloWorld() {
String name = "tout le monde";
public void greet() {
greetSomeone("tout le monde");
}
public void greetSomeone(String someone) {
name = someone;
System.out.println("Salut " + name);
}
};
// 3. Anonymous classes implement the HelloWorld interface
HelloWorld spanishGreeting = new HelloWorld() {
String name = "mundo";
public void greet() {
greetSomeone("mundo");
}
public void greetSomeone(String someone) {
name = someone;
System.out.println("Hola, " + name);
}
};
englishGreeting.greet();
frenchGreeting.greetSomeone("Fred");
spanishGreeting.greet();
}
public static void main(String... args) {
HelloWorldAnonymousClasses myApp = new HelloWorldAnonymousClasses();
myApp.sayHello();
}
}
public class HelloWorldAnonymousClasses {
/**
* HelloWorld interface with two methods
*/
interface HelloWorld {
public void greet();
public void greetSomeone(String someone);
}
public void sayHello() {
// 1. The local class EnglishGreeting implements the HelloWorld interface
class EnglishGreeting implements HelloWorld {
String name = "world";
public void greet() {
greetSomeone("world");
}
public void greetSomeone(String someone) {
name = someone;
System.out.println("Hello " + name);
}
}
HelloWorld englishGreeting = new EnglishGreeting();
// 2. Anonymous classes implement the HelloWorld interface
HelloWorld frenchGreeting = new HelloWorld() {
String name = "tout le monde";
public void greet() {
greetSomeone("tout le monde");
}
public void greetSomeone(String someone) {
name = someone;
System.out.println("Salut " + name);
}
};
// 3. Anonymous classes implement the HelloWorld interface
HelloWorld spanishGreeting = new HelloWorld() {
String name = "mundo";
public void greet() {
greetSomeone("mundo");
}
public void greetSomeone(String someone) {
name = someone;
System.out.println("Hola, " + name);
}
};
englishGreeting.greet();
frenchGreeting.greetSomeone("Fred");
spanishGreeting.greet();
}
public static void main(String... args) {
HelloWorldAnonymousClasses myApp = new HelloWorldAnonymousClasses();
myApp.sayHello();
}
}
1 Hello world
2 Salut Fred
3 Hola, mundoSyntax of anonymous inner classes
HelloWorld frenchGreeting = new HelloWorld() {
String name = "tout le monde";
public void greet() {
greetSomeone("tout le monde");
}
public void greetSomeone(String someone) {
name = someone;
System.out.println("Salut " + name);
}
};Access local variables within the scope, define and access anonymous inner class members
Anonymous inner classes and local classes have the same access rights to variables in the scope.
(1) Anonymous inner class can access all members in the external class;
(2) . anonymous internal classes cannot access variables without final modification of external classes (Note: JDK1.8 can be accessed even without final modification);
(3) . attribute shielding is the same as embedded classes. The types defined by anonymous inner classes (such as variables) will shield other types (variables) with the same name within their scope:
Case 1: attribute shielding of embedded classes:
public class ShadowTest {
public int x = 0;
class FirstLevel {
public int x = 1;
void methodInFirstLevel(int x) {
System.out.println("x = " + x);
System.out.println("this.x = " + this.x);
System.out.println("ShadowTest.this.x = " + ShadowTest.this.x);
}
}
public static void main(String... args) {
ShadowTest st = new ShadowTest();
ShadowTest.FirstLevel fl = st.new FirstLevel();
fl.methodInFirstLevel(23);
}
}Static properties and methods cannot be defined in anonymous inner classes;
public class ShadowTest {
public int x = 0;
interface FirstLevel {
void methodInFirstLevel(int x);
}
FirstLevel firstLevel = new FirstLevel() {
public int x = 1;
public static String str = "Hello World"; // Compilation error
public static void aa() { // Compilation error
}
public static final String finalStr = "Hello World"; // normal
public void extraMethod() { // normal
// do something
}
};
}Anonymous classes are classes that cannot have names. They cannot be referenced. They can only be declared in new syntax when they are created
The case anonymous class inherits a parent class
The Ploygon class is created. This class has only one method, the display() method, and the AnonymousDemo class inherits Ploygon
Override the method of Ploygon class, display() method
class Polygon{
public void display(){
System.out.prinln("stay Poly Class interior")
}
}
class AnonymousDemo{
// Creating an anonymous class inherits the Polygon class
Polygon p1 = new Polygon(){
public void disPlay(){
System.out.println("Inside an anonymous class")
}
}
}