（java总结）匿名内部类

喜欢ヅ旅行 2023-05-29 09:22 21阅读 0赞

package Demo21;
    /*
    如果一个事物的内部包含另一个事物，那么这就是一个类内部包含另一个类。
    
    分类：
    1、成员内部类
    2、局部内部类(包含匿名内部类)
    
    成员内部类的定义格式：
    修饰符 class 外部类名称｛
           修饰符 class 内部类名称｛
                //...
            }
            //...
        }
    注意：内用外，随意访问，外用内，需要内部类对象。
    ================================================
    如何使用成员内部类：两种方式
    1、间接方式：在外部类的方法当中，使用内部类，然后main只是调用外部类的方法
    2、直接方式，公式：
    外部类名称.内部类名称 对象名 = new 外部类名称().new 内部类名称();
     */
    public class DemoInnerClass {
        
        public static void main(String[] args) {
        
            Body body = new Body();//外部类的对象
            //通过外部类的对象，调用外部类的方法，里面间接在使用内部类Heart
            body.methodBody();
            System.out.println("================");
    
            //按照公式写
            Body.Heart heart = new Body().new Heart();
            heart.beat();
    
    
        }
    }

package Demo21;
    
    public class Body {
        //外部类
    
        public class Heart{
        //成员内部类
                //内部类的方法
            public void beat(){
        
                System.out.println("心胀跳动：蹦蹦蹦！");
                System.out.println("我叫：" + name);//正确写法
            }
        }
    
        //外部类的成员变量
        private String name;
    
        public void methodBody(){
        
            System.out.println("外部类的方法");
            //匿名对象
            new Heart().beat();
        }
    
        public String getName() {
        
            return name;
        }
    
        public void setName(String name) {
        
            this.name = name;
        }
    }

package Demo21;
    //如果出现了重名的现象，那么格式就是：外部类名称.this.外部类成员变量名
    public class Outer {
        
        int num = 10;//外部类的成员方法
    
        public class Inner{
        
            int num = 20;//内部类的成员变量
    
            public void methodInner(){
        
                int num = 30;//内部类方法的局部变量
                System.out.println(num);//30局部变量，就近原则
                System.out.println(this.num);//20内部类的成员变量
                System.out.println(Outer.this.num);//外部类的成员变量
    
            }
        }
    }

package Demo21;
    
    public class DemoInner {
        
        public static void main(String[] args) {
        
            //外部类名称.内部类名称 对象名 = new 外部类名称().new 内部类名称();
            Outer.Inner obj = new Outer().new Inner();
            obj.methodInner();
        }
    }

package Demo22;
    /*
    局部内部类，如果希望访问所在方法的局部变量，那么这个变量必须是【有效final的】
    
    备注：从java8+开始，只要局部变量事实不变，那么final关键字就可以省略
    
    原因：
    1、new出来的对象是在堆内存中的
    2、局部变量是跟着方法走的。
    3、方法运行结束后，立即出栈，局部变量就会立刻消失
    4、new出来的对象会在堆内存中持续存在，直到垃圾回收
     */
    public class MyOuter {
        
        public void methodOuter(){
        
            //所在方法的局部变量
            final int num = 10;
    
    
            class MyInner{
        
                public void methodInner(){
        
                    System.out.println(num);
                }
            }
        }
    }

package Demo22;
    /*
    如果一个类是定义在一个方法内部的，那么这就是一个局部内部类
    【局部】: 只有当前所属的方法才能使用它，除了这个方法就不能用了
    
    定义格式：
    修饰符 class 外部类名称｛
           修饰符  返回值类型  外部类方法名称(参数列表)｛
                class 局部内部类名称｛
                    //...
                 }
              }
          }
    总结权限修饰符：
    public > protected > (default) > private
    定义一个类的时候，权限修饰符的规则：
    1、外部类：public / (default)
    2、成员方法类：public / protected / (default) / private
    3、局部内部类:什么都不能写
    
     */
    public class Outer {
        
        public void methodOuter(){
        
            class Inner{
        
                int num = 10;
                public void methodInner(){
        
                    System.out.println(num);
                }
    
            }
            //只能在这个方法中使用，出了方法就不能用了
            Inner inner = new Inner();
            inner.methodInner();
    
        }
    }

package Demo22;
    
    public class DemoMain {
        
        public static void main(String[] args) {
        
            Outer obj = new Outer();
            obj.methodOuter();
        }
    }

package Demo22;
    /*
    如果接口的实现类(或者是父类的子类) 只需要使用唯一的一次，
    那么这种情况下就可以省略该类的定义，而改为使用【匿名内部类】
    
    匿名内部类的定义格式：
    接口名称 对象名 = new 接口名称(){
        
           //覆盖重写所有的抽象方法
    }
    
    对格式“new 接口名称(){
        ...}”解析：
    1、new代表创建对象的动作
    2、接口名称就是匿名内部类需要实现那个接口
    3、{
        ...}这是匿名内部类的内容
    
    注意的问题：
    1、匿名内部类，在【创建对象】的时候，只能使用唯一一次。
    如果希望多次创建对象，而且类的内容一样的话，那么就必须使用单独定义的实现类了
    2、匿名对象，在【调用方法】的时候，只能调用唯一一次
    如果希望同一个对象，调用多次方法的话，那么必须给这个对象起个名字
    3、匿名内部类是省略了【实现类/子类名称】,但是匿名对象是省略了【对象名称】
     */
    public class DemoMain1 {
        
        public static void main(String[] args) {
        
    //        MyInterface impl = new MyInterfaceImpl();
    //        impl.method();
    
            //使用匿名内部类，但不是匿名对象
            //有名称就是objA
            MyInterface objA = new MyInterface() {
        
    
                @Override
                public void method1() {
        
                    System.out.println("名内部类实现类方法！111A");
                }
    
                @Override
                public void method2() {
        
                    System.out.println("匿名内部类实现类方法！222A");
                }
            };
            objA.method1();
            objA.method2();
            System.out.println("==========================");
    
            //好处：定义接口的话必须创建有一个实现类，匿名内部类可以直接new接口。可以省略在写一个类
            //匿名内部类，而且省略了对象名称，也是匿名对象
             new MyInterface() {
        
    
                @Override
                public void method1() {
        
                    System.out.println("名内部类实现类方法！111B");
                }
    
                @Override
                public void method2() {
        
                    System.out.println("匿名内部类实现类方法！222B");
                }
            }.method1();
    
    
        }
    }

package Demo22;
    
    public interface MyInterface {
        
        void method1();//抽象方法
        void method2();//抽象方法
    }

package Demo22;
    
    public class MyInterfaceImpl implements MyInterface{
        
    
    
        @Override
        public void method1() {
        
    
        }
    
        @Override
        public void method2() {
        
    
        }
    }