你的位置:首页 > Java教程

[Java教程]四种内部类详细解释和代码示例



//成员内部类
成员变量 :

    成员内部类 : (详情:请看成员内部类文件夹,有代码示例)
        //成员内部类
        //可以用访问控制权限的修饰符修饰,如:private 私有的。
        //public,protected,private,缺省(默认,default)
        //在成员内部类的内部可以随意访问外部类的成员方法和成员变量
        //不能在成员内部类里面声明静态方法和静态变量
        //先编译一个外部类的类文件然后摘编译一个内部类的类文件
        //内部类的类名:_01_OuterClass$InnerClass
            可以等同看做成员变量,可以随意访问外部类的任意变量和任意方法,并且,不能在成员内部类中声明静态变量和静态方法

  
/*
    变量:
        成员变量 -- 普通内部类
        静态变量 -- 静态内部类
        局部变量 -- 局部内部类
        //形参变量
        实参变量 -- 匿名内部类

    变量声明:
        数据类型  变量名  赋值
        类
        String s1; String.java--->String.class-->String
        String.java

    关于成员内部类
    
        1.成员内部类可以等同看做成员变量
        
        2.成员内部类中不能有静态声明.
        
        3.成员内部类可以访问外部类所有的数据.
*/
public class _01_OuterClass{
    
    //静态变量
    private static String s1 = "A";
    
    //成员变量
    private String s2 = "B";
    
    //静态方法
    private static void m1(){
        System.out.println("static's m1 method execute!");
    }
    
    //成员方法
    private void m2(){
        System.out.println("m2 method execute!");
    }
    
    //成员内部类
    //可以用访问控制权限的修饰符修饰。
    //public,protected,private,缺省
    //在成员内部类的内部可以随意访问外部类的成员方法和成员变量
    //不能在成员内部类里面声明静态方法和静态变量
    //先编译一个外部类的类文件然后摘编译一个内部类的类文件
    //内部类的类名:_01_OuterClass$InnerClass

    //成员内部类
    class InnerClass{
        
        //静态变量
        //static int i = 9999;
        //静态方法
        //public static void m3(){}
        
        //成员方法
        public void m4(){
            System.out.println(s1);
            m1();
            
            System.out.println(s2);
            m2();
        }
    }
    //相当于: InnerClass ...
    
    //入口
    public static void main(String[] args){
        
        //创建外部类对象
        _01_OuterClass oc = new _01_OuterClass();
        //怎么访问一个成员内部类
        //外部类对象的引用名.new 内部对象
        
        InnerClass inner = oc.new InnerClass();
        
        inner.m4();
    }
    
}



      
//静态内部类
静态变量 :

    静态内部类 : (详情:请看静态内部类文件夹,有代码示例)
        //静态内部类
        //可以用访问控制权限的修饰符修饰,如:private 私有的。
        //public,protected,private,缺省(默认,default)
        //内部可以声明静态变量和成员变量,静态方法和成员方法
        //可以访问外部的静态变量和静态方法,不能直接访问成员变量和成员方法(需要有对象引用)
        //成员内部类和静态内部类命名没区别
            可以等同看做静态变量,可以访问外部类的静态变量和静态方法,但是不能直接访问外部类的成员变量和成员方法(要有对象引用,如同main(),也是静态的,有引用,就什么都能调用),并且,能声明任意变量和任意方法

  
/*
    关于静态内部类
        1.静态内部类可以等同看做静态变量
        
        内部类重要的作用:可以访问外部类中私有的数据。
        
        2.静态内部类可以直接访问外部类的静态数据,无法直接访问成员。
*/
public class _02_OuterClass{
    
    //静态变量
    private static String s1 = "A";
    
    //成员变量
    private String s2 = "B-------";
    
    //静态方法
    private static void m1(){
        System.out.println("static's m1 method execute!");
    }
    
    //成员方法
    private void m2(){
        System.out.println("m2 method execute!");
    }
    
    //静态内部类
    //可以用访问控制权限的修饰符修饰。
    //public,protected,private,缺省
    //内部可以声明静态变量和成员变量,静态方法和成员方法
    //可以访问外部的静态变量和静态方法,不能访问成员变量和成员方法
    //成员内部类和静态内部类命名没区别
    
    //静态内部类
    static class InnerClass{
        
        //静态方法
        public static void m3(){
            System.out.println(s1);
            m1();
            
            //也有外部静态类,性质一样
            //成员变量和成员方法:无法从静态上下文中引用非静态 变量 s2
            _02_OuterClass a = new _02_OuterClass();
            System.out.println(a.s2+"kkkkkkkkkkkkk");//调用成员属性,有对象引用就行
            //m2();
        }
        
        //成员方法
        public void m4(){
            System.out.println(s1);
            m1();
            
            //System.out.println(s2);
            //m2();
        }
    }
    
    
    //入口
    public static void main(String[] args){
        
        //执行m3
        _02_OuterClass.InnerClass.m3();
        
        //执行m4
        InnerClass inner = new _02_OuterClass.InnerClass();
        inner.m4();
    }
    
}



//局部内部类
局部变量(方法中写的类) :

    局部内部类 : (详情:请看局部内部类文件夹,有代码示例)
            //局部内部类不能用访问控制权限修饰符修饰。
            //但是能访问外部方法的局部变量,但是局部变量必须用final修饰 , java8以后,可以不写final修饰
            局部内部类中,不能声明静态变量和静态方法,只能声明成员变量和成员方法
            1 如果外部方法是静态方法,那内部类中就不能访问外部类的成员变量和成员方法
            2 如果外部方法是成员方法,那内部类中就能访问外部类的成员变量和成员方法

 

  
/*
    局部内部类等同于局部变量
    
    重点:局部内部类在访问外部类的局部变量的时候,局部变量必须使用final修饰。

    在成员方法中能声明一个局部静态内部类吗?不能

    在静态方法中能声明一个局部静态内部类吗? 自己试一下 不能


*/
public class _03_OuterClass{
    
         int i1 = 222;
        static int i2 = 255;
    //方法
//---------------------------------------成员方法里面的内部类测试-------------------------
    public  void m1(){//成员方法
        
        //局部变量
        final int i = 10;//java8以后,局部内部类访问方法的局部变量,可以不加final修饰
        
        //局部内部类;
        //局部内部类不能用访问控制权限修饰符修饰。

        //局部内部类
        class InnerClass{
            
            //局部内部类不能有静态声明
            //public static void m1(){}
            
            //成员方法
            public void m2(){
                System.out.println(i); // 10  访问局部变量
                System.out.println( i1 );//访问外类的成员变量
                System.out.println( i2 );//访问外类的静态变量
            }
                
        }
        
        //调用m2
        InnerClass inner = new InnerClass();

        inner.m2();
        
    }
//---------------------------------------静态方法里面的内部类测试-------------------------
    public static void m11(){//静态方法
            //局部变量
        final int i = 10;//java8以后,局部内部类访问方法的局部变量,可以不加final修饰
        
        //局部内部类;
        //局部内部类不能用访问控制权限修饰符修饰。

        //局部内部类
        class InnerClass{
            
            //局部内部类不能有静态声明
            //public static void m1(){}
            
            //成员方法
            public void m22(){
                System.out.println(i); // 10  访问局部变量
               // System.out.println( i1 );//访问外类的成员变量
                System.out.println( i2 );//访问外类的静态变量
            }
                
        }
        
        //调用m2
        InnerClass inner = new InnerClass();

        inner.m22();
    }
    
    
    //入口
    public static void main(String[] args){
        _03_OuterClass oc = new _03_OuterClass();
        oc.m1();
        oc.m11();
        
    }
    
}




//匿名内部类
局部变量(调用方法传参) :

    匿名内部类 : (详情:请看匿名内部类文件夹,有代码示例)
        /*匿名内部类:指在方法调用时,方法的效用需要传入某个类对应的对象实参
        但是也可以直接new一个某个类型的一个对象,这个对象没有名字

        如果反方定义形参,一般是个接口,那么调用的时候,要用其实现类传入
        但是我可以不实现这个实现类,而是直接new这个接口的对象,也也可以
        相当于:省下了,书写实现类和实例化实现类对象的代码
        也可以这么说,直接实例化了一个类,只不过这个类和接口名相同
        */
    //优点 : 少定义一个雷
    //缺点 : 只能用一次,无法重复使用

        匿名内部类几个原则 :
            // 1 没有构造方法(因为匿名内部类是没有类名的)
            // 2 不能定义任何变量(静态,成员),不能定义任何方法(静态,成员),不能定义任何类
            // 3 不能使抽象类(因为在创建匿名内部类的时候,会立即创建匿名内部类的对象。从而也可知匿名内部类必须实现它的抽象父类或者接口里包含的所有抽象方法)
            // 4 匿名内部类不能使public ,protected,private,static
            // 5 只能创建匿名内部类的一个实例
            // 6 匿名类和内部类中的中的this : 有时候,我们会用到一些内部类和匿名类。当在匿名类中用this时,这个this则指的是匿名类或内部类本身。这时如果我们要使用外部类的方法和变量的话,则应该加上外部类的类名。
            匿名内部类能访问外部的静态变量和静态方法,私有的也能,但是不能访问成员变量和成员方法,除非在实现类中,也要用外部类的引用去调用访问
            


/*
    匿名内部类:指在方法调用时,方法的效用需要传入某个类对应的对象实参
    但是也可以直接new一个某个类型的一个对象,这个对象没有名字

    如果反方定义形参,一般是个接口,那么调用的时候,要用其实现类传入
    但是我可以不实现这个实现类,而是直接new这个接口的对象,也也可以
    相当于:省下了,书写实现类和实例化实现类对象的代码
    也可以这么说,直接实例化了一个类,只不过这个类和接口名相同
*/
public class _04_OuterClass{
    
    //静态方法
    public static void t(CustomerService cs){
        cs.logout();
    }
    
    //入口
    public static void main(String[] args){
        
        //调用t方法
        //t(new CustomerServiceImpl()); //匿名内部类 2 对应下面的类
        
        //使用匿名内部类的方式执行t方法
        //整个这个"new CustomerService(){}"就是个匿名内部类
        t(new CustomerService(){//匿名内部类 1
            public void logout(){
                System.out.println("exit!");
            }
        });
        
        //匿名内部类的优点:少定义一个类.
        //缺点:无法重复使用!
    }
    
}


//接口
interface CustomerService{
    
    //退出系统
    public void logout();
    
}

//编写一个类实现CustomerService接口
/*
class CustomerServiceImpl implements CustomerService{ //匿名内部类 2

    public void logout(){
        System.out.println("系统已经安全退出!");
    }
}
*/