java面向对象编程---内部类，成员、匿名、局部内部类详细解析

1.内部类的要点

1.内部类是一类特殊的类，指的是定义在一个类的内部的类。 2.实际开发中，为了方便的使用外部类的相关属性和方法，这时我们通常会定义一个内部类。内部类可以直接访问外部类的私有属性，内部类被当成其外部类的成员。但外部类不能访问内部类的内部属性。

3.内部类提供了更好的封装。只能让外部类直接访问；

内部类只能被外部类直接访问，外部类之外不能不能直接调用内部类，需要通过外部类间接的去使用它。

总结：内部类的存在，就是为了外部类而存在的，就像人的心脏，只为一个人服务。

2.内部类的分类

 3.代码展示 案例一 成员内部类之非静态内部类的创建与基本语法

//实现类

public class Outer {
    private int age = 20;
    public void show()
    {
        System.out.println("外部类,age:"+age);
    }
    //内部类。定义在外部类Outer里边。
    //非静态内部类不能有静态的方法、属性以及初始化块。
    class Inner{

        private int id = 114514;
        private int age = 18;

        public void text()
        {
            System.out.println("Inner.text");
            System.out.println("内部类的属性,age:"+this.age);     //访问内部类的属性
            System.out.println("外部类的属性,age:"+Outer.this.age); //通过 外部类名.this.属性名  访问外部类的属性
            Outer.this.show();
        }
    }
}

//测试类


//测试 调用内部类和外部类
public class Test1 {
    public static void main(String[] args) {
        //非静态内部类的对象必须寄存在外部类对象里
        //先创建外部类的对象，然后使用外部类对象创建内部类对象
        Outer.Inner inner = new Outer().new Inner();
        inner.text();
    }
}

案例二 静态内部类

使用要点 ：

1.静态内部类可以访问外部类的静态成员，不能访问外部类的普通成员。

2.静态内部类看做外部类的一个静态成员。

//测试静态内部类
public class Outer2 {
    private int a = 10;
    private static int b = 20;

    //静态内部类
    static class Inner2{

        public void test()
        {
            //System.out.println(a);  //错误 静态内部类不能访问外部类的普通属性和方法
            System.out.println(b);
        }
    }
}

//测试调用 静态内部类
public class Text2 {
    public static void main(String[] args) {
        //通过 new 外部类名.内部类名（); 来创建静态内部类的对象
        Outer2.Inner2 inner2 = new Outer2.Inner2();
        {
            inner2.test();
        }

    }
}

普通非静态内部类与静态内部类调用的方法区别

//非静态内部类的调用语法
 //非静态内部类的对象必须寄存在外部类对象里
 //先创建外部类的对象，然后使用外部类对象创建内部类对象
//即 new 外部类名（）. new 内部类名();
Outer.Inner inner = new Outer().new Inner();
        inner.text();
//静态内部类的调用语法
//通过 new 外部类名.内部类名（); 来创建静态内部类的对象
Outer2.Inner2 inner2 = new Outer2.Inner2();
        inner2.test();
        

案例三 匿名内部类

使用要点：适合那种只需要使用一次的类。比如：键鼠监听 *** 作等等。在安卓开发中 awt swing GUI里开发中常见。

public class Text3 {
    public void text(A3 a)
    {
        System.out.println("Text3.text");
        a.run();
    }

    public static void main(String[] args) {
        Text3 js = new Text3();
        js.text(new TextA3());  
    }
}
//没有匿名内部类是这样干的
//这个类定义好后可以反复调用
class TextA3 implements A3{
    @Override
    public void run()
    {
        System.out.println("Text.A3");
    }

}
interface A3{                   //text需要实现类来传递A3 但是现在A3没有实现类
    void run();
}

public class Text3 {
    public void text(A3 a)
    {
        System.out.println("Text3.text");
        a.run();
    }

    public static void main(String[] args) {
        Text3 js = new Text3();
        //匿名内部类只使用一次
        js.text(new A3() {       //new A3回车idea会自动补充
            @Override            //在括号里边定义了匿名内部类，同时创建匿名内部类的对象
            public void run() {  //方法重写
                System.out.println("匿名内部类的run()");                    
            }
        });
        //上述用完即报废
        //在定义一个新的类
        js.text(new A3() {
            @Override
            public void run() {
                System.out.println("Text3.run");
            }
        });
    }
}


interface A3{                   //text需要实现类来传递A3 但是现在A3没有实现类
    void run();
}

案例四 局部内部类

定义在方法内部的，作用域只限于本方法，称为局部内部类。

局部内部类在实际开发中应用很少，了解即可，

public class Locatext {
    public void show()
    {
        System.out.println("stpe1");
        
        //局部内部类,作用域仅限于show方法内
        class Inner3{
            public void run()
            {
                System.out.println("Inner3.run");
            }
        }
        //本方法中，直接使用局部内部类
        new Inner3().run();
    }

    public static void main(String[] args) {
        new Locatext().show();
    }
}