Android（java）学习笔记52：成员位置的内部类的介绍

1. 内部类的定义

/*
    内部类概述:
        把类定义在其他类的内部，这个类就被称为内部类。
        举例：在类A中定义了一个类B，类B就是内部类。
    
    内部的访问特点：
        A:内部类可以直接访问外部类的成员，包括私有。
        B:外部类要访问内部类的成员，必须创建对象。
    
*/
class Outer {
    private int num = 10;
    
    class Inner {
        public void show() {
            System.out.println(num);
        }
    }
    
    public void method() {
        //找不到符号
        //show();
    
        Inner i = new Inner();
        i.show();
    }
    
}

class InnerClassDemo {
    public static void main(String[] args) {
    
    }
}

2. 内部类的位置

/*
    内部类位置
        成员位置:在成员位置定义的类，被称为成员内部类。    
        局部位置:在局部位置定义的类，被称为局部内部类。
        
        
    成员位置:在成员位置定义的类，被称为成员内部类。    
        
*/
class Outer {
    private int num = 10;

    //成员位置
    /*
    class Inner {
        
    }
    */
    

    public void method() {
        //局部位置
        class Inner {
        
        }
    }
}

class InnerClassDemo2 {
    public static void main(String[] args) {
        
    }
}

/*
    成员内部类:
        如何直接访问内部类的成员。
        外部类名.内部类名 对象名 = 外部类对象.内部类对象;
*/
class Outer {
    private int num = 10;
    
    class Inner {
        public void show() {
            System.out.println(num);
        }
    }
}

class InnerClassDemo3 {
    public static void main(String[] args) {
        //需求：我要访问Inner类的show()方法
        //Inner i = new Inner();
        //i.show();---这样的方式是错误的
        
        //格式：外部类名.内部类名 对象名 = 外部类对象.内部类对象;
        Outer.Inner oi = new Outer().new Inner();
        oi.show();
    }
}

3. 实例梳理成员内部类的修饰符

/*
    成员内部类的修饰符：
        private 为了保证数据的安全性
        static 为了方便访问数据
            注意：静态内部类访问的外部类数据必须用静态修饰。
    
    案例：我有一个人(人有身体，身体内有心脏。)
        
        class Body {
            private class Heart {
                public void operator() {
                    System.out.println("心脏搭桥");
                }
            }
            
            public void method() {
                if(如果你是外科医生) {
                    Heart h = new Heart();
                    h.operator();
                }
            }
        }
        
        按照我们刚才的讲解，来使用一下
        Body.Heart bh = new Body().new Heart();
        bh.operator();//但是我们是不希望外界对我们自己身体内部"心脏"进行操作的，怎么样才能实现这个？
        //加了private后，就不能被访问了，那么，怎么玩呢?
        Body b =  new Body();
        b.method();
*/
class Outer {
    private int num = 10;
    private static int num2 = 100;
    
    //内部类用静态修饰是因为内部类可以看出是外部类的成员
    public static class Inner {
        public void show() {
            //System.out.println(num);//静态内部类访问外部类数据必须是静态修饰的，num不是静态，所以不能访问，num2可以访问
            System.out.println(num2);
        }

        public static void show2() {
            //System.out.println(num);
            System.out.println(num2);
        }        
    }
}

class InnerClassDemo4 {
    public static void main(String[] args) {
        //使用内部类
        // 限定的新静态类，下面这样写法是错误的，内部类加了静态static修饰之后，是不能通过外部对象访问的，直接调用类名访问
        //Outer.Inner oi = new Outer().new Inner();
        //oi.show();
        //oi.show2();
        
        //成员内部类被静态修饰后的访问方式是:
        //格式：外部类名.内部类名 对象名 = new 外部类名.内部类名();
        Outer.Inner oi = new Outer.Inner();
        oi.show();
        oi.show2();
        
        //show2()的另一种调用方式
        Outer.Inner.show2();
    }
}

4. 面试题

/*
    面试题：
        要求请填空分别输出30，20，10。
        
    注意：
        1:内部类和外部类没有继承关系。
        2:通过外部类名限定this对象
            Outer.this
*/
class Outer {
    public int num = 10;
    class Inner {
        public int num = 20;
        public void show() {
            int num = 30;
            System.out.println(num);
            System.out.println(this.num);
            //System.out.println(new Outer().num);//这个是也是可以实现的
            System.out.println(Outer.this.num);
        }
    }
}
class InnerClassTest {
    public static void main(String[] args) {
        Outer.Inner oi = new Outer().new Inner();
        oi.show();
    }    
}