Java内部类

内部类

内部类：在一个类中定义一个类。
什么时候使用内部类：B类表示的事物是A类的一部分，且B单独存在没有意义。

例：在类A中定义类B，类B称为内部类

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

public class Car {//外部类
    String carName;
    int carAge;
    int carColor;
    class Engine{//内部类
        String engineName;
        int engineAge;
    }
}

ctrl+F12查看类里面的东西
m为方法
f为属性（成员变量）
c为内部类

需求：写一个Javabean类描述汽车。
属性：汽车的品牌、年龄、颜色、发动机的品牌、使用年限。

Main：

public class Main {
    public static void main(String[] args) {
        System.out.println("Hello world!");
        
        Car car = new Car();
        car.carName = "宾利";
        car.carAge = 2;
        car.carColor = "红色";

        car.show();
    }
}

Car：

public class Car {//外部类
    String carName;
    int carAge;
    String carColor;

    public void show(){
        System.out.println(carName);
        Engine engine = new Engine();
        System.out.println(engine.engineName);
    }

    class Engine{//内部类
        String engineName;
        int engineAge;

        public void show(){
            System.out.println(engineName);
            System.out.println(carName);
        }
    }
}

内部类的分类：

成员内部类：

  写在成员位置的，属于外部类的成员。
  成员内部类可以被一些修饰符所修饰，比如：private，默认，protected，public，static等
  在成员内部类里面，JDK16之前不能定义静态变量，JDK16开始才可以定义静态变量。

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

1. 成员内部类被private修饰时：外部类编写方法，对外提供内部类对象
2. 成员内部类被非私有修饰时： 直接创建
格式：外部类名.内部类名 对象名 = 外部类对象.内部类对象；
范例：Outer.Inner oi = new Outer().new Inner();

public class Car {//外部类
    String carName;
    int carAge;
    String carColor;

    class Engine{//成员内部类
        String engineName;
        int engineAge;
    }
}

例子：

Test：

package demo3;

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

Outer:

package demo3;

public class Outer {
    private int a = 10;
    class Inner{
        private int a = 20;
        public void show(){
            int a = 30;
//            Outer.this  获取了外部类对象的地址值
            System.out.println(Outer.this.a);//10
            System.out.println(this.a);//20
            System.out.println(a);//30
        }
    }
}

静态内部类

   1.什么是静态内部类?
         静态内部类是一种特殊的成员内部类。
   2.直接创建静态内部类对象的方式？
         Outer.Inner oi = new Outer.Inner();
   3.如何调用静态内部类中的方法？
         非静态方法：先创建对象，用对象调用
         静态方法：外部类名.内部类名.方法名();

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

public class Car {//外部类
    String carName;
    int carAge;
    String carColor;

   static class Engine{//静态内部类
        String engineName;
        int engineAge;
    }
}

  创建静态内部类对象的格式：外部类名.内部类名 对象名 = new 外部类名.内部类名();
  调用非静态方法的格式：先创建对象，用对象调用
  调用静态方法的格式：外部类名.内部类名.方法名();

Test:

package demo4;

public class Test {
    public static void main(String[] args) {
//        注意事项：
//        1.静态内部类也是成员内部类中的一种
//        2.静态内部类只能访问外部类中的静态变量和静态方法
//        如果想要访问非静态的需要创建对象。

//        创建静态内部类对象的格式：外部类名.内部类名 对象名 = new 外部类名.内部类名();
//        调用非静态方法的格式：先创建对象，用对象调用
//        调用静态方法的格式：外部类名.内部类名.方法名();


//        创建静态内部类的对象
//        只要是静态的东西,都可以用类名点直接获取
        Outer.Inner oi = new Outer.Inner();
        oi.show1();

        //静态方法
        Outer.Inner.show2();
    }
}

Outer:

package demo4;

import java.sql.SQLOutput;

public class Outer {
    int a = 10;
    static int b = 20;
    //静态内部类
    static class Inner {
        public void show1() {
            System.out.println("非静态方法被调用了");

        }

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

    }
}

局部内部类

    1.将内部类定义在方法里面就叫做局部内部类，类似于方法里面的局部变量。
    2.外界无法直接使用，需要在方法内部创建对象并使用
    3.该类可以直接访问外部类的成员，也可以一访问方法内的局部变量。

Test：

package demo5;

public class Test {
    public static void main(String[] args) {

        //调用show方法,让代码执行
        Outer o = new Outer();
        o.show();
    }
}

Outer:

package demo5;

public class Outer {

    int b = 20;

    public void show() {
        int a = 10;
        //局部内部类
        class Inner {
            String name;
            int age;

            public void method1(){
                System.out.println(a);
                System.out.println(b);
                System.out.println("局部内部类中的method1方法");
            }

            public static void method2(){
                System.out.println("局部内部类中的method2静态方法");
            }
        }
        //创建局部内部类的对象
        Inner i = new Inner();
        System.out.println(i.name);
        System.out.println(i.age);
        i.method1();
        Inner.method2();
    }


}

- 匿名内部类（重点掌握）

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

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

范例：

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

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

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