Java继承——内部类

定义：在一个类里面，再定义一个类

什么时候用到：

        B类是A类的一部分，且B类单独存在没有意义，

内部类的访问特点：

        1，内部类可以直接访问外部类的成员，包括它的私有方法

        2，外部类要访问内部类的成员，必须创建对象

成员内部类

        写在成员的内部类，在类中，方法外。

如何书写成员内部类：

        写在成员位置，属于外部类的成员

        成员内部类可以被修饰符修饰

获取成员内部类对象的两种方式：

        方式一：外部类编写方法，对外提供内部类对象

        

public class Outter{
    String name;
    int age;
    
    private class Inner{
        String type;
     }

    public Inner getInner(){
        return new Inner();
      }

public static void main(String[] args){
    Outter o = new Outter();
    O.getInner();
    }
}

        方式二：直接编写       格式：外部类名.内部类名  对象名 = 外部类对象.内部类对象

public class Outer{
    String name;
    int age;

    public class Inner{
        String type;

    }
    
   
public static void main(String[] args){
    //方式二：直接创建
   Outer.Inner oi = new Outer().new Inner();
    System.out.println(oi);
    
}
}

成员内部类如何获取外部类的成员变量：

public class Outter{
    public int a = 10;
    
    class Inner{
        public int a = 20;

    public void show(){
        public int a = 30;
        
    System.out.println(a);//打印30
    System.out.println(this.a);//打印20
    System.out.println(Outter.this.a);//打印10
    }
}
}

静态内部类

注意：

        1.静态内部类也是成员内部类的一种

        2.静态内部类只能访问外部类的静态变量和静态方法，如果想要访问非静态的需要创建外部类的对象

创建静态内部类对象的格式：

        外部类名.内部类名  对象名 = new 外部类名.内部类名（）

调用静态方法的格式：

        外部类名.内部类名.方法名（）

public class Outter{
    int a = 10;
    static int b = 20;

    static class Inner{
        public void show1(){
            System.out.println("非静态方法调用了");
        }
        
        public static void show2(){
            System.out.println("静态方法调用了");
        }
    }

    Outter.Inner oi = new Outter.Inner();
    oi.show1();
}

局部内部类

定义：将内部类定义在方法里的类，类似与方法里的局部变量。

注意：1.外部无法直接使用，需要在方法内部创建对象并使用

            2.该类可以直接访问外部类的成员，也可以访问内部类的局部变量

public class Outter{
    
    public void show(){
        String name;
        int age;
        
//   局部内部类
        class Inner{
                int a=10;
                String type;
            public void menthod1(){
                System.out.println("局部内部类访问成员方法");
            }
            
            public static void menthod2(){
                System.out.println("局部内部类访问静态成员方法");
            }
        }
            
            Inner i = new Inner();
            System.out.println(i.a);
            System.out.println(i.type);
            i.menthod1();
            i.menthod2();
    }
}