1.概述:

2.内部类之一:静态内部类

3.内部类之二:成员内部类

4.内部类之三:局部内部类

5.内部类之四:匿名内部类

1.概述:

内部类就是定义在一个类里面的类，里面的类可以理解成(寄生)。

2.内部类的使用场景、作用：

①当一个事务的内部，还有一个部分需要一个完整的结构进行描述，而这个内部的完整的结构又只为外部事物提供服务，那么整个内部的完整结构可以选择使用内部类来设计；

②内部类通常可以方便访问外部类的成员，包括私有的成员；

③内部类提供了更好的封装性，内部类本身就可以用private protectecd等修饰，封装性可以做更多控制。

3.内部类的分类

①静态内部类

②成员内部类

③局部内部类

④匿名内部类

2.内部类之一:静态内部类

1.概述:

有static修饰，属于外部类本身；

它的特点和使用与普通类是完全一样的，类有的成分它都有，只是位置在别人里面而已；

2.静态内部类创建对象的格式:

3.静态内部类的访问扩展:

①静态内部类是否可以直接访问外部类的静态成员？

可以，外部类的静态成员只有一份可以被共享访问。

②静态内部类是否可以直接访问外部类的实例成员？

不可以，外部类的实例成员必须用外部类对象访问。

4.代码演示:

外部类:

/**
 * 外部类
 */
public class Outer {
    /**
     * 静态成员内部类
     * 格式:外部类名.内部类名 对象名 = new 外部类名.内部类构造器
     * 范例: Outer.inner in = new Outer.inner();
     * 静态内部类可以直接访问外部类静态成员，因为外部类的静态成员只有一份可以被共享访问
     * 静态内部类不可以直接访问外部类实例成员，因为外部类的实例成员必须用外部类对象访问（可以new一个对象间接访问）
     */
     public static class Inner{
         public static int num = 111;
         private String hobby;
         private String name;
         private int age;
         public static String schoolName;

        public Inner() {

        }

        public Inner(String name, int age) {
            this.name = name;
            this.age = age;
        }
        public void show(){System.out.println("名称 ："+name);}
        public String getName() {return name;}
        public void setName(String name) {this.name = name;}
        public int getAge() {return age;}
        public void setAge(int age) {this.age = age;}
        public static String getSchoolName() {return schoolName;}
        public static void setSchoolName(String schoolName) {Inner.schoolName = schoolName;}
   
    }
}

main类:

public class Test {
    public static void main(String[] args) {
        Outer.Inner in = new Outer.Inner();
        in.setName("张三");
        in.show();
        Outer.Inner in2 = new Outer().new Inner();
        in2.show2();
        Outer.Inner.test();
        System.out.println("----------------");
        Outer.Inner in3 = new Outer("爱听课").new Inner();
    }
}

5.总结:

①如果一个类中包含了一个完整的成分，如汽车中的发动机类；

②特点、使用与普通类是一样的，类的成分它都有，只是位置在别人里面而已；

③可以直接访问外部类的静态成员，不能直接访问外部类的实例成员；

④注意:开发中实际上用的还是比较少。

3.内部类之二:成员内部类

1.概述:

①无static修饰，属于外部类的对象；

②JDK16之前，成员内部类中不能定义静态成员，JDK16开始也可以定义静态成员了；

2.成员内部类创建对象的格式:

3.代码演示:

外部类:

/**
 * 外部类
 */
public class Outer {
      /**
      * 成员内部类：不能加static修饰，属于外部类对象
      *格式：外部类名.内部类名 in = new Outer().new inner();
      * 范例:Outer.inner in = new Outer().new inner();
      * 成员内部类可以直接访问外部类静态成员，因为外部类的静态成员只有一份可以被共享访问
      * 成员内部类可以直接访问外部类实例成员，因为必须要先有外部类，才能有成员内部类对象。
      */
     public static class Inner{
         private String name;
         private int age;
     public static int a =100;
//构造方法
     public static void test(){
         System.out.println(a);
     }
     public void show (){
         System.out.println("名称："+name);
         System.out.println("数量："+name);
         System.out.println("爱好："+hobby);
     }
        public String getName() {return name;}
        public void setName(String name) {this.name = name;}
        public int getAge() {return age;}
        public void setAge(int age) {this.age = age;}
    }

}

main类:

public class Test {
    public static void main(String[] args) {
        Outer.Inner in = new Outer.Inner();
        in.setName("张三");
        in.show();
        Outer.Inner in2 = new Outer.Inner();
        in2.show();
        Outer.Inner.test();
        System.out.println("----------------");
        Outer.Inner in3 = new Outer("爱听课").new Inner();
        in3.show();
        }

}

4.成员内部类的访问扩展:

①成员内部类是否可以直接访问外部类的静态成员？

可以，外部类的静态成员只有一份可以被共享访问。

②成员内部类是否可以直接访问外部类的实例成员？

可以，因为必须现有外部类对象，才能有成员内部类对象，所以可以直接访问外部类对象的实例成员。

5.总结:

①成员内部类是什么样的、有什么特点？

无static修饰，属于外部类的对象；

可以直接访问外部类的静态成员，实例方法中可以直接访问外部类的实例成员；

②成员内部类如何创建对象？

外部类名.内部类名对象名 = new 外部类构造器.new 内部类构造器()；

6.注意:

在成员内部类中访问所在外部类对象。

格式:外部类名.this。

4.内部类之三:局部内部类

1.概述:

①局部内部类放在方法、代码块、构造器等执行体中；

②局部内部类的类文件名为:外部类$N内部类.class。

2.代码演示:

public class Test {
    static{
        class Dog{
            
        }
        abstract class Animal{//定义抽象类
            
        }
        interface SportManInter{//定义接口
            
        }
    }
    public static void main(String[] args) {
        /**
         * 局部内部类
         */
        class cat{
            private String name;
            public int onlineNumber = 100;
            public String getName(String s) {
                return name;
            }

            public void setName(String name) {
                this.name = name;
            }
        }
        cat c = new cat();
        System.out.println(c.getName("叮当猫~~"));

5.内部类之四:匿名内部类

1.概述:

本质上是一个没有名字的局部内部类，定义在方法中、代码块中、等。

2.作用:

方便创建子类对象，最终目的是为了简化代码编写。

3.格式:

例如:

4.特点:

匿名内部类是一个没有名字的内部类；
匿名内部类写出来就会产生一个匿名内部类对象；
匿名内部类的对象类型相当于是当前new的那个的类型的子类对象；
匿名内部类无需创建子类，方便简化代码；

5.案例:匿名内部类在开发中的使用形式。

需求: 某学校让老师，学生，运动员一起参加游泳比赛。

/**
 * 匿名内部类:可以作为方法的实际参数传输~~
 */
public class Test {
    public static void main(String[] args) {
        Swimming s = new Swimming() {
            @Override
            public void swim() {
                System.out.println("学生快乐的自由游泳~~");
            }
        };
        go(s);
        System.out.println("--------------");
        go(new Swimming() {
            @Override
            public void swim() {
                System.out.println("");
            }
        });
        go(s);
    }
    public static void go(Swimming s){
        System.out.println("开始————");
        s.swim();
        System.out.println("结束------");
    }
}
//游泳接口
interface Swimming{
    void swim();
}

使用总结: 匿名内部类可以作为方法的实际参数进行传输。

6.Lambda

①Lambda :简化匿名内部类的代码写法

②注意 :Lambda只能简化函数接口的匿名内部类的写法形式

③Lambda只能简化函数接口：首先必须是接口，其次接口中有且仅有一个抽象方法的形式

④Lambda表达式的省略规则:

参数类型可以省略；
如果只有一个参数，参数类型可以省略，（）也可以省略，同时省略分号；
如果Lambda表达式的方法体代码只有一行代码，可以省略大括号不写。此时如果这行代码是return语句，必须省略return不写，";"也可以省略；

public class Lambda {
    public static void main(String[] args) {
        swimming s1 =()->{
            System.out.println("老师游泳很快~~");
        };
    go(s1);
        System.out.println("=======================");
        go(new swimming() {
            @Override
            public void swim() {
                System.out.println("学生游泳很开心~~");
            }
        });
    }
    public static void go(swimming s){
        System.out.println("开始");
        s.swim();
        System.out.println("结束");
    }
}
interface swimming{
    void swim();
}

7.案例:匿名内部类在开发中的真实使用场景。

需求: 给按钮绑定点击事件

/**
 * 通过GUI，理解匿名内部类的真实使用场景
 */
public class Test {
    public static void main(String[] args) {
        //1.创建窗口
        JFrame win = new JFrame("登陆界面");
        JPanel panel = new JPanel();
        win.add(panel);
        //创建一个按钮对象
        JButton btn = new JButton("登录");
        //讲解匿名内部类的使用
        btn.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                JOptionPane.showMessageDialog(win,"点我一下，说明爱我！");
            }
        });
        //简化代码
        btn.addActionListener(e -> JOptionPane.showMessageDialog(win,"点我一下，告诉我你在！"));
        //3.把按钮对象添加到窗口上展示
        win.add(btn);
        //4.展示窗口
        win.setSize(400,300);
        win.setLocationRelativeTo(null);
        win.setVisible(true);
    }
}

使用总结:

①开发中不是我们主动去定义匿名内部类的，而是别人需要我们写或者我们可以写的时候才会使用。

②匿名内部类的代码可以实现代码的进一步简化。