Java internal classes are divided into 4 types:
1) Static internal classes: Classes modified by static are called static classes. Putting static classes inside a class is called static internal classes
Features: Can access the outside world: static methods /Static properties, cannot access instance resources
Case:
import inner.Foo.Koo;//Be sure to import the Koo static inner class
public class Demo9 {
public static void main(String[] args) {
Koo koo = new Koo();
koo.add();
}
}
class Foo{
int a = 12;//Instance variable
static int aa=16;
public static void show(){ System.out.println("static method");}
//static inner class
static class Koo{
public void add(){
// System.out .println(a); Static inner classes cannot access instance resources (variables)
System.out.println(aa);
show();//Static inner classes can access static properties and methods of the outside world
}
}
}
2) Member inner class: Inside a class, a class without static modification is directly defined. When creating a member inner class object, the outer class must be created first.
Features: member inner class, can access external properties and methods
Case:
import inner.Foo1.Koo1;
public class Demo10 {
public static void main(String[] args) {
/ /Koo1 koo1 = new Koo1(); To create a member inner class, you must first create an external class object
Foo1 foo1 = new Foo1();
//Remember (written examination)
Koo1 koo1 = foo1. new Koo1();
koo1.show();
}
}
class Foo1{
int a =12;
static int aa = 16;
class Koo1{
void show() {
System.out.println(a+" , "+aa);
}
}
}
3) Local internal classes: very rarely used, characterized by defining a class within a method (enterprise development Medium and rarely used)
Features: local inner class, when referencing external variables, the variable must be modified with final
Case:
public class Demo11 {
public static void main(String[] args) {
final int a = 12;
final int b = 13;
class Foo2{
int c = 16;
public int add(){
//In the local inner class, refer to external variables , then the variable must be modified with final
return a+b+c;
}
}
Foo2 foo2 = new Foo2();
System.out.println(foo2.add());
}
}
4) Anonymous inner class: an inheritance of the original class
Features: used in combination with interfaces/abstract classes
eg new class name/interface name {
overridden method
};
Case:
public class Demo1 {
public static void main(String[] args) {
Koo koo = new Koo(){
// You can override the method
public String toString() {
Return "A Koo object is generated";
}
// New methods cannot be created in anonymous inner classes
// public void show(){
// System.out.println( "liu");
// }
};
System.out.println(koo);
// koo.show();
}
}
class Koo{
}
For more java internal classes and anonymous internal classes related articles, please pay attention to the PHP Chinese website!