内部类

概念

　内部类

　　  内部类访问规则

　　　　1.内部类可以直接访问外部类中的成员，包括私有[例1]

　　　　　  之所以可以直接访问外部类成员，是因为内部类中持有了一个外部类的引用，格式是 外部类名.this[例3]

　　　　  2.外部类要访问内部类，必须建立内部类对象[两种写法][例2]

　　　　　　第二种写法格式

　　　　　　当内部类定义在外部类成员位置上，而且非私有，可以在外部其他类中，直接创建内部类对象

　　　　　　外部类名.内部类名  变量名 =外部类对象.内部类对象

　　　　　　Outer.  Inner  in=new Outer().new Inner();

　　　　  3.当内部类在成员位置，就可以被外部类修饰符所修饰

　　　　　  比如：private 将内部类在外部类中进行封装

　　　　  4.静态内部类（static）

　　　　　  当内部类被static修饰后，内部类就具备了static特性，只能直接访问外部类中的static成员，也就是说出现了访问局限　

　　　　 误区

　　　　　　在外部其他类中，如何访问static内部类中的非static成员[例4]

　　　　　　外部类对象.内部类名().内部类非staic方法名()

　　　　　　new InnerDemo.ClassDemo().Demo();

　　　　　　在外部其他类中，如何访问static内部类中的static成员[例5]

　　　　　　外部类名.内部类名().内部类static方法();

　　　　　　InnerDemo.ClassDemo.Demo();

　　　　  注意　　

　　　　　　当内部类中定义了静态成员，该内部类必须是静态的[例6]

　　　　　　当外部类中的静态方法访问内部类时，内部类必须是静态的[例7]

 　　　　 什么时候使用内部类？

　　　　　当描述事物时，事物的内部还有事物，该事物用内部类来描述，因为内部事物在使用外部事物的内容　　

　　　    5.内部类定义在局部时[定义在外部类的方法中]

　　　　　注意：内部类可以定义在外部类的任意位置，分为成员位置和局部位置，所以局部不单单指定义在方法中

　　　　　  (1)可以直接访问外部类的成员，因为还持有外部类的引用，但是不可以访问它所在的局部中的变量，只能访问被final修饰的局部中的变量[常量][例8]

　　　　　  　  典型特殊案例[例9]

　　匿名内部类　

　　　　  1.匿名内部类其实就是内部类的简写格式[例10]

　　　　  2.定义匿名内部类的前提[例10]

　　　　　　　内部类必须是继承一个类或者实现接口

 　　　　  3.匿名内部类的格式[例10]

　　　　　　　 new 父类或者接口() {定义子类的内容}

 　　　　  4.其实匿名内部类就是一个匿名子类对象，而且这个对象有点"胖"，可以理解为没有名字带内容的对象[例10]

　　　　　　匿名内部类一次只能调用一个方法[例11]

　　　　   5.匿名内部类中定义的房啊最好不要超过3个[不包括3个]　 

　　　　　　什么时候使用匿名内部类？　

　　　　　 　一个类继承一个接口，并且这个接口只有不到3个方法 　

示例代码

例1

import java.lang.reflect.Method;

import com.preview.seven.InnerDemo.ClassDemo;

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

    }
}

class InnerDemo {
    private int num = 3;

    class ClassDemo {
        public void Demo() {
            System.out.println("我是内部类的方法" + " " + num); //可以直接父类中的num，不会报错
        }
    }

    public void inner2() {
        System.out.println("我是外部类的方法");
    }
}

例2

第一种写法

import java.lang.reflect.Method;

import com.preview.seven.InnerDemo.ClassDemo;

public class InnerClass {
    public static void main(String[] args) {
        InnerDemo innerDemo=new InnerDemo();
        innerDemo.inner2();
    }
}

class InnerDemo {
    private int num = 3;

    class ClassDemo {
        public void Demo() {
            System.out.println("我是内部类的方法" + " " + num); //我是内部类的方法 3
        }
    }

    public void inner2() {
        System.out.println("我是外部类的方法");  //我是外部类的方法
        ClassDemo classDemo=new ClassDemo();
        classDemo.Demo();
    }
}

第二种写法

import java.lang.reflect.Method;

import com.preview.seven.InnerDemo.ClassDemo;

public class InnerClass {
    public static void main(String[] args) {
        InnerDemo.ClassDemo classDemo=new InnerDemo().new ClassDemo();
        classDemo.Demo();
    }
}

class InnerDemo {
    private int num = 3;

    class ClassDemo {
        public void Demo() {
            System.out.println("我是内部类的方法" + " " + num); // 我是内部类的方法 3
        }
    }

    public void inner2() {
        System.out.println("我是外部类的方法");

    }
}

例

import java.lang.reflect.Method;

import com.preview.seven.InnerDemo.ClassDemo;

public class InnerClass {
    public static void main(String[] args) {
        InnerDemo.ClassDemo classDemo = new InnerDemo().new ClassDemo();
        classDemo.Demo();
    }
}

class InnerDemo {
    private int num = 3;

    class ClassDemo {
        private int num=4;
        
        public void Demo() {
            System.out.println("我是内部类的方法" + " " + num); // 我是内部类的方法 4
            System.out.println("我是内部类的方法" + " " + InnerDemo.this.num); // 我是内部类的方法 3
        }
    }

    public void inner2() {
        System.out.println("我是外部类的方法");

    }
}

例4

import java.lang.reflect.Method;

import com.preview.seven.InnerDemo.ClassDemo;

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

        new InnerDemo.ClassDemo().Demo();
    }
}

class InnerDemo {
    private static int num = 3;

    static class ClassDemo {

        public void Demo() {
            System.out.println("我是内部类的方法" + " " + num); // 我是内部类的方法 3
        }
    }

    public void inner2() {
        System.out.println("我是外部类的方法");

    }
}

例5

public class InnerClass {
    public static void main(String[] args) {
        InnerDemo.ClassDemo.Demo();
    }
}

class InnerDemo {
    private static int num = 3;

    static class ClassDemo {

        public static void Demo() {
            System.out.println("我是内部类的方法" + " " + num); // 我是内部类的方法 3
        }
    }

    public void inner2() {
        System.out.println("我是外部类的方法");

    }
}

例6

import java.lang.reflect.Method;

import com.preview.seven.InnerDemo.ClassDemo;

public class InnerClass {
    public static void main(String[] args) {
        InnerDemo.ClassDemo.Demo();
    }
}

class InnerDemo {
    private static int num = 3;

    class ClassDemo {

        public static void Demo() {
            System.out.println("我是内部类的方法" + " " + num); // 我是内部类的方法 3
        }
    }

    public void inner2() {
        System.out.println("我是外部类的方法");

    }
}

视图

例7

import java.lang.reflect.Method;

import com.preview.seven.InnerDemo.ClassDemo;

public class InnerClass {
    public static void main(String[] args) {
        InnerDemo innerDemo=new InnerDemo();
        innerDemo.inner2();
    }
}

class InnerDemo {
    private static int num = 3;

    class ClassDemo {

        public void Demo() {
            System.out.println("我是内部类的方法" + " " + num); // 我是内部类的方法 3
        }
    }

    public static void inner2() {
        new ClassDemo().Demo();
        
    }
}

视图

 

例8 

import java.lang.reflect.Method;

public class InnerClass {
    public static void main(String[] args) {
        InnerDemo innerDemo = new InnerDemo();
        innerDemo.method();

    }
}

class InnerDemo {
    private int x = 3;

    public void method() {
        int y = 10;

        class Demo {

            void methodDemo() {
                System.out.println("我是局部内部类中的方法" + " " + y); // 我是局部内部类中的方法 3

            }
        }

        new Demo().methodDemo();
    }

}

视图

例9

 情况一，不会出错

import java.lang.reflect.Method;

public class InnerClass {
    public static void main(String[] args) {
        InnerDemo innerDemo = new InnerDemo();
        innerDemo.method(10);
        innerDemo.method(75);

    }
}

class InnerDemo {
    private int x = 3;

    public void method(final int a) {
        final int y = 10;

        class Demo {

            void methodDemo() {
                System.out.println("我是局部内部类中的方法" + " " + a); // 我是局部内部类中的方法 10
                                                                // 我是局部内部类中的方法75
                                                                 

            }
        }

        new Demo().methodDemo();
    }

}

解析

　　在这个代码中，虽然final定义的内容只能初始化一次，并且无法修改，但是当第一次调用method方法时，系统会在栈内存中创建一个final a，但是当第一个method调用完成后，这个栈中的a就会销毁，当第二次调用method方法时，系统会在栈内存重新定义一个final a，所以两次调用method方法所使用的a不是同一个，所以调用两次都会输出不同的结果

视图

情况二，会出错

 

import java.lang.reflect.Method;

public class InnerClass {
    public static void main(String[] args) {
        InnerDemo innerDemo = new InnerDemo();
        innerDemo.method(10);
        innerDemo.method(75);

    }
}

class InnerDemo {
    private int x = 3;

    public void method(final int a) {

        a++;
        final int y = 10;
        class Demo {

            void methodDemo() {
                System.out.println("我是局部内部类中的方法" + " " + a);

            }
        }

        new Demo().methodDemo();
    }

}

 

视图

例10

原代码

import java.lang.reflect.Method;

public class InnerClass {
    public static void main(String[] args) {
        InnerDemo innerDemo=new InnerDemo();
        innerDemo.test01();
    }
}

abstract class AbsDemo {
    abstract void show();
}

class InnerDemo {
    int a = 0;

    class Demo01 extends AbsDemo {
        void show() {
            System.out.println("我是改写为匿名内部类之前的代码"+" "+a); //我是改写为匿名内部类之前的代码 0

        }
    }

    void test01(){
        new Demo01().show();
    }
}

改为内部类代码

import java.lang.reflect.Method;

public class InnerClass {
    public static void main(String[] args) {
        InnerDemo innerDemo = new InnerDemo();
        innerDemo.test01();
    }
}

abstract class AbsDemo {
    abstract void show();
}

class InnerDemo {
    int a = 0;

    void test01() {
        new AbsDemo() {
            void show() {
                System.out.println("我是改写为匿名内部类之后的代码" + " " + a); //我是改写为匿名内部类之后的代码 0

            }
        }.show();
    }

}

例11

匿名内部类一次只能调用一个方法

import java.lang.reflect.Method;

public class InnerClass {
    public static void main(String[] args) {
        InnerDemo innerDemo = new InnerDemo();
        innerDemo.test01();
    }
}

abstract class AbsDemo {
    abstract void show();
}

class InnerDemo {
    int a = 0;

    void test01() {
        new AbsDemo() {
            void show() {
                System.out.println("我是改写为匿名内部类之后的代码" + " " + a); // 我是改写为匿名内部类之后的代码
                                                                    // 0

            }

            void asd() {
                System.out.println("我是内部类自己的方法" + a);
            }

        }.asd(); // 我是内部类自己的方法0
        
        
        new AbsDemo() {
            void show() {
                System.out.println("我是改写为匿名内部类之后的代码" + " " + a); // 我是改写为匿名内部类之后的代码 0
                                                                    

            }

            void asd() {
                System.out.println("我是内部类自己的方法" + a);
            }

        }.show(); //我是改写为匿名内部类之后的代码 0

    }

}