Java 内部类学习笔记

Java 内部类学习笔记

前言

本文会详细介绍内部类是什么，以及介绍几种不同的内部类的用法和细节

一、内部类是什么？

概念:
将类写在其他类的内部
可以写在其他类的成员位置和局部变量的位置

按照定义的位置不同
    成员内部类
    局部内部类

//public 默认不写的 final abstract
    public class A {//外部类
        //属性 成员变量 全局变量
        public int num;

        //成员内部类
        //private public 默认不写的 protected
        //static final abstract
        public class Inner1{
        }

        //静态成员内部类
        //身份和静态方法差不多
        public static class Inner2{
        }

        //成员方法
        public void m(){
            //局部内部类(身份和局部变量差不多)
            //默认不写的 final abstract修饰
            class X{
            }
        }
    }

二、内部类细节

  (1)每个内部类无论是成员内部类还是局部内部类都会产生一个.class文件
    外部类的字节码文件名称:
        A.class
    内部类的字节码文件名称:
    内部类是不能单独存在
        A$1X.class
        A$Inner1.class
        A$Inner2.class

(2)访问的特点
    内部类可以直接访问外部类的成员

三、内部类分类

1、非静态内部类

    概念:就是位于类的成员变量的位置

 public class 外部类{
       private 数据类型 属性名;
       public void 方法名{}
       public static void 方法名{}
       public class 内部类{//没有static修饰的内部类(非静态内部类)
         //属性
         //方法
         //特点:可以使用外部类中所有的成员你变量和成员方法(包括私有的)
         //可以直接访问外部的属性
         //还可以直接调用外部的成员方法
       }
}

如何创建这个非静态内部类的对象?
        外部类类名.内部类名 自定义对象名 = new 外部类构造器.new 内部类构造器();
        Outer.Inner oi = new Outer().new Inner();

上代码：

       非静态内部类中常见的修饰符?
            private 修饰
            public class 外部类 {
                //外部类的两个属性
                private String name;
                private String age;

                //在一个类中的方法需要调用内部类中的元素,但是又不希望内部类中的元素
                //被其他的内调用保证信息的安全
                public void access(String quanxian){
                    //添加权限判断
                    if("管理员".equals(quanxian)){
                        //创建内部类的对象然后调用内部类中的方法
                        Student student = new Student();
                        student.print();
                    }else{
                        System.out.println("你没有访问的权限");
                    }
                }
                 private class Student{
                    //打印学生学籍信息
                    public void print(){
                        System.out.println("姓名:" + name + "\n" + "年龄:" + age);
                    }
                }
            }

非静态内部类的经典题目

  public class Outer {
            private int a = 10;//外部类的成员变量
            class Inner{
                private int a = 20;//内部类的成员变量
                public void show(){
                    int a = 30;//局部变量
                    System.out.println(a);//30  局部变量
                    System.out.println(this.a);//20  this指本类中的元素,也就是内部类
                    System.out.println(Outer.this.a);//10
                }
            }
        }

2、静态内部类

       我们知道static可以修饰属性和方法
    static可不可以修饰外部类?不可以
    但是可以修饰内部类,这种用static修饰的内部类,称之为静态内部类

    回顾:
        静态方法中能通过    类名.静态方法名称 进行调用
        静态方法中只能调用静态的元素(静态方法和静态属性),非静态的
        无法进行调用,不能使用 this 和 super

    特点:
        静态内部类使用static进行修饰,只能直接访问外部类中的 静态 的成分
        原因:
            非静态的内部类编译之后会默认保存在一个指向外部类的引用,
            静态的内部类没有这个引用

        如何创建静态内部类的对象?
            Outer.Inner 自定义对象名 = new Outer.Inner();

上代码：

 public class StaticInner {
                    //外部类中的成员变量
                    static int num = 10;
                    public StaticInner() {
                        System.out.println("外部类的构造函数");
                    }
                    //外部类中的普通方法
                    public void n(){
                        System.out.println(num);
                    }
                    //外部类中的静态方法
                    public static void m(){
                        System.out.println(num);
                    }
                    //静态内部类
                    public static class Inner{
                        public Inner() {
                            System.out.println("静态内部类中的构造函数");
                        }
                        //静态内部类的方法
                        public void print(){
                            m();
                        }
                    }
                }

                public static void main(String[] args) {
                    StaticInner.Inner oi = new StaticInner.Inner();
                    oi.print();
                }

3、局部内部类

局部内部类 – 定义方法或者代码块中的内部类,身份和局部变量是一致的
特点:
主要是作用于发生了改变,只能在自身的方法中被调用
它的生命周期和方法是一致的,方法执行完了,这个内部类就不存在了

    格式:
        class Outer{
            public void m(){
                //只能使用final,abstract修饰,其他的修饰符都不可以使用
                class Inner{
                    //局部内部类中的方法
                }
                //创建局部内部类的对象
                //调用方法
            }
        }

上代码：

 public class Party {
                //吹气球的方法
                public void puffBall(){
                    //局部内部类
                    class Ball{
                        //局部内部类中的方法
                        public void puff(){
                            System.out.println("给气球,打气");
                        }
                    }
                    //在方法中创建局部内部类的对象才能将局部内部类中的方法调用
                    Ball ball = new Ball();
                    ball.puff();
                }

                public static void main(String[] args) {
                    Party party = new Party();
                    party.puffBall() ;
                }
            }

4、匿名内部类

匿名内部类 属于 局部内部类 ,说明在方法里面
最常用的到内部类就是匿名内部类,它是局部内部类的一种

        学习抽象类和接口的时候,知道不能创建对象,可以通过子类或者实现类创建对象
        调用方法
        可以通过匿名内部类来创建一个抽象了和接口的对象