Java中的内部类（成员内部类、静态内部类、局部内部类、匿名内部类）

- 日理万妓 2022-02-16 18:51 280阅读 0赞

# Java中的内部类（成员内部类、静态内部类、局部内部类、匿名内部类） #

我们先看这样一段话：人是由大脑、肢体、器官等身体结果组成。而组成我们人体的心脏它也有自己的属性和行为（血液、跳动），显然，此处不能单方面用属性或者方法表示一个心脏了，而需要一个类，但是这个类要依赖于人这个类存在（因为心脏不能脱离人体而存活，当然不考虑现今社会的发达科技，只从正常情况下来说），所心脏以需要写在人类的内部。内部类就相当于其中的某个器官之一。

首先看看什么是内部类：在类的内部定义另一个类。没错，定义就这么简单。如果在类Outer的内部再定义一个类Inner，此时Inner就称为内部类，而Outer则称为外部类。内部类的定义格式如下：

public class 外部类的名称{ 
        //外部类的成员
        public class 内部类的名称{ 
                 //内部类的成员
        }
    }

使用内部类有什么好处；

1）实现多重继承;

2）内部类可以很好的实现隐藏：一般的非内部类，是不允许有 private 与protected权限的，但内部类可以

3）减少了类文件编译后的产生的字节码文件的大小

使用内部类的缺点：使程序结构不清楚。

内部类在编译完成后也会产生.class文件，但文件名称是：外部类名称$内部类名称.class

内部类的种类：成员内部类、静态内部类、局部内部类、匿名内部类。下面分别详细学习一下这四种内部类的具体使用。

**一、成员内部类**

1、成员内部类也叫实例内部类。应用场合：每一个外部类对象都需要一个内部类的实例，内部类离不开外部类存在（相当于心脏对人体）

2、成员内部类的特征：

作为外部类的一个成员存在，与外部类的属性、方法并列

成员内部类持有外部类的引用

成员内部类中不能定义static变量和方法

3、使用格式：

Outer outer = new Outer();
    Outer.Inner inner = outer.new Inner();

代码演示一：

/* * 成员内部类 */
    public class Body { 
        String arm;
        String leg;
        String blood;
        public Body(String arm, String leg, String blood) { 
            super();
            this.arm = arm;
           this.leg = leg;
            this.blood = blood;
        }
        //内部类Heart
        class Heart{ 
            String name;
             void work() { 
                System.out.println("心脏正在给"+arm+leg+"输"+blood);
            }
         };
    }

public class Test { 
        public static void main(String[] args) {        
            Body body=new Body("两个胳膊","两条腿","血");
            Body.Heart  heart=body.new Heart();
            heart.work();
        }
    }

运行截图：

[![942621-20160427202347267-1221863720.png][]][942621-20160427202347267-1221863720.png 1]

代码演示二：

/* * 成员内部类 */
    public class Outer { 
    
        private String name="Hello World";
        
        public class Inner{ 
            public void print(){ 
                System.out.println(name);
            }
        };
        public void print(){ //定义外部类方法
            new Inner().print();//通过内部类的实例化对象调用方法
        }
        public static void main(String[] args) { 
            Outer outer=new Outer();
            outer.print();//调用外部类的方法
        }
    }

运行截图：[![942621-20160427202506080-1611230690.png][]][942621-20160427202347267-1221863720.png 1]

解释一下，上述代码中，new Inner().print();代码相当于
    Inner inner=new Inner();
    Inner.print();

**二、静态内部类**

1、内部类如果使用static声明，则此内部类就称为静态内部类。（其实也相当于外部类）可以通过外部类 . 内部类来访问。

2、静态内部类使用场合：内部类不需要外部类的实例（注意区分成员内部类），静态内部类存在仅仅为外部类提供服务或者逻辑上属于外部类，且逻辑上可以单独存在。

3、静态内部类的特征：

静态内部类不会持有外部类的引用

静态内部类可以访问外部的静态变量，如果访问外部类的成员变量必须通过外部类的实例访问

4、Java中只有内部类才可以是静态的

使用格式：Outer.Inner inner = new Outer.Inner();

代码演示一：

/* * 静态内部 */
    public class Company { 
        String companyNam;
        static String country;
        static class Clear{ 
            String name;
            public Clear() { 
                // TODO Auto-generated constructor stub
            }
            
            public Clear(String name) { 
                super();
                this.name = name;
            }
    
            public void work(String name){ 
                String na=new Company().companyNam="联想";
                country="中国";
                System.out.println(name+"为"+na+"打扫卫生，该公司属于"+country);
            }
        }
    }

public class Test { 
        public static void main(String[] args) { 
            Company.Clear zcl=new Company.Clear();
            zcl.work("shen_hua");
        }
    
    }

运行截图：[![942621-20160427203441423-21297669.png][]][942621-20160427202347267-1221863720.png 1]

代码演示二：

/* * 静态内部类 */
    public class Outer { 
        private static String info="Hello World";
        private int i=8;
        
        static class Inner{ 
            int num=new Outer().i;//获取外部类的非静态成员变量，景天成员变量可以直接使用
            public  void show() { 
                System.out.println(info+"---"+num);
            }
        };
    }

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

运行截图：[![942621-20160427203416080-81422984.png][]][942621-20160427202347267-1221863720.png 1]

**三、局部内部类：**

1、局部内部类也叫区域内嵌类，局部内部类与成员内部类类似，不过，区域内嵌类是定义在一个方法中的内嵌类。

2、使用场合：如果内部类对象仅仅为外部类的某个方法使用，使用局部内部类

3、特征：

用在方法内部，作用范围仅限于该方法中

根据情况决定持有外部类对象引用

不能使用private，protected，public修饰符

不能包含静态成员

代码演示一：

/* * 局部内部类 */
    public class School { 
    
        String schoolName;
        String buss="培养人才";
        int studentNum;
        public School() { 
            // TODO Auto-generated constructor stub
        }
        
        public School(String schoolName, String buss, int studentNum) { 
            super();
            this.schoolName = schoolName;
            this.buss = buss;
            this.studentNum = studentNum;
        }
    
        //宣传
        public void show(){ 
            final double tvMoney=10000;
            final double netMoney=20000;
            class AdverTeam{ 
                String teamName="shen_hua";
                //电视宣传
                public void tvShow(){ 
                    System.out.println("宣传队是："+teamName);
                    System.out.println("这是电视宣传，学校名称"+schoolName+",业务内容："+buss+"，学校人数："+studentNum+",宣传所需费用"+tvMoney);
                }
                //网络宣传
                public void netShow(){ 
                    System.out.println("宣传队是："+teamName);
                    System.out.println("这是网络宣传，学校名称"+schoolName+",业务内容："+buss+"，学校人数："+studentNum+",宣传所需费用"+netMoney);
                }
            }
            new AdverTeam().tvShow();
            new AdverTeam().netShow();
        }
    }

public class Test { 
        public static void main(String[] args) { 
            School qinghua=new School("清华","互联网培训",1000);
            
            qinghua.show();
        }
    }

运行截图：[![942621-20160427203257080-800698500.png][]][942621-20160427202347267-1221863720.png 1]

**四、匿名内部类**

1、如果一个内部类在整个操作中只使用一次的话，就可以定义为匿名内部类。匿名内部类也就是没有名字的内部类，这是java为了方便我们编写程序而设计的一个机制，因为有时候有的内部类只需要创建一个它的对象就可以了，以后再不会用到这个类，这时候使用匿名内部类就比较合适。

2、使用场合：简化内部类的使用

3、特征：

使用new创建 ，没有具体位置

创建的匿名类，默认继承或实现new后面的类型

根据使用情况决定是否持有外部类对象引用

内嵌匿名类编译后生成的.class文件的命名方式是”外部类名称$编号.class”，编号为1，2，3…n，编号为x的文件对应的就是第x个匿名类

代码演示：

/* * 匿名内部类 */
    public interface Person { 
        public void run();
    }

/* * 测试类 */
    public class Test { 
        public static void main(String[] args) { 
            Person p=new Person() {         
                public void run() { 
                    System.out.println("匿名内部类实现的");
                }
            };
            p.run();
        }
    
    }

运行截图：[![942621-20160427203141627-998477783.png][]][942621-20160427202347267-1221863720.png 1]

[942621-20160427202347267-1221863720.png]: /images/20220216/a9cf9fc817074a95949ca76302f147b9.png
[942621-20160427202347267-1221863720.png 1]: http://www.cnblogs.com/shen-hua/
[942621-20160427202506080-1611230690.png]: /images/20220216/ab313050005c470db5e405c147213954.png
[942621-20160427203441423-21297669.png]: /images/20220216/c4bf26e1bd3449e5b57087094716f685.png
[942621-20160427203416080-81422984.png]: /images/20220216/c4eeb8942af847ce91b393546c587d9d.png
[942621-20160427203257080-800698500.png]: /images/20220216/489c2afde0c14ec398cbdb47ab1ae3aa.png
[942621-20160427203141627-998477783.png]: /images/20220216/5f684c9f4bf5404ab41cce1813c8e466.png