第一 成员内部类
定义在另一个类的内部，而且与成员方法和属性平级叫成员内部类。
1成员内部类中不能存在static关键字，即，不能声明静态属性、静态方法、静态代码块等。
2在成员内部类中访问外部类的成员方法和属性，要使用“外部类名.this.成员方法”和“外部类名.this.成员属性”的形式
3创建成员内部类的实例使用“外部类名.内部类名 实例名 = 外部类实例名.new 内部类构造方法(参数)”的形式。在创建内部类实例之前需要先创建外部类的实例对象。
package test5;
public class MyTest {
public static void main(String[] args) {
Outer outer=new Outer("test");
Outer.Inner inner = outer.new Inner(20);
}
}
class Outer{
Outer(String str){
}
protected class Inner{
public Inner(int a){
}
}
}
4成员内部类可以可以使用public,protected,default,private,static,final,abstract来修饰.当然了，被static修饰的内部类，是静态内部类。
5内部类在编译之后生成一个单独的class文件，里面包含该类的定义，所以内部类中定义的方法和变量可以跟父类的方法和变量相同。例如上面定义的三个类的class文件分别是：MyTest.class、Outer.class和Outer$Inner.class三个文件。内部类的定义文件名形式是“外部类定义名$内部类定义名”，即Outer$Inner.class。该文件反编译之后的代码是：
package test5;
public class Outer$Inner
{
public Outer$Inner(Outer paramOuter, int a)
{
}
}
6外部类无法直接访问成员内部类的方法和属性，只能通过“内部类实例名.方法名(参数)”和“内部类实例名.属性名”的形式访问内部类的方法和属性
package test5;
public class MyTest {
public static void main(String[] args) {
Outer outer=new Outer("test");
outer.test();
}
}
class Outer{
private Inner inner;
Outer(String str){
//创建内部类实例
inner = new Inner(10);
}
public void test(){
//只能通过实例访问方法和属性
inner.print();
}
protected class Inner{
public Inner(int a){
}
public void print(){
System.out.println("Inner");
}
}
}
7与外部类平级的类继承内部类时，其构造方法中需要传入父类的实例对象。且在构造方法的第一句调用“外部类实例名.super(内部类参数)”。
如：
package test5;
public class MyTest {
public static void main(String[] args) {
Outer outer = new Outer("test");
new Extender(outer,10);
}
}
class Outer{
Outer(String str){}
protected class Inner{
public Inner(int a){
}
}
}
class Extender extends Outer.Inner{
public Extender(Outer outer,int a){
//外部类实例名.super(内部类参数列表)
outer.super(a);
}
}
第二 静态内部类
使用static修饰的成员内部类叫静态内部类。
1静态内部类更外部类没有任何关系，只是在生成类名和类定义时有影响。静态内部类可以看做是与外部类平级的类。使用方式与外部类平级的类完全相同。
2静态内部类不能访问外部类的非静态的属性和方法。外部类不能访问内部类的非静态的属性和方法。
3静态内部类创建实例的形式：外部类名.内部类名 实例名 = new外部类名.内部类名(参数)
第三 局部内部类
定义在代码块、方法体内、作用域（使用花括号“{}”括起来的一段代码）内的类叫局部内部类。
1局部内部类只能在代码代码块、方法体内和作用域中使用（创建对象和使用类对象）.
如：
package test5;
public class MyTest {
public static void main(String[] args) {
}
}
class Outer{
Outer(String str){}
{
class Inner{
public Inner(int a){
}
}
System.out.println("Inner.class.getName()=="+Inner.class.getName());
}
public void test(){
//这是错误的，局部内部类只在本作用域中可见
//System.out.println("Inner.class.getName()=="+Inner.class.getName());
}
}
2局部内部类访问外部类的属性和方法使用“外部类名.this.属性名”和“外部类名.this.方法名(参数)”的形式
3局部内部类访问作用域内的局部变量，该局部变量需要使用final修饰。
4局部内部类的定义可以使用abstract修饰，声明为抽象类。
第四 匿名内部类
1匿名内部类定义和实例化形式如下：
new父类构造方法（参数）{
//注：该方法名必须在父类中已经存在
修饰符 返回参数类型 方法名（参数列表）{
}
}
2匿名内部类只能和new连用，用于创建一个实例。匿名内部类只能使用一次，创建实例之后，类定义会立即消失（想要多次使用就要用到反射的知识了）。
3匿名内部类必须继承一个类（抽象的、非抽象的都可以）或者实现一个接口。如果父类（或者父接口）是抽象类，则匿名内部类必须实现其所有抽象方法。
如：
public class InnerClassTest {
public static void main(String[] args) {
//定义一个匿名内部类，并实例化对象
Test test = new Test(){
@Override
public void print() {
System.out.println("匿名内部类实现父类所有的抽象方法！");
}
};
test.print();
System.out.println("匿名内部类的类名：test.getClass().getName()=="+test.getClass().getName());
System.out.println("父类的类名：Test.class.getName()=="+Test.class.getName());
System.out.println("test.getClass().equals(Test.class)=="+test.getClass().equals(Test.class));
System.out.println("test.getClass().getSuperclass().equals(Test.class)=="+test.getClass().getSuperclass().equals(Test.class));
}
}
abstract class Test{
public abstract void print();
}
运行结果：
匿名内部类实现父类所有的抽象方法！ 匿名内部类的类名：test.getClass().getName()==test5.InnerClassTest$1 父类的类名：Test.class.getName()==test5.Test test.getClass().equals(Test.class)==false test.getClass().getSuperclass().equals(Test.class)==true
InnerClassTest$1.class文件反编译之后的结果如下，证明它确实是继承了父类:
class InnerClassTest$1 extends Test
{
public void print()
{
System.out.println("匿名内部类实现父类所有的抽象方法！");
}
}
4匿名内部类不能是抽象类，因为匿名内部类在定义之后，会立即创建一个实例。
5匿名内部类不能定义构造方法，匿名内部类没有类名，无法定义构造方法，但是，匿名内部类拥有与父类相同的所有构造方法。
6匿名内部类中可以定义代码块，用于实例的初始化，但是不能定义静态代码块。
如下：
public class InnerClassTest {
public static void main(String[] args) {
//定义一个匿名内部类，并实例化对象
Test test = new Test(){
{
System.out.println("匿名内部类的代码块");
}
public void print(){
System.out.println("匿名内部类的print方法");
}
};
test.print();
}
}
class Test{
public void print(){
System.out.println("class Test的print方法");
}
}
输出结果为：
匿名内部类的代码块 匿名内部类的print方法
7匿名内部类中可以定义新的方法和属性(不能使用static修饰)，但是无法显式的通过“实例名.方法名(参数)”的形式调用，因为使用new创建的是“上转型对象”。
注：
上转型对象特点：
<!--[if !supportLists]-->① <!--[endif]-->父类声明指向子类对象，形式：
父类名（父接口名） 上转型实例名 = new 子类构造方法(参数);
<!--[if !supportLists]-->② <!--[endif]-->子类可以重写父类的方法，上转型实例调用的方法只能是子类重写父类的方法或者父类的方法，不能调用子类独有的方法。
<!--[if !supportLists]-->③ <!--[endif]-->上转型对象可以强制转换成子类对象：形式：子类名 实例名 = (子类名)上转型对象;
转换成子类对象之后，与“new 子类构造方法(参数)”形式定义的对象无区别。
虽然不能通过“实例名.方法名(参数)”的形式调用子类独有的方法，但是可以通过反射来调用：
package test5;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
public class InnerClassTest {
public static void main(String[] args)
throws SecurityException, NoSuchMethodException,
IllegalArgumentException, IllegalAccessException,
InvocationTargetException {
//定义一个匿名内部类，并实例化对象
Test test = new Test(){
//匿名内部类中可以定义属性
private int a;
//匿名内部类中可以定义方法
public void xxx() {
System.out.println("xxx方法");
}
//匿名内部类中可以重写父类的方法
public void print() {
a = 10;
}
};
//通过反射调用子类方法
Class c = test.getClass();
Method m = c.getMethod("xxx");
m.invoke(test);
}
}
class Test{
public void print(){
System.out.println("父类方法");
}
}
8匿名内部类访问外部类的局部变量，则该局部变量需要使用final声明。匿名内部类中访问外部类的成员方法和属性使用“外部类名.this.方法名(参数)”和“内部类名.this.属性名”的形式。
package test5;
public class InnerClassTest {
private int a;
public static void main(String[] args) {
new InnerClassTest().go();
}
public void go(){
a = 100;
//外部类的局部变量
final int b=10;
Test test = new Test(){
public void print() {
//匿名内部类访问外部类的属性
System.out.println("InnerClassTest.this.a=="+InnerClassTest.this.a);
//匿名内部类中访问外部类的局部变量
System.out.println("b=="+b);
}
};
test.print();
}
}
abstract class Test{
public abstract void print();
}
9匿名内部类不能重写父类的静态方法。
相关推荐
### Java内部类总结 在Java编程语言中，内部类是一个重要的概念，它允许开发者在一个类的内部定义另一个类。这种特性极大地增强了代码的封装性和复用性，同时也为解决特定问题提供了灵活的方法。本文将围绕Java内部...
### JAVA内部类总结 在Java编程语言中，内部类（Inner Classes）是一种非常重要的特性，它允许我们在一个类的内部定义另一个类。这种结构不仅能够提高代码的组织性，还能帮助我们更好地处理类与类之间的关系。根据...
Java 内部类总结 Java 内部类是指在一个外部类的内部再定义一个类。内部类作为外部类的一个成员，并且依附于外部类而存在的。内部类可为静态，可用 protected 和 private 修饰（而外部类只能使用 public 和缺省的包...
Java内部类详解 Java内部类是Java语言中的一种特殊类别，它是指定义在另外一个类内部的类。内部类可以访问外部类的所有成员变量和方法，包括私有的变量和方法。内部类可以分为四种：成员内部类、静态嵌套类、方法...
定义在一个类内部的类叫内部类，包含内部类的类称为外部类。内部类可以声明public、protected、private等访问限制，可以声明为abstract的供其他内部类或外部类继承与扩展，或者声明为static、final的，也可以实现...
Java 内部类总结 Java 内部类是 Java 语言的一个重要概念，指的是在一个外部类的内部再定义一个类。内部类作为外部类的一个成员，并且依附于外部类而存在的。内部类可为静态，可用 protected 和 private 修饰（而...
内部类分为四种主要类型：成员内部类、局部内部类、静态内部类和匿名内部类。每种类型的内部类都有其特定的使用场景和优势。 1. 成员内部类： 成员内部类作为外部类的成员，与外部类的字段和方法并列存在。成员...
Java 中的匿名内部类总结 Java 中的匿名内部类是一种特殊的内部类，它没有名字，因此也称为匿名类。匿名内部类是一种简洁的编程方式，能够简化代码编写，但它也有一些限制和特点。 匿名内部类的定义 匿名内部类是...
Java内部类总结 Java内部类是指在一个外部类的内部再定义一个类。内部类作为外部类的一个成员，并且依附于外部类而存在的。内部类可为静态，可用protected和private修饰（而外部类只能使用public和缺省的包访问权限...
Java内部类主要分为以下四种类型： 1. 成员内部类：这是最常见的内部类形式，它作为外部类的一个成员，可以在外部类的任何地方声明。成员内部类可以访问外部类的所有成员，包括私有成员。 2. 局部内部类：定义在...
Java内部类是Java语言中一个独特且强大的特性，它允许我们在一个类的内部定义另一个类。内部类提供了增强封装的能力，使得内部类可以被隐藏在外部类中，仅对外部类可见，从而增加了代码的隐私性和安全性。同时，内部...
总结来说，Java 内部类提供了一种强大的工具，可以增强代码的封装性和灵活性。成员内部类方便访问外部类的私有成员，方法内部类常用于匿名内部类的创建，而静态内部类则允许我们不依赖外部类实例来创建对象。理解并...
Java内部类是Java语言的一个独特特性，它允许一个类被定义在另一个类的内部。这种设计使得代码结构更加紧凑，同时也提供了对封装和抽象的新层次。内部类在J2EE编程中可能用得较少，但在GUI编程中尤其常见，主要用于...
总之，Java 内部类提供了一种强大的工具，可以增强代码的封装性和可读性，同时提供了对私有成员的直接访问，这在设计复杂的系统时非常有用。然而，过度使用内部类可能导致代码结构混乱，所以要根据实际需求谨慎使用...
Java匿名内部类是Java语言中一个独特且强大的特性，它允许我们在不需要定义一个单独的类的情况下创建类的实例。这在处理回调、事件监听、单例模式以及其他需要短时间内定义一个简单类的情况时非常有用。本篇文章将...
### JAVA语法总结 - 内部类 #### 一、内部类概述 内部类（Inner Class）自Java 1.1版本引入以来，一直是Java编程语言中的一个重要特性。它允许开发者在一个类的内部定义另一个类，这有助于更好地组织代码并实现更...