Java内部类和匿名内部类的用法说明
一、内部类:
（1）内部类的同名方法
内部类可以调用外部类的方法，如果内部类有同名方法必须使用"OuterClass.this.MethodName()"格式调用（其中OuterClass与MethodName换成实际外部类名及其方法；this为关键字，表示对外部类的引用）；若内部类无同名方法可以直接调用外部类的方法。
但外围类无法直接调用内部类的private方法，外部类同样无法直接调用其它类的private方法。注意：内部类直接使用外部类的方法与该方法的权限与是否static无关，它取决于内部类是否有同名方法。
packageinnerclass;
publicclassOuterClass{
privatevoidouterMethod(){
System.out.println("It'sMethodofOuterClass");
}
publicstaticvoidmain(String[]args){
OuterClasst=newOuterClass();
OuterClass.Innerclassin=t.newInnerclass();
in.innerMethod();
}
classInnerclass{
publicvoidinnerMethod(){
OuterClass.this.outerMethod();//内部类成员方法与外部类成员方法同名时，使用this调用外部类的方法
outerMethod();//内部类没有同名方法时执行外部类的方法
}
privatevoidouterMethod(){
System.out.println("It'sMethodofInnerclass");
}
}
}
输出结果为：
It'sMethodofOuterClass
It'sMethodofInnerclass
（2）内部类访问外部类的变量必须声明为final
方法中的局部变量，方法结束后这个变量就要释放掉，final保证这个变量始终指向一个对象。
首先，内部类和外部类其实是处于同一个级别，内部类不会因为定义在方法中就会随着方法的执行完毕而跟随者被销毁。问题就来了，如果外部类的方法中的变量不定义final，那么当外部类方法执行完毕的时候，这个局部变量肯定也就被GC了，然而内部类的某个方法还没有执行完，这个时候他所引用的外部变量已经找不到了。如果定义为final，java会将这个变量复制一份作为成员变量内置于内部类中，这样的话，由于final所修饰的值始终无法改变，所以这个变量所指向的内存区域就不会变。
注意，若使用JDK1.8，方法中内部类的方法是可以直接访问外部类的方法的局部变量，并且不需要声明为final类型。
publicclassOuterClass{
intnum1=0;//成员变量
privatevoidouterMethod(){
intnum2=0;//方法内的局部变量
classInnerclass_1{
publicvoidinnerMethod(){
System.out.println(num1);//方法中内部类的方法，可以正常访问外部类的成员变量
System.out.println(num2);//JDK1.8以前，方法中内部类的方法，不能直接访问外部类的方法的局部变量，必须声明为final
}
}
}
}
如果使用JDK1.8以前的版本，Eclipse会出现如下错误提示：
（3）内部类的实例化
内部类实例化不同于普通类，普通类可以在任意需要的时候实例化，而内部类必须在外层类实例化以后方可实例化，并与外部类建立关系
因此在外部类中的非static方法中，是可以实例化内部类对象
privatevoidouterMethod(){
System.out.println("It'sMethodofOuterClass");
Innerclassin=newInnerclass();//在外部类的outerMethod方法中实例化内部类是可以啊
}
但在static方法中，就要注意啦！！！！不能在static方法中直接new内部类，否则出现错误：
NoenclosinginstanceoftypeOuterClassisaccessible.MustqualifytheallocationwithanenclosinginstanceoftypeOuterClass(e.g.x.newA()wherexisaninstanceofOuterClass).
这是因为静态方法是在类实例化之前就可以使用的，通过类名调用，这时动态内部类都还没实例化呢，怎么用，总不能调用一个不存在的东西吧。
如果想在Static方法中new内部类，可以把内部类声明为Static
publicclassOuterClass{
privatevoidouterMethod(){
System.out.println("It'sMethodofOuterClass");
}
publicstaticvoidmain(String[]args){
Innerclassin=newInnerclass();
in.innerMethod();
}
staticclassInnerclass{//把内部类声明为static
publicvoidinnerMethod(){
System.out.println("It'sMethodofinnerMethod");
}
}
}
当然，一般不使用static的方式，而是推荐这种方法：x.newA()，其中x是外部类OuterClass的实例，A是内部类Innerclass
packageinnerclass;
publicclassOuterClass{
privatevoidouterMethod(){
System.out.println("It'sMethodofOuterClass");
}
publicstaticvoidmain(String[]args){
OuterClass.Innerclassin=newOuterClass().newInnerclass();//使用x.newA()的方式
in.innerMethod();
}
classInnerclass{
publicvoidinnerMethod(){
System.out.println("It'sMethodofinnerMethod");
}
}
}
x.newA()，其中x是外部类OuterClass的实例，A是类部类Innerclass，当然可以拆分如下，这样就显然很明白啦：
publicstaticvoidmain(String[]args){
OuterClassout=newOuterClass();//外部实例
OuterClass.Innerclassin=out.newInnerclass();//外部实例.new外部类
in.innerMethod();
}
（4）什么情况下使用内部类
典型的情况是，内部类继承自某个类或实现某个接口，内部类的代码操作创建其的外层类的对象。所以你可以认为内部类提供了某种进入其外层类的窗口。
使用内部类最吸引人的原因是：每个内部类都能独立地继承自一个（接口的）实现，所以无论外层类是否已经继承了某个（接口的）实现，对于内部类都没有影响。如果没有内部类提供的可以继承多个具体的或抽象的类的能力，一些设计与编程问题就很难解决。从这个角度看，内部类使得多重继承的解决方案变得完整。接口解决了部分问题，而内部类有效地实现了“多重继承”。
（5）在静态方法中实例化内部类例子：（内部类放在静态方法中）
packagejavatest2;
publicclassJavaTest2{
publicstaticvoidmain(String[]args){
classBoyimplementsPerson{
publicvoidsay(){//匿名内部类自定义的方法say
System.out.println("say方法调用");
}
@Override
publicvoidspeak(){//实现接口的的方法speak
System.out.println("speak方法调用");
}
}
Personper=newBoy();
per.speak();//可调用
per.say();//不能调用
}
}
interfacePerson{
publicvoidspeak();
}
per.speak()可调用，而per.say()不能调用，这时因为per是Person对象，要想调用子类的方法，可以强制向下转型为：((Boy)per).say();或者直接改为Boyper=newBoy();。从中可发现，要想调用内部类的自定义的方法，必须通过内部类的对象来调用。那么，匿名内部类连名字都没有，怎么调用内部类自定义的方法？
（二）匿名内部类
匿名内部类也就是没有名字的内部类正因为没有名字，所以匿名内部类只能使用一次，它通常用来简化代码编写，但使用匿名内部类还有个前提条件：必须继承一个父类或实现一个接口，但最多只能继承一个父类，或实现一个接口。
关于匿名内部类还有如下两条规则：
1）匿名内部类不能是抽象类，因为系统在创建匿名内部类的时候，会立即创建内部类的对象。因此不允许将匿名内部类定义成抽象类。
2）匿名内部类不等定义构造器（构造方法），因为匿名内部类没有类名，所以无法定义构造器，但匿名内部类可以定义实例初始化块，
怎样判断一个匿名类的存在啊？看不见名字，感觉只是父类new出一个对象而已，没有匿名类的名字。
先看段伪代码
abstractclassFather(){
....
}
publicclassTest{
Fatherf1=newFather(){....}//这里就是有个匿名内部类
}
一般来说，new一个对象时小括号后应该是分号，也就是new出对象该语句就结束了。但是出现匿名内部类就不一样，小括号后跟的是大括号，大括号中是该new出对象的具体的实现方法。因为我们知道，一个抽象类是不能直接new的，必须先有实现类了我们才能new出它的实现类。上面的伪代码就是表示new的是Father的实现类，这个实现类是个匿名内部类。
其实拆分上面的匿名内部类可为：
classSonOneextendsFather{
...//这里的代码和上面匿名内部类，大括号中的代码是一样的
}
publicclassTest{
Fatherf1=newSonOne();
}
先看一个例子，体会一下匿名内部类的用法：
运行结果：eatsomething
可以看到，我们直接将抽象类Person中的方法在大括号中实现了，这样便可以省略一个类的书写。并且，匿名内部类还能用于接口上
publicclassJavaTest2{
publicstaticvoidmain(String[]args){
Personper=newPerson(){
publicvoidsay(){//匿名内部类自定义的方法say
System.out.println("say方法调用");
}
@Override
publicvoidspeak(){//实现接口的的方法speak
System.out.println("speak方法调用");
}
};
per.speak();//可调用
per.say();//出错，不能调用
}
}
interfacePerson{
publicvoidspeak();
}
这里per.speak()是可以正常调用的，但per.say()不能调用，为什么呢？注意Personper=newPerson()创建的是Person的对象，而非匿名内部类的对象。其实匿名内部类连名字都没有，你咋实例对象去调用它的方法呢？但继承父类的方法和实现的方法是可以正常调用的，本例子中，匿名内部类实现了接口Person的speak方法，因此可以借助Person的对象去调用。
若你确实想调用匿名内部类的自定义的方法say()，当然也有方法：
（1）类似于speak方法的使用，先在Person接口中声明say()方法，再在匿名内部类中覆写此方法。
（2）其实匿名内部类中隐含一个匿名对象，通过该方法可以直接调用say()和speak()方法；代码修改如下：
publicclassJavaTest2{
publicstaticvoidmain(String[]args){
newPerson(){
publicvoidsay(){//匿名内部类自定义的方法say
System.out.println("say方法调用");
}
@Override
publicvoidspeak(){//实现接口的的方法speak
System.out.println("speak方法调用");
}
}.say();//直接调用匿名内部类的方法
}
}
interfacePerson{
publicvoidspeak();
}
补充知识：Java内部类的定义、如何创建内部类、内部类的分类、内部类与外部类的关系
1.内部类的基本概念
1.1内部类的定义
内部类：所谓内部类就是在一个类内部进行其他类结构的嵌套操作。
classOuter{
privateStringstr="外部类中的字符串";
//**************************
//定义一个内部类
classInner{
privateStringinStr="内部类中的字符串";
//定义一个普通方法
publicvoidprint(){
//调用外部类的str属性
System.out.println(str);
}
}
//**************************
//在外部类中定义一个方法，该方法负责产生内部类对象并调用print()方法
publicvoidfun(){
//内部类对象
Innerin=newInner();
//内部类对象提供的print
in.print();
}
}
publicclassTest{
publicstaticvoidmain(String[]args)
{
//创建外部类对象
Outerout=newOuter();
//外部类方法
out.fun();
}
}
运行结果：外部类中的字符串
但是如果去掉内部类：
classOuter{
privateStringoutStr="Outer中的字符串";
publicStringgetOutStr()
{
returnoutStr;
}
publicvoidfun(){//2
//this表示当前对象
Innerin=newInner(this);//3
in.print();//5
}
}
classInner{
privateStringinStr="Inner中的字符串";
privateOuterout;
//构造注入
publicInner(Outerout)//3
{
this.out=out;//4.为Inner中的out变量初始化
}
publicvoidprint(){//6
System.out.println(out.getOutStr());//7
}
}
publicclassTest{
publicstaticvoidmain(String[]args)
{
Outerout=newOuter();//1.
out.fun();//2.
}
}
执行结果：Outer中的字符串
但是去掉内部类之后发现程序更加难以理解。
1.2内部类的优缺点
内部类的优点:
内部类与外部类可以方便的访问彼此的私有域（包括私有方法、私有属性）。
内部类是另外一种封装，对外部的其他类隐藏。
内部类可以实现java的单继承局限。
内部类的缺点:
结构复杂。
记录：使用内部类实现多继承：
classA{
privateStringname="A类的私有域";
publicStringgetName(){
returnname;
}
}
classB{
privateintage=20;
publicintgetAge(){
returnage;
}
}
classOutter{
privateclassInnerClassAextendsA{
publicStringname(){
returnsuper.getName();
}
}
privateclassInnerClassBextendsB{
publicintage(){
returnsuper.getAge();
}
}
publicStringname(){
returnnewInnerClassA().name();
}
publicintage(){
returnnewInnerClassB().age();
}
}
publicclassTest2{
publicstaticvoidmain(String[]args){
Outteroutter=newOutter();
System.out.println(outter.name());
System.out.println(outter.age());
}
}
2.创建内部类
2.1在外部类外部创建非静态内部类
语法：外部类.内部类内部类对象=new外部类().new内部类();
举例：Outer.Innerin=newOuter().newInner();
2.2在外部类外部创建静态内部类
语法：外部类.内部类内部类对象=new外部类.内部类();
举例：Outer.Innerin=newOuter.Inner();
2.3在外部类内部创建内部类语法
在外部类内部创建内部类，就像普通对象一样直接创建：Innerin=newInner();
3.内部类的分类
在Java中内部类主要分为成员内部类、静态内部类、方法内部类、匿名内部类
3.1成员内部类
类比成员方法
成员内部类内部不允许存在任何static变量或方法正如成员方法中不能有任何静态属性（成员方法与对象相关、静态属性与类有关）
classOuter{
privateStringname="test";
publicstaticintage=20;
classInner{
publicstaticintnum=10;
publicvoidfun()
{
System.out.println(name);
System.out.println(age);
}
}
}
publicclassTest{
publicstaticvoidmain(String[]args)
{}
}
2.成员内部类是依附外部类的，只有创建了外部类才能创建内部类。
3.2静态内部类
关键字static可以修饰成员变量、方法、代码块、其实还可以修饰内部类，使用static修饰的内部类我们称之为静态内部类，静态内部类和非静态内部类之间存在一个最大的区别，非静态内部类在编译完成之后会隐含的保存着一个引用，该引用是指向创建它的外围类，但是静态类没有。没有这个引用就意味着：
1.静态内部类的创建不需要依赖外部类可以直接创建。
2.静态内部类不可以使用任何外部类的非static类（包括属性和方法），但可以存在自己的成员变量。
classOuter{
publicStringname="test";
privatestaticintage=20;
staticclassInner{
privateStringname;
publicvoidfun()
{
System.out.println(name);
System.out.println(age);
}
}
}
publicclassTest{
publicstaticvoidmain(String[]args)
{
Outer.Innerin=newOuter.Inner();
}
}
3.3方法内部类
方法内部类顾名思义就是定义在方法里的类
1.方法内部类不允许使用访问权限修饰符（public、private、protected）均不允许。
classOuter{
privateintnum=5;
publicvoiddispaly(finalinttemp)
{
//方法内部类即嵌套在方法里面
publicclassInner{
}
}
}
publicclassTest{
publicstaticvoidmain(String[]args)
{}
}
2.方法内部类对外部完全隐藏，除了创建这个类的方法可以访问它以外，其他地方均不能访问(换句话说其他方法或者类都不知道有这个类的存在)方法内部类对外部完全隐藏，出了创建这个类的方法可以访问它，其他地方均不能访问。
3.方法内部类如果想要使用方法形参，该形参必须使用final声明（JDK8形参变为隐式final声明）
classOuter{
privateintnum=5;
//普通方法
publicvoiddispaly(inttemp)
{
//方法内部类即嵌套在方法里面
classInner{
publicvoidfun()
{
System.out.println(num);
temp++;
System.out.println(temp);
}
}
//方法内部类在方法里面创建
newInner().fun();
}
}
publicclassTest{
publicstaticvoidmain(String[]args)
{
Outerout=newOuter();
out.dispaly(2);
}
}
3.4匿名内部类
匿名内部类就是一个没有名字的方法内部类，因此特点和方法与方法内部类完全一致，除此之外，还有自己的特点：
1.匿名内部类必须继承一个抽象类或者实现一个接口。
2.匿名内部类没有类名，因此没有构造方法。
//匿名内部类
//声明一个接口
interfaceMyInterface{
//接口中方法没有方法体
voidtest();
}
classOuter{
privateintnum=5;
publicvoiddispaly(inttemp)
{
//匿名内部类，匿名的实现了MyInterface接口
//隐藏的class声明
newMyInterface()
{
publicvoidtest()
{
System.out.println("匿名实现MyInterface接口");
System.out.println(temp);
}
}.test();
}
}
publicclassTest{
publicstaticvoidmain(String[]args)
{
Outerout=newOuter();
out.dispaly(3);
}
}
4.内部类与外部类的关系
对于非静态的内部类，内部类的创建依赖外部类的实例对象，在没有外部类实例之前是无法创建内部类的。内部类可以直接访问外部类的元素（包括私有域）—外部类在内部类之前创建，创建内部类时会将外部类的对象传入
classOuter{
//成员变量与对象有关
privateStringmsg;
privateintage;
//--------------------------
classInner{
publicvoiddispaly()
{
//此处有一个隐藏的Outer.this
msg="test";
age=20;
System.out.println(msg);
System.out.println(age);
}
}
//--------------------------
publicvoidtest()
{
Innerin=newInner();
in.dispaly();
}
}
publicclassTest{
publicstaticvoidmain(String[]args)
{
Outerout=newOuter();
out.test();
}
}
外部类可以通过内部类的引用间接访问内部类元素–-要想访问内部类属性，必须先创建内部类对象
classOuter{
publicvoiddispaly()
{
//外部类通过创建内部类的对象间接访问内部类元素
Innerin=newInner();
in.dispaly();
}
classInner{
publicvoiddispaly()
{
System.out.println("内部类");
}
}
}
publicclassTest1{
publicstaticvoidmain(String[]args)
{
Outerout=newOuter();
out.dispaly();
}
}
内部类是一个相对独立的个体，与外部类没有关系。
以上这篇Java内部类和匿名内部类的用法说明就是小编分享给大家的全部内容了，希望能给大家一个参考，也希望大家多多支持毛票票。
声明：本文内容来源于网络，版权归原作者所有，内容由互联网用户自发贡献自行上传，本网站不拥有所有权，未作人工编辑处理，也不承担相关法律责任。如果您发现有涉嫌版权的内容，欢迎发送邮件至：czq8825#qq.com（发邮件时，请将#更换为@）进行举报，并提供相关证据，一经查实，本站将立刻删除涉嫌侵权内容。