Java内部类的定义和使用

为什么要用到内部类：

在java开发学习中我们经常会碰到内部类。内部类又有很多的优势：首先举一个简单的例子，如果你想实现一个接口，但是这个接口中的一个方法和你构想的这个类中的一个方法名称参数相同，你应该怎么办？这时候，你可以建一个内部类实现这个接口。由于内部类对外部类的所有内容都是可访问的，所以这样做可以完成所有你直接实现这个接口的功能。不过你可能要质疑，更改一下方法的不就行了吗？的确，以此作为设计内部类的理由，实在没有说服力。真正的原因是这样的，java中的内部类和接口加在一起，从而java 通过内部类加上接口，可以很好的实现多继承的效果。

内部类的分类和使用

1、成员内部类： 即作为外部类的一个成员存在，与外部类的属性、方法并列。注意：成员内部类中不能定义静态变量,但可以访问外部类的所有成员。值得注意的是成员内部类编译成功后会生成的两个不同的类（.class）

成员内部类的优点：

1）、内部类作为外部类的成员，可以访问外部类的私有成员或属性。（即使将外部类声明为PRIVATE，但是对于处于其内部的内部类还是可见的。）

2）、用内部类定义在外部类中不可访问的属性。这样就在外部类中实现了比外部类的private还要小的访问权限。

 

package one;

public class Outer{
    private static int outer_i = 1;
    private int k=20;
    public static void outer1(){
       //...
    }

    //成员内部类
    class Inner{
        int j=100;//内部类中外部类的实例变量可以共存
        int inner_i=1;
        void inner1(){
           System.out.println(outer_i);//外部类的变量如果和内部类的变量没有同名的，则可以直接用变量名访问外部类的变量
           System.out.println(j);//在内部类中访问内部类自己的变量直接用变量名
           System.out.println(this.j);//也可以在内部类中用"this.变量名"来访问内部类变量
           //访问外部类中与内部类同名的实例变量可用"外部类名.this.变量名"。
           System.out.println(k);//外部类的变量如果和内部类的变量没有同名的，则可以直接用变量名访问外部类的变量
           outer1();
        }
    }
    //外部类的非静态方法访问成员内部类
    public void outer2(){
       Inner inner = new Inner();
       inner.inner1();
    }
    //外部类的静态方法访问成员内部类，与在外部类外部访问成员内部类一样
    public static void outer3(){
       Outer out = new Outer();//step1 建立外部类对象
       Inner inner=out.new Inner();//step2 根据外部类对象建立内部类对象
       inner.inner1();//step3 访问内部类的方法
    }
    public static void main(String[] args){
        outer3();
    }
}

2、局部内部类： 即在方法中定义的内部类，与局部变量类似，在局部内部类前不加修饰符public或private，其范围为定义它的代码块。

public class Outer {

    public void say(){
        System.out.println("关门说真话！");
    }
}

public class Test {

    public void ting(){
        class MiMi extends Outer{//定义一个局部的内部类，继承Outer方法
            //……
        }

        new MiMi().say();//调用局部内部类中继承的say方法

        System.out.println("别人都不知道");
    }

    public static void main(String[] args) {
        new Test().ting();
    }
}

3、静态内部类： 静态内部类定义在类中，任何方法外，用static定义。注意：静态内部类中可以定义静态或者非静态的成员

package three;

public class StaticTest {
    private static String name="abc";
    private String sex="男";

    static class Person{
        private String age = "18";//内部私有成员
        public String heigth = "180";//内部类公有成员
        public void display(){
            //System.out.println(sex);//报错，不能直接访问外部类的非静态成员
            System.out.println(name);//只能直接访问外部类的静态成员
            System.out.println(age);//访问本内部类成员。
        }
    }

    public void testone(){
        Person person = new Person();
        person.display();
        //System.out.println(heigth);//报错，是因为不可以直接访问内部类私有成员
        //System.out.println(age);//报错，是因为不可以直接访问内部类公有成员
        System.out.println(person.age);//可以访问内部类的私有成员
        System.out.println(person.heigth);//可以访问内部类的公有成员
    } 

    public void testtwo(){
        StaticTest st = new StaticTest();
        System.out.println(name);
        System.out.println(sex);
        //System.out.println(age);//不可以直接访问内部类的成员
        //System.out.println(heigth);//不可以直接访问内部类的成员
    }

    public static void main(String[] args) {
        //调用StaticTest
        StaticTest staticTest = new StaticTest();
        staticTest.testone();
        staticTest.testtwo();
    }
}  

 

4、匿名内部类： 匿名内部类是在抽象类和接口的基础之上发展起来的。匿名内部类如果继承自接口,必须实现指定接口的方法,且无参数 。匿名内部类如果继承自类,参数必须按父类的构造函数的参数传递

匿名内部类的特点：

1），一个类用于继承其他类或是实现接口，并不需要增加额外的方法，只是对继承方法的事先或是覆盖。

2），只是为了获得一个对象实例，不需要知道其实际类型。

3），类名没有意义，也就是不需要使用到。

package three;

abstract class parent {

public abstract void like();
}

public class Demo {
    public static void main(String[] args) {
        parent pt = new parent(){
            public void like(){
                System.out.println("吃饭睡觉打豆豆。。。");
            }
        };
        pt.like();
    }
}

匿名类与内部的联系与区别：

 

按所在位置可以分为两大类：

      1、在类的方法中

            特点：

            a、可以访问宿主类的所有元素 ；

            b、保存宿主类对象的引用，创建对象时必须有宿主类对象；

            c、 不能有静态数据；

 继续划分：

            A、本地内部类；

            B、匿名内部类

 两者的区别在于本地内部类有构造方法，而匿名内部类只能实例初始化；

      2、在类或接口作用域中；

            A、普通内部类

            B、静态内部类

 

内部类总结：

1.内部类作为外部类的一个特殊的成员来看待，因此它有类成员的封闭等级：private ,protected,默认(friendly),public 它有类成员的修饰符:   static,final,abstract

2.非静态内部类nested inner class,内部类隐含有一个外部类的指针this,因此，它可以访问外部类的一切资源（当然包括private）外部类访问内部类的成员，先要取得内部类的对象,并且取决于内部类成员的封装等级。非静态内部类不能包含任何static成员.

3.静态内部类：static inner class,不再包含外部类的this指针，并且在外部类装载时初始化. 静态内部类只能访问外部类static成员. 外部类访问静态内部类的成员：static成员：类名.成员；非static成员：对象.成员

4.对于方法中的内部类或块中内部类只能访问块中或方法中的final变量。