Java基础学习之内部类

内部类：把类定义在其他类的内部，这个类就被称为内部类

class Outer{

    class Inner{

       

    }

}

 

内部类的特点:

         1.内部类可以访问外部类的成员，包括私有成员。

         class Outer{

    privateintnumber = 20;

    class Inner{

        publicvoid show(){

            System.out.println(number);

        }

    }

}

 

         2.外部类想要访问内部类，必须要先创建对象

         class Outer{

    privateintnumber = 20;

    class Inner{

        publicvoid show(){

            System.out.println(number);

        }

    }

   

    publicvoid metod(){

        Innerinner = newInner();

        inner.show();

    }

}

 

内部类根据定义的位置不同，分为两种

1.      成员内部类：定义在成员位置的内部类

2.      局部内部类：定义在方法内部的内部类。

class Outer{

    privateintnumber= 20;

    class Inner{

        publicvoid show(){

            System.out.println(number);

        }

    }

   

    publicvoidmetod(){

        Inner inner = new Inner();

        inner.show();

    }

   

    publicvoidtest(){

        class InnerDemo2{

            publicvoid show(){

                System.out.println(number);

            }

        }

        InnerDemo2 innerd = new InnerDemo2();

        innerd.show();

    }

}

 

 

成员内部类在其他类中的访问方式：

         成员内部类相当于外部类的一个成员变量

访问格式  外部类.内部类 对象名 = new 外部类().new 内部类();

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

out.show();

         成员内部类的修饰符： 

private   不能被外界访问 。一般是外部类提供一个方法给其他类来访问私有内部类

static     只能访问外部类的静态成员，其内部的方法都是被静态修饰后的方法 访问格式  外部类.内部类   对象名 = new 外部类.内部类();

class Outer{

                                    privatestaticintnumber = 20;

                                    staticclass Inner{

                                        publicvoid show(){

                                            System.out.println(number);

                                        }

                                    }

   

}

 

publicclass InnerDemo {

 

                        publicstaticvoid main(String[] args) {

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

                            inner.show();

                            }

}

                                                        默认修饰符  成员内部类相当于外部类的一个成员变量

访问格式  外部类.内部类 对象名 = new 外部类().new 内部类();

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

out.show();

public   修饰的内部类，访问时，必须先创建外部类对象，通过外部类对象去获取内部类的引用

                                                        class Outer{

                            privatestaticintnumber = 20;

                            public  class Inner{

                                publicvoid show(){

                                    System.out.println(number);

                                    }

                                }

   

}

 

publicclass InnerDemo {

 

                            publicstaticvoid main(String[] args) {

                            Outer outer=new Outer();           

                            Outer.Inner inner =outer.newInner();

                        }

 

}

 

static 不能与private同时出现。

可以在this前加外部类来限定，表示当前代表的是外部类的对象。

 

局部位置的内部类：局部内部类不能使用public修饰    局部内部类也不能用static修饰

         可以直接访问外部类的成员

         在局部位置可以创建内部类的对象，通过内部类的对象来局部调用内部类的方法。

         局部内部类访问局部变量时，该局部变量必须是用final修饰的

因为局部变量会随着方法的调用完毕而消失，但是局部对象并没有立刻从堆内存中消失，还要使用那个变量。为了让数据能够继续使用，就用final修饰，这样，在堆内存中存储的其实是一个常量值(数值，变量会消失，但是数字仍在)。

 

局部内部类不能被外界所访问。

 

匿名内部类：就是内部类的简写。

                            匿名内部类必须继承某个或者是实现没有个接口。

                            格式：new 父类名或者接口名{ 重写方法}

匿名内部类调用自己的方法的格式：new 父类名或者接口名{ 重写方法}.方法名();

 

匿名内部类一般只实现一个方法，因为多余的方法无法调用。

 

匿名内部类其实就是一个子类对象。

 

每一次创建匿名内部类，都是一个新的对象。

 

匿名内部类可以按照多态的方式赋值给接口或者是父类，来完成多个方法的调用。

 

匿名内部类本质上就是继承类或者实现了接口的子类的匿名对象。

 

匿名内部类的好处：用完即销毁，内存能够及时回收。

 

interface Inner{

   void show();

}

 

class Outer{

   publicstatic Inner method(){

      returnnew Inner() {       

        publicvoid show() {

           // TODO Auto-generatedmethod stub

           System.out.println("helloworld");

        }

      };

   }

}

 

publicclass InnerTest {

 

   publicstaticvoid main(String[] args) {

      // TODO Auto-generatedmethod stub

      Outer.method().show();

   }

}