20220727学习内容 内部类概述和非静态内部类

一个类或者接口定义在另外一个类后者接口的内部

public class A1 { // 外部类

class B1 {} // 内部类

interface C1 {} // 内部接口

}

将一个类定义置入另一个类定义中，这就叫作 “ 内部类 ”：

        内部类之外的类称为外部类

        内部类的名称必须区别于它所在的外部类，和其它类之间没有要求

内部类的全名叫做 [ 外部类名称 $ 内部类名称 ]

public class A1 {

public class A1 {} // 语法报错

class B1 {} 语法正确，默认编译的结果名称为 A1$B1 . class

}

class B1 {}

 内部类可以访问其外部类的所有变量和方法

public class A1 { // 外部类的范围限定词只能是 public 或者默认 package

private String name ;

public class B1 { // 内部类的范围限定词可以是 4 种

public void pp () {

System . out . println ( name );

System . out . println ( A1 . this . name ); // 这里的 A1.this 用于表示 A1 类对

象

A1 . this . name = "ffff" ;

// System.out.println(this.name); 报错的原因是 this 用于指代当前类

的对象，当前类 B1 中并没有属性 name

pp ();

A1 . this . pp ();

}

}

private void pp (){}

}

 外部类不能直接访问内部类的实现细节

public class A1 {

private String name ;

public class B1 {

private int age = 99 ;

public void ff () {

System . out . println ( name );

System . out . println ( A1 . this . name );

A1 . this . name = "ffff" ;

}

private void dd (){}

}

private void pp (){

B1 b = new B1 (); // 如果需要在外部类中访问内部类的实现细节则需要构建内部类

对象，然后通过内部类对象进行访问

b . ff ();

System . out . println ( b . age ); // 注意：可以直接访问内部类中的私有属性

b . dd (); // 私有方法仍旧可以直接调用

}

}

内部类比外部类多了 private/protected/static 三个修饰符，这三个修饰符不能用在外部类上

非静态内部类不能拥有静态成员

 

protected class B1 {

private int age = 99 ;

{ } // 允许包含非静态代码块

private static String password = "123456" ; // 非静态内部类中不能包含静态属 性

static { } // 非静态内部类中不允许包含静态代码块

public B1 () { // 允许定义构造器和析构器方法

}

public static void hh (){} // 非静态内部类中不允许包含静态方法

1.1 内部类的作用：

内部类提供更好的封装

内部类可以直接访问外部类的私有成员

外部类不能直接访问内部类的成员，需要构建内部类对象才能访问

匿名内部类适合用于创建仅仅使用一次使用的类

1.2内部类分类

在 Java 中，可以将一个类定义在另一个类里面或者一个方法里面，这样的类称为内部类。广泛意义上的

内部类一般来说包括这四种：成员内部类、局部内部类、匿名内部类和静态内部类。

内部类实际拥有外部类的一个引用，在构造函数中将外部类的引用传递进来。

非静态内部类

非静态内部类的特点：

和其他类一样，它只是定义在外部类中的另一个完整的类结构

可以继承自己的想要继承的父类，实现自己想要实现的父接口们，和外部类的父类和父接口无 关

可以在非静态内部类中声明属性、方法、构造器等结构，但是不允许声明静态成员，但是可以

继承父类的静态成员，而且可以声明静态常量。

可以使用 abstract 修饰，因此它也可以被其他类继承

可以使用 final 修饰，表示不能被继承

编译后有自己的独立的字节码文件，只不过在内部类名前面冠以外部类名和 $ 符号。

和外部类不同的是，它可以允许四种权限修饰符： public ， protected ，缺省， private

外部类只允许 public 或缺省的

还可以在非静态内部类中使用外部类的所有成员，哪怕是私有的

在外部类的静态成员中不可以使用非静态内部类哦

就如同静态方法中不能访问本类的非静态成员变量和非静态方法一样

在外部类的外面必须通过外部类的对象才能创建非静态内部类的对象

因此在非静态内部类的方法中有两个 this 对象，一个是外部类的 this 对象，一个是内部类的

this 对象

在创建非静态内部类对象时，一定要先创建起相应的外部类对象

public class A1 {

public static void main ( String [] args ) {

B1 b = new B1 ();

B1 . C1 cc = b . new C1 (); // 内部类的写法为 [ 外部类名 . 内部类名 ] ，否则需要

import com.yan.B1.C1; 则可以直接使用 C1 类。至于 C1 类是否可见取决于 C1 类的范围限定词

System . out . println ( cc );

}

}

class B1

在任何非静态内部类中，都不能有静态数据、静态方法或者又一个静态内部类  

语法错误

public class A1 {

public class B1 {

public static String name = "yan" ; // 语法错误 , 除非 B1 类是静态内部类

static class B1{}

static {} // 语法错误

public static void pp (){} // 语法错误

public static class C1 {} // 语法错误

}

}

注意内部类的可见性范围限制

访问方法：直接访问外部类中内部类中的成员

 

class B1 {

private String pwd ;

private void dd (){}

protected class C1 {

private String name ;

private void pp (){

System . out . println ( pwd ); // 内部类可以直接访问外部类中的私有成

员

// 另外的写法 B1.this.pwd

dd ();

// 另外的写法 B1.this.dd();

}

}

public void ee (){

// 如果需要访问内部类中的成员，则必须首先创建内部类对象

C1 cc = new C1 ();

// 通过构建的内部类对象则可以访问内部类中的私有成员

cc . name = "abc" ;

cc . pp ();

}

}

外部类.内部类 in=new 外部类().new 内部类();  

public class A1 {

public static void main ( String [] args ) {

B1 b = new B1 ();

B1 . C1 cc = b . new C1 (); // 内部类是否可以访问到，取决于内部类上的范围限

定词

}

}

class B1 {

class C1 {}

}

in.内部类方法();  

public class A1 {

public static void main ( String [] args ) {

B1 b = new B1 ();

B1 . C1 cc = b . new C1 ();

cc . pp (); // 是否可以访问 pp 方法取决于 pp 方法的范围限定词

}

}

class B1 {

class C1 {

public void pp (){}

}

}

 注意内部类的可见性范围限制

class B1 {

private class C1 { // 注意这个 C1 类只能在 B1 类中进行使用，其它位置不可见

public void pp (){}

}

}