面向对象加强3 内部类

内部类
1.非静态内部类—类型名称: 外部类名.内部n类名， 如果在同一个类中则“外部类名.”可省略

2.内部类中可以自由声明自己的成员变量与成员方法，和外部类相同则是隐藏对方

3.非静态内部类(等同非静态方法)中访问非静态内部类 —由于是共用this(共同处理同一个实例对象中)，因此不采用outer.new的方式创建对象

4.属同一个外部类的内部类之间也是彼此信任，可以访问对方的所有成员

5.静态内部类(等同静态方法),不能直接访问外部类的非静态成员(实例成员),只有通过对象才可以

7.非静态的东西(包括内部类)是属于对象的

8.内部类型与其他外层类型”彼此”信任，能访问”对方”的所有成员。

//成员式内部类 (属于类级或实例级)
public class Outer {
    private int counter=10;
    private int size=5;
    public void doSth(){
        size++;
    }

    public class Inner{
        private int size;//可以隐藏外部类成员
        private void doStuff(){
            System.out.println(counter);
        }
        private void doSth(){
            size++;
            System.out.println("size="+size);//访问的是内部类的变量size
            System.out.println("size2="+Outer.this.size);//访问的是外部类的变量size  ---外部类的非静态成员,若被隐藏，要显式访问则: Outer.this.成员 
        }
    }

    public class Inner2{
        private int b;
        private void doStuff2(){
            Inner inner = new Inner();
            inner.doStuff();//属同一个外部类的内部类之间也是彼此信任，可以访问对方的所有成员
        }
        public void do2(){
            System.out.println(size);
        }
    }


    public static class Inner3{
        private int b=3;
        public void aa(){
            //System.out.println(size); //WA
            Inner2 inner = new Outer().new Inner2();
            inner.doStuff2();
        }
    }

    public static void main(String[] args) {
        Inner inner=null; //AC
        //inner = new Outer.Inner();//WA
        Outer outer = new Outer();
        inner = outer.new Inner(); //非静态的东西(包括内部类)是属于对象的

        inner.doStuff(); //内部类型与其他外层类型"彼此"信任，能访问"对方"的所有成员。
        inner.doSth();
    }
}

public class Outer2 {
    public static void main(String[] args) {
        //访问另一个类的非静态内部类
        Outer outer = new Outer();
        //Outer.Inner2 in1 = outer.new Outer.Inner2();//WA
        Outer.Inner2 in2 = outer.new Inner2();//AC
        in2.do2();

        //访问另一个类的静态内部类
        Outer.Inner3 in3 = new Outer.Inner3();
        in3.aa();
    }
}

//局部内部类 (在方法内部定义的)
public class Outer2 {

    public void aa(){

        //非匿名局部内部类---实现接口
        class Rectangle implements Area{
            @Override
            public double area() {
                return 0;
            }
        }
        Area a1 = new Rectangle();

        //匿名局部内部类---实现接口
        Area a = new Area(){
            @Override
            public double area() {
                return 0;
            }
        };


        //非匿名局部内部类---继承类
        class B extends A{
            @Override
            public void aa() {
                System.out.println("11111111");
            }
        }
        A obj1 = new B();

        //匿名局部内部类---继承类
        A obj = new A(){
            @Override
            public void aa() {
                System.out.println("22222");
            }
        };

    }
}

interface Area{
    public abstract double area();
}

class A{
    public void aa(){
        System.out.println("aa....");
    }
}

//局部内部类 访问外部的变量: 成员变量能够随便访问，但局部变量(方法内部声明的)必须是final的
public class Outer3 {
    private int size=5; 

    public void aa(){

        final int x=3;

        //内部类编译之后和外部类的成员变量与成员方法是并列的
        Area a = new Area(){
            @Override
            public double area() {
                size=10; //可以不是final
                System.out.println(x); //必须final
                return 0;
            }
        };

    }
}