编程教程 - 技术改变世界

Search

Java编程技术

Java 精炼解读数据结构的顺序表如何操作

Java 精炼解读时间复杂度与空间复杂度

一起来了解Java的内部类

内部类：

其实内部类顾名思义，就是类中类，一个类里面还有一个类。

内部类分为四种：

1.普通内部类

2.静态内部类

3.方法内部类

4.匿名内部类

我们一一去了解一下~~

A、普通内部类：

我们先通过代码去了解一下：

package InternalClass;
/**
* 内部类
*/
public class Car {
  public int a = 10;
  public int b = 20;
  //外部类的方法
  public void method() {
      System.out.println("我是外部类Car的普通方法！");
      bus b = new bus();     //创建内部类的对象
      b.internalMethod();
  }
  //内部类（在Car类中的bus类）
  public class bus {
      int b = 30;
      //内部类方法
      public void internalMethod() {
          System.out.println("**这是bus内部类的普通方法！");
          System.out.println("**我是内部类，现在在访问外部类Car的a:" + a);
          System.out.println("**我是内部类，现在在访问内部类bus的b:" + this.b);
          System.out.println("**我是内部类，现在在访问外部类bus的b:" + Car.this.b);
          //注意，如果在内部类需要使用外部类的属性，必须通过外部的类去this外部类的属性
      }
  }    
	//程序运行入口：
	public static void main(String[] args) {
	    Car car = new Car();   //创建外部类的对象
	    car.method();
	    // 运行上面的代码 会输出 ： 我是外部类Car的普通方法！
	   	//运行内部类的方法
	   	//在上面method方法中已经创建了内部类bus的对象b
	   	//这里就是通过使用外部类Car的对象car去new一个内部类对象
	   	bus b = car.new bus();  
	   	//通过内部类对象b 去使用方法即可
	    b.internalMethod();   
		//输出：
		/*
		**这是bus内部类的普通方法！
		**我是内部类，现在在访问外部类Car的a:10
		**我是内部类，现在在访问内部类bus的b:30
		**我是内部类，现在在访问外部类bus的b:20
*/
 }
}

B、静态内部类：

静态内部类顾名思义也是把内部类用static修饰变为静态的，可以直接用外部类类名去调用，不需要创建对象：

package InternalClass;
public class Person {
  String name = "小王";
  static int age = 20;
  //创建静态内部类
  public static class Student{
      String name = "小红";
      //静态内部类的方法
      public static void study(){
          Person p = new Person(); //创建外部类的对象
          //静态访问非静态需要使用对象去调用
          System.out.println("内部类静态方法访问外部非静态成员:"+p.name);
          System.out.println("内部类静态方法访问外部静态成员:"+Person.age);
          System.out.println("内部类静态方法访问内部非静态成员:"+new Student().name);
      }
  }
  //程序运行入口
  public static void main(String[] args) {
      //静态内使用方法不需要创建对象
      Student.study();
  }
/*
输出：
内部类静态方法访问外部非静态成员:小王
内部类静态方法访问外部静态成员:20
内部类静态方法访问内部非静态成员:小红
*/
}

C、方法内部类：

方法内部类顾名思义也是在外部类的方法体内新建一个类:

package InternalClass;
/**
* 方法内部类
*/
public class Student {
  //方法
  public void study(){
      int age = 20;
      String name = "小王";
      //在方法内写类：方法内部类
      class child{
          //方法内部类的方法
          public void play(){
              System.out.println("孩子喜欢玩！");
          }
      }
      //在外部类study的方法内创建一个生成内部类child的对象，并使用方法
      child c = new child();
      c.play();
  }
  //程序执行入口
  public static void main(String[] args) {
      Student stu = new Student();
      //这里调用study方法后，在study方法体内创建了child的对象和调用了play的方法
      stu.study();  
  }
}
//输出：我叫：小王我今年：20我爱学习
//	   孩子喜欢玩！

内部类的小结（有很多局限性，所以应该注意使用场景）：

1.类前不能有访问修饰符

2.只能在此方法内使用

3.无法创造静态信息

4.可以直接访问方法内的局部变量和参数，但是不能修改

5.可以随意的访问外部类的任何信息

D、匿名内部类：

匿名内部类就是没有名字的内部类：

先定义一个接口：

public interface USB {
  void read();
}

package InternalClass;
/**
* 匿名内部类
*/
public class Child {
  public static void main(String[] args) {
      USB u = new USB() {
          @Override
          public void read() {
              System.out.println("这是匿名内部类，是USB接口没有具名的子类，必须重写 接口做具体实现");
          }
      };
      u.read();
  }
}

匿名内部类需要注意的四点：

1.匿名内部类不能定义任何静态成员、方法

2.匿名内部类中的方法不能是抽象的

3.匿名内部类必须实现接口或抽象父类的所有抽象方法

4.匿名内部类访问的外部类成员变量或成员方法必须用static修饰