Javase之内部类概述

内部类概述

• 把类定义在其他类的内部就称为内部类

class A{

	class B{

	}

}

B就称为内部类，A称为外部类。

• 内部类的访问特点

  1. 内部类直接访问外部类成员，包括私有。
  2. 外部类要访问内部类要创建对象。
  3. 内部类可用static修饰，它可以看作外部类的成员。

• 内部类的位置

  1. 成员位置：在成员位置定义的类，称为成员内部类。

  2. 局部位置：在局部位置定义的类，称为局部内部类。

     class Outer{
     
     	private int num = 10;
     
     	//成员内部类
     
     	class Inner1{
     
     	}
     
     	public void method(){
     
     		//局部内部类
     
     		class Inner2{
     
     		}
     
     	}
     
     }
     
     

     ​

  • 成员内部类

    • 访问方式：外部类名.内部类名 对象名 = 外部类对象.内部类对象 （因为一般非静态成员可只能通过对象访问）

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

    • 修饰符

      private ：保证数据的安全行。

      static ：为了方便访问数据。

      注意：静态内部类访问外部成员时，只能访问外部的静态成员。

      此时访问内部类的方式为：外部类名.内部类名 对象名 = new 外部类名.内部类名（）; （因为静态成员可直接通过类名访问）

      eg: Outer.Inner obj = new Outer.Inner();

    • 注意：

      1.内部类与外部类没有继承关系。

      2.内部类若要访问外部类的非静态成员，要通过外部类名限定this对象。(Outer.this)

      class Outer{
      
      	public int num = 10;
      
      	class Inner1{
      
      		public int num = 20;
      
      		public void show(){
      
      			int num = 30;
      
      			System.out println(num);
      
      			System.out println(this.num);
      
      			System.out println(outer.this.num);
      
      		}
      
      	}
      
      }
      

      out:

      30

      20

      10

  • 局部内部类

    1.可直接访问外部类的成员。

    2.在局部位置，可创建内部类对象，通过对象调用内部类的方法，来使用局部内部类的功能。

    • 局部内部类访问局部变量的注意事项：

      1.局部内部类访问的局部变量必须要被final修饰。

      2.原因：局部变量随着方法的调用而调用，方法调用完毕就消失。而堆内存的内容不会立即消失，所以，要用final修饰局部变量。加入final修饰后，所有调用这个变量的地方就变成常量数据，常量在内存中存在是固定的，故即使局部变量随着方法调用而消失，数据依旧存在。

      class Outer{
      
      	private int num1 = 10;
      
      	public void method(){
      
      		//局部内部类
      
      		final int num2 = 20;
      
      		class Inner{
      
      			public void show(){
      
      				System.out.println(num1);
      
      				//从内部类访问本地变量num2；num2需要被申明为最终类型。
      
      				System.out.println(num2);
      
      			}
      
      		}
      
      	}
      
      }
      
      

• 匿名内部类

  内部类的简化写法

  前提：存在一个类（抽象类）或接口。

  格式：

  ​ new 类名（抽象类名）或接口名（）{

  ​ 重写方法；

  ​ }

  本质：是一个继承该类或实现改接口的子类的匿名对象。

  interface Inter {
      public abstract void show();
      public abstract void show2();
  }
  
  class Outer {
      public void method() {
          new Inter(){
              public void show() {
                  System.out.println("show");
              }
              //只调用一个匿名内部类的方法时直接在new出的对象后面加要调用的方法名。
          }.show();
          //若要调用匿名内部类的多个方法则把匿名内部类变成有名的。(通过多态)
          Inter i = new Inter(){
              public void show() {
                  System.out.println("show");
              }
               public void show2() {
                  System.out.println("show2");
              }
          }
          i.show();
          i.show2();
      }
  }
  class Main {
      public static void main(String[] args) {
          Outer o = new Outer();
          o.method();
      }
  }
  

  • 匿名内部类的应用

  interface Inter {
      public abstract void show();
  }
  
  class InterTest {
      //接口作为形参，要的不是接口而是接口的实现类
      public void method(Inter p) {
          p.show();
      }
  }
  
  class InterImp implement Inter {
      public void show() {
          System.out.println("show");
      }
  }
  
  class Outer {
      public static void main(String[] args) {
          InterTest it = new InterTest();
          Inter i = new InterImp();
          it.show();
  
          //匿名内部类在开发中的使用
          //匿名内部类的本质是继承该类或实现改接口的子类的匿名对象。
          //作用：方法结束匿名内部类就被回收节省资源。
          it.show(new Inter() {
              public void show() {
         	 		System.out.println("show");
      		}
          });
      }
  }
  

  • 匿名内部类的案例

  补齐代码：
  
  interface Inter { void show();}

  class Outer {
  
  //补齐代码
  
  }

  class Main {
  
  public static void main(String[] args){
  
  Outer.method().show();
  
  }
  
  }

  //要求输出“hello world”

 interface Inter { void show();}

 class Outer {
     //补齐代码
     public static Inter method(){
         return new Inter(){
             public static void show(){
                 System.out.println("hello world");
             }
         };
     }
 }

 class Main {
     public static void main(String[] args){
         Outer.method().show();
         //由Outer.method()可以看出method()为静态方法，而Outer.method().show();
         //则说明method()方法的返回值类型为Inter所以
     }
 }

​

​