Java内部类

 一、类的五大成员：属性、方法、构造方法、代码块、内部类

内部类：在一个类的里面，再定义一个类

举例：在A类的内部定义B类，B类就被称为内部类

示例：写一个JavaBean类描述汽车，属性：汽车的品牌，车龄，颜色，发动机的品牌，使用年限

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

内部类表示的事物是外部类的一部分，内部类单独出现没有任何意义

内部类的访问特点：内部类可以直接访问外部类的成员，包括私有

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

示例：

package a10innerclassdemo1;

public class Car {
    String carName;
    int carAge;
    String carColor;
    public void show(){
        System.out.println(carName);
        Engine e=new Engine();
        System.out.println(e.engineName);
    }
    class Engine{
        String engineName;
        int engineAge;
        public void show(){
            System.out.println(engineName);
            System.out.println(carName);
        }
    }
}

测试类：

package a10innerclassdemo1;

public class Test {
    public static void main(String[] args) {
        Car c=new Car();
        c.carName="宾利";
        c.carAge=1;
        c.carColor="白色";
        c.show();

    }
}

运行结果：

二、内部类的分类：

（一）成员内部类：

1.写在成员位置（类中，方法外），属于外部类的成员。上边Engine就是成员内部类

2.成员内部类可以被一些修饰符所修饰，比如：private，默认，protected，public，static等

3.在成员内部类里面，JDK16之前不能定义静态变量，JDK16开始才可以定义静态变量

4.获取成员内部类对象：

方式1：当成员内部类被private修饰时：

             在外部类中编写方法，对外提供内部类的对象 

方式2：当成员内部被非私有修饰时：

             直接创建格式：外部类名.内部类名 对象名=外部类对象.内                  部类对象

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

外部类：

package a11innerclassdemo2;

public class Outer {
    String name;
     private class Inner{//一种是改成public修饰

    }
    public Inner getInstance(){
        return new Inner();//另一种是：在外部类中编写方法，对外提供内部类的对象 
    }
}

测试类：

package a11innerclassdemo2;

public class Test {
    public static void main(String[] args) {
        //Outer.Inner oi=new Outer().new Inner();
        Outer o=new Outer();
        System.out.println(o.getInstance());
    }
}

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

外部类成员变量和内部类成员变量重名时，在内部类访问：

System.out.println(Outer.this.变量名);

例如：外部类：

package a11innerclassdemo2;

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

 测试类：

package a11innerclassdemo2;

public class Test1 {
    public static void main(String[] args) {
        Outer1.Inner1 oi=new Outer1().new Inner1();
        oi.show();
    }
}

运行结果：

（二）、静态内部类

成员内部类被static修饰，就是静态内部类

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

创建静态内部类对象的格式：外部类名.内部类名 对象名=new 外部类名.内部类名();

                                               Outer.Inner oi=new Outer.Inner();

调用非静态方法的格式：先创建对象，用对象调用

调用静态方法的格式：外部类名.内部类名.方法名();

示例：外部类：

package a11innerclassdemo2;

public class Outer2 {
    int a=10;
    static int b=20;
    static class Inner2{
        public void show1(){
            System.out.println("非静态的方法被调用了");
            Outer2 o=new Outer2();
            System.out.println(o.a);
            System.out.println(b);
        }
        public static void show2(){
            System.out.println("静态的方法被调用了");
        }
    }
}

测试类：

package a11innerclassdemo2;

public class Test2 {
    public static void main(String[] args) {
        //创建静态内部类的对象
        //只要是静态的东西都可以用类名点直接获取
        Outer2.Inner2 oi=new Outer2.Inner2();
        oi.show1();//调用非静态的方法

        //调用静态方法
        Outer2.Inner2.show2();
    }
}

运行结果：

（三）、局部内部类

1.将内部类定义在方法里面就叫做局部内部类，类似于方法里面的局部变量

2.外界是无法直接使用的，需要在方法内部创建对象并使用

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

示范：外部类：

package a11innerclassdemo2;

public class Outer3 {
    int b=20;
    public void show() {
        int a=10;
        //局部内部类
        class Inner3 {
            String name;
            int age;
            public void method1(){
                System.out.println("局部内部类中的method1方法");
            }
            public static void method2(){
                System.out.println("局部内部类中的method2静态方法");
            }

        }

        //创建局部内部类的对象
        Inner3 i = new Inner3();
        System.out.println(i.name);
        System.out.println(i.age);
        i.method1();
        Inner3.method2();
    }
}

测试类：

package a11innerclassdemo2;

public class Test3 {
    public static void main(String[] args) {
        //调用show方法，让代码执行
        Outer3 o=new Outer3();
        o.show();

    }
}

运行结果：

（四）、匿名内部类

匿名内部类本质就是隐藏了名字的内部类，可以写在成员位置，也可以写在局部位置

格式： new 类名或者接口名(){

            重写方法;

            };

格式的细节：包含了继承或实现，方法重写，创建对象

                     整体就是一个类的子类对象或者接口的实现类对象

使用场景：当方法的参数是接口或者类时，以接口为例，可以传递这个接口的实现类对象，如果                       实现类只要使用一次，就可以用匿名内部类简化代码，没必要创建一个新的类了

举例：

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

示例：接口类：

package a12innerclassdemo3;

public interface Swim {
    public abstract void swim();
}

测试类：

package a12innerclassdemo3;

public class Test {
    public static void main(String[] args) {
        //编写匿名内部类的代码
        new Swim(){
            @Override
            public void swim() {
                System.out.println("重写了游泳的方法");
            }
        };
    }
}