【Java】内部类

内部类

1.内部类的定义与应用

1.1基本概念

内部类：在一个类的内部定义类

范例：

class Outer{
    private String str="hello";
    //定义一个内部类
    class Inner{
        //定义一个普通方法
        public void print(){
            System.out.println(str);
        }
    }
    //在外部类中定义一个方法，该方法负责产生内部类对象并且调用print()方法
    public void fun(){
        //内部类对象
        Inner in=new Inner();
        in.print();
    }
}
public class Test {
    public static void main(String[] args) {
        //外部类对象
        Outer out=new Outer();
        out.fun();
    }
}

可以发现，引入内部类之后，程序的结构混乱了，虽然内部类破坏了程序的结构，但是从另一方面来说，内部类可以方便的操作外部类的私有访问。

1.2 内部类存在的原因

1.内部类方法可以访问该类定义所在作用域中的数据，包括被private修饰的私有属性

2.内部类可以对同一包中的其他类隐藏起来

3.内部类可以实现java单继承的缺陷

范例：使用内部类来实现“多继承”

class A{
    private String name="A类的私有域";
    public String getName(){
        return name;
    }
}

class B{
    private int age=20;
    public int getAge(){
        return age;
    }
}

class Outter{
    private class InnerClassA extends A{
        public String name(){
            return super.getName();
        }
    }
    private class InnerClassB extends B{
        public int age(){
            return super.getAge();
        }
    }
    public String name(){
        return new InnerClassA().name();
    }
    public int age(){
        return new InnerClassB().age();
    }
}

public class Test{
    public static void main(String[] args) {
        //外部类对象
        //Outer out=new Outer();
        //out.fun();
        Outter outter=new Outter();
        System.out.println(outter.name());
        System.out.println(outter.age());
    }
}

1.3内部与外部类的关系

• 静态内部类可直接访问外部类的静态成员，但不能直接访问外部类的非静态成员，需要实例化
• 局部内部类跟实例内部类一样能访问外部类的所有成员
• 对于非静态内部类，内部类的创建依赖外部列的实例对象，在没有外部类实例之前是无法创建内部类的
• 内部类是一个相对独立的实体，与外部类不是is-a关系
• 内部类可以访问外部类的私有域，但是外部类不可以直接访问内部类的元素
• 外部类可以通过内部类引用间接访问内部类的元素

2.内部类的分类

java中内部类可以分为：

• 成员内部类
• 静态内部类
• 方法内部类
• 匿名内部类

3.成员内部类

3.1成员内部类使用时注意：

1.成员内部类中不能存在任何static的变量和方法

2.成员内部类依附于外部类，所以只有先创建了外部类才能创建内部类

3.2 解释

在一个类中除了可以定义成员变量，成员方法，还可以定义类，这样的类被称为成员内部类，在成员内部类中可以访问外部类的所有成员。

class Outer{
    private int num=4;
    //方法中访问成员内部类
    public void test(){
        Inner inner=new Inner();
        inner.show();
    }
    //成员内部类
    class Inner{
        void show(){
            System.out.println("num:"+num);
        }
    }
}
public class Test{
    public static void main(String[] args) {
        //创建外部类对象
        Outer outer=new Outer();
        //调用test方法
        outer.test();
    }
}

结果说明：内部类可以在外部类中被使用，并能使用外部类的成员。

通过外部类去访问内部类语法格式：

外部类名.内部类名 变量名=new 外部类名（）.new 内部类名（）；

4.静态内部类

4.1 理解

用static关键字来修饰一个成员内部类，该内部类被称为成员内部类。它可以再不创建外部类对象的情况下被实例化，格式为：

外部类名.内部类名 变量名=new 外部类名.内部类名（）；

class Out{
    private static int num=8;
       //创建静态内部类
    static class In {
           void show() {
               System.out.println("num=" + num);
           }
       }
}
public class Test1 {
    public static void main(String[] args) {
        Out.In in=new Out.In();
        in.show();
    }
}

注意：

静态内部类中只能能访问外部类的静态成员；

在静态内部类中可以定义静态的成员，而在非静态的内部类中不允许定义静态成员

4.方法内部类

4.1理解

方法内部类是指在成员方法中定义的类，他只能在当前方法中被使用。

class Outter{
    private int num=9;
    public void test(){
        //方法内部类
        class Iner{
            void show(){
                System.out.println("num="+num);
            }
        }
        Iner  in=new Iner();
        in.show();
    }
}

public class Test1 {
    public static void main(String[] args) {
        Outter out=new Outter();
        out.test();
    }
}

方法内部类也可以访问外部类的成员变量。

5.匿名内部类

匿名内部类主要用来实现接口

5.1 格式

new 父类 （参数列表） 或父接口（）{

//匿名内部类实现部分

}

//定义动物类接口
interface Animal{
    void shout();
}
public class Test2 {
    public static void main(String[] args) {
        //定义匿名内部类作为参数传递给animalShout()方法
        animalShout(new Animal(){
            @Override
            public void shout() {
                System.out.println("wangwang……");
            }
        });
    }
    public static void animalShout(Animal an){
        an.shout();
    }
}

5.2匿名内部类的具体写法

1.在调用animalShout()方法时，在方法的参数位置写上new Animal(){},这相当于创建了一个实例对象，并将该对象作为参数传递给animalShout()方法，在new Animal()后面有一对大括号，表示创建的对象为Animal的子类实例，该子类是匿名的。

animalShout(new Animal() {} );

2.在大括号中编写匿名子类的实现代码；

注：匿名内部类是实现接口的一种简便方法，但在程序中不一定要写匿名内部类。