匿名内部类在接口和抽象类中的使用

匿名内部类在接口和抽象类中的使用

匿名内部类：

匿名内部类：没有名字的内部类。
由于接口和抽象类不能创建类对象，若一个接口的实现类需要使用一次，或者一个抽象类的子类需要使用一次，那么就可以使用匿名内部类；匿名内部类 只能创建一个对象。
类的本体就是大括号里面的所有内容。。

匿名内部类实现抽象类的子类：

例如：

package com.qfedu.inner.type;

abstract class AbstractTestType {
    abstract public void testInnerType();
}

/**
 * 一个类继承了Abstract修饰的类，强制要求完成的代码块 testInnerType
 */
class TestA extends AbstractTestType
{

    @Override
    public void testInnerType() {
        System.out.println("一个类继承Abstract修饰的类，从而要求完成的方法！！！");
    }
}

/*
我们要学习匿名类:
    没有名字的类！！！
    是没有类的本体吗???
        类的本体 就是大括号里面的所有内容！！！
 */

public class Demo1 {
    public static void main(String[] args) {
        TestA testA = new TestA();

        testA.testInnerType();

        /*
        以下代码的大括号中，是一个普通类继承abstract修饰的抽象类，必须完成的
        abstract方法。这不过，当前大括号没有class + 类名，只有【类的本体】

        这里实际上创建的对象是一个abstract类的子类对象。
        这里隐含一个继承关系！！！

        而且这里使用了多态！！！
        AbstractTestType att 是父类的引用类型变量
        new 创建的是一个子类对象！！！
         */
        AbstractTestType att = new AbstractTestType() {
            @Override
            public void testInnerType() {
                System.out.println("匿名内部类对象，调用该方法！！！");
            }
        };

        // 匿名内部类的对象调用方法！！！
        att.testInnerType();

        /*
        使用了一个匿名内部类，并且创建了一个对象，而这个对象也没有名字！！！
        匿名内部类的匿名对象
         */
        new AbstractTestType() {

            @Override
            public void testInnerType() {
                System.out.println("匿名内部类的匿名对象，直接调用方法！！！");
            }
        }.testInnerType();

        // low
        test(testA);

        // 匿名内部类的匿名对象，直接作为方法的参数！！！
        test(new AbstractTestType() {
            @Override
            public void testInnerType() {
                System.out.println("匿名内部类的匿名对象，直接作为方法的参数！！！");
            }
        });
    }

    public static void test(AbstractTestType t) {
        t.testInnerType();;
    }
}

匿名内部类接口的实现类：

例如：

package com.qfedu.inner.type;

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

/*

 */
interface A {
    public void testInterface();
}

interface B {
    public void print(int a);
}

class ZZ implements A {

    @Override
    public void testInterface() {
        System.out.println("ZZ类遵从A接口，实现testInterface方法");
    }
}


class SingleDogStaticPreson {
    private int id;
    private String name;
    private int salary;

    public SingleDogStaticPreson() {
    }

    public SingleDogStaticPreson(int id, String name, int salary) {
        this.id = id;
        this.name = name;
        this.salary = salary;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

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

    public int getSalary() {
        return salary;
    }

    public void setSalary(int salary) {
        this.salary = salary;
    }

    @Override
    public String toString() {
        return "SingleDogStaticPreson{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", salary=" + salary +
                '}';
    }
}

public class Demo2 {
    public static void main(String[] args) {
        ZZ zz = new ZZ();

        zz.testInterface();

        A a = new A() {
            @Override
            public void testInterface() {
                System.out.println("匿名内部类对象，调用类内的成员方法");
            }
        };

        a.testInterface();

        new A() {
            @Override
            public void testInterface() {
                System.out.println("匿名内部类的匿名对象，直接调用类内的成员方法");
            }
        }.testInterface();

        SingleDogStaticPreson s1 = new SingleDogStaticPreson(1, "萌萌", 10);
        SingleDogStaticPreson s2 = new SingleDogStaticPreson(2, "超超", 5);
        SingleDogStaticPreson s3 = new SingleDogStaticPreson(3, "帅帅", 6);
        SingleDogStaticPreson s4 = new SingleDogStaticPreson(4, "嘉豪", 2);
        SingleDogStaticPreson s5 = new SingleDogStaticPreson(5, "托马斯冲", 3);
        SingleDogStaticPreson s6 = new SingleDogStaticPreson(6, "国梁", 0);


        SingleDogStaticPreson[] arr = {s1, s2, s3, s4, s5, s6};

        /*
        匿名内部类的匿名对象，直接作为方法的参数！！！
        超级常用：
            Project
            DBUtils
         */
        Arrays.sort(arr, new Comparator<SingleDogStaticPreson>() {
            @Override
            public int compare(SingleDogStaticPreson o1, SingleDogStaticPreson o2) {
                return o1.getSalary() - o2.getSalary();
            }
        });

        System.out.println(Arrays.toString(arr));
    }
}