内部类

// 外部类
class Demo{
 private int num = 3;
 // 定义内部类
 class Int{
  void show(){
   System.out.println("num="+num); 
  }
 }

 void method(){
  Int int = new Int();
  int.show();
 }
}

class Inner{
 public static void main(Stirng[] args){
  Demo demo = new Demo();
  demo.method();
 }
}

内部类可以直接访问外部类，但是外部类要访问内部类中的成员变量，就必须要创建内部类的对象。

class Outer{
    …
    class Inner{
        ….
    }
}

外部类如果不创建外部类对象，就不能直接创建内部了对象

内部类可访问外部类，而且不破坏封装

内部类的分类：
1. 静态内部类
2. 局部内部类
3. 成员内部类
4. 匿名内部类

成员内部类：
在成员变量的位置上定义的类为成员内部类。如果要使用成员内部类就要使用外部类.内部类来访问。

使用外部类的名字来访问，是因为一个内部类可能有不同的外部类。要有一个内部类，必须要有外部类的对象，因为成员内部类要用外部类访问。

成员内部类可以访问外部类的所有属性，成员内部类不能定义有静态属性。

静态内部类：
在成员位置上用static修饰的内部类为静态内部类。静态内部类只能访问外部类的静态成员和本内部类的成员；且不能访问外部类的非静态成员。

局部内部类：
局部，在一个方法中内的类，为局部内部类，局部内部类不能用访问修饰符，作用域在定义的它的区域内。

局部内部类可以访问外部类的成员属性和静态属性，也可以访问final修饰的局部变量，但不能访问非final的局部变量。

匿名内部类：
是一种特殊的局部内部类。

访问外部类中的内部类，非静态

Outer.Inner int = new Outer().new Innter();

对静态内部类中的非静态成员

Outer.Inner int = new Outer().new Innter();

非静态内部类中不允许定义静态成员，内部类被静态修饰后，随着外部类的加载而加载。

内部类

内部类：
在类Out的内部中定义一个类为Int，此时的Int类为内部类，Out则为外部类。内部类可被修饰为public或private，当对其访问的限制和成员变量和方法相同。

内部类格式：

标识符 class 外部类的名称 {
 // 外部类的成员
 标识符 class 内部类的名称{
  //内部类的成员
 }
}

实例：

class Student{
 int score = 100;
 void add(){
  Shu shu = new Shu();
  shu.show();
 }
 class Shu{
  void show(){
   System.out.println("成绩"+score);
  }
 }
}
// 测试
public class Demo{
 public static void main(String[] args){
  Student stu = new Student();
  stu.add();
 }
}

用static声明的内部类，则内部类变成外部类，用static声明的内部类不能访问非static的外部类属性，外部类的属性要用static才能访问。

内部类用static修饰的，无法访问外部类的非static类型的属性。

// 下方代码出错
class Student{
 int score = 100;
 void add(){
  Shu shu = new Shu();
  shu.show();
 }
 static class Shu{
  void show(){
   System.out.println("成绩"+score);
  }
 }
}
// 测试
public class Demo{
 public static void main(String[] args){
  Student stu = new Student();
  stu.add();
 }
}

在类外部引用内部类

class Student{
 int score = 100;
 void add(){
  Shu shu = new Shu();
  shu.show();
 }
public class Shu{
  void show(){
   System.out.println("成绩"+score);
  }
 }
}
// 测试
public class Demo{
 public static void main(String[] args){
  Student stu = new Student();
  Student.Stu inner = stu.new Shu();
  // Stuent.Stu inner = new Student().new Shu();
 inner.show();
 }
}

在方法中定义内部类

class Student{
 int score = 100;
 void add(){
 class Shu{
  void show(){
   System.out.println("成绩"+score);
  }
 }  
 Shu shu = new Shu();
  shu.show();
 }
}
// 测试
public class Demo{
 public static void main(String[] args){
  Student stu = new Student();
  stu.add();
 }
}

final类型的局部变量

在内部类中的final类型的局部变量，可以被访问，用final修饰的相当于一个常量，可以访问。

// 错误
class Student{
 int score = 100;
 void add(final int s){
 int t = 20;
 class Shu{
  void show(){
   System.out.println("成绩"+score+s+t);
  }
 }  
 Shu shu = new Shu();
  shu.show();
 }
}
// 测试
public class Demo{
 public static void main(String[] args){
  Student stu = new Student();
  stu.add();
 }
}

改：final int t = 20;

class Student{
 int score = 100;
 void add(final int s){
 final int t = 20;
 class Shu{
  void show(){
   System.out.println("成绩"+score+s+t);
  }
 }  
 Shu shu = new Shu();
  shu.show();
 }
}
// 测试
public class Demo{
 public static void main(String[] args){
  Student stu = new Student();
  stu.add();
 }
}

内部类

内部类可以使用外部类所有的方法和变量，就算被私有化也一样可以，如：

class Outer{
 private int x;
 // 创建内部类的实例
 Inner inner = new Inner();
 public void do(){
  // 调用内部类的方法
  inner.go();
 }
 // 内部类
 class Inner{
  void go(){
   x = 30;
  }
 }
}

结语

• 本文主要讲解 Java基础-内部类
• 下面我将继续对Java、 Android中的其他知识 深入讲解 ，有兴趣可以继续关注
• 小礼物走一走 or 点赞