Day32内部类

内部类

1. 内部类就是在一个类中定义一个类，（在A类中定义一个B类，B类就被称为内部类）

   格式：public class 类名{ 修饰符 class 类名{} } 如：public class Outer{ public class Inner {} }

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

public class Outer{
    private int num = 10;
    public class Inner{
        public void show(){
            System.out.pirntln(num);//内部类可以直接访问外部类的成员，包括私有
        }
    }
    public void method(){
        Inner i = new Inner();//外部类想要访问内部类需要创建对象
        i.show();
    }
}

1. 按照内部类在类中定义的位置不同，可以分为两种：在类的成员位置被称为成员内部类；在类的局部位置（方法位置）被称为局部内部类。

   //成员内部类创建对象格式：外部类名 . 内部类名 对象名 = 外部类对象 . 内部类对象；(Outer.Inner oi = new Outer().new Inner();)

public class Outer{
    private int num = 10;
    private class Inner{
        public void show(){
            System.out.println(num);
        }
    }
    public void method(){
        Inner i = new Inner();//在method的方法中创建Inner内部类的对象并调用方法
        i.show();
    }
}
​
//测试类
public class InnerDemo{
    public static void main(String[] args){
        Outer o = new Outer();//在测试方法中创建外部类对象
        o.method();         //外部类对象调用method方法间接调用内部类对象和方法
    }
}

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

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();
    }
}
​
//测试类
public class OuterDemo{
    public static void main(String[] args){
        Outer o = new Outer();//定义外部类对象
        o.method();//外部类对象调用方法，间间访问到局部内部类的对象i调用的show方法
    }
}

1. 匿名内部类（局部内部类的一种）

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

   格式：new 类名或者接口名（）{ 重写方法； }; 如：new Inter(){ public void show(){} }; //最后分号不要缺少

//定义一个接口
public interface Inter {
    void show();
}
​
//在外部类中写局部内部类，然后写匿名内部类
public class Outer{
    public void method(){
        new Inter(){
            @Override
            public void show(){
                System.out.println("匿名内部类");
            }
        };//现在本质是一个对象
        
        new Inter(){
            @Override
            public void show(){
                System.out.println("匿名内部类");
            }
        }.show();//匿名内部类对象调用show方法，可以多次调用
        
        //因为定义的是个接口的实现类对象
        Inter i = new Inter(){
            @Override
            public void show(){
                System.out.println("匿名内部类");
            }
        };
        i.show();
    }
}
​
//定义一个测试类
public class OuterDemo{
    public static void main(String[] args){
        Outer o = new Outer();
        o.method();
    }
}

//创建跳高接口
public interface Jumpping{
    void jump();
}
​
//接口的操作类，里面有一个方法方法的参数是接口名
public class JumppingOperator{
    public void method(Jumpping j){
        j.jump();
    }
}
​
//测试类
public class JumppingDemo{
    public static void main(String[] args){
        //需求：创建接口操作类的对象，调用method方法
        JumppingOperator jo = new Jumpping Operator();
        Jumpping j = new Cat();//需要先创建实现类，然后在测试类中创建实现类对象
        jo.method(j);//调的是接口名，因为接口不能直接引用，因此需要定义一个实现类对象
        
        //如果不想创建实现类再定义对象，可以使用匿名内部类（本质是一个对象）
        jo.method(new Jumpping(){
            @Override
            public void jump(){
             System.out.println("猫可以跳高了");   
            }
        });
    }
}