【JAVA】内部类

什么是内部类

将一个类定义在另一个类的内部，这个类就称为内部类。

内部类的分类 

内部类可以分为四类：

• 成员内部类
• 静态内部类
• 局部内部类
• 匿名内部类

 成员内部类

成员内部类：就是位于外部类成员位置的类。

特点：可以使用外部类中所有的成员变量和成员方法，包括private私有的。

public class Demo1 {
    //成员内部类
    private int n=10;

    public int sumN(){
        for (int i = 0; i < 10; i++) {
            n++;
            new Demo1Inner().AddN();//内部类一般在本类中使用
        }
        return n;
    }
    //内部类指在类的内部定义的类
    //内部类可以直接使用本类中的成员，即使是private私有的
    //成员内部类
    class Demo1Inner{
        public void AddN(){
            if (n%2==0){
                n--;
            }
        }
    }
}
public class DemoTest {
    public static void main(String[] args) {
        System.out.println(new Demo1().sumN());
    }
}

静态内部类

静态内部类：被 static 所修饰的内部类，按位置分，属于成员内部类，但也可以称作静态内部类，也常叫做嵌套内部类。

特点：不能使用外部类的非static成员变量和成员方法。

public class StaticInner {
    //静态内部类
    static private int n = 10;//静态成员变量

    public int sumN() {
        for (int i = 0; i < 10; i++) {
            n++;
            new Demo1Inner().AddN();//内部类一般在本类中使用
        }
        return n;
    }

    //静态内部类只能访问外部类中的静态成员
    static class Demo1Inner {
        public void AddN() {
            if (n % 2 == 0) {
                n--;
            }
        }
    }
}

局部内部类

局部内部类：就是定义在一个方法或者一个作用域里面的类。

特点：主要是作用域发生了变化，只能在自身所在方法和属性中被使用。

public class Demo2 {
    //局部内部类，定义在一个方法或者一个作用域里面的类
    private int n=10;

    public int sumN(){
        for (int i = 0; i < 10; i++) {
            n++;
            //局部内部类，只能在自身所在方法和属性中被使用
            class Demo1Inner{
                public void AddN(){
                    if (n%2==0){
                        n--;
                    }
                }
            }
        }
        return n;
    }


}

匿名内部类

匿名内部类：一个没有名字的类，是内部类的简化写法。只在本类中使用的功能，定义在内部类中，实现封装，需要使用时new 内部类就可以。只使用一次的情况，我们可以在使用的地方，使用匿名内部类来直接重写。

匿名的特点：

• 内部类仍然是一个独立的类，在编译之后内部类会被编译成独立的.class文件，但是前面冠以外部类的类名和$符号。
• 内部类不能用普通的方式访问。内部类是外部类的一个成员，因此内部类可以自由地访问外部类的成员变量，无论是否为 private 的。
• 内部类声明成静态的，就不能随便访问外部类的成员变量，仍然是只能访问外部类的静态成员变量。

匿名内部类的意义：实现封装性，隐藏起来，外界不知道里面的代码，间接实现多继承。

import java.util.Arrays;
import java.util.Comparator;

public class AnimalTest {
    /*
    匿名内部类，只在本类中使用的功能，定义在内部类中，实现封装，需要使用时new 内部类就可以。
    内部类的意义：实现封装性，隐藏起来，外界不知道里面的代码，间接实现多继承
     */
    public static void main(String[] args) {
        Animal animal1=new Animal(4,"金毛");
        Animal animal2=new Animal(5,"柯基");
        Animal animal3=new Animal(2,"拉布拉多");
        Animal animal4=new Animal(6,"哈士奇");

        Animal[] animals={animal2,animal1,animal4,animal3};
        //需要多次使用时，我们可以在新建一个类来实现Compare接口
        //Animal年龄从小到大排序
        Arrays.sort(animals,new MyCompare());//使用Arrays中的sort()需要实现Comparable接口中的CompareTo方法
        //Compare接口，比较器
        System.out.println("Animal年龄从小到大排序"+Arrays.toString(animals));
        System.out.println();

        //只使用一次的情况，我们可以在使用的地方，使用匿名内部类来直接重写
        //Animal年龄从大到小排序
        Arrays.sort(animals, new Comparator<Animal>() {
            @Override
            public int compare(Animal o1, Animal o2) {
                return o2.age-o1.age;
            }
        });
        System.out.println("Animal年龄从大到小排序"+Arrays.toString(animals));

    }
}
public class Animal {
    int age;
    String name;

    public Animal(int age, String name) {
        this.age = age;
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Animal{" +
                "age=" + age +
                ", name=" + name +
                '}';
    }
}
import java.util.Comparator;

public class MyCompare implements Comparator<Animal> {

//为Animal开发排序比较类
    @Override
    public int compare(Animal o1, Animal o2) {
        return o1.age-o2.age;
    }
}