Java（46）：九个demo彻底让你明白内部类的语法使用！！

最新推荐文章于 2024-04-17 02:43:35 发布

原创最新推荐文章于 2024-04-17 02:43:35 发布 · 432 阅读

0 ·

CC 4.0 BY-SA版权

Java 同时被 3 个专栏收录

66 篇文章

订阅专栏

Java基础与积累

66 篇文章

订阅专栏

后台工作总结

34 篇文章

订阅专栏

2019年5月3日

引入

一般项目编程中，很少业务代码会使用到内部类，但是我经常看到源码对它应用很多，正巧最近项目也开发一个功能，有用到它的地方，所以在这里做个总结。

demo1：普通内部类

内部类的设计:分析事物时,发现该事物描述中还有事物,而且这个事物还在访问被描述事物的内容,这时候就定义内部类；

下面是初始化Outer，然后调用方法时，去创建一个Inner内部类；


public class InnerClassDemo1 {

    public static void main(String[] args){
        Outer outer = new Outer();
        outer.show();
    }

}

class Outer{
    private int num = 3;

    //内部类
    class Inner{
        //方法
        void show(){
            System.out.println("show [demo-1]	run..."	+	num);
        }
    }

    public void show (){
        //创建内部类
        Inner inner = new Inner();
        inner.show();
    }
}

show [demo-1] run...3

demo2：直接创建普通内部类

直接访问外部类中的内部类中的成员

//直接访问外部类中的内部类中的成员
public class InnerClassDemo2 {
    public static void main(String[] args){
        Outer.Inner inner = new Outer().new Inner();
        inner.show();
    }

}

class Outer{
    private int num = 4;

    class Inner{
        void show(){
            System.out.println("show [demo-2]	run..."	+	num);
        }
    }
}

show [demo-2] run...4

demo3：静态内部类

内部类定义在成员位置上,可以被private、static成员修饰符修饰。被static修饰的内部类只能访问外部类中的静态成员。

public class InnerClassDemo3 {
    public static void main(String[] args){
        Outer.Inner inner = new Outer.Inner();
        inner.show();
    }

}

class Outer{
    private static int num = 6;
    //如果内部类是静态的,相当于一个外部类
    static class Inner {
        void show(){
            System.out.println("show [demo -3] run..."	+	num);
        }
    }
}

demo4：内部类与内部类成员

如果内部类是静态的,内部类成员也是静态的,可以不用创建内部类对象,直接调用(内部类方法或者内部类属性)。

PS：如果内部类中定义了静态成员,该内部类也必须是静态的!

public class InnerClassDemo4 {
    public static void main(String[] args){
        Outer.Inner.show();
    }
}

class Outer{
    private static int num = 8;
    static class Inner{
        int a = 100;
        static void show(){
            System.out.println("show [8234897]	run..."	+	num);
        }
    }
}

class Outer2{
    private static int num2 = 99;
    static class Inner{
        static int a = 110;
        static void show(){

        }
    }
}

demo5：内部类与外部类成员调用关系

为什么内部类能直接访问外部类中的成员呢?    
那是因为内部类持有了外部类的引用,外部类名.this。

public class InnerClassDemo5 {
    public static void main(String[] args){
        new Outer().method();
    }
}

class Outer{
    int num = 109;

    class Inner{
        int num = 44;
        void show(){
            int num = 5;
            System.out.println("内部类方法的局部变量："+num);
            System.out.println("內部类成员变量："+this.num);
            System.out.println("外部类成员变量："+Outer.this.num);
        }
    }

    void method(){
        new Inner().show();
    }

}

内部类方法的局部变量：5
內部类成员变量：44
外部类成员变量：109

demo6：内部类访问外部类成员

内部类定义在局部位置上,也可以直接访问外部类中的成员； 同时可以访问所在局部方法中的局部变量,但必须是被final修饰的。

public class InnerClassDemo6 {
    public static void main(String args []){
        new Outer().method(55);
    }
}

class Outer{
    int num = 3;
    void method(int y){
        //局部方法的变量要是final修饰的，这样内部类才能使用（否则要建立一个拷贝）
        final int finalX = 9;
        class Inner {
            void show(){
                System.out.println("show..."	+ finalX +	","	+	y);
            }
        }
        Inner in = new Inner();
        in.show();
    }

}

demo7：匿名内部类是抽象类

/**
 * 匿名内部类
 * 定义:就是内部类的简化写法。
 * 前提:内部类可以继承或实现一个外部类或者接口。
 * 前提:内部类可以继承或实现一个外部类或者接口。
 * 前提:内部类可以继承或实现一个外部类或者接口。(说三遍！！)
 * 格式:new  外部类名或者接口名(){覆盖类或者接口中的代码,(也可以自定义内容。)}
 *      简单理解:就是建立一个带内容的外部类或者接口的子类匿名对象。
 * 什么时候使用匿名内部类呢?
 *      通常使用方法是接口类型参数,并且该接口中的方法不超过三个,可以将匿名内部类作为参数传递。
 * 好处:增强阅读性。
 * */

public class InnerClassDemo7 {
    public static void main(String [] args){
        new	Outer().method();
    }

}

//抽象类
abstract class Demo{
    abstract void show();
}


class Outer{
    int num = 4;

    void method(){

        new	Demo(){ //匿名内部类
            void show(){
                System.out.println("show......"	+	num);
            }
        }.show();
    }
}

demo8：匿名内部类是接口

public class InnerClassDemo8 {
    public static void main(String[] args){
        new	Outer().method();
    }
}

//接口定义
interface	Inter{
    void	show1();
    void	show2();
}

class Outer{
    public void method(){
        Inter inner2 = new Inter() {
            public void show1() {
                System.out.println("...show1....");
            }

            public void show2() {
                System.out.println("...show2....");
            }
        };
        inner2.show1();
        inner2.show2();
    }
}

demo9：内部类作函数实参

当函数参数是接口类型时,而且接口中的方法不超过三个。可以用匿名内部类作为实际参数进行传递。


public class InnerClassDemo9 {
    public static void main(String[] args){
        show(new Inter() {
            @Override
            public void show1() {
                System.out.println("...show1..."	);
            }

            @Override
            public void show2() {
                System.out.println("...show2..."	);
            }
        });
    }

    public static void show(Inter inter) {
        inter.show1();
        inter.show2();
    }
}

//接口定义
interface	Inter{
    void	show1();
    void	show2();
}