内部类的定义和使用

内部类

内部类的简介

内部类：就是在一个类中定义另外一个类，这个在类中被定义的类就叫做内部类

内部类格式

public class 类名{
	修饰符 class 内部类名{
        成员……
    }
}

内部类的案例

demo

/**
 * @Classname : demoTest
 * @Description : TODO 内部测试类
 * @Author : lin_refuel@qq.com
 */
//外部类 demoTest
public class demoTest {
    //定义一个外部的私有成员变量
    private String External = "我是外部私有成员变量";

    //定义一个外部的私有成员方法
    private void External() {
        System.out.println("我是外部的私有的成员方法");
    }

    //demoTest类里面定义一个内部类，innerClass
    public /*static*/ class innerClasses {
        //定义一个公有成员变量和公有成员方法
        public String innerStr = "我是内部的公有成员变量";

        public void innerStr() {
            System.out.println("我是内部公有的成员方法");
        }

        //内部类中可以直接访问调用外部类中成员变量和成员方法
        public void runOutStr() {
            System.out.println(External);
            External();
        }
    }

    private void externalMethods() {
        //实例化类 innerClasses
        innerClasses innerClasses = new innerClasses();
        System.out.println(innerClasses.innerStr);
        innerClasses.innerStr();
        System.out.println("================");
        //通过内部方法也可以直接输出外部成员遍和成员方法的内容
        innerClasses.runOutStr();
    }

    public static void main(String[] args) {
        //调用内部类中成员变量的两个方式
        //1.内部类加上修饰符 static，变成一个静态类
        //innerClasses innerClasses = new innerClasses();
        //System.out.println(innerClasses.innerStr);
        //innerClasses.innerStr();
        //==========================================================
        //2.通过公有方法，externalMethods进行调用
        demoTest demoTest = new demoTest();//实例化外部类demoTest
        demoTest.externalMethods();
        System.out.println("=================");
        demoTest.External();//同类中私有方法可以直接访问
        System.out.println(demoTest.External);//同类中私有变量也可以直接访问
    }
}

运行结果：

成员局部类

按照内部类在类中定义的位置不同，可以分为以下两种形式

• 在类的成员位置：成员内部类
• 在类的局部位置：局部内部类

demo：成员内部类

定义一个类，里面定义一个成员内部类

/**
 * @Classname : demo01
 * @Description : TODO 成员局部类
 * @Author : lin_refuel@qq.com
 */
public class demo01 {
    private String outStr = "我是外部的私有方法";

    //定义一个成员内部类
    public class inside{
        public void show(){
            System.out.println("我是成员内部类中的公有方法：show");
            System.out.println(outStr);//输出外部私有成员变量outStr
        }
    }
    //定义一个公有方法
    public void outMonth(){
        inside inside = new inside();//实例化内部对像inside
        inside.show();
    }
}

成员局部类（）测试类

/**
 * @Classname : demo01Test
 * @Description : TODO 成员内部类测试
 * @Author : lin_refuel@qq.com
 */
public class demo01Test {
    public static void main(String[] args) {
         //间接访问成员内部类的方式
        demo01 demo01 = new demo01();//实例化对象
        demo01.outMonth();//通过公有的方法调用成员内部类中的show方法
        System.out.println("=================================");
        //直接访问成员变量的方式
        //创建外部类的空间，在进行创建一个内部的空间
        //语法 new 外部类名().new 成员局部类名字();
        demo01.inside inside = new demo01().new inside();
        inside.show();//调用成员局部类里面的show方法

    }
}

运行结果：

局部内部类

按照内部类在类中定义的位置不同，可以分为以下两种形式

• 在类的成员位置：成员内部类
• 在类的局部位置：局部内部类

demo:局部内部类案例

定义一个类

/**
 * @Classname : Demo02
 * @Description : TODO 局部内部类
 * @Author : lin_refuel@qq.com
 */
public class Demo02 {
    private String strOut = "我是一个外部私有成员变量";

    //定义一个方法
    public void OutMonth(){
        String strOut ="我是OutMonth方法里面的局部变量";
        //定义一个局部内部部分类，在成员方法里面进行定义
        class inside{
            public void show(){
                System.out.println("我是局部内部类inside中的show方法，已被调用");
                System.out.println(strOut);
            }
        }
        //实例化对象 inside
        inside inside = new inside();
        inside.show();
    }

测试类

/**
 * @Classname : Demo02Test
 * @Description : TODO 测试类
 * @Author : lin_refuel@qq.com
 */
public class Demo02Test {
    public static void main(String[] args) {
        //实例化对象Demo02
        Demo02 demo02 = new Demo02();
        demo02.OutMonth();
    }
}

运行结果：

匿名内部类

前提：存在一个类或者接口，这里的类可以是具体的类也可以是抽象类

本质：匿名内部类实际上就是一个继承类该类或者实现类该类接口的子类匿名对象

demo：匿名内部类的使用

定义一个抽象类，名字为Inner

package com.itxs.demo02;

/**
 * @Classname : Inner
 * @Description : TODO 抽象类
 * @Author : lin_refuel@qq.com
 */
public abstract class Inner {
    //定义一个抽象方法
    public abstract void show();
}

定义一个名字为implement的类，作为上面抽象类的实现类
下面代码中，匿名对象类的定义，调用和对匿名对象起名后调用

package com.itxs.demo02;

/**
 * @Classname : implement
 * @Description : TODO
 * @Author : lin_refuel@qq.com
 */
public class implement {
    //定义一个方法
    public void month(){
        //定义一个匿名内部类
        new Inner() {
            @Override
            //重写Inner类中的方法
            public void show() {
                System.out.println("内部类中show方法调用");
            }
        }.show();
        System.out.println("==========================");
        //内部类可以起一个名字,名字为inner
        Inner inner = new Inner() {
            @Override
            public void show() {
                System.out.println("匿名内部类命名后，调用了show方法");
            }
        };
        //通过对象名字进行调用里面的show方法
        inner.show();
    }
}

定义一个子类继承上面Inner抽象类

package com.itxs.demo02;

/**
 * @Classname : Innerext
 * @Description : TODO
 * @Author : lin_refuel@qq.com
 */
public class Innerext extends Inner{
    @Override
    //抽象方法必须被重写
    public void show() {
        System.out.println("通过子类去调用Inner里面的show方法");
    }
}

测试类-输出匿名对象类的调用结果

package com.itxs.demo02;

/**
 * @Classname : test
 * @Description : TODO 测试类
 * @Author : lin_refuel@qq.com
 */
public class test {
    public static void main(String[] args) {
          //实例化对象 implement
        implement implement = new implement();
        implement.month();
        System.out.println("====================");
        //实例化Innerext
        Innerext innerext = new Innerext();
        innerext.show();
        System.out.println("====================");
        //匿名对象类可以直接在main方法里面直接使用
        new Inner() {
            @Override
            public void show() {
                System.out.println("main方法中，匿名内部类，show方法调用");
            }
        }.show();
    }
}

运行结果：

匿名内部类的案例

那个动物会跑？

定义一个名字为Animal的接口

package com.itxs.demo03;

/**
 * @Classname : Animal
 * @Description : TODO 动物接口
 * @Author : lin_refuel@qq.com
 */
public interface Animal {
    //定义一个功能,跑
     void sport();
}

定义一个名字为run的类

package com.itxs.demo03;

/**
 * @Classname : whoRun
 * @Description : TODO 谁再跑？
 * @Author : lin_refuel@qq.com
 */
public class whoRun {
    //定义一个功能
    public void show(Animal animal){
        animal.sport();
    }
}

定义一个Cat类作为接口Animal的实现类

package com.itxs.demo03;

/**
 * @Classname : Cat
 * @Description : TODO
 * @Author : lin_refuel@qq.com
 */
public class Cat implements Animal{
    @Override
    public void sport() {
        System.out.println("猫会吃鱼儿");
    }
}

测试类

package com.itxs.demo03;

/**
 * @Classname : test
 * @Description : TODO 测试类
 * @Author : lin_refuel@qq.com
 */
public class test {
    public static void main(String[] args) {
          //实例化对象
        //通过多态的方式传递一个Cat类的空间，调用重写后的sport方法
        whoRun whoRun = new whoRun();
        whoRun.show(new Cat());

        //传递一个内部类的方式
        /**
         *  new Animal:创建一个匿名内部类
         */
        whoRun.show(new Animal() {
            @Override
            //重写sport方法
            public void sport() {
                System.out.println("小肆，拿着冰激凌跑~");
            }
        });
    }
}

运行结果：