FJ--匿名内部类预习

1. 匿名内部类 

interface Inter {
      public void show();
}

class Outer {
     /* class Inner implement Inter {
        public void show() {
             System.out.println("1111111111111111");
        }
     */
        }
       public void print() {
       /*
       Inner in = new Inner();
       in.show();
       Inter in = new Inner();
       in.show();*/
       //new Inner().show();
       /*
            new Inter() {
                public void show() {
                      System.out.println("22222222");
                }.show();
           }
       */
       }
}

 格式： new 要继承的类或者要实现的的接口（）{

                            重写继承的类或实现的接口中的抽象方法

             }

注意:上面的格式是一个语句,并不是成员方法和属性,所以必须要写在方法里.

解释：1.这种格式new Inter() {}就相当于实现了接口，也就相当于创建了Inner对象，所以可以直接调用show方法。上面不是测试了(new Inner().show() 和 上面格式调用show方法输出是一模一样).

 new Inter() {
           public void show() {
                  System.out.println("2222222222222222222222222");
           }
      }

2.上面复制的整个代码这一块就相当于Inter的子类对象，也就是相当于这样Inner in = new Inner();

3. 为什么写这个匿名内部类呢？因为你看Outer类里面有一个类可以实现Inter接口（也就是Inter的子类），然后可以重写接口里面的抽象方法，然后经过创建对象调用show方法. 但是如果我们没有Inner这个类,又怎么调用接口里面的抽象方法呢！！！这就用到了上面老师讲的两个相当于

二.匿名内部类练习

public class Not_Name_Class_interface01 {
    public static void main(String[] args) {
        Outer o = new Outer();
        o.print();
    }
}

interface Inter {
    public void show1();

    public void show2();
}

class Outer {
    /*
    class Inner implements Inter {
        public void show1() {
            System.out.println("show1输出了");
        }

        public void show2() {
            System.out.println("show2输出了");
        }
    }
    */

    public void print() {
       /*
        Inner i = new Inner();
        i.show1();
        i.show2();
    */
        new Inter() {
            public void show1() {
                System.out.println("show1输出了");
            }

            public void show2() {
                System.out.println("show2输出了");
            }
        }.show1();

        new Inter() {
            public void show1() {
                System.out.println("show1输出了");
            }

            public void show2() {
                System.out.println("show2输出了");
            }
        }.show2();
    }
}

 1.下面是匿名内部类调用方法:这样是可以的

 new Inter() {
            public void show1() {
                System.out.println("show1输出了");
            }

            public void show2() {
                System.out.println("show2输出了");
            }
        }.show1();
new Inter() {
            public void show1() {
                System.out.println("show1输出了");
            }

            public void show2() {
                System.out.println("show2输出了");
            }
        }.show2();

  解释:但是匿名内部类得初衷是为了少写代码但是你看匿名内部类调用方法方式太复杂了.

 2.改善

Inter in = new Inter() {
            public void show1() {
                System.out.println("show1输出了");
            }

            public void show2() {
                System.out.println("show2输出了");
            }
        };
        in.show1();//编译看左边(看接口里的),运行看右边看子类里面的
        in.show2();//编译看左边(看接口里的),运行看右边看子类里面的
        
//上面的代码和下面的意思是一样的
Inner i = new inner();

  解释:因为new Inter() {}整个这一块相当于Inter的子类对象,在这个对象前面加上一个Inter in不就是相当于父类类型的变量指向子类对象.这不就是多态吗!其实它就是多态. 它和 Inner i = new inner();是一个意思

 

in.show1();//编译看左边(看接口里的),运行看右边看子类里面的
        in.show2();//编译看左边(看接口里的),运行看右边看子类里面的

  总结: 匿名内部类什么时候最合适使用,当接口里面只有一个抽象方法的时候.有多个时候就用多态吧.

三.匿名内部类练习(思想,特别重要) 

/*
匿名内部类补足代码练习
*/
class Demo11_InnerClass {
      public static void main(String[] args) {
             Outer.method().show();
      }
}
interface Inter {
      void show();
}
class Outer {
//请补足代码,要求用匿名内部类来实现.
      public static ? method() {
             return 对象;
     }
}

 分析:

1. 我们在主方法里看到Outer.method()竟然可以调用方法,我们学的只有对象才能调用方法,说明什么?说明Outer调用method()方法后返回了一个对象,然后调用show()方法.

2. 调用show方法必须要有个类实现接口,并且实现这个接口里面的show方法,然后才能调用show方法.

3. 实现接口的类,就是这个接口的子类,然后想想咱们学的多态,父类里面的方法,子类重写后的调用过程(父类类型的引用指向子类对象,编译看左边,运行看右边)所以可以判断这个返回值类型应该写Inter,也就是用父类来接收.这样返回的对象是Inter的子类对象.对象的引用类型是Inter.

     4.下面来实现这个代码

 

/*
匿名内部类补足代码练习
*/
class Demo11_InnerClass {
      public static void main(String[] args) {
            // Outer.method().show();
            //相当于  Inter in = Outer.method();
      }
}
interface Inter {
      void show();
}
class Outer {
//请补足代码,要求用匿名内部类来实现.
      public static Inter method() {
            /*
            return new Inter() {
                  public void show() {
                       System.out.println("11");
                  }
             };
             */
             //注释的这个代码还可以这样写
              Inter in = new Inter() {
                  public void show() {
                       System.out.println("11");
                  }
             };
             return in;
     }
}

  5. 补充:method方法可以直接调用,说明method方法是静态的,然后它接着还能调用,说明调用method方法返回的是一个对象.

四.匿名内部类练习3

  1.匿名内部类以参数传递练习

/*
匿名内部类以参数传递练习
*/
class Demo12_InnerClass {
      pulic static void main(String[] args){
            function(new Inter() {
                 public void show() {
                    System.out.println("传递参数的形式来弄得");
                 }
            });
      }
      pulic static void function(Inter in) {//传过来之后就相当于父类引用指向子类对象.
             in.show();
      }
interface Inter {
      void show();
}

 2.匿名内部类的.class文件没有名字.