黑马程序猿——JAVA基础------内部类

——Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ ——-

一、内部类的基本概念

内部类就是在一个类的内部定义的类。
成员内部类格式如下:

    class Outer { 
        Class Inner{}
    }

编译上述代码会产生两个文件:
Outer.class和Outer$Inner.class。

访问修饰符	同一个类	同包	不同包子类	不同包非子类
public	√	√	√	√
protected	√	√	√
default	√	√
private	√

二、在外部创建内部类对象

• 内部类除了可以在外部类中产生实例化对象,也可以在外部类的外部来实例化。
• 那么,根据内部类生成的*.class文件：Outer$Inner.class。

”$“符号在程序运行时将替换成“.”
• 所以内部类的访问:通过“外部类.内部类”的形式表示。
• Outer out = new Outer() ;// 产生外部类实例
• Outer.Inner in = null; // 声明内部类对象
in = out.new Inner() ; // 实例化内部类对象

代码演示：

package com.joe.innerClass;

/**
 * 内部类：成员内部类
 */
public class InnerClassDemo {

    public static void main(String[] args) {
        Dog d = new Dog("多多");
        d.say();

        // 此方式一般不使用
        Dog.ChildDog child = null;// 声明内部类引用
        child = d.new ChildDog();// 创建内部类的实例
        child.talk();
        // 一般在外部类里定义个方法创建内部类对象
        d.childTalk();

    }
}

// 狗类
class Dog {
    private String name;

    public Dog(String name) {
        this.name = name;
    }

    public void say() {
        System.out.println("我是一只狗，主人叫我" + name);
    }

    // 内部类(成员内部类)
    class ChildDog {
        public void talk() {
            System.out.println("我是一只狗狗，我妈是" + name);
        }
    }
//在类中定义一个方法，实例化内部类对象
    public void childTalk() {
        ChildDog child = new ChildDog();
        child.talk();
    }
}

三、方法内部类

• 内部类可以作为一个类的成员外, 还可以把类放在方法内定义。
注意:
• 1、方法内部类只能在定义该内部类的方法内实例化,不可以在此方法外对其实例化。
• 2、方法内部类对象不能使用该内部类所在方法的非final局部变量。
（原因局部变量的生命周期没有对象的生命周期长）
格式如下：

class Outer{
    public void doSomething(){
        class Inner{
            public void seeOuter(){
            }
        }
    }
}

代码演示：

package com.joe.innerClass;

/**
 * 内部类：方法内部类
 */
public class InnerClassDemo02 {

    public static void main(String[] args) {
        Cat d = new Cat("咪咪");
        d.childTalk("小小咪");

    }
}

// 猫类
class Cat {
    private String name;

    public Cat(String name) {
        this.name = name;
    }

    public void say() {
        System.out.println("我是一只猫，主人叫我" + name);
    }

    public Child child;

    // 在方法里面声明一个内部类
    public void childTalk(final String childName) {
        class ChildCat implements Child {
            public void talk() {
                System.out.println("我是一只小猫咪，我妈妈是" + name);
                System.out.println("我的名字是" + childName);
            }
        }
        child = new ChildCat();
        child.talk();
    }

}

//创建一个接口
interface Child {
    public void talk();
}

四、静态内部类

• 在一个类内部定义一个静态内部类:
• 静态的含义是该内部类可以像其他静态成员一样,没有外部类对象时,也能够访问它。静态嵌套类仅能访问外部类的静态成员和方法。

 class Outer{ 
    static class Inner{} 
 } 

代码演示：

package com.joe.innerClass;

/**
 * 内部类：静态内部类 一个静态内部类相当于外部类
 */
public class InnerClassDemo03 {

    public static void main(String[] args) {
        // 第一种方法
        Dog.ChildDog child = new Dog.ChildDog();
        child.talk();
        // 第二种方法
        Dog.childTalk();

    }
}

// 狗类
class Dog {
    private String name;

    public Dog(String name) {
        this.name = name;
    }

    public void say() {
        System.out.println("我是一只狗，主人叫我" + name);
    }

    // 静态内部类
    static class ChildDog {
        public void talk() {
            System.out.println("我是一只狗狗");
        }
    }

    // 第二种方法:通过静态方法实例化内部类
    public static void childTalk() {
        ChildDog c = new ChildDog();
        c.talk();
    }

}

五、匿名内部类

• 匿名内部类就是没有名字的内部类。

• 匿名内部类的三种情况:

(1)继承式的匿名内部类
(2)接口式的匿名内部类
(3)参数式的匿名内部类

在使用匿名内部类时，要记住以下几个原则：
1、不能有构造方法，只能有一个示例；
2、不能定义任何静态成员、静态方法；
3、不能是public,protected,private,static修饰符修饰；
4、一定是在new的后面，用其隐含实现一个接口或实现一个类；
5、匿名内部类为局部的，所以局部内部类的所有限制都对其生效。

代码演示：

package com.joe.innerClass;

/**
 * 内部类：匿名内部类（继承式匿名内部类）
 */
public class InnerClassDemo04 {
    public static void main(String[] args) {
        // (1)继承式匿名内部类
        Dog dog = new Dog("多多") {
            public void say() {
                System.out.println("我是一只母犬，主人叫我" + name);
            }
        };
        dog.say();

        // (2)接口式匿名内部类
        // 定义一个接口
        Child1 child = new Child() {
            public void talk() {
                System.out.println("我是一只狗狗");
            }
        };
        child.talk();

        // (3)参数式匿名内部类
        // 调用接口，但接口不能实例化
        childTalk(new Child() {
            public void talk() {
                System.out.println("我是一只小狗狗");
            }
        });

    }
    //带参的静态方法
    public static void childTalk(Child c) {
        c.talk();
    }

}

// 狗类
class Dog {
    String name;

    public Dog(String name) {
        this.name = name;
    }

    public void say() {
        System.out.println("我是一只狗，主人叫我" + name);
    }
}


interface Child {
    public void talk();
}

六、内部类的作用

每个内部类都能独立地继承自一个(接口的)实现,所以无论外部类是否已经继承了某个(接口的)实现,对于内部类都没有影响。
如果没有内部类提供的可以继承多个具体的或抽象的类的能力,一些设计与编程问题就很难解决。
从这个角度看, 内部类使得多重继承的解决方案变得完整。接口解决了部分问题,而内部类有效地实现了“多重继承”。