207/208匿名内部类和匿名内部类的注意事项

匿名内部类

如果接口的实现类（或者是父类的子类）只需要使用唯一的一次，

那么这种情况下就可以省略掉该类的定义，而改为使用【匿名内部类】。

匿名内部类的定义格式:

　　　接口名称对象名=new接口名称() {
　　　　//覆盖重写所有抽象方法
　　};

接口

public interface MyInterface {
    void method();
}

实现类

public class MyInterfaceImpl implements MyInterface{
    @Override
    public void method() {
        System.out.println("实现类覆盖重写了方法");
    }
}

测试类

public class test {
    public static void main(String[] args) {
        //使用匿名内部类
        MyInterface obj = new MyInterface() {
            @Override
            public void method() {
                System.out.println("匿名内部类实现了方法! ");
            }
        };
        obj.method();
    }
}

 

匿名内部类的注意事项

 

另外还要注意几点问题:

1．匿名内部类，在【创建对象】的时候，只能使用唯一—次。

　　如果希望多次创建对象，而且类的内容一样的话，那么就必须使用单独定义的实现类了。

2．匿名对象,在【调用方法】的时候，只能调用唯——次。

　　如果希望同一个对象，调用多次方法，那么必须给对象起个名字。

3．匿名内部类是省略了【实现类/子类名称】，但是匿名对象是省略了【对象名称】

强调:匿名内部类和匿名对象不是一回事!!!l

 

接口

public interface MyInterface {
    void method1();
    void method2();
}

实现类

public class MyInterfaceImpl implements MyInterface{
    @Override
    public void method1() {
        System.out.println("实现类覆盖重写了方法");
    }
    @Override
    public void method2() {
        System.out.println("实现类覆盖重写了方法");
    }
}

测试类

public class test {
    public static void main(String[] args) {
        //使用匿名内部类
        MyInterface objA=new MyInterface() {

            public void method1() {
                System.out.println("匿名内部类实现了方法!111-A");
            }

            public void method2() {
                System.out.println("匿名内部类实现了方法!222-A");
            }
        };
        objA.method1();
        objA.method2();

       new MyInterface() {
            @Override
            public void method1() {
            System.out.println("匿名内部类实现了方法!111-B");
        }

        public void method2() {
        System.out.println("匿名内部类实现了方法!222-B");
        };
    }.method1();

    new MyInterface(){
        @Override
        public void method1() {
            System.out.println("匿名内部类实现了方法！");
        }

        @Override
        public void method2() {
            System.out.println("匿名内部类实现了方法！");
        }
    };
        }
}

 

public interface MyInterface {
    void d1();
    void d2();}



public class MyInterfaceImpl implements MyInterface{
    @Override
    public void d1() {
        System.out.println("覆盖重写了方法");
    }
    @Override
    public void od2() {
        System.out.println("覆盖重写了方法");
    }}


public class test {
    public static void main(String[] args) {
        //使用匿名内部类
        MyInterface objA=new MyInterface() {

            public void d1() {
                System.out.println("方法1");
            }

            public void d2() {
                System.out.println("方法2");
            }
        };
        objA.d1();
        objA.d2();

       new MyInterface() {
            @Override
            public void d1() {
            System.out.println("方法1");
        }

        public void d2() {
        System.out.println("方法2");
        };
    }.d1();

    new MyInterface(){
        @Override
        public void d1() {
            System.out.println("1");
        }

        @Override
        public void method2() {
            System.out.println("2");
        }
    };
        }
}