Java内部类

成员内部类

成员：类中的属性

内部类代码

package 成员内部类;

/**
 * @auther LiuWeirui
 * @date 2022/3/5 13:50
 * 成员内部类特点:
 * 1.内部类可以访问外部类的成员（包括方法和属性包括私有的）
 * 2.外部类如果访问内部类的成员,必须创建内部类对象
 * 3.内部类可以修饰共有私有，因为他在外部类中被作为一个成员属性看待
 */
public class Outer{
    private static int i;
    //成员内部类，充当一个成员属性
    public class Inner{
        public void show(){
            //内部类可以访问外部类的方法
            System.out.println(i);
        }
    }

    //静态成员内部类
    static class Inner2{
        public void show(){
            System.out.println(i);
        }
    }

    public void show1(){
        new Inner().show();
    }
}

调用外部类的内部类

package 成员内部类;

/**
 * @auther LiuWeirui
 * @date 2022/3/5 13:53
 */
public class Test {
    public static void main(String[] args) {
        //创建成员内部类对象
        new Outer().new Inner().show();
        //静态内部类调用
        new Outer.Inner2().show();
    }
}

局部内部类

局部：方法内部的属性

局部类代码

package 局部内部类;

/**
 * @auther LiuWeirui
 * @date 2022/3/5 14:00
 */
public class Outer {
    private int num;
    public void show(){
        String name = "张三";
        //局部内部类
        class Inner{
            public void show1(){
                //局部内部类可以访问外部类的成员属性
                System.out.println(num);
                //局部内部类也可以访问外部类的局部属性
                System.out.println(name);
            }
        }
        //局部内部类在外部类的局部方法中声明调用
        new Inner().show1();
    }
}

调用局部内部类

package 局部内部类;

/**
 * @auther LiuWeirui
 * @date 2022/3/5 14:00
 * 1.局部内部类是定义在外部类方法里的类
 * 2.局部内部类不能直接使用，需要在外部类的方法内创建对象（其实和方法内的属性一个规则）
 * 3.局部内部类可以访问外部类的成员变量和局部变量
 */
public class Test {
    public static void main(String[] args) {
        //调用外部类的局部内部类
        //局部内部类不能在外部new调用，只能在方法内部new其对象（和局部属性一样的道理）
        new Outer().show();
    }
}

匿名内部类

匿名内部类主要实现接口使用，使用范围取决于其声明对象的范围（看代码即可理解），匿名内部类可以使用lambada表达式简化

接口

package 匿名内部类;

/**
 * @auther LiuWeirui
 * @date 2022/3/5 14:09
 */
public interface Flying {
    void fly();
}

匿名内部类代码

package 匿名内部类;

/**
 * @auther LiuWeirui
 * @date 2022/3/5 14:07
 */
public class Bird {

    public void show() {
        /*
         * 1.匿名内部类,用于实现接口
         * 2.接口类型 对象 = new 接口类型(){重写接口中的方法};
         * 用于简化省略接口的实现类
         * 3.接口对象接收接口实现来方便调用接口以重写方法
         * */
        Flying f = new Flying() {
            //重写接口中的方法
            @Override
            public void fly() {
                System.out.println("我是一只会飞的鸟");
            }
        };

        /*
        * lambada表达式简化匿名内部类
        * 1.接口类型 对象 = 重写方法的(参数列表) -> {重写方法的代码体};    代码体部分可以加花括号
        *使用lambada表达式你重写哪个方法，是根据->左侧的要被重写的参数列表决定的，换而言之，lambada表达式是根据匹配参数列表来决定你要重写的方法
        * */
        Flying f2 = () -> System.out.println("我是一只会飞的鸟");
        /*
        *   匿名内部类用对象接收实例，对象使用的范围取决于对象是（局部还是成员）属性
        *   因为这里用的是局部对象接收，所以只能在局部中调用接口重写方法
        * */
        f.fly();
        f2.fly();
    }
}

lambada表达式更详细,以及其他的用法，大家可以看我今后发布的文章会详细介绍的

调用匿名内部类

package 匿名内部类;

/**
 * @auther LiuWeirui
 * @date 2022/3/5 14:07
 * 1.匿名内部类主要实现接口使用
 * 2.匿名内部类可以写在局部也可以写在成员中
 * 匿名内部类
 * 前提:有一个可以被继承的类或者接口
 * 格式:new 类名或者接口名(){
 *     重写方法
 * }
 * 本质:
 * 一个继承了该类或者实现了该接口的子类匿名对象
 */
public class Test {
    public static void main(String[] args) {
        new Bird().show();
    }
}

总结

---

        1.使用匿名内部类就意味着接口可以被当做参数传递，因为匿名内部类可以传递一个已经被实例化的接口对象（接口作为参数，原先只能传接口实现类的对象，现在有了大幅度的简化）

示例代码

接口

public interface Jump {

    void jump();
}

接口实现类（演示老的写法）

public class Monkey implements Jump {
    @Override
    public void jump() {
        System.out.println("猴子跳");
    }
}

实体类（使用接口功能）

public class Person {
    public void  play(Jump j){
        j.jump();

    }
}

测试类（main方法）

public class Test {
    public static void main(String[] args) {

        Person person = new Person();
        //方法1(老的写法)
             //Monkey monkey = new Monkey();
             //person.play(monkey);

        //方法2(匿名内部类的写法)
        person.play(new Jump() {
            @Override
            public void jump() {
                System.out.println("羚羊跳跃");
            }
        });
    }
}