Java基础笔记18-内部类

Java基础笔记18-内部类

• 定义
  • 内部类就是定义在类中的类
• 作用
  • 类的生命周期是程序运行开始到程序运行结束销毁，但是当有些类使用频率很低，就将其定义为内部类，以缩短类的生命周期。
  • 内部类的重要作用就是缩短类的生命周期。
• 分类：
  • 内部类，局部内部类，匿名内部类

1.内部类

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

• 当使用它时，遵循成员变量的规则，当使用内部类内部的方法及属性时，在遵循成员变量的规则前提下遵循类的规则。

• 内部类可以调用外部类的属性及方法。

• /**
   * 内部类
   */
  public class Outter {
  	int count = 1;
  	class Inner{
  		int count = 2;
  		public void show() {
  			int count = 3;
  			System.out.println("count="+count);
  		}
  	}
      
  	public static void main(String[] args) {
  		//调用内部类方法
  		//内部类相当于外部类的一个成员变量
  		//外部类调用内部类，相当于外部类调用成员变量，需要一个外部类的对象
  		//内部类调用内部类的方法，需要将内部类看成一个整体的类
  		//需要一个内部类的对象调用内部类的方法
          
  		//直接调用形式
  		new Outter().new Inner().show();
  		
  		//创建内部类对象并赋给变量值的方式
  		Outter.Inner inner = new Outter().new Inner();
  		inner.show();
  	}
  }
  

• 输出：

• count=3
  count=3
  

• 当调用内部类的成员属性时，可以在变量前加 this 以指代成员变量，将上述内部类改为以下形式

• 	class Inner{
  		int count = 2;
  		public void show() {
  			int count = 3;
  			System.out.println("count="+this.count);
  		}
  	}
  

• 输出：

• count=2
  count=2
  

• 内部类使用修饰符的状态

  • 当内部类使用 static 修饰后就变成了一个静态类，生命周期与程序相同，就失去了定义内部类的意义。但可以正常调用。

    • 如果内部类不是静态类，内部类的方法也不能是静态方法。

    • 静态内部类调用形式

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

  • 使用 final 修饰后，就变成了一个最终类，无法被继承。

  • 使用 private 修饰后就只能在当前类中使用，当前程序外部无法使用，也无法通过其他方式在外部调用。

####　2.局部内部类

• 在类的方法中定义的类称为局部内部类

• 生命周期与方法一致，作用域只在方法内。

• 如果要使用局部内部类，只能在此类所在的方法中使用。

• public class PartInner {
  	/*
  	 * 在方法中定义一个类
  	 */
  	public void method() {
  		/*
  		 * 在方法中的类被称为局部内部类
  		 */
  		class Inner{
  			public  void show() {
  				System.out.println("局部内部类run");
  			}
  		}
  		//局部内部类必须在方法中调用用，因为生命周期与方法相同
  		Inner in = new Inner();
  		in.show();
  	}
  	
  	public static void main(String[] args) {
           //使用局部内部类只需调用拥有局部内部类的方法即可
  		PartInner part = new PartInner();
  		part.method();
  	}
  }
  

• 输出：

• 局部内部类run
  

3.匿名内部类

• 概念：

  • 定义在类中或方法中的类，没有具体名字和含义。

• 语法：

  • 父类类型 名字 = new 父类类型(){};

• 注意点：

  • 匿名内部类必须要有继承或实现，继承或实现父类的方法。
  • new 父类类型(){}就是一个子类对象。
  • 语法为多态形式，向上转型。

• public class NoNameInner {
  	/**
  	 * 这是一个接口
  	 */
  	interface Father{
  		public abstract void method();
  	}
  	/**
  	 * 单独创建一个类，实现接口
  	 */
  	public class Son implements Father{
  		@Override
  		public void method() {
  			System.out.println("Son中重写");
  		}
  	}
  
  	public static void main(String[] args) {
  		/*
  		 * 匿名内部类相当于创建了一个类，用于重写父类方法，实现接口，但生命周期短
  		 */
  		Father part1 = new Father() {
  			@Override
  			public void method() {
  				System.out.println("匿名内部类中重写");
  			}
  		};
  		part1.method();
  		
  		Object part2 = new Father() {
  
  			@Override
  			public void method() {
  				System.out.println("多态情况下的匿名内部类中重写");
  			}
  		};
  		((Father)part2).method();
  		
  
  		/**
  		 * Son类中调用方法
  		 */
  		NoNameInner.Son son = new NoNameInner().new Son();
  		son.method();
  	}
  }
  

• 输出

• 匿名内部类中重写
  多态情况下的匿名内部类中重写
  Son中重写