面向对象之内部类

类里面定义的类称之为内部类。定义方式与普通类的定义方式一样，只是普通类只能被访问修饰符public，default修饰，但是内部可以被所有的访问修饰符修饰。

内部类分类：

成员内部类：

静态内部类：

方法内部类：

匿名内部类：

4.1 成员内部类

在内中定义一个普通类，这个普通类只能被访问修饰符修饰。

public class Monkey {//外部类
​
    //当前类中可以定义成员变量，成员方法，代码区，静态代码块
    // 还可以定义类
​
    public class A{// 这个类称为成员内部类
        //当前类中可以定义成员变量，成员方法，代码区，静态代码块
    }
}

调用：

1、在当前外部类中的方法调用内部类中的属性和行为，直接在指定的方法中创建内部类的对象即可。

public class Monkey {//外部类
​
    //当前类中可以定义成员变量，成员方法，代码区，静态代码块
    // 还可以定义类
    public void show(){
        A a=new A();
        a.run();
    }
    public class A{// 这个类称为成员内部类
        //当前类中可以定义成员变量，成员方法，代码区，静态代码块
        public void run(){
            System.out.println("a A class of run");
        }
    }
}
2、在外部类以外的其它类中使用该内部类，此时要注意当前成员内部类的访问修饰符。

需要使用外部类对象调用内部类对象的方式创建内部类对象。

Monkey.A a=new Monkey().new A();

注意：一般情况下创建内部类时仅供当前类所使用的，其它类使用的评率不高。

4.2 静态内部类

成员内部类被static修饰，该内部类就是一个静态内部类。

public class Monkey2 {//外部类
     
    // 静态内部类
   public static class A{
       
   }
}

调用

1. 在当前外部类中创建对象

   public class Monkey2 {//外部类
       public void show(){
           B b=new B();//创建静态内部类对象的方式
           b.run();
       }
   ​
       // 静态内部类
      public static class B{
           public void run(){
               System.out.println("Hello World");
           }
      }
   }
   ​

1. 在其他类中创建对象

public static void main(String[] args) {
    Monkey2.B b=new Monkey2.B();
    b.run();
}

4.3 方法内部类

在方法中也可以定义类。当前类作用域只能是在当前的方法中。

public void method(){
​
  class Z{
     public void run(){
         System.out.println("Hello Z");
     }
 }
​
 Z z=new Z();//只能在当前方法中使用。
  z.run();
}

4.4 匿名内部类

匿名内部类就是一个没有名字的内部类。这种内部类没有对象。但是可以认为是一个值，赋值给某个变量，直接使用这个变量。

匿名内部类也有分类：

类类型的匿名内部类

接口式匿名内部类。

参数式匿名内部类。

使用抽象类创建的匿名内部类称为类类型的匿名内部类，使用接口创建的匿名内部类称为接口式匿名内部类。

在面向对象中，抽象类和接口都不能创建对象，原因是抽象类和接口中可能存在抽象方法，想要创建对象必须先实现这些抽象方法。如果直接new抽象类或者接口，要求你完成其中的抽象方法，由于方法存放在类中的，因此new出来的是一个类，称这个类为匿名内部类。

类类型的匿名内部类：

public abstract class AbstractPerson {
public abstract void eat();
}
​
public static void main(String[] args) {
new AbstractPerson() {//匿名内部类
  @Override
  public void eat() {
​
  }
};
​
}

接口式匿名内部类

public interface PersonInterface {
void run();
void eat();
}
​
public static void main(String[] args) {
  new PersonInterface() {// 接口式匿名内部类
      @Override
      public void run() {
      }
      @Override
      public void eat() {
      }
  };
}

参数式匿名内部类：

​
public class Student {
​
public void show(){
  System.out.println("Hello ");
}
}
​
​
public static void main(String[] args) {
JFrame jFrame=new JFrame();
jFrame.addKeyListener(new KeyListener() {// 当前的匿名内部类当做参数直接传递给了某个方法，称这个内部类叫做参数式匿名内部类
  @Override
  public void keyTyped(KeyEvent e) {
​
  }
​
  @Override
  public void keyPressed(KeyEvent e) {
​
  }
​
  @Override
  public void keyReleased(KeyEvent e) {
​
  }
});
​
​
Student s=new Student(){
  @Override
  public void show() {//短暂的重写，只能对s变量起作用。
      System.out.println("hehe");
  }
};
s.show();
Student s2=new Student();
s2.show();
}