JavaSE学习（13）：面向对象：内部类详解

public class OutClass {
    int num=1;
    //定义一个成员内部类
    public class inner{
        //成员内部类中有一个方法
        public void cpu(){
            System.out.println("我是一个cpu");
            System.out.println("num="+num);
        }
    }
    public void method(){
        System.out.println("我是电脑");
        //创建内部了对象，并调用内部类方法
        new inner().cpu();
    }
}

public class ClassTest {
    @Test
    public void Test(){
        //创建一个外部类对象
        OutClass outClass = new OutClass();
        outClass.method();
    }
}

输出结果为：

1. 通过这个简单的例子，我们可以看出内部类访问外部类可以随意访问（包括私有的成员变量和方法），如果内部类中的变量名和外部类的成员变量名一样，要通过创建外部类对象 "."属性来访问外部类属性，通过this.属性访问内部类成员属性out.this

2. 而外部类访问内部类，得先创建内部类对象。

问题：其他类怎么访问外部类？

   public void test2(){
        OutClass.inner inner = new OutClass().new inner();
        inner.cpu();
    }

三、静态内部类

3.1 定义

静态内部类就是在一个类的内部里面定义了一个使用 static 修饰的类。

静态内部类对象是外部类所有，而不是外部类对象所有

3.2 四个问题

1.内部类怎么访问外部类？

可以直接访问，包括私有，但是只能访问外部类中的静态static成员

2.外部类怎么访问内部类

和前面相同，需创建一个内部类对象Inner in = new Inner()

3.其它类怎么访问内部类

通过外部类名创建一个内部类对象

Outer.Inner in = new Outer.Inner();，注意定义格式个成员内部类不同

4.内部类和外部类出现同名变量

默认访问内部类的变量，若要访问外部类的变量，只需要用外部类名加以区分（因为内部类只能访问外部类的静态变量，所以可以用外部类名直接调用，所以不需要Outer.this）

3.3 一个例子

【注意】：静态内部类没有out.this关键字

如果出现了同名的成员，用外部类类名区分！（只能访问外部类静态的内容）

class Outer{
    private int a=1;
    public int b=2;
    private static int num1=10;
    public static int num2=20;

    public static void function(){
        Inner inner=new Inner();
        System.out.println(inner.i1);//可以访问
    }
    static class Inner{
        private int i1=100;
        public int i2=200;
        public void method(){
              // System.out.println(a);
               //System.out.println(b);不是静态     访问不了    
               System.out.println(num1);
               System.out.println(num2);

        }
    }
}

四、局部内部类

4.1 定义

局部内部类就是把一个类放在方法内定义。不能使用 static 修饰。并且不能使用任何访问控制符修饰，因为它的作用域只能在方法内。

4.2 注意的点

1.局部内部类访问外部类的局部变量是，必须加final修饰

2.默认会根据就近原则访问自己的变量。

如何去访问外部类中的同名变量？

a.如果内部类定义在成员方法中：Outer.this （代表外部类对象）

b.如果内部类定义在静态方法：Outer类名，因为只能访问外部类中静态的变量。

class Outer {
	public int a = 1;
	private int b = 2;
	
	public static int c = 3;
	private static int d = 4;
	
	public void method() {
		// 局部位置
		// Inner inner = new Inner(); 在这里不能创建内部类对象
		//只能在内部类创建之后的位置，才能创建内部类对象
           // 而且只能在这个方法内部创建
           int N = 100   //
           
		class Inner {
			public int num1 = 10;
			private int num2 = 20;
			
			public int a = 100;
			private int b = 200;
			
			public void show() {
				System.out.println(a); //
				System.out.println(b); //a和b正常打印
				 System.out.println(Outer.this.a);
				System.out.println(Outer.this.b);
                            //正常打印出外部类中的a和b
                            
                            System.out.println(N)； //内部类可以调用输出局部变量
                            int N = 101;
                            System.out.println(N);//编译失败，N不能改变
			}
			
		}
		
		Inner inner = new Inner(); //在方法内，Inner后，可以创建内部类对象
		
		System.out.println(inner.num1);
		System.out.println(inner.num2)； //可以访问内部类的变量
		inner.show(); //调用show方法来打印
	}
	
	public static void method2() {  //定义在静态方法内部
		
		class Inner {
			public int num1 = 10;
			private int num2 = 20;
			
			public int c = 300;
			private int d = 400;
			
			public void show() {
				System.out.println(c);
				System.out.println(d); //输出300，400
				System.out.println(Outer.c);//3
				System.out.println(Outer.d);//4 静态方法的话，
                            //调用外部类成员变量只需要通过类名Outer即可
			}
			
		}
	}	
}

class InnerClassDemo4 {
	public static void main(String[] args) {
		// Outer.Inner inner = new Outer().new Inner(); 失败
		// Outer.Inner inner = new Outer.Inner(); 失败
           // 原因就是外部类无法访问内部类，自然无法创建内部类对象
		Outer outer = new Outer(); //创建外部类
		outer.method(); //通过外部类变量来调用内部类所在的方法。
	}
}

五、匿名内部类

5.1 定义

匿名内部类就是一种没有名字的内部类，它只会使用一次。匿名内部类必须必须是继承一个父类或者实现一个接口，但最多只能继承一个父类或实现一个接口。

这里的类可以是具体类也可以是抽象类。

格式：new 类名或者接口名() {重写方法;}

本质：是一个继承了该类或者实现了该接口的子类匿名对象

5.2 匿名内部类的方法调用

interface Inter{
    public abstract void show();
    public abstract  void show2();
}

class Outer {
    public void method() {
        //一个方法的时候
//        new Inter(){
//            public void show(){
//                System.out.println("show");
//            }
//        }.show();//本质是对象

//        //二个方法的时候
//        new Inter(){
//            public  void show(){
//                System.out.println("show1");
//            }
//            public void show2(){
//                System.out.println("show2");
//            }
//        }.show();
//        new Inter(){
//            public  void show(){
//                System.out.println("show1");
//            }
//            public void show2(){
//                System.out.println("show2");
//            }
//        }.show2();
        //如果是很多的方法就很麻烦了
        //改进方法,把它变成接口的子类实现类对象-->多态
        Inter i = new Inter() {
            public void show() {
                System.out.println("show1");
            }
            public void show2(){
                System.out.println("show2");
            }
        };
        i.show();
        i.show2();
    }
}
public class InnerClassDemo {
    public static void main(String[] args) {
        Outer o=new Outer();
        o.method();//show1 show2
        
    }
}

5.3 匿名内部类在开发中如何使用

//定义一个人的接口
interface Person{
    public abstract void study();
}

class PersonDemo{
    //接口名作为形式参数
    //其实这里需要的不是接口，而是该接口的实现类的对象
    public void method(Person p){
        p.study();
    }
}

//实现类
class Student implements Person {
    public void study(){
        System.out.println("good good study!");
    }
}

public class InnerClassTest {
    public static void main(String[] args) {
        //测试
        PersonDemo pd=new PersonDemo();
        Person p=new Student();//这里的p外面只使用一次，而却独立为它编写了一个类，很玛法
        pd.method(p);
        System.out.println("----------------");
        //匿名内部类在开发中的使用
        //匿名内部类的本质是对象
        pd.method(new Person() {
            @Override
            public void study() {
                System.out.println("好好学习");
            }
        });
    }
}