JavaSE---内部类
1、概述
1.1 内部类：一个类 定义在 其他类的内部，这个类被称为内部类；
内部类可以 放在 外部类 的任何位置；
1.2、语法
public class Test {
修饰符 class 内部类类名{
}
}
2、内部类访问特点
内部类 可以直接访问外部类的成员，包括私有
外部类 想访问内部类的成员，必须创建对象
3、根据内部类存放的位置，分为
成员内部类 ：
package com.an.innerclass.memberinnerclass;
public class Outer {
private int age=18;
private static String name="jack";
String job="teacher";
public void say(){
System.out.println("Outer say...");
}
private MemberInnerClass memberInnerClass=null;
public MemberInnerClass getMemberInnerClass(){
if (null==memberInnerClass){
memberInnerClass=new MemberInnerClass();
}
return memberInnerClass;
}
/**
* 位置：作为外部类的成员
* 成员内部类 可以 访问 外部类的所有成员属性、成员方法（包括 private、static）
*
*/
public class MemberInnerClass{
void useOuter(){
System.out.println(age);
System.out.println(name);
System.out.println(job);
//如果 成员内部类 拥有的成员变量或方法 与 外部类同名时，默认访问的 是成员内部类的成员
say();
//如果 成员内部类 拥有的成员变量或方法 与 外部类同名时，要访问外部类成员，需要使用 外部类.this.成员方法｜成员变量
Outer.this.say();
}
void say(){
System.out.println("MemberInnerClass say...");
}
}
}
class Test{
public static void main(String[] args) {
//外部类 访问 内部类 的成员 只能创建 内部类对象，再由 内部类对象 访问 内部类成员
//第一种方式：
Outer.MemberInnerClass memberInnerClass=new Outer().new MemberInnerClass();
memberInnerClass.useOuter();
//第二种方式：
Outer.MemberInnerClass memberInnerClass1=new Outer().getMemberInnerClass();
}
}
javac编译Outer.java
public class Outer {
private int age = 18;
private static String name = "jack";
String job = "teacher";
private Outer.MemberInnerClass memberInnerClass = null;
public Outer() {
}
public void say() {
System.out.println("Outer say...");
}
public Outer.MemberInnerClass getMemberInnerClass() {
if (null == this.memberInnerClass) {
this.memberInnerClass = new Outer.MemberInnerClass();
}
return this.memberInnerClass;
}
public class MemberInnerClass {
public MemberInnerClass() {
}
void useOuter() {
System.out.println(Outer.this.age);
System.out.println(Outer.name);
System.out.println(Outer.this.job);
this.say();
Outer.this.say();
}
void say() {
System.out.println("MemberInnerClass say...");
}
}
}
public class Outer$MemberInnerClass {
public Outer$MemberInnerClass(Outer var1) {
this.this$0 = var1;
}
void useOuter() {
System.out.println(Outer.access$000(this.this$0));
System.out.println(Outer.access$100());
System.out.println(this.this$0.job);
this.say();
this.this$0.say();
}
void say() {
System.out.println("MemberInnerClass say...");
}
}
class Test {
Test() {
}
public static void main(String[] var0) {
Outer var10002 = new Outer();
var10002.getClass();
MemberInnerClass var1 = new MemberInnerClass(var10002);
var1.useOuter();
MemberInnerClass var2 = (new Outer()).getMemberInnerClass();
}
}
局部内部类：
定义在方法中，仅在方法中有效；
不能使用任何修饰符，也不能用static修饰；
package com.an.innerclass.partinnerclass;
public class Outer {
private String name="jack";
private static int age=18;
public void say(){
/**
* 局部内部类 不能有 public、protected、private 以及 static 修饰符的
*
* 外部如何使用局部内部类 ：
* 外部类对象.外部类成员方法.内部类对象.内部类成员方法
*/
class PartInnerClass{
public void show(){
System.out.println(name);
System.out.println(age);
}
}
new PartInnerClass().show();
}
}
class Test{
public static void main(String[] args) {
new Outer().say();
}
}
javac编译Outer.java
public class Outer {
private String name = "jack";
private static int age = 18;
public Outer() {
}
public void say() {
class PartInnerClass {
PartInnerClass() {
}
public void show() {
System.out.println(Outer.this.name);
System.out.println(Outer.age);
}
}
(new PartInnerClass()).show();
}
}
class Outer$1PartInnerClass {
Outer$1PartInnerClass(Outer var1) {
this.this$0 = var1;
}
public void show() {
System.out.println(Outer.access$000(this.this$0));
System.out.println(Outer.access$100());
}
}
class Test {
Test() {
}
public static void main(String[] var0) {
(new Outer()).say();
}
}
匿名内部类：
a, 只使用一次；
b, 语法：
new 父类构造器(实参) | 实现接口(){ }
c, 必须 继承一个父类（最多一个） 或 实现一个接口（最多一个）；
d, 不能 定义构造器，但 可以有初始化块；
e, 不能 是抽象类；
package com.an.innerclass.nonameinnerclass;
public interface NonameInnerClass {
void say();
}
class Test{
public static void main(String[] args) {
/**
* 匿名内部类 不能有访问修饰符和 static 修饰符
*
* 位置：参数
*/
say(new NonameInnerClass() {
public void say() {
System.out.println("NonameInnerClass say...");
}
});
}
public static void say(NonameInnerClass nonameInnerClass){
nonameInnerClass.say();
}
}
javac编译Outer.java
public interface NonameInnerClass {
void say();
}
class Test {
Test() {
}
public static void main(String[] var0) {
say(new NonameInnerClass() {
public void say() {
System.out.println("NonameInnerClass say...");
}
});
}
public static void say(NonameInnerClass var0) {
var0.say();
}
}
final class Test$1 implements NonameInnerClass {
Test$1() {
}
public void say() {
System.out.println("NonameInnerClass say...");
}
}
匿名内部类 实质：
创建一个 实现接口的 类，重写方法；
静态内部类：
package com.an.innerclass.staticinnerclass;
public class Outer {
private String name="rose";
static String job="teacher";
/**
* 静态内部类 static修饰
* 不能访问外部类非static成员
*
* 不依赖于外部类对象，直接使用new Outer.StaticInnerClass()
*/
public static class StaticInnerClass{
public void say(){
System.out.println(job);
}
}
}
class Test{
public static void main(String[] args) {
Outer.StaticInnerClass staticInnerClass =new Outer.StaticInnerClass();
staticInnerClass.say();
}
}
javac编译Outer.java
public class Outer {
private String name = "rose";
static String job = "teacher";
public Outer() {
}
public static class StaticInnerClass {
public StaticInnerClass() {
}
public void say() {
System.out.println(Outer.job);
}
}
}
public class Outer$StaticInnerClass {
public Outer$StaticInnerClass() {
}
public void say() {
System.out.println(Outer.job);
}
}
class Test {
Test() {
}
public static void main(String[] var0) {
StaticInnerClass var1 = new StaticInnerClass();
var1.say();
}
}
静态内部类 不依赖 外部类；
4、使用内部类
a, 外部类 中使用 内部类
b, 外部类 以外使用 内部类
非静态内部类：
声明 变量： OuterClass.InnerClass 变量名 ;
实例化 ： OuterInstance.new InnerConstructor() ;
Outer.MemberInnerClass memberInnerClass=new Outer().new MemberInnerClass();
public class Outer$MemberInnerClass {
public Outer$MemberInnerClass(Outer var1) {
this.this$0 = var1;
}
void useOuter() {
System.out.println(Outer.access$000(this.this$0));
System.out.println(Outer.access$100());
System.out.println(this.this$0.job);
this.say();
this.this$0.say();
}
void say() {
System.out.println("MemberInnerClass say...");
}
}
静态内部类：
声明 变量： OuterClass.InnerClass 变量名 ;
实例化 ： new OuterClass.InnerConstructor() ;
Outer.StaticInnerClass staticInnerClass =new Outer.StaticInnerClass();
public class Outer$StaticInnerClass {
public Outer$StaticInnerClass() {
}
public void say() {
System.out.println(Outer.job);
}
}
