内部类

一： 内部类

1 定义：

内部类就是在一个类的内部在定义一个类 比如 A类中定义一个B类，那么B类相对于A类来说就是内部类

2 内部类的分类

1 成员内部类

     1 定义格式

修饰符 class 外部类名称{
		修饰符  class  内部类名称{
			//....
		}
		//...					
}

     2.注意事项：内部类使用外部类的成员变量和方法，可以随便用；外部类使用内部类的成员变量和方法，需要创建内部类对象。

     3.使用方式：

           a.直接调用：在外部类成员位置定义一个方法，在方法内创建内部类对象，调用内部类成员；main方法只是调用外部类方法。

           b.间接调用：外部类名.内部类名   对象名=new   外部类名().new  内部类名();通过对象名调用内部类成员。

package demo2;
//外部类
public class Person {
    //内部类
    class Heart{
       public void myHeart(){
           System.out.println("这是内部类方法");
       }
    }
 
    public void person(){
        //直接调用，创建内部类对象，通过内部类对象调用内部类成员变量和方法
        Heart inter=new Heart();
        inter.myHeart();
        System.out.println("这是外部类方法");
    }
}

public class Person_test {
    public static void main(String[] args) {
        //直接调用---在外部类方法中创建内部类对象，调用内部类方法
        //在测试类中创建外部类对象，调用外部类方法
        Person t=new Person();
        t.person();
 
        //间接调用---创建内部类对象，访问内部类方法
        Person.Heart h=new Person().new Heart();
        h.myHeart();
    }
}

　　

结果：

Connected to the target VM, address: '127.0.0.1:62641', transport: 'socket'
这是内部类方法
这是外部类方法
这是内部类方法
Disconnected from the target VM, address: '127.0.0.1:62641', transport: 'socket'

Process finished with exit code 0

　　2 静态内部类

 

class Out {
    private static int age = 12;
     
    static class In {
        public void print() {
            System.out.println(age);
        }
    }
}
 
public class Demo {
    public static void main(String[] args) {
        Out.In in = new Out.In();
        in.print();
    }
}//结果为12

3 局部内部类
 定义：如果一个类是定义在一个方法内部的，那么这就是一个局部额内部类“局部”：只有当前这个方法可以使用它，出了这个方法外面就不可以用了。

package demo2;
//局部内部类
 
//外部类
public class Outer {
    //外部类方法
    public void methodOuter(){

        //局部内部类
        class Inner{
            int num=10;
        //内部类的方法
            public void methodInner(){
                System.out.println(num+"局部内部类测试");
            }
        }
 
        //在外部类方法创建内部类对象，调用内部类成员
        Inner i=new Inner();
        i.methodInner();
    }
}

　　4 匿名内部类
(定义：如果接口的实现类(或者是父类的子类)只需要使用唯一的一次。那么这种情况下就可以省略掉该类的定义，而改为使用匿名内部类。)

接口名称   对象名 = new  接口名称(){
	//覆盖重写接口中所以的抽象方法
};

 

package demo2;
 
public class MyInterface_test {
    public static void main(String[] args) {
 
        //匿名内部类
        MyInterface m=new MyInterface(){
            @Override
            public void work(){
                System.out.println("匿名内部类实现了方法");
            }
        };
        m.work();
    }
}