java面向对象内部类中有关知识点2

/*一道面试题
   class Outer {
      public int num = 10;
      class Inner {
         public int num = 20;
         public void show() {
            int num = 30;
            System.out.println(?);
            System.out.println(??);
            System.out.println(???);
         }
      }
   }
在控制分别输出：30，20，10
 */，。，，，，，

class Outer5{
    public int num = 10;

    class Inner5 {
        public int num = 20;
        public void show() {
            int num = 30;
            System.out.println(num); //30
            System.out.println(this.num); //20
//上面那句输出20  也可以这样写：  System.out.println(Inner5.this.num);
            //Outer5和Inner5不是继承关系，没有super关键字
//            System.out.println(super.num); //10
//            System.out.println(new Outer5().num);//创建对象调用方法，可以实现但不推荐
            System.out.println(Outer5.this.num);

        }
    }
}



public class InnerClassDemo5 {
    public static void main(String[] args) {
        Outer5.Inner5 oi5 = new Outer5().new Inner5();
        oi5.show();
    }
}

五、 局部内部类：

1、定义在方法中的类

2、局部内部类可以直接方法外部类中所有成员

3、要想使用局部内部类中的方法， 在定义局部内部类的成员方法中，创建局部内部类对象调用方法。

在局部内部类中引用的本地的变量必须是最终变量或者实际上的最终变量
通过反编译工具观察发现，存在局部内部类的方法中定义的局部变量自动加上了final关键字
在JDK1.8之后会自动加上final关键字

 

class Outer6{
    private int num = 10;

    public void fun(){
         int num2= 30;//编译后会自动加上关键字final int num2=30，此时不可在赋值
        class Inner6{
            int num3 = 300;
            public void show(){
                num3 = 30;
//在局部内部类中引用的本地的变量必须是最终变量或者实际上的最终变量
//通过反编译工具观察发现，存在局部内部类的方法中定义的局部变量自动加上了final关键字
//在JDK1.8之后会自动加上final关键字
//              num2 = 22;（放开会报错final修饰）
                num = 44;

                System.out.println(num);
                System.out.println(num2);
                System.out.println(num3);
            }
        }

        Inner6 inner6 = new Inner6();
        inner6.show();
    }

匿名内部类

interface A{
    b();
    c();
}

class B implements A{
    b(){...};
    c(){...};
}

A a = new B();
a.b();
a.c();

语句定义格式：

        new 类名（可以是抽象类也可以是具体的类）/接口（）{

        要重写的方法；

}；

上面的案例通过匿名内部类改进：
     A a = new A(){
             b(){...}
             c(){...}
         };

匿名内部类存在的前提：
 要存在一个类或者是一个接口，这个类可以是具体的类也可以是抽象的类

interface Inter{
    public abstract void show();
    public abstract void show2();
}

//class B implements Inter{
//
//    @Override
//    public void show() {
//
//    }
//
//    @Override
//    public void show2() {
//
//    }
//}

//Inter i = new B()

class Outer7{
    public void fun(){
        //使用匿名内部类的形式创建对象调用show方法
        new Inter(){
            @Override
            public void show() {
                System.out.println("这是show方法");
            }

            @Override
            public void show2() {
                System.out.println("这是show2方法");
            }
        }.show();

        //使用匿名内部类的形式创建对象调用show2方法
        new Inter(){
            @Override
            public void show() {
                System.out.println("这是show方法");
            }

            @Override
            public void show2() {
                System.out.println("这是show2方法");
            }
        }.show2();

        System.out.println("======================================");

        //想一想，我现在的接口中，只有两个方法，方法的个数比较少，没调用一个方法，都要new一下，并且new之后的内容都是一样的
        //如果以后接口中的方法很多的时候，你再用这样的方法，就会很麻烦
        //怎么改进呢？
        //利用接口多态的形式给匿名内部类起名字
        Inter inter = new Inter(){
            @Override
            public void show() {
                System.out.println("这是show方法");
            }

            @Override
            public void show2() {
                System.out.println("这是show2方法");
            }
        };

        inter.show();
        inter.show2();



    }
}


public class InnerClassDemo7 {
    public static void main(String[] args) {
        Outer7 outer7 = new Outer7();
        outer7.fun();
    }
}