Java局部内部类和匿名内部类的使用

Java内部类（转）内部类 ———定义在类的内部的类为什么需要内部类？ 典型的情况是，内部类继承⾃某个类或实现某个接⼝，内部类的代码操作创建其的外围类的对象。

所以你可以认为内部类提供了某种进⼊其外围类的窗⼝。

java中的内部类和接⼝加在⼀起，可以实现多继承。

可以使某些编码根简洁。

隐藏你不想让别⼈知道的操作。

使⽤内部类最吸引⼈的原因是： 每个内部类都能独⽴地继承⾃⼀个（接⼝的）实现，所以⽆论外围类是否已经继承了某个（接⼝的）实现，对于内部类都没有影响。

如果没有内部类提供的可以继承多个具体的或抽象的类的能⼒，⼀些设计与编程问题就很难解决。

从这个⾓度看，内部类使得多重继承的解决⽅案变得完整。

接⼝解决了部分问题，⽽内部类有效地实现了“多重继承”。

　内部类分为: 成员内部类、静态嵌套类、⽅法内部类、匿名内部类。

特点：　⼀、内部类仍然是⼀个独⽴的类，在编译之后内部类会被编译成独⽴的.class⽂件，但是前⾯冠以外部类的类命和$符号。

⼆、内部类可以直接或利⽤引⽤访问外部类的属性和⽅法，包括私有属性和⽅法（但静态内部类不能访问外部类的⾮静态成员变量和⽅法）。

内部类所访问的外部属性的值由构造时的外部类对象决定。

三、⽽外部类要访问内部类的成员，则只能通过引⽤的⽅式进⾏，可问内部类所有成员 四、访问机制： System.out.println(this.x);或System.out.println(x);//内部类访问内部类的成员变量或成员⽅法可⽤此⽅法。

System.out.println(OuterClass.this.x);//内部类访问外部类的同名变量时可⽤此⽅法，如果没有同名可⽤System.out.println(x); 五、内部类可以使⽤任意的范围限定：public/private/protected class InnerClass，且严格按照这⼏种访问权限来控制内部类能使⽤的范围。

普通类的范围限定只可以是public或者不加。

一、实验目的1. 理解内部类的概念及其在Java编程中的应用。

2. 掌握内部类的定义、使用方法和特点。

3. 通过实例分析，加深对内部类的理解。

二、实验环境1. 操作系统：Windows 102. 开发工具：Eclipse IDE3. 编程语言：Java三、实验内容1. 内部类的定义及特点2. 成员内部类3. 静态内部类4. 局部内部类5. 匿名内部类四、实验步骤1. 创建一个名为“OuterClass”的类，作为外部类。

2. 在“OuterClass”中定义一个成员内部类“InnerClass”。

3. 在“OuterClass”中定义一个静态内部类“StaticInnerClass”。

4. 在“OuterClass”中定义一个局部内部类“LocalInnerClass”。

5. 创建一个匿名内部类的实例，并演示其使用。

五、实验代码```java// 1. 创建外部类OuterClasspublic class OuterClass {// 2. 成员内部类InnerClasspublic class InnerClass {public void display() {System.out.println("这是成员内部类InnerClass的方法");}}// 3. 静态内部类StaticInnerClasspublic static class StaticInnerClass {public void display() {System.out.println("这是静态内部类StaticInnerClass的方法");}}// 4. 局部内部类LocalInnerClasspublic void outerMethod() {class LocalInnerClass {public void display() {System.out.println("这是局部内部类LocalInnerClass的方法");}}LocalInnerClass localInner = new LocalInnerClass();localInner.display();}// 5. 匿名内部类public void anonymousInnerClass() {Runnable runnable = new Runnable() {@Overridepublic void run() {System.out.println("这是匿名内部类的方法");}};new Thread(runnable).start();}public static void main(String[] args) {OuterClass outer = new OuterClass();OuterClass.InnerClass inner = outer.new InnerClass(); InnerClass.display();StaticInnerClass staticInner = new StaticInnerClass(); staticInner.display();outer.outerMethod();outer.anonymousInnerClass();}}```六、实验结果与分析1. 成员内部类：通过定义在类中的内部类，可以访问外部类的成员变量和方法。

Java 类与对象选择题练习附加答案解析1. 以下关于Java类的描述，正确的是：A. 类是对象的实例。

B. 类可以包含属性和方法。

C. 类不能继承其他类。

D. 类只能包含一个方法。

答案: B。

解析：类是对象的蓝图或模板，可以包含属性（成员变量）和方法（成员函数）。

2. 在Java中，要创建一个类的对象，应使用哪个关键字？A. newB. createC. instantiateD. make答案: A。

解析：在Java中，使用`new`关键字来创建类的对象。

3. 在以下关于构造方法的描述中，正确的是：A. 构造方法必须有返回类型。

B. 构造方法的名称必须与类名相同。

C. 构造方法可以是静态的。

D. 构造方法可以重载但不能覆盖。

答案: B。

解析：构造方法的名称必须与类名相同，并且没有返回类型（包括void）。

构造方法可以重载（多个同名但参数不同的方法），但不能覆盖（重写父类方法）。

4. 如果`MyClass`类有一个名为`display`的方法，且`myObject`是`MyClass`类的一个实例，如何调用该方法？A. display();B. MyClass.display();C. myObject.display();D. MyClass::display();答案: C。

解析：通过对象实例`myObject`来调用类的非静态方法`display`。

5. 以下哪个选项是关于`this`关键字的正确描述？A. `this`关键字指向类的超类（父类）。

B. `this`关键字只能在静态方法中使用。

C. `this`关键字引用当前对象的实例。

D. `this`关键字用于创建新的对象。

答案: C。

解析：`this`关键字引用当前对象的实例，可以在类的方法和构造方法中使用来引用当前对象的成员变量或方法。

6. 在Java中，如果类B继承自类A，且类A是基类，则下列哪个选项是正确的？A. 类B是类A的超类。

java typereference 二层嵌套-回复Java中的嵌套类型（Nested Types）是指在一个类中定义另一个类。

这种二层嵌套类型可以是内部类（Inner Class），也可以是静态嵌套类（Static Nested Class）。

在本文中，我们将探讨Java中的二层嵌套类型，并深入了解它们的使用和作用。

首先，让我们从内部类开始。

内部类是指在另一个类内部定义的类。

这种定义方式使得内部类可以直接访问外部类的成员变量和方法，而不需要使用实例变量。

内部类有四种类型：成员内部类（Member Inner Class）、局部内部类（Local Inner Class）、匿名内部类（Anonymous Inner Class）和静态内部类（Static Inner Class）。

成员内部类是最常见的内部类类型，它是在外部类的成员位置上定义的。

下面是一个例子：javapublic class Outer {private int outerField;成员内部类public class Inner {public void printField() {System.out.println("外部类的成员变量outerField 的值是：" + outerField);}}}在这个例子中，类`Inner`是类`Outer`的成员内部类。

它可以直接访问外部类`Outer`的成员变量`outerField`。

为了创建内部类的实例，我们需要先创建外部类的实例，然后使用外部类的对象来创建内部类的对象，如下所示：javapublic class Main {public static void main(String[] args) {Outer outer = new Outer();Outer.Inner inner = outer.new Inner();inner.printField();}}在上面的示例中，我们首先创建外部类`Outer`的实例`outer`，然后使用`outer`来创建内部类`Inner`的实例`inner`。

实验三：内部类实验说明：本实验通过测试对话框来来实现测试内部类实验。

在该实验中，定义了成员内部类MyMoliter和MyDialog1，局部内部类MyDialog2，还有在Button1上通过添加匿名内部类来添加动作事件。

运行结果：点击确定后点击取消后源代码：import java.awt.*;import java.awt.event.*;import javax.swing.*;public class InnerClassTest{public static void main(String[] arges){MyFrame f = new MyFrame();}}class MyFrame extends Frame{/*在类MyFrame中定义成员内部类MyMoliter和MyDialog1 成员内部类定义在一个里面，方法体外面*/class MyMoliter implements ActionListener {public void actionPerformed(ActionEvent e) { MyDialog1 dialog = new MyDialog1();dialog.setVisible(true);}}class MyDialog1 extends JDialog {public MyDialog1() {setBounds(50, 50, 200, 100);Label lbl = new Label("欢迎进入这个界面！");add(lbl);}}public MyFrame() { //MyFrame的构造方法super("InnerClassTest！");/*在构造方法中定义局部内部类MyDialog2局部内部类定义在一个方法体的里面*/class MyDialog2 extends JDialog {public MyDialog2() {setBounds(50, 50, 200, 100);Label lbl = new Label("谢谢您的使用！");add(lbl);}}setLayout(new FlowLayout(FlowLayout.LEFT, 20, 40)); setBounds(100, 100, 300, 200);JButton b1 = new JButton("取消");JButton b2 = new JButton("确定");b2.addActionListener(new MyMoliter());add(b2);/*在JButton b1上添加动作事件，是用匿名内部类 */b1.addActionListener(new ActionListener(){public void actionPerformed(ActionEvent e) { MyDialog2 dialog = new MyDialog2();dialog.setVisible(true);}});add(b1);pack();setVisible(true);}}。

内部类的定义方法内部类是指在一个类的内部定义另一个类的情况，它是一种嵌套类的表现形式，具有特定的访问权限和作用域。

在Java等多种编程语言中，内部类提供了一种便捷的方式来组织和管理相关的类，同时也能够实现更加灵活的程序设计和模块化开发。

内部类的定义方法通常包括以下几种形式：1. 成员内部类：成员内部类是定义在类内部的非静态类，它能够访问外部类的成员变量和方法，并且可以使用外部类的引用。

成员内部类的定义方式如下：```javapublic class OuterClass {private int outerVar;public class InnerClass {public void innerMethod() {System.out.println("Accessing outer class variable: " + outerVar);}}}```在上述例子中，InnerClass 就是一个成员内部类，可以直接访问 OuterClass 的成员变量 outerVar。

2. 静态内部类：静态内部类是定义在类内部且带有 static 修饰符的类，它与外部类不具有依赖关系，可以直接通过类名进行访问。

静态内部类的定义方式如下：```javapublic class OuterClass {private static int outerVar;public static class InnerClass {public void innerMethod() {System.out.println("Accessing outer class variable: " + outerVar);}}}```在这个例子中，InnerClass 是一个静态内部类，可以直接通过OuterClass.InnerClass 的方式进行访问。

3. 局部内部类：局部内部类是定义在方法内部的类，它只能在定义它的方法中使用，通常用于辅助实现某个特定的功能。

java编程思想第四版习题答案【篇一：java编程思想第四版_读书笔记】面向对象程序设计（object-oriented programming oop），uml(unitied modelling language 统一建模语言)。

将对象想像成“服务提供者” ，它们看起来像什么？能够提供哪些服务？需要哪些对象？2.java中动态绑定是默认行为。

java采用动态内存分配方式，通过new操作在堆(heap)的内存池中动态创建对象。

java存储结构类型：1）寄存器2）堆栈，主要存储对象引用3）堆，主要用于存放所有的java对象4）常量存储，也就是程序代码区5）非ram存储，如流对象和持久化对象。

基本类型不用new来创建变量，而且这个变量直接存储”值”，并置于堆栈中。

3.biginteger和bigdecimal的使用。

当变量作为类的成员使用时当变量作为类的成员使用时，java才确保给定其默认初当变量作为类的成员使用时始值，但是在方法中定义的变量，它有可能是任意值。

面向对象的程序设计可以归纳为“向对象发送消息” 。

关键字static。

4.javadoc只能为public和protected成员进行文档注释，但是也可以通过-private进行标记注释。

javadoc常用方法： @see 引用其他类，link package.class#member label}， {@ {@docroot}，{@inheritdoc},@version，@ author，@since,@param，@return,@throws,@deprecated。

5.整数除法会直接去掉结果的小数位。

基本类型的对象如果直接对它们赋值，对象指向同一个常量存储区，但是如果通过对象来初始化则会指向不同的堆的存储区。

如：string st1 = new string(a);string st2 = new string(a); st1==st2 false string st1 = a; string st2 = a; st1==st2 true6.逻辑操作符：与()、或(||)、非(!)，其中与()、或(||)会产生短路现象。

匿名内部类调用方法匿名内部类是指在Java中创建一个没有名字的内部类。

它与普通的内部类不同，没有名字，只能在创建它的地方使用。

它通常用于实现某个接口或继承某个类，并且可以在类的内部直接调用方法。

在Java中，可以通过创建匿名内部类实现某个接口，并在创建对象的同时实现接口的方法。

例如：javapublic class Main {public static void main(String[] args) {MyInterface myObject = new MyInterface() {@Overridepublic void myMethod() {System.out.println("Hello from anonymous innerclass!");}};myObject.myMethod();}}interface MyInterface {void myMethod();}在上面的例子中，创建了一个没有名字的内部类来实现`MyInterface` 接口，并重写了`myMethod` 方法。

然后，通过创建该匿名内部类的对象，可以直接调用`myMethod` 方法。

匿名内部类中的方法调用与普通的方法调用类似。

可以在匿名内部类中直接调用方法，也可以通过外部类的对象来调用匿名内部类中的方法。

例如：javapublic class Main {public static void main(String[] args) {OuterClass outer = new OuterClass();outer.callInner();}}class OuterClass {public void callInner() {MyInterface myObject = new MyInterface() {@Overridepublic void myMethod() {System.out.println("Hello from anonymous inner class!");}};myObject.myMethod();anotherMethod();}public void anotherMethod() {System.out.println("Hello from outer class!");}}interface MyInterface {void myMethod();}在上面的例子中，`OuterClass` 创建了一个匿名内部类并调用了`myMethod` 方法。

java嵌套类(Nested Classes)总结Nested Classes定义在java语言规范里面，嵌套类(Nested Classes)定义是：A nested class is any class whose declaration occurs within the body of another class or interface. A top level class is a class that is not a nested class.说的简单一点，就是定义在类里面的类。

一般把定义内部类的外围类成为包装类（enclosing class)或者外部类嵌套类分类根据nested class定义的地方，可以分为member nested class,local nestedclass , anonymous nested classmember nested class（成员嵌套类）：成员嵌套类作为 enclosing class 的成员定义的，成员嵌套类有enclosing class属性local nested class （局部嵌套类）: 局部嵌套类定义在 enclosing class 的方法里面，局部嵌套类有enclosing class 属性和enclosing method 属性anonymous nested class（匿名嵌套类）：匿名嵌套类没有显示的定义一个类，直接通过new 的方法创建类的实例。

一般回调模式情况下使用的比较多member nested class 可以使用public,private,protected访问控制符，也可以用static,final关键字local nested class 可以使用final关键字anonymous nested class 不使用任何关键字和访问控制符见下面的代码public class EnclosingClass {public static final class NestedMemberClass{}public void nestedLocalClass() {final class NestedLocalClass {}}public void nestedAnonymousClass() {new Runnable() {@Overridepublic void run() {}};}}在大多数情况下，一般把nested classes 分为两种：Static Nested Classes（静态嵌套类）: 就是用static修饰的成员嵌套类InnerClass：静态嵌套类之外所有的嵌套类的总称,也就是没有用static定义的nestedclasses，Inner Classes 不能定义为static，不能有static方法和static初始化语句块。