JAVA内部类 （成员内部类、局部内部类、匿名内部类、静态内部类、内部类的继承））

成员内部类
1.成员内部类简介

package cn.com.inner;
/**
 * 成员内部类<br>
 * 使用方式：OuterClass.InnerClass
 * @author wutz
 *
 */
public class OuterClass {       //外部类
    InnerClass inner = new InnerClass();

    private class InnerClass{       //内部类
        int y = 0;                  //内部类成员变量
        InnerClass(){               //内部类构造函数
        }               
        public void innerFunction(){    //内部类成员函数
            System.out.println("调用内部类的方法"); 
        }
    }

    public InnerClass getInsatnceOfInnerClass(){   //外部类操作内部类的属性
        //y = 4;
        inner.y = 100;
        inner.innerFunction();
        return inner;
    }

    public static void main(String[] args) {
        OuterClass outer = new OuterClass();
        OuterClass.InnerClass inner1 = outer.getInsatnceOfInnerClass();
        System.out.println(inner1.y);
        System.out.println("********************");
        OuterClass.InnerClass inner2 = outer.new InnerClass();
        System.out.println(inner2.y);
        inner2.innerFunction();
    }
}

console:
调用内部类的方法
100
********************
0
调用内部类的方法

2.使用this关键字获取内部类与外部类的引用

package cn.com.inner;
/**
 * 通过this获取外部类内部类的引用
 * @author wutz
 *
 */
public class TheSameName {

    private int x;

    private class Inner{
        private int x = 9;
        public void doit(int x){
            x++;                    //调用的是形参x
            System.out.println(x);
            this.x++;               //调用的是内部类x
            System.out.println(this.x);
            TheSameName.this.x++;   //调用的是外部类x
            System.out.println(TheSameName.this.x);
        }
    }

    public static void main(String[] args) {
        TheSameName outClass = new TheSameName();
        TheSameName.Inner inner = outClass.new Inner();
        inner.doit(100);
    }
}

console:
101
10
1

局部内部类
局部内部类是指在类的方法中定义内部类，它的作用范围也是在这个方法体内

package cn.com.inner;

/**
 * 局部内部类<br>
 * 定义在方法内的类，作用方法仅限该方法
 * @author wutz
 *
 */
public class SellOutClass {

    private String name;
    public SellOutClass(){
        name = "苹果";
    }

    public void sell(){
        class Apple{
            int innerPrice = 0;
            public Apple(int price){
                innerPrice = price;
            }
            public void price(){
                System.out.println("现在开始销售:"+name);
                System.out.println("价格:"+innerPrice);
            }
        }

        Apple apple = new Apple(100);
        apple.price();
    }

    public static void main(String[] args) {
        SellOutClass outClass = new SellOutClass();
        outClass.sell();
    }
}

console：
现在开始销售:苹果
价格:100

匿名内部类
在编写程序代码时，不一定要给内部类取一个名字，可以直接以对象名来代替。匿名内部类的所有实现代码都需要在大括号之间进行编写。

package cn.com.inner;
/**
 * 服务于匿名内部类
 * @author wutz
 *
 */
public interface OuterString {

    public String filterBlankChar();
}

package cn.com.inner;
/**
 * 匿名内部类
 * @author wutz
 *
 */
public class OutString{

    public static void main(String[] args) {
        final String sourceStr = "h e l l o w o r d";
        OuterString outString = new OuterString() {

            @Override
            public String filterBlankChar() {
                return sourceStr.replaceAll(" ","");
            }
        };

        System.out.println("源字符串：" + sourceStr);
        System.out.println("转换后的字符串：" +outString.filterBlankChar());

    }
}

console:
源字符串：h e l l o w o r d
转换后的字符串：helloword

静态内部类
在内部类前添加修饰符static，这个内部类就变成静态内部类。一个静态内部类中可以声明static成员，但是在非静态内部类中不可以声明静态成员。静态内部类有一个最大的特点，就是不可以使用外部类的非静态成员。所以静态内部类在程序开发中比较少见。

静态内部类具有以下两个特点：
1.创建静态内部类的对象，不需要先创建外部类对象。
2.不能从静态内部类的对象中访问非静态外部类的对象。

package cn.com.inner;
/**
 * 静态内部类1
 * @author wutz
 *
 */
public class StaticInnerClass {

    private static int x = 0;

    static class InnerClass{
        static void doInner() {
            System.out.println(x);
        }
    }

    public static void main(String[] args) {
        StaticInnerClass.InnerClass b = new StaticInnerClass.InnerClass();
        b.doInner();

    }
}

package cn.com.inner;
/**
 * 静态内部类2
 * @author wutz
 *
 */
public class StaticInnerClass {

    private static int x = 0;

    static class InnerClass{
        static void doInner() {
            System.out.println(x);
        }
        public static void main(String[] args) {
            doInner();
        }
    }
}

内部类的继承

package cn.com.inner;

public class Outer {

    class Inner{

    }
}

package cn.com.inner;

public class InnerExtend extends Outer.Inner{

    public InnerExtend(Outer outer) {
        outer.super();
    }
}