Java_内部类_10

内部类

概述和分类

1. 内部类是类的五大成分之一：成员变量，方法，构造器，代码块，内部类。

2. 什么是内部类？
   定义在一个类里面的类就是内部类。

3. 内部类有什么用？
   可以提供更好的封装性, 内部类有更多权限修饰符 , 封装性有更多的控制。
   可以体现出组件的思想。

4. 内部类的分类:
   （1）静态内部类。
   （2）实例内部类。（成员内部类）
   （3）局部内部类。
   （4）匿名内部类。（重点）

小结：
匿名内部类是我们的重点。

public class InnerClass {
    private static class English{
        private int age;
    }
}

静态内部类

1. 什么是静态内部类？
   有static修饰，属于外部类本身，会加载一次。

2. 静态内部类中的成分研究：
   类有的成分它都有，静态内部类属于外部类本身，只会加载一次
   所以它的特点与外部类是完全一样的，只是位置在别人里面而已。

3. 外部类=宿主
   内部类=寄生

4. 静态内部类的访问格式：
   外部类名称.内部类名称

5. 静态内部类创建对象的格式：
   外部类名称.内部类名称 对象名称 = new 外部类名称.内部类构造器;

6. 静态内部类的访问拓展：
   静态内部类中是否可以直接访问外部类的静态成员?
   可以的，外部类的静态成员只有一份，可以被共享！
   静态内部类中是否可以直接访问外部类的实例成员?
   不可以的,外部类的是成员必须用外部类对象访问！！

7. 小结：
   静态内部类属于外部类本身，只会加载一次
   所以它的特点与外部类是完全一样的，只是位置在别人里面而已。

public class InnerClass {
    public static void main(String[] args){
        System.out.println(Outter.English.Schoolname);
        Outter.English eng = Outter.English.createEnglish();
    }
    public static class Outter {
        public static class English {
            private int age;
            private String name;

            public static String Schoolname = "白马";

            public English(String name,int age) {
                this.age = age;
                this.name = name;
                System.out.println(name +"-->" + age + "岁");
            }
            public static English createEnglish(){
                return new English("夏明",10);
            }
        }
    }
}

（成员）实例内部类

1. 什么是实例内部类：
   无static修饰的内部类，属于外部类的每个对象的，跟着对象一起加载的。

2. 实例内部类的成分特点：
   实例内部类中不能定义静态成员，其他都可以定义。
   可以定义常量。

3. 实例内部类的访问格式：
   外部类名称.内部类名称。

4. 创建对象的格式：
   外部类名称.内部类名称 对象名称 = new 外部类构造器.new 内部构造器;

5. 拓展：
   实例内部类中是否可以直接访问外部类的静态成员？可以的，外部类的静态成员可以被共享访问！
   实例内部类中是否可以访问外部类的实例成员？可以的，实例内部类属于外部类对象，可以直接访问当前外部类对象的实例成员！

6. 小结：
   实例内部类属于外部类对象，需要用外部类对象一起加载，
   实例内部类可以访问外部类的全部成员！

public class InnerClass {
    public static void main(String[] args) {
        // 实例内部类属于外部类对象。实例内部类的宿主是外部类对象！！
        Outter.Inner in = new Outter().new Inner();
        in.show();
    }
}
// 外部类
class Outter{
    public static int age = 1;
    private double salary;

    // 实例内部类：无static修饰，属于外部类的对象
    public class Inner{
        private String name ;

        public static final String schoolName = "黑马";
        // 不能在实例内部类中定义静态成员！！！
//      public static String schoolName = "黑马";
//      public static void test(){
//
//      }

        // 实例方法
        public void show(){
            System.out.println(name+"名称！");
            System.out.println(age);  //实例内部类可以访问外部类的全部成员
            System.out.println(salary);
        }

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }
    }
}

局部内部类

1. 定义在方法中，在构造器中，代码块中，for循环中定义的内部类
   就是局部内部类。

2. 局部内部类中的成分特点：
   只能定义实例成员，不能定义静态成员
   可以定义常量的。

3. 小结：
   局部内部类没啥用。

public class InnerClass {

    static {
        abstract class A{   //局部抽象类

        }
    }

    public static void main(String[] args) {
        class A{
            private String name;

            public void test(){
            }
            public String getName() {
                return name;
            }

            public void setName(String name) {
                this.name = name;
            }
        }
        A a = new A();
        a.test();
    }

    public static void test(){
       class Animal{   //局部内部类
       }
       class Cat extends Animal{

       }
    }
}

匿名内部类

1. 什么是匿名内部类？
   就是一个没有名字的局部内部类。
   匿名内部类目的是为了：简化代码，也是开发中常用的形式。

2. 匿名内部类的格式：
   new 类名|抽象类|接口(形参){
   方法重写。
   }

3. 匿名内部类的特点：
   1.匿名内部类是一个没有名字的内部类。
   2.匿名内部类一旦写出来，就会立即创建一个匿名内部类的对象返回。
   3.匿名内部类的对象的类型相当于是当前new的那个的类型的子类类型。

4. 小结：
   1.匿名内部类是一个没有名字的内部类。
   2.匿名内部类一旦写出来，就会立即创建一个匿名内部类的对象返回。
   3.匿名内部类的对象的类型相当于是当前new的那个的类型的子类类型。

    public void main(String[] args){
        Animal a = new Animal() {
            @Override
            public void run() {
                System.out.println("猫猫跑的贼快");
            }
        }; //大括号到这里是匿名内部类
        a.run();
        a.go();
    }

匿名类的使用

需求：很多角色要一起参加游泳比赛（老师，学生，运动员）

分析过程： 对象回调！！！

具体代码实现如下：

public class InnerClass_2 {
    public static void main(String[] args){
        swim zhaocai = new swim() {
            @Override
            public void swimming() {
                System.out.println("猫猫油的很快~~");
            }
        };
        go(zhaocai);
    }
    public static void go(swim s){
        System.out.println("游泳开始~~");
        s.swimming();
        System.out.println("游泳结束~~");
    }
}
interface swim{
    void swimming();
}

像下面这样将整体传过去也可以！！

匿名内部类应用

实现窗口按钮点击事件

public class InnerClass_3 {
    public static void main(String[] args){
        //1.创建窗口
        JFrame win = new JFrame("登陆界面");
        //2.设置窗口大小
        win.setSize(400,300);
        //3.居中
        win.setLocationRelativeTo(null);
        //4.为当前界面加上按钮对象
        JButton btn = new JButton("开始登录");
        JPanel panel = new JPanel();
        panel.add(btn);
        win.add(panel);
        //5.为当前按钮对象绑定一个点击事件监听器
        btn.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                System.out.println("用户点击触发登录~~~");
            }
        });
        //6.显示窗口
        win.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
        win.setVisible(true);
    }
}