内部类（成员、局部、匿名）

内部类

概述：内部类就是在一个类中定义一个类。举例：在一个类A的内部定义一个类B，类B就被称为内部类

内部类定义格式

public class 类名{

		修饰符   class   类名{

		}

}

内部类的访问特点

• 内部类可以直接访问外部类的成员，包括私有
• 外部类要访问内部类的成员，必须创建对象

``

package com.itheima_01;
/*## 内部类的访问特点

 * 内部类可以直接访问外部类的成员，包括私有
 * 外部类要访问内部类的成员，必须创建对象*/
public class Outer {
    private  int num=100;

    public class Inner{
        //内部类可以访问外部类的成员，包括私有
        public void show(){
            System.out.println(num);
        }

    }

    public void method(){
       // show();  会报错，外部类访问内部类要创建对象
        Inner i=new Inner();
        i.show();
    }
}

按照内部类在类中的定义的位置不同，分为两种形式

• 在类的成员位置：成员内部类
• 在类的局部位置：局部内部类

成员内部类

上面这个方法不常使用

经常是定义一个外部类的对象，然后调用外部类的方法A，方法A里面在调用内部类

``

package com.itheima_02;

public class Outer {
    private int num=10;

    public class Inner{
        public void show(){
            System.out.println(num);
        }
    }

    public void method(){
        Inner i=new Inner();
        i.show();
    }

}

``

package com.itheima_02;
/*测试类*/
public class InnerDemo {
    public static void main(String[] args) {
        //创建对象调用
//        Outer.Inner oi=new Outer().new Inner();
//        oi.show();
        Outer outer=new Outer();
        outer.method();
    }
}

局部内部类

局部内部类是方法中定义的类，所以外界是无法直接使用，需要在方法内部创建对象并使用。该类可以直接访问外部类的成员，也可以访问方法内的局部变量

``

package com.itheima_03;

public class Outer {
    private int num = 100;

    public void method() {
        int num2=90;
        class Inner {
            public void show() {
                System.out.println(num);
                System.out.println(num2);
            }

        }
        Inner i = new Inner();
        i.show();

    }


}

``

package com.itheima_03;
/*测试类*/
public class Demo {
    public static void main(String[] args) {
        Outer o=new Outer();
        o.method();
    }
}

匿名内部类

前提：存在一个类或者接口，这里的类可以是具体类也可以是抽象类

本质：是一个继承了该类或者实现了该接口的子类匿名对象

``

package com.itheima_04;

public class OuterDemo {
    public static void main(String[] args) {
        Outer outer=new Outer();
        outer.method();
    }
}

``

package com.itheima_04;

public class Outer {
    public void method(){
        // 是定义在方法内部，且本质是一个对象
        //对象调用方法形式
      /*  new Inter(){
            @Override
            public void show() {
                System.out.println("匿名内部类");
            }
        }.show();
*/
       Inter i= new Inter(){
            @Override
            public void show() {
                System.out.println("匿名内部类");
            }
        };
       //利用接口创建对象，实现多次调用
       i.show();
       i.show();
    }
}

匿名内部类在开发中的使用

``

package com.itheima_05;
/*测试类
* 需求：创建接口操作类的对象，调用method方法*/
public class JumppingDemo {
    public static void main(String[] args) {
        JumppingOperator jo=new JumppingOperator();
        Jumpping j=new Cat();
        jo.method(j);
        System.out.println("-----");

        //使用匿名内部类，这样就不用每次调用jump方法都需要先创建一个类，然后再让该类继承接口，再让接口指向该类对象
        //因为匿名内部类本质上就是一个实现该接口的实现类或者继承该类的子类的  对象，
        //用匿名内部类有了对象，直接调用方法
        jo.method(new Jumpping() {
            @Override
            public void jump() {
                System.out.println("Fox可以跳高了");
            }
        });

        jo.method(new Jumpping() {
            @Override
            public void jump() {
                System.out.println("Pig");
            }
        });
    }
}
em.out.println("Fox可以跳高了");
            }
        });

        jo.method(new Jumpping() {
            @Override
            public void jump() {
                System.out.println("Pig");
            }
        });
    }
}