Java之Java基础十三（内部类）

• 内部类是定义在另一个中的类
• 内部类可以把一些数据统一的隐藏起来从而增强了面向对象的封装性
• 内部类分类:非静态成员式内部类；局部内部类；匿名内部类；静态成员式内部类

一、非静态成员式内部类

• 内部类中的非静态成员式内部类【class】可以访问该类定义所在的作用域中【即内部类往外一层的大 括号】的的所有数据和方法【包括私有数据】
• 内部类中的非静态成员式内部类不能声明static成员【变量，方法等】
• 非静态成员式内部类不能再该类定义的静态方法中直接使用
• 访问非静态成员式内部类的方法：用外部类对象通过外部类中调用内部类的方法访问内部类方法；通过外部类直接访问内部类方法
• 作用：实现多继承

//非静态成员式内部类
public class Test3 extends Test{
    private String[] sex= {"男","女"};
    class Inclass{              //内部类
        String name;
        public String showsex() {
            System.out.println(sex[0]);
            return sex[0];
        }
    }
    public void useInclass() {    //访问内部类方法
        Inclass inc=new Inclass();
        inc.showsex();
    }
    public static void main(String[] args) {
        Test3 test=new Test3();   //通过外部类的方法访问内部类方法
        test.useInclass();  
        
        Test3.Inclass inc=new Test3().new Inclass();  //通过外部类直接访问内部类方法
        inc.showsex();
         Inclass inc2=new Test3().new Inclass();
        inc2.showsex();
    }
    
}

二、局部内部类

• 定义在代码块，方法体内
• 不能使用public,private,protected,static修饰
• 只能在当前方法中使用
• 和非静态成员式内部类一样不能拥有静态成员
• 可以访问外部类的所有数据和方法【包括私有数据】
• 访问的局部变量必须用final修饰【jdk8以后自动隐式加上了】

 package test2;
 public class Test3{
    private String[] sex= {"男","女"};
    int age=1;
    public void test() {
        int age2=3;
        age2=6;   //被局部内部类访问的局部变量默认为用final修饰，更改后不能被局部内部类访问
        class People{
            private String name="xaioming";
            public void test2() {
                age=2;
 //              System.out.println(age2);   报错，访问的局部变量必须用final修饰  
                System.out.println("局部内部类"+sex[0]);  //可以访问外部类的所有数据和方法
                System.out.println(age);
            }
        }
        People p=new People();
        p.test2();
        System.out.println(p.name);
    }
    public static void main(String[] args) {
 //      People p=new People();   报错，只能在外一层大括号处直接使用
        Test3 t=new Test3();    //可以通过外部调用
        t.test();
    }
    
}

三、匿名内部类

• 是局部内部类的一种特殊形式，是一个没有类名的局部内部类
• 使用前提必须继承一个父类或者实现一个接口

 //Test3类
public abstract class Test3{
    public abstract void sleep();
 }
 //Test4类
public class Test4 {
    public static void main(String[] args) {
        //匿名内部类,相当于临时创造了一个抽象类的子类用来实现抽象类中的方法
        
        Test3 T=new Test3(){         //面向过程编程思想,适用于使用次数很少的时候
            @Override
            public void sleep() {
                System.out.println("sleeping");
            }               
        };
        T.sleep();
        
        new Test3(){         //不创建对象写法
            @Override
            public void sleep() {
                System.out.println("sleeping2");
            }               
        }.sleep();
    }
 }

四、静态成员式内部类

• 如果一个类只想把另一个类隐藏起来，而不想引用外部类的对象【变量和方法】，于是出现了静态成 员式内部类
• 创建实例时不必创建外部类实例
• 访问静态成员内部类方法：【Test3.】Test5 t1=new Test3.Test5();
• 可以直接访问外部类的静态成员
• 可以定义静态和非静态成员
• 外部类可以直接通过完整类名直接访问静态内部类的静态成员

public class Test3{
    public String name1="1";
    public static String name2="2";
    static class Test5{           //静态成员内部类定义
        public String name3="3";
        public static String name4="4";
        public void eat() {           //可以定义静态和非静态成员
//          System.out.println(name1);  报错,不能不能对非静态字段 name1 进行静态引用
            System.out.println(name2);  //可以可以直接访问外部类的静态成员
        }
        public static void sleep() {  //可以定义静态和非静态成员
            System.out.println("sleeping");  
        }
    }
    public static void main(String[] args) {
        Test3.Test5 t1=new Test3.Test5();     //访问静态成员内部类方法
        Test5 t2=new Test3.Test5();  
        t1.eat();
        t1.sleep();
        t2.eat();
        t2.sleep();
        
        Test3.Test5.sleep();   //外部类可以直接通过完整类名直接访问静态内部类的静态成员【方
法】
        Test5.sleep();   
        
        System.out.println(t1.name3);
        System.out.println(t2.name4);
        System.out.println(Test3.Test5.name4);//外部类可以直接通过完整类名直接访问静态内部
//类的静态成员【变量】 
    }
 }

五、相关问题

• 关于JAVA的内部类以及内、外部类变量重复问题

 //普通情况：R.this.agr
 public class R {
    int agr=12;
    public class Intse{
        int agr=22;
        public void ins(){
            System.out.println("外部类age:"+ R.this.agr);
            System.out.println("内部类age:"+agr);
        }
    }
    public static void main(String[] args){
        System.out.println("关于相同变量在内外部类的使用：");
        System.out.println("外部类需：Hent.this.agr");
        Intse ist=new R().new Intse();
        ist.ins();
    }
 }
 //静态成员式内部类：Test3.agr 
public class Test3{
    private static int agr=19;
    public static class Intse{
        int agr=99;
        public void ins(){
            System.out.println("外部类age:"+ Test3.agr);
            System.out.println("内部类age:"+agr);
        }
    }
    public static void main(String[] args) {
        System.out.println("关于相同变量在内外部类的使用：");
        Intse ist = new Intse();
        ist.ins();
    }
 }