内部类 Java

内部类：

就是在一个类中定义一个类

定义格式：

public class 类名{
	修饰符 class 类名{
	}
}

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

package learn;

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();
    }
}

根据内部类在类中定义的位置不同，可以分为如下两种形式：
在类的成员位置：成员内部类
在类的局部位置：局部内部类

成员内部类：
成员内部类，外界如何创建对象使用呢？

1、格式：外部类名.内部类名 对象名=外部类对象.内部类对象;
eg.Outer.Inner oi=new Outer().new Inner();

package learn;

public class Outer {
    private int num=10;
    public class Inner{
        public void show(){
            System.out.println(num);
        }
    }
}

package learn;

public class TestDemo {
    public static void main(String[] args){
        Outer.Inner oi=new Outer().new Inner();
        oi.show();
    }
}

2、（常用）

package learn;

public class Outer {
    private int num=10;
    private class Inner{
        public void show(){
            System.out.println(num);
        }
    }

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

package learn;

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

局部内部类：

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

package learn;

public class Outer {
    private int num=10;

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

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

package learn;

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

匿名内部类： 局部内部类的一种特殊形式
前提：存在一个类或者接口，这里的类可以是具体类也可以是抽象类
格式：

new 类名或者接口名(){
	重写方法;
};

eg.

new Inter(){
	public void show(){
	}
}

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

package learn;

public interface Inter {
    void show();
}

package learn;

public class Outer {
    public void method(){
        /*
        new Inter(){
            public void show(){
                System.out.println("匿名内部类");
            }
        }.show();
        */
        Inter i=new Inter(){
            public void show(){
                System.out.println("匿名内部类");
            }
        };
        i.show();
    }
}

package learn;

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

匿名内部类在开发中的使用：
函数参数是接口名时，不用创建一个新的类来实现该接口并重写方法。使用匿名内部类即可

package learn;
/*
    跳高接口
*/
public interface Jumpping {
    void jump();
}

package learn;
/*
    接口操作类，里面有一个方法，方法的参数是接口名
 */
public class JumppingOperator {
    public void method(Jumpping j){
        j.jump();
    }
}

package learn;

public class TestDemo {
    public static void main(String[] args){
        JumppingOperator jo=new JumppingOperator();
        Jumpping j=new Cat();
        jo.method(j);

        Jumpping j2=new Dog();
        jo.method(j2);
        //每次想表明一种动物会跳高，都要新建一个类，太麻烦

        System.out.println("------------");

        jo.method(new Jumpping(){
            public void jump(){
                System.out.println("猫会跳高");
            }
        });
        jo.method(new Jumpping(){
            public void jump(){
                System.out.println("狗会跳高");
            }
        });
    }
}

package learn;

public class Cat implements Jumpping{
    @Override
    public void jump() {
        System.out.println("猫会跳高");
    }
}

package learn;

public class Dog implements Jumpping{
    @Override
    public void jump() {
        System.out.println("狗会跳高");
    }
}