内部类java_day9

内部类

定义：内部类就是定义在一个类里面的类，里面的类可以理解成==“寄生”，外部类可以理解成“宿主”==。

使用场景、作用

1. 当一个事物的内部，还有一个部分需要一个完整的结构进行描述，而这个内部的完整的结构又只能为外部事物提供服务，那么整个内部的完整结构可以选择内部类来设计（汽车&发动机）
2. 内部类通常可以方便地访问外部类的成员，包括私有成员
3. 内部类提供了更好的封装性，内部类本身就可以用private、protected等修饰，封装性可以得到更多控制（外部类只能用public修饰）

内部类的分类

1. 静态内部类（了解）
2. 成员内部类（非静态内部类，了解）
3. 局部内部类（了解）
4. 匿名内部类（重点！！！）

静态内部类

1. 有static修饰，属于外部类本身(相当于外部类的成员)
2. 它的特点和使用与普通类完全一样，类有的成分它都有，只是位置在别人里面而已

注意事项

1. 静态内部类里可以访问外部类的静态成员
2. 不能直接访问外部类的实例成员，只能通过外部类对象来访问
3. 静态内部类创建对象的方式：外部类.内部类 对象名 = new 外部类.内部构造器

例如下面的例子：外部类Outer、内部类Inner

package innerclass;
/**
 * 静态内部类
 */
public class Outer {
    public static int num = 100;
    private String hobby;

    public static class inner{//可以用private、protected等修饰
        private String name;
        private int age;
        private String schoolName;
        public void show(){
            System.out.println(num);//可以访问外部类的静态成员
//            System.out.println(hobby);//不能直接访问外部类的实例成员，只能通过外部类对象来访问
        }
        public inner() {
        }

        public inner(String name, int age, String schoolName) {
            this.name = name;
            this.age = age;
            this.schoolName = schoolName;
        }

        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 String getSchoolName() {
            return schoolName;
        }

        public void setSchoolName(String schoolName) {
            this.schoolName = schoolName;
        }
    }
}

package innerclass;

/**
 * 静态内部类
 */
public class TestMain {
    public static void main(String[] args) {
        Outer.inner in = new Outer.inner();//对象创建方式
        in.setName("小敏");
        System.out.println(in.getName());
    }
}

成员内部类

1. 无static修饰，属于外部类的对象
2. JDK16之前，成员内部类中不能定义静态成员，从16开始可以定义了

注意事项

1. 成员内部类的实例方法可以直接访问外部类的变量，因为必须有外部类对象，才能有内部类对象
2. 成员内部类属于外部类对象
3. 在成员内部类中访问外部类的同名成员变量时，外部类名.this.变量名
4. 成员内部类对象创建方式：外部类.成员内部类 对象名称 = new 外部构造器.new 内部构造器; Outer.Inner inner = new Outer().new Inner();

代码举例：外部类Outer、成员内部类Inner

package innerclass1;

/**
 * 成员内部类
 */
public class Outer {
    private String kind;//内部类的实例方法可以直接访问，因为必须有外部类对象，才能有内部类对象
    public static int age = 100;//内部类可以直接访问
    public class Inner{//属于外部类对象
        private String name;
        private int age;
//        public static int number;//16开始支持
        public void show(){
            System.out.println(kind);
            System.out.println(this.age);
            System.out.println(Outer.this.age);//在成员内部类中访问外部类对象，外部类名.this.变量名
        }
        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;
        }
    }
}

package innerclass1;

public class Test {
    public static void main(String[] args) {
        Outer.Inner inner = new Outer().new Inner();//创建对象方式，寄生与外部类对象
        inner.setName("老六");
        System.out.println(inner.getName());
    }

}

局部内部类

基本用不到，这里不做介绍

匿名内部类

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

2. 作用：方便创建子类对象，最终目的是为了简化代码编写

3. 格式：

   new 类/抽象类名/接口名(){
   重写方法；
   }

4. 特点：

   1. 匿名内部类是一个没有名字的内部类
   2. 匿名内部类写出来就会产生一个匿名内部类的对象
   3. 匿名内部类的对象类型相当于是当前new的那个类型的子类类型

5. 开发中不是我们主动去定义匿名内部类的，而是别人需要我们写或者我们可以写的时候才使用。匿名内部类的代码可以实现代码进一步的简化

场景举例

如今有一个父类Animal类，每个动物跑的特点不一样，即run方法在子类中表现出不一样的特征
现在我想创建一个Tiger类对象（当然它继承Animal），然后执行一下Tiger的run方法

一般思路：创建一Tiger类继承Animal,重写run方法，再Animal animal = new Tiger();多态创建对象来调用run方法

public class Test {
    public static void main(String[] args) {
        Animal animal = new Tiger();
        animal.run();
    }
}
class Tiger extends Animal{
    @Override
    public void run() {
        System.out.println("老虎跑的快");
    }
}
abstract class Animal{
    public abstract void run();
}

运行结果

老虎跑得快

不爽的地方：自己还要再写一个Tiger类，代码相对多

而使用匿名内部类的写法

public class Test {
    public static void main(String[] args) {
        Animal animal = new Animal() {//不是Animal对象，它不能创建对象
            @Override
            public void run() {
                System.out.println("老虎跑的快");
            }
        };
        animal.run();

    }
}
abstract class Animal{
    public abstract void run();
}

跑出来的结果一样

老虎跑得快

这样的代码显然比之前的更简洁

另外
匿名内部类可以作为方法的实际参数进行传输

因为上面用了抽象类举例，现在用一下接口来举例

场景：游泳课上，将老师下水游泳和学生下水游泳视为不同的特征

写法一

/**
 * 掌握匿名内部类的使用形式（语法）
 */
public class Test1 {
    public static void main(String[] args) {
        Swimming person1 = new Swimming() {
            @Override
            public void swim() {
                System.out.println("老师来游泳");
            }
        };
        go(person1);
    }
    public static void go(Swimming s){//对象回调
        System.out.println("开始。。。。");
        s.swim();
        System.out.println("结束。。。");
    }
}
interface Swimming{
    void swim();
}

运行结果

开始。。。。
老师来游泳
结束。。。

写法二

/**
 * 掌握匿名内部类的使用形式（语法）
 */
public class Test1 {
    public static void main(String[] args) {
    	Swimming person1 = new Swimming() {
            @Override
            public void swim() {
                System.out.println("老师来游泳");
            }
        };
        go(person1);
        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();
}

运行结果

开始。。。。
老师来游泳
结束。。。
开始。。。。
学生来游泳
结束。。。

匿名内部类还可以用lambda表达式继续简化，后面会介绍
待续~~~~