java 中的内部类

一 ：内部类的定义：

  下面先来看看内部类的定义：

(1)、内部类仍然是一个独立的类，在编译之后内部类会被编译成独立的.class文件，但是前面冠以外部类的类名和$符号

(2)内部类不能用普通的方式访问。内部类是外部类的一个成员，因此内部类可以自由地访问外部类的成员变量，无论是否是private的 。

(3)、内部类声明成静态的，就不能随便的访问外部类的成员变量了，此时内部类只能访问外部类的静态成员变量 。

一 ：内部类的分类：

1:普通的内部类

语法格式：
class Outer {
class Inner{}
}
// 编译上述代码会产生两个文件：Outer.class和Outer$Inner.class。

下面直接上代码测试：

package inner;

/**
 * 一.常规内部类：常规内部类没有用static修饰且定义在在外部类类体中。
 *1.常规内部类中的方法可以直接使用外部类的实例变量和实例方法。
 *2.在常规内部类中可以直接用内部类创建对象
 * @author Administrator
 *
 */
public class Out_inner {
    //定义了外部类的方法和属性
    private int age =50;
    public void outShow(){
        System.out.println("这话外部类的方法"+"----------"+age);
    }
    class myInner{
        public void show(){
            System.out.println("这话外部类的属性age"+"----------"+age);
            outShow();  
            System.out.println("这话外部类的属性age,测试this"+"----------"+Out_inner.this.age);
        }
    }
    //
    myInner mInner=new myInner();
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        // // 使用外部类构造方法创建mo对象
        Out_inner out_inner=new Out_inner();
        //常规内部类需要通过外部类的实例才能创建对象，与实例变量需要通过对象来访问相似
        Out_inner.myInner inner = out_inner.new myInner();
        inner.show();
    }
}

下面是输出的结果：

介绍：

**一.常规内部类：常规内部类没有用static修饰且定义在在外部类类体中

*1.常规内部类中的方法可以直接使用外部类的实例变量和实例方法。

2.在常规内部类中可以直接用内部类创建对象

常规内部类需要通过外部类的实例才能创建对象，与实例变量需要通过对象来访问相似

2:静态的内部类

静态内部类中可以定义静态或者非静态的成员，

1 :静态内部类：与类的其他成员相似，可以用static修饰内部类，这样的类称为静态内部类。

2 ：静态内部类与静态内部方法相似，只能访问外部类的static成员，不能直接访问外部类的实例变量，与实例方法，只有通过对象引用才能访问。

3 :由于static内部类不具有任何对外部类实例的引用，因此static内部类中不能使用this关键字来访问外部类中的实例成员， 但是可以访问外部类中的static成员和静态的方法。

4: 静态内部类不通过外部实例就可以创建对象；与类变量可以通过类名访问相似,这是优势

直接上代码：

public class Text {
    public static int x=100;
    public static void show1(){
        System.out.println("这是外部的静态的方法");
    }
    //创建了一个静态的内部类
    static class Inner{
        private void show(){
            System.out.println("这是测试的静态的内部了调用外部类的静态的属性------"+x);
            show1();
        }
    }
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        //静态内部类不通过外部实例就可以创建对象；与类变量可以通过类名访问相似
        Text.Inner inner=new Text.Inner();
        inner.show();
    }
}

运行结果

还有，匿名内部类，方法内部类在这里就不多讲了，只介绍是上面的常用的

二：为什么要使用内部类：

典型的情况是，内部类继承自某个类或实现某个接口，内部类的代码操作创建其的

外围类的对象。所以你可以认为内部类提供了某种进入其外围类的窗口。使用内部

类最吸引人的原因是：

大家都知道Java只能继承一个类，它的多重继承在我们没有学习内部类之前是用接口来实现的。但使用接口有时候有很多不方便的地方。比如我们实现一个接口就必须实现它里面的所有方法。而有了内部类就不一样了。它可以使我们的类继承多个具体类或抽象类

实现了“多重继承”。

1.内部类可以很好的实现隐藏

一般的非内部类，是不允许有 private 与protected权限的，但内部类可以

3.可是实现多重继承

4.可以避免修改接口而实现同一个类中两种同名方法的调用。

三：内部类的多继承：

既然我们知道了用内部类可以实现多继承，那么我们就来做一个例子：

上图 上代码：

父类：Text2

package inner;

public class Text2 {
    protected int age =20;
    protected void show(){
        System.out.println("这是类1");
    }
}

父类：Text3

package inner;

public class Text3 {
    protected String name="张三";
    protected void show3(){
        System.out.println("这话类3");
    }
}

下面写一个测试了测试，上代码

package inner;

public class Text4 {
    //这是内部类ageText1继承了Text2
    static class ageText1 extends Text2{
        //返回父类的年龄
        public int age()
        {
          return super.age;  
        }
        public void show4(){
             super.show();
        }
    }

    这是内部类nameText2继承了Text3
    static class nameText2 extends Text3{
        //返回父类的年龄
        public String name()
        {
          return super.name;  
        }
        public void show4(){
             super.show3();
        }
    }
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        ageText1 text1=new Text4.ageText1();
        nameText2 text2=new Text4.nameText2();
        System.out.println("这是父类的年龄---"+text1.age());
        text1.show();
        System.out.println("===============================");
        System.out.println("这是父类的name---"+text2.name());
        text2.show3();
    }
}

上面代码可以看出的是：ageText1，nameText2 是两个内部类，分别继承了

Text2和Text3，并返回父类的年龄和定义了一个方法显示父类的方法

这是text2

这是text3

下面是测试的输出的结果：