匿名内部类

目录

引入与介绍

匿名内部类的缺点

匿名内部类中的this

练习案例

---

引入与介绍

匿名内部类是指没有名字的内部类，主要针对于接口和对象，是局部内部类的一种

 interface  Computer{//计算接口
     int sum(int a,int b);
 }

 class Math1 {//数学类
     //求和方法
     public void sum1(Computer c, int x, int y) {
         System.out.println(c.sum(x, y));
     }
 }

 ​
 class ComputerImpl implments Computer{
     @Override
     public int sum(int a, int b) {
         return a+b;
     }
 }


 public class Class1 {
     public static void main(String[] args) {
         Math1 math=new Math1();
         //math.sum1(,100,200);//sum1(Computer c, int x, int y)
 /*此时如果要调用sum1方法，第一个参数要为姐阔的对象，但是接口不能实例化对象，解决办法：
         1.要用一个类来实现接口，用这个实现接口的类的对象来代替接口的对象
         2.使用匿名内部类可以不用定义实现接口
         
 */
         //1.使用方法1
         math.sum1(new ComputerImpl(),100,200);
         //2.使用方法2，不用定义实现接口的类
         math.sum1(new Computer(){
             @Override
             public int sum(int a, int b) {
                 return a+b;
             }
         },100,200);
 /* 在这个方法2中，
         new Computer(){
             @Override
             public int sum(int a, int b) {
                 return a+b;
             }
         }
 是匿名内部类创建的对象，这里看上去是接口直接new了，但实际上接口并没有直接new，
 后面{}代表了对接口的实现
 */ 
         
     }
 }

匿名内部类的缺点

不建议使用匿名内部类，使用匿名内部类，没有名字，不能重复使用，代码只能使用一次，可读性差

1. 代码太复杂，太乱，可读性差

2. 类没有名字不能重复使用

匿名内部类中的this

 class Class1{
     interface A{
         public static final int b=3;
         public void eat();
     }
     public static void main(String[] args) {
       
         Class1.A  c= new A() {
             @Override
             public void eat() {
                 System.out.println(this.b);
                 //此处的this，代表的是匿名内部类
             }
         };
 ​
     }
 }

练习案例

1. 补全代码

    interface Inter { 
            void show(); 
        }
        class Outer { 
            //补齐代码 
            
        }
        class OuterDemo {
            public static void main(String[] args) {
                  Outer.method().show();
              }
        }
        要求在控制台输出”HelloWorld”

   代码补全后为

   interface Inter {
        void show();
    }
    class Outer {
        //补齐代码
        public static Inter  method(){
           return new Inter(){
                @Override
                public void show() {
                    System.out.println("HelloWorld");
                }
            };
        }
    }
    class OuterDemo {
        public static void main(String[] args) {
            Outer.method().show();
   //Outer.method()是调用Outer类中的方法，可以直接调用说明该方法属于类，则该方法为静态的
        }
    }

2. 请编写程序，通过接口的方式创建匿名内部类

    interface Animal{
        public void eat();
    }
    class A{
        public void a(Animal a){
            a.eat();
        }
    }
    class Class1{
        public static void main(String[] args) {
            A a=new A();
            a.a(new Animal() {
                @Override
                public void eat() {
                    System.out.println("猫吃鱼");
                }
            });
        }
    }

3. 请编写程序，通过抽象类的方式创建匿名内部类

    abstract class Animal{
       public abstract void eat();
    }
    class A{
        public void a(Animal a){
            a.eat();
        }
    }
    class Class1{
        public static void main(String[] args) {
            A a=new A();
            a.a(new Animal() {
                @Override
                public void eat() {
                    System.out.println("猫吃鱼");
                }
            });
        }
    }

4. 请编写一个类中定义了一个接口然后在该类中在使用这个接口

   class Class1{
        interface A{
            public void eat();
        }
        class B{
            //内部类B
            public void b(){
                System.out.println("内部类B的方法b");
            }
        }
        public static void a(A c){
            c.eat();
        }
        public static void main(String[] args) {
           Class1.a(new A() {
               @Override
               public void eat() {
                   System.out.println("吃饭1");
               }
           });
           Class1.B s=new Class1().new B();
           s.b();
            Class1.A  c= new A() {
                @Override
                public void eat() {
                        System.out.println("吃饭2");
    ​
                }
            };
            c.eat();
        }
    }