内部类

1.1内部类概述

内部类：就是在一个类中定义另外一个类。

例如我们在A类中定义一个B类，那么B类就是A类的内部类，A则是B的外部类。

好比我们的手机是一个类，而手机内部的零件又属于一个类。

内部类的定义格式：

/*格式：
public class 类名{
    修饰符 class 类名{
        
    }
}
*/

//范例：
public class Outer{//外部类
    public class Inner{//内部类
        
    }
}

内部类的特点：

• 内部类可以直接访问外部类的所有成员
• 外部类访问内部类的成员必须创建对象

public class Outer{
    private int a=10;
    public String name="工地佬";
    public void show(){
        System.out.println("外部类的方法");
    }
    
    //内部类
    public class Inner{//当内部类的修饰符为静态时，则无法访问外部类的非静态成员，因为静态成员与类共加载，而非静态成员从属于对象，时间上有所差异
        public void show(){
        System.out.println("内部类的方法");
        System.out.println("外部类的属性"+a+name);//内部类可以访问外部类的所有成员
        }  
    }
    
    //外部类访问内部类的方法必须创建内部类的对象
    public void Method(){
        Inner i=new Inner();
        i.show();
    }
    
}

1.2 内部类的种类

根据内部类所在类的位置不同，将内部类划分为以下两种形式：

• 成员内部类：为内部类的成员位置

• 局部内部类：为类的局部位置，也就是方法内的类

1.2.1成员内部类

当外部程序访问内部类时，如何将内部类对象实例化？

• 当在外部访问一个类中的成员内部类时：

我们要先创建外部类的对象，再通过外部类对象再创建内部类的对象；

格式：外部类名.内部类名 类名=外部类对象.内部类;

范例：Outer.Inner i=new Outer().new Inner();

//创建一个含有成员内部类的类
public class Outer{
    private int a=10;
    public class Inner{
        public void show(){
            System.out.println(a);
        }
    }
}

//测试类
public class Test{
    public static void main(String[] args){
        //创建内部类格式
        Outer.Inner i=new Outer().new Inner();
        i,show();
    }
}

我们创建内部类其实是不想让外界直接访问，所以我们的内部类的修饰符一般不会用public，而是用private

当我们将内部类私有化后，会在外部类留有一个方法来访问内部类

public class Outer{
    private int a=10;
       /* public class Inner{
        public void show(){
            System.out.println(a);
        }我们的内部类一般不用public
    }
    */
    private class Inner{
        public void show(){
           System.out.println(a); 
        }
    }
    //在外部类中留下一个方法来访问内部类
    public void method(){
        Inner i=new Inner();
        i.show();
    }
    
}

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

1.2.2 局部内部类

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

public class Outer{
    private int a=10;
    public void method(){
        int b=20;//方法中的局部变量
        class Inner{
            public void show(){
            System.out.println(a);//可以访问外部类的成员
            System.out.println(b);//可以访问方法中的局部变量
          }
        }
        Inner i=new Inner();//要访问局部内部类的成员，必须通过在外部类的方法中建立局部内部类的对象进而调用
        i.show();
    }
}

public class Test{
    public static void main(String[] args){
        /*Outer o=new Outer();
        o.method;    直接调用方法并不会将方法中的类的方法执行，因为并没有明确的指令去调用局部内部类的方法
        */
        //在方法中建立局部内部类后方可访问
        Outer o=new Outer();
        o.method; // 10  20
    }
}

1.2.2.1 局部内部类中的匿名内部类

前提：有一个类或者接口，这个类可以是普通类，也可以是抽象类。

格式：new 类名/接口名(){

重写的方法}；

案例：

new Inter(){
   public void show{
        Syestem.out.println("匿名内部类输出了");
    }
);

匿名内部类也是在方法之中，其本质其实是一个继承类的子类对象或者是接口的实现类对象，只是没有名字而已。

public interface Inter{
    void show();
}

public class Outer{
    
    private int a=10;
    
    public void method{//外部类方法
        
        String name="工地佬";
        
        new Inter(){//匿名内部类，本质为实现类的对象
            public void show(){
                System.out.println("匿名内部类");
            }
        };
        //如何访问匿名内部类的方法呢？
        //既然其是一个对象，那么直接 对象.方法 调用即可
        new Inter(){
            public void show(){
                System.out.println("匿名内部类");
            }
        }.show();//匿名内部类直接.方法可以且只能调用其自身重写的方法
        //因为该匿名内部类为一个实现类对象，我们可以用多态的方式去接收这个对象
        Inter i=new Inter(){
            public void show(){
                System.out.println("匿名内部类");
            }
        };
        //然后直接用i来调用方法
        i.show();
    }
}

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