内部类

定义

       将一个类的定义置入另一个类的定义中，这个类就是内部类。

嵌套在另外的一个类中，和外部类的属性使用方式差不多。

public class Out {
    int i = 10;
    class Inner1{
        public void show(){
            System.out.println("this is Inner1!");
        }
    }
    public class Inner2{
        public Inner2() {}
        public Inner2(String desc){
            System.out.println(desc);
            System.out.println(i);
        }
    }
    public void show(){
        Inner1 inner1 = new Inner1();
        Inner2 inner2 = new Inner2("inner2");
        inner1.show();
        System.out.println("Out's method!");
    }
    public static void main(String[] args) {
        Out out = new Out();
        out.show();
    }
}

方法和作用域中的内部类

目的

实现某种形式的接口，使自己能够创建和返回一个句柄
解决复杂问题的时候，希望创建一个类并辅助自己的程序方案，同时不愿意公开。

1. 在一个方法中定义，作用域在这个方法内

/**
 2. 定义在方法中的内部类实现了Shape接口，其作用域在整个方法
 3. @author lenovo
 4.  */
public class Out {
    public void show(){
        class Circle implements Shape{
            public void show(double r) {
                System.out.println("这是一个半径为"+r+"的圆！");
            }
        }
//      Scanner in = new Scanner(System.in);
//      double r = in.nextDouble();
        Shape shape = new Circle();
        shape.show(3.33);
    }
    public static void main(String[] args) {
        Out out = new Out();
        out.show();
    }
}

1. 在方法的作用域定义

/**
 1. 定义一个用于测试作用域区间的内部类，范围介于花括号之间
 2. 虽然类是在作用域中，但是类并不是根据条件创建的，是随其他一起得到编译的。
 3. 并且除了作用范围在花括号间，它和普通的类没什么区别
 4. @author lenovo
 5.  */
public class Out2 {
    public void ceshi(boolean flag){
        if(flag){
            class Inner{
                public void show(){
                    System.out.println("用于测试用例！");
                }
            }
            Inner inner = new Inner();
            inner.show();
        }
    }
    public static void main(String[] args) {
        Out2 out2 = new Out2();
        out2.ceshi(true);
    }
}

3.一个匿名类，实现一个接口

/**
 * 一个匿名的内部类，必须继承抽象类或者实现接口，并且会自动的向上转型
 * @author lenovo
 *
 */
public class Out3 {
    public Shape shape(){
        return new Shape() {
            //
            @Override
            public void show(double r) {
                // TODO Auto-generated method stub
                tt();
            }
            public void tt(){
                System.out.println("nihao");
            }
        };
    }
    public static void main(String[] args) {
        Out3 out3 = new Out3();
        Shape  shape = out3.shape();
        shape.show(3);
    }
}

4.扩展拥有非默认构造器的类

public class Warp {
    int i;
    public Warp(int i){
        this.i = i;
    }
    public int value(){
        return i;
    }
}
/**
 * 一个普通的基础类
 * 基础类只有带参的构造方法，使用匿名类继承这个基础类
 * @author lenovo
 *
 */
public class Test {
    public Warp warp(int x){
        return new Warp(x){
            public int value(){
                return super.value()*10;
            }
        };
    }
    public static void main(String[] args) {
        Test test = new Test();
        Warp warp = test.warp(2);
        int n = warp.value();
        System.out.println(n);
    }
}
结果：20

5.如果想要在匿名内部类中使用某个参数，这个参数必须是final的

/**
*匿名内部类中使用外部的参数
/
public class Ceshi2 {
    public Warp warp(final int x){
        return new Warp(x){
            int n = x;
            public int value(){
                System.out.println(n);
                return super.value()*10;
            }
        };
    }
}

**内部类非常重要的一点：拥有对封装类的所有的访问权限
5.如何在别的类中创建一个内部类对象
       首先创建外部类的对象
       利用外部类的对象创建内部类的对象

Out out = new out();
Out.Inner inner = out.new Inner();

6.静态内部类
       牢记一点：内部类的对象默认持有创建它的 封装类的对象；不能从一个static内部类对象访问一个外部类；好比是普通的内部类是外部类的属性，和对象挂钩，静态内部类则是不需要外部类的对象也能访问。
7.从内部类中继承
继承必需要有外部类的句柄进行初始化

/**
 * 从一个内部类中继承，那么进行实例化必须采用一种特殊的语法来明确这种关系
 * @author lenovo
 *
 */
public class ExtendsInner extends WithInner.Inner {
    public ExtendsInner(WithInner wi) {
        wi.super();
    }
    public static void main(String[] args) {
        WithInner withInner = new WithInner();
        ExtendsInner ei = new ExtendsInner(withInner);
        ei.show();
    }
}