四种内部类
在一个类或者一个方法中定义的类，叫内部类。
1.成员内部类
package com.dh.innerclass;
public class OuterClass {
//外部类可任意定义属性和方法（无限制）
public String name = "outer";
public static int age;
public void eat(){
System.out.println("吃饭");
}
public static void sleep(){
System.out.println("睡觉");
}
//-----------------------------------------------
//成员内部类，与成员属性和成员方法同一级别
// 可用四个权限符修饰，包括类、属性、方法
public class InnerClass{
//可定义属性和方法,并且可以与外部类重名
public String name = "inner";
//属性不可以用static修饰
// public static int age;
//定义内部类独有的属性
public char sex;
//与外部类重名的方法
public void eat(){
//内部类可以直接使用外部类的属性和方法（包含静态）
System.out.println(age);
sleep();
//方法中使用外部类和内部类相同的属时，就近原则，使用的是内部类的属性
System.out.println("内部类---吃饭");
//如果要使用外部类的同名属性，需要借助外部类
OuterClass outerClass = new OuterClass();
System.out.println(outerClass.name); //输出outer
}
//方法不可以用static修饰，所以内部类中不能有main方法
// public static void sleep(){
// System.out.println("内部类---睡觉");
// }
//内部类独有的方法
public void walk(){
System.out.println("内部类---散步");
}
}
public static void main(String[] args) {
//外部类直接实例化对象
OuterClass outerClass = new OuterClass();
//外部类可直接使用外部类的属性和方法
System.out.println(outerClass.name);
outerClass.eat();
//外部类不能使用内部类的属性和方法
//内部类需要借助外部类实例化对象
OuterClass.InnerClass innerClass = outerClass.new InnerClass();
//内部类可直接使用内部类的属性和方法
System.out.println(innerClass.sex);
innerClass.walk();
//内部类也不能直接使用父类的属性和方法，可以间接的在内部类的方法中使用
}
}
2.静态内部类
当成员内部类加上static修饰符的时候就变成了静态内部类。
成员内部类与静态内部类的区别：
- 成员内部类中不能使用static修饰变量和方法，静态内部类可以；
- 成员内部类可以直接访问外部类的任意属性和方法，包含static，静态内部类只能直接访问static修饰的变量和方法；
- 静态内部类可以通过对象访问外部类的非静态属性和方法，以及同名的方法。
- 成员内部类的实例化需要依靠外部类，静态内部类的实例化不需要依靠外部类。
package com.dh.innerclass;
public class OuterClass2 {
//外部类可任意定义属性和方法（无限制）
public String name = "outer";
public static int age;
public int num;
public void eat(){
System.out.println("吃饭");
}
public static void sleep(){
System.out.println("睡觉");
}
public void play(){
System.out.println("玩游戏");
}
//-----------------------------------------------
//成员内部类，与成员属性和成员方法同一级别
// 可用四个权限符修饰，包括类、属性、方法
public static class InnerClass{
//可定义属性和方法,并且可以与外部类重名
public String name = "inner";
//属性可以用static修饰
public static int age;
public char sex;
public void eat(){
//内部类中只能直接使用外部类中静态的属性和方法
//要使用非静态的，依靠外部类对象（如下同名属性）
System.out.println(age);
// System.out.println(num);
sleep();
// play();
//方法中使用外部类和内部类相同的属时，就近原则，使用的是内部类的属性
System.out.println("内部类---吃饭");
//如果要使用外部类的同名属性，需要借助外部类
OuterClass outerClass = new OuterClass();
System.out.println(outerClass.name); //输出outer
}
//方法可以用static修饰
public static void sleep(){
System.out.println("内部类---睡觉");
}
public void walk(){
System.out.println("内部类---散步");
}
}
public static void main(String[] args) {
//外部类直接实例化对象
OuterClass outerClass = new OuterClass();
//外部类可直接使用外部类的属性和方法
System.out.println(outerClass.name);
outerClass.eat();
//外部类不能使用内部类的属性和方法
//内部类 不需要 借助外部类实例化对象
InnerClass innerClass = new InnerClass();
//内部类可直接使用内部类的属性和方法
System.out.println(innerClass.sex);
innerClass.eat();
//内部类也不能直接使用父类的属性和方法，可以间接的在内部类的方法中使用
}
}
3.局部内部类
在成员方法中定义的类叫局部内部类。
与成员内部类和静态内部类最大的不同：局部内部类的实例化在局部内部类所在的成员方法中，而非main方法中。
package com.dh.innerclass;
public class OuterClass3 {
//外部类可任意定义属性和方法（无限制）
public String name = "outer";
public static int age;
public int num;
public void eat() {
System.out.println("吃饭");
}
public static void sleep() {
System.out.println("睡觉");
}
public void play() {
System.out.println("玩游戏");
}
public void innerClass() {
//成员方法也可以定义局部变量，可与内部类和外部类重名
int age = 3;
//在成员方法中定义的类叫局部内部类
//只能使用默认的default修饰局部内部类
class InnerClass {
//可定义属性和方法,并且可以与外部类重名
//属性和方法可以用四个权限修饰符修饰
String name = "inner";
//属性不可以用static修饰
// public static int age;
public char sex;
public void eat(int age) {
//通过方法参数访问成员方法中的局部参数
System.out.println(age);
//内部类可以直接使用外部类的属性和方法（包含静态）
//因为方法中有一个age，所以不能直接访问外部类的age，要指明是外部类的
System.out.println(OuterClass3.age);
System.out.println(num);
sleep();
play();
//方法中使用外部类和内部类相同的属时，就近原则，使用的是内部类的属性
System.out.println("内部类---吃饭");
//如果要使用外部类的同名属性，需要借助外部类
OuterClass outerClass = new OuterClass();
System.out.println(outerClass.name); //输出outer
}
//方法不可以用static修饰
// public static void sleep(){
// System.out.println("内部类---睡觉");
// }
public void walk() {
System.out.println("内部类---散步");
}
}
//直接在成员方法中实例化内部类对象
InnerClass innerClass = new InnerClass();
//可以调用内部类的属性和方法
System.out.println(innerClass.name);
innerClass.walk();
//访问外部类的属性和方法
System.out.println(OuterClass3.this.name);
OuterClass3.this.play();
}
public static void main(String[] args) {
//外部类直接实例化对象
OuterClass outerClass = new OuterClass();
//外部类可直接使用外部类的属性和方法
System.out.println(outerClass.name);
outerClass.eat();
//外部类不能使用内部类的属性和方法
//内部类的实例化在内部类所在的成员方法中
}
}
4.匿名内部类
通过接口或者抽象类和外部类实现，不能实例化对象。
package com.dh.innerclass;
//定义一个接口
interface A{
public void show();
}
public class OuterClass4 {
//外部类可任意定义属性和方法（无限制）
public String name = "outer";
public static int age;
public int num;
public void eat() {
System.out.println("吃饭");
}
public static void sleep() {
System.out.println("睡觉");
}
public void play() {
System.out.println("玩游戏");
}
//在外部类书写一个方法，参数为接口，里面调用接口的方法
public void show(A a){
a.show();
}
public static void main(String[] args) {
//匿名内部类
new OuterClass4().show(
//-------------------------------------------------------------------------------------
new A() {
//可定义属性和方法,并且可以与外部类重名
public String name = "inner";
//属性不可以用static修饰
// public static int age;
public char sex;
public void eat(){
//内部类中只能直接使用外部类中静态的属性和方法
//要使用非静态的，依靠外部类对象（如下同名属性）
System.out.println(age);
// System.out.println(num);
sleep();
// play();
//方法中使用外部类和内部类相同的属时，就近原则，使用的是内部类的属性
System.out.println("内部类---吃饭");
//如果要使用外部类非静态的属性、方法和同名属性，需要借助外部类
OuterClass outerClass = new OuterClass();
System.out.println(outerClass.name); //输出outer
}
//方法不可以用static修饰，所以内部类中不能有main方法
// public static void sleep(){
// System.out.println("内部类---睡觉");
// }
public void walk(){
System.out.println("内部类---散步");
}
@Override
public void show() {
System.out.println("匿名内部类---show");
}
}
);
//--------------------------------------------------------------------------------------
}
}
写完这些我人都快没了╥﹏╥...
极大可能有遗漏或错误|_・)
