Java内部类的使用小结

Java内部类的使用小结

☆：为什么要使用内部类：
使用内部类最吸引人的原因是：每个内部类都能独立地继承一个（接口的）实现，所以无论外围类是否已经继承了某个（接口的）实现，对于内部类都没有影响。
内部类：顾名思义就是把类放在某个范围里
类可以放在包中
类可以放在文件夹中
类可以放在类中 　　 //内部类
类可以放在方法中 　　 //内部类

一、成员内部类
类中放置内部类，类里套类，类中类
要使用内部类，就需要在外部类中实例化内部类的对象，然后通过对象打点调用内部类中的方法，通过方法操作内部类数据
内部类可以直接使用外部类的属性和方法，就像孙悟空钻进铁扇公主肚子里

public class OuterClass {
    //外部类中的属性
    private int outer_1=100;        //私有属性    
    public  int outer_2=10;            //公有属性
    
    //外部类方法outer_method1
    public void outer_method1(){
        System.out.println("outer_method1");
        InnerClass ic=new InnerClass();
        //调用内部类中的方法
        ic.inner_method1();            
        //调用内部类中的私有属性和公有属性
        System.out.println(ic.inner_1+" "+ic.inner_2);    
    }
    
    //有名的内部类InnerClass
    class InnerClass{
        //内部类中的属性
        private int inner_1=123;    //私有属性
        public int inner_2=321;        //公有属性
        //内部类方法inner_method1
        public void inner_method1(){
            //调用外部类中的方法，
            outer_method1();
            //调用外部类中的私有属性和公有属性
            System.out.println(outer_1+" "+outer_2);
        }    
    }    
}    

二、局部内部类
方法中中放置内部类
要使用方法中的内部类，就必须在方法中，内部类定义的下面实例化内部类的对象，然后通过内部类对象打点调用内部类的方法，
内部类的作用域仅限于当前方法，对内部类定义开始到方法结束，作用域消失。
在内部类中可以直接使用外部类中的当前方法中的局部变量，在方法的外面不能使用方法中的内部类

/**
 *方法中放置内部类 
 */
public class OuterClass {
    //外部类中的属性
    private int outer_1=100;        //私有属性
    public  int outer_2=10;            //公有属性
    //外部类中的方法
    public void outer_method1(){
        System.out.println("outer_method1()");
        System.out.println("outer_1"+"outer_2");
        
        //方法中的内部类
        class InnerClass{
            //内部类中的属性
            private int inner_1=123;    //私有属性
            public int inner_2=321;        //公有属性
            //内部类中的公有方法
            public void inner_method1(){
                System.out.println("public method1");
                System.out.println(outer_1);
            }    
            //内部类中的私有 方法
            private void inner_method2(){
                System.out.println("private method2");
                System.out.println(outer_1+" "+outer_2);
            }    }
        //实例化内部类
        InnerClass ic=new InnerClass();
        ic.inner_method1();
        ic.inner_method2();
        System.out.println(ic.inner_1+" "+ic.inner_2);    
        //作用域到此处结束
    }    
}

三、匿名内部类
1. 匿名内部类是没有访问修饰符的。
2.有时候我为了免去给内部类命名，便倾向于使用匿名内部类，因为它没有名字
3.匿名内部类是没有构造方法的。因为它连名字都没有何来构造方法。
4.当前匿名内部类中实现的方法，只能实现一次，如果还想其他的实现，必须用匿名内部类重新new实现

public class Demo {
    public void TetMethod1(){    
        //匿名内部类    new 的是CommonPerson的子实现，但没有类名，把子实现的对象赋值给长辈引用
        CommonPerson cp=new CommonPerson(){
            @Override
            public void study() {
            }
            @Override
            public void eat() {
            }
        };
    }
    public static void main(String[] args) {
        //有名内部类
        class Student implements IPerson{
            public void study(){}
            public void eat(){}
        }
        Student stu1=new Student();
        IPerson ip=stu1;
        
        //匿名内部类
        IPerson ip1=new IPerson(){
            public void study(){}
            public void eat() {}
        };
        IPerson ip2=new IPerson(){
            public void study(){}
            public void eat() {}
        };    
    }
}


public interface IPerson {      //定义的接口IPerson

    public void study();
    public void eat();
}

四、嵌套内部类
嵌套内部类分为静态内部类和非静态内部类
1.静态内部类
1、 它的创建不需要依赖于外部类。
2、 它不能使用任何外围类的非static成员变量和方法。
2.非静态内部类
1.它的创建需要依赖于外部类
2.在编译完成之后会隐含地保存着一个引用，该引用是指向创建它的外围类，可以随便调用外部类中的成员，不管是静态的还是非静态的，相当霸道。

public class OuterClass {
    private String sex;
    public static String name = "ma";
    /**
     *静态内部类
     */
    static class InnerClass1{
        /* 在静态内部类中可以存在静态成员 */
        public static String name1 = "1_static";
        public void display(){
                  //静态内部类只能访问外围类的静态成员变量和方法
            System.out.println("OuterClass name :" + name);
        }    }
    /**
     * 非静态内部类
     */
    class InnerClass2{
        /* 非静态内部类中不能存在静态成员 */
        public String name2 = "2_inner";
        /* 非静态内部类中可以调用外围类的任何成员,不管是静态的还是非静态的,这就有点霸道了*/
        public void display(){
            System.out.println("OuterClass name：" + name);
        }
    }
    public void display(){
        // 外部类访问静态内部类
        System.out.println(InnerClass1.name1);
        new InnerClass1().display();  
        /* 非静态内部的创建需要依赖于外部类 */
        OuterClass.InnerClass2 inner2=new OuterClass().new InnerClass2();
        System.out.println(inner2.name2);
        inner2.display();
    }  
}

 

posted on 2018-08-14 21:33 沙漏，为谁转 阅读(...) 评论(...) 编辑 收藏