hubowei1
- 浏览: 139058 次
- 性别:
- 来自: 深圳
-
文章分类
最新评论
Java语言基础：内部类
Java语言基础：内部类
1. 普通内部类
普通内部类的一个最简单的例子：
view plaincopy to clipboardprint?
// 外部类
class OutterClass {
// 内部类
public class InnerClass {
private int i = 0;
public int getInt(){
return i;
}
}
public void proc(){
InnerClass inClass = new InnerClass();
System.out.println(inClass.getInt());
}
}
public class Main {
public static void main(String[] args) {
OutterClass outClass = new OutterClass();
outClass.proc();
}
}
// 外部类
class OutterClass {
// 内部类
public class InnerClass {
private int i = 0;
public int getInt(){
return i;
}
}
public void proc(){
InnerClass inClass = new InnerClass();
System.out.println(inClass.getInt());
}
}
public class Main {
public static void main(String[] args) {
OutterClass outClass = new OutterClass();
outClass.proc();
}
}
外部类可以访问内部类的私有成员，内部类也可以访问外部类的私有成员：
view plaincopy to clipboardprint?
// 外部类
class OutterClass {
private int mOut = 10;
// 内部类
public class InnerClass {
private int mIn = 0;
public void printOutPrivate(){
// 直接打印外部类的成员
System.out.println(mOut);
}
}
public void printInPrivate(){
InnerClass inClass = new InnerClass();
// 直接打印内部类的私有成员
System.out.println(inClass.mIn);
}
public void printOutPrivate(){
InnerClass inClass = new InnerClass();
inClass.printOutPrivate();
}
}
public class Main {
public static void main(String[] args) {
OutterClass outClass = new OutterClass();
outClass.printInPrivate();
outClass.printOutPrivate();
}
}
// 外部类
class OutterClass {
private int mOut = 10;
// 内部类
public class InnerClass {
private int mIn = 0;
public void printOutPrivate(){
// 直接打印外部类的成员
System.out.println(mOut);
}
}
public void printInPrivate(){
InnerClass inClass = new InnerClass();
// 直接打印内部类的私有成员
System.out.println(inClass.mIn);
}
public void printOutPrivate(){
InnerClass inClass = new InnerClass();
inClass.printOutPrivate();
}
}
public class Main {
public static void main(String[] args) {
OutterClass outClass = new OutterClass();
outClass.printInPrivate();
outClass.printOutPrivate();
}
}
如果外部类的成员变量与内部类的成员变量名字相同，当内部类要访问外部类的该成员时，可以使用“OutClass.this.mem”来区分：
view plaincopy to clipboardprint?
// 外部类
class OutterClass {
private int mMem = 10;
// 内部类
public class InnerClass {
private int mMem = 0;
public void printOutPrivate(){
// 直接打印外部类的成员
System.out.println(OutterClass.this.mMem);
}
}
}
// 外部类
class OutterClass {
private int mMem = 10;
// 内部类
public class InnerClass {
private int mMem = 0;
public void printOutPrivate(){
// 直接打印外部类的成员
System.out.println(OutterClass.this.mMem);
}
}
}
要创建普通内部类，必须先创建相应的外部类：
view plaincopy to clipboardprint?
// 外部类
class OutterClass {
private int mMem = 10;
// 内部类
public class InnerClass {
private int mMem = 0;
public void printOutPrivate(){
// 直接打印外部类的成员
System.out.println(OutterClass.this.mMem);
}
}
}
public class Main {
public static void main(String[] args) {
OutterClass outClass = new OutterClass();
OutterClass.InnerClass inClass = outClass.new InnerClass();
inClass.printOutPrivate();
}
}
// 外部类
class OutterClass {
private int mMem = 10;
// 内部类
public class InnerClass {
private int mMem = 0;
public void printOutPrivate(){
// 直接打印外部类的成员
System.out.println(OutterClass.this.mMem);
}
}
}
public class Main {
public static void main(String[] args) {
OutterClass outClass = new OutterClass();
OutterClass.InnerClass inClass = outClass.new InnerClass();
inClass.printOutPrivate();
}
}
也可以用下面的方式：
view plaincopy to clipboardprint?
// 外部类
class OutterClass {
private int mMem = 10;
// 内部类
public class InnerClass {
private int mMem = 0;
public void printOutPrivate(){
// 直接打印外部类的成员
System.out.println(OutterClass.this.mMem);
}
}
public InnerClass newInnerClass() {
return new InnerClass();
}
}
public class Main {
public static void main(String[] args) {
OutterClass outClass = new OutterClass();
OutterClass.InnerClass inClass = outClass.newInnerClass();
inClass.printOutPrivate();
}
}
// 外部类
class OutterClass {
private int mMem = 10;
// 内部类
public class InnerClass {
private int mMem = 0;
public void printOutPrivate(){
// 直接打印外部类的成员
System.out.println(OutterClass.this.mMem);
}
}
public InnerClass newInnerClass() {
return new InnerClass();
}
}
public class Main {
public static void main(String[] args) {
OutterClass outClass = new OutterClass();
OutterClass.InnerClass inClass = outClass.newInnerClass();
inClass.printOutPrivate();
}
}
2. 静态内部类
普通内部类前面加上static修饰符，就成为静态内部类，静态内部类类似于C++的嵌套类，与普通内部类相比有如下区别：
静态内部类没有指向外部类的引用，外部类对于它来说更像一个名字空间。
普通内部类不能有静态成员，静态方法，或另一个静态内部类；而静态内部类可以有这一切。
静态内部类可以直接创建，不必先创建外部类：
view plaincopy to clipboardprint?
// 外部类
class OutterClass {
private int mMem = 0;
// 静态内部类
static public class InnerClass {
private int mMem = 0;
public void printOutPrivate(){
// 这是错误的
// System.out.println(OutterClass.this.mMem);
}
}
public void printInPrivate() {
InnerClass inClass = new InnerClass();
// 可以直接访问静态内部类的成员
System.out.println(inClass.mMem);
}
}
public class Main {
public static void main(String[] args) {
// 直接创建静态内部类
OutterClass.InnerClass inClass = new OutterClass.InnerClass();
inClass.printOutPrivate();
}
}
// 外部类
class OutterClass {
private int mMem = 0;
// 静态内部类
static public class InnerClass {
private int mMem = 0;
public void printOutPrivate(){
// 这是错误的
// System.out.println(OutterClass.this.mMem);
}
}
public void printInPrivate() {
InnerClass inClass = new InnerClass();
// 可以直接访问静态内部类的成员
System.out.println(inClass.mMem);
}
}
public class Main {
public static void main(String[] args) {
// 直接创建静态内部类
OutterClass.InnerClass inClass = new OutterClass.InnerClass();
inClass.printOutPrivate();
}
}
从上面描述可以看出，静态内部类与一般类没有太大区别，只不过它是放在一个类的里面，这个类相当于它的名字空间，可以防止命名冲突。
3. 局部内部类
Java可以把一个类定义在一个方法里面，甚至是一个{}块里面，它的作用域就在这个块里面：
view plaincopy to clipboardprint?
// 外部类
class OutterClass {
public void testLocalInner() {
if (true)
{
class LocalInner {
public void proc() {
System.out.println("hello");
}
}
// 可以创建使用
LocalInner localInner = new LocalInner();
localInner.proc();
}
// 错误：超出类定义的作用域
LocalInner localInner = new LocalInner();
localInner.proc();
}
}
// 外部类
class OutterClass {
public void testLocalInner() {
if (true)
{
class LocalInner {
public void proc() {
System.out.println("hello");
}
}
// 可以创建使用
LocalInner localInner = new LocalInner();
localInner.proc();
}
// 错误：超出类定义的作用域
LocalInner localInner = new LocalInner();
localInner.proc();
}
}
局部内部类的一般用途是实现某个接口，并作为这个接口传出方法被使用：
view plaincopy to clipboardprint?
// 接口
interface Talker {
public void Talk();
}
// 外部类
class OutterClass {
public Talker getTalker() {
// 现实该接口的局部内部类
class SomeTalker implements Talker {
public void Talk() {
System.out.println("hello");
}
}
// 创建类实例并作为Talker返回
SomeTalker talker = new SomeTalker();
return talker;
}
}
public class Main {
public static void main(String[] args) {
OutterClass outClass = new OutterClass();
Talker talker = outClass.getTalker();
talker.Talk();
}
}
// 接口
interface Talker {
public void Talk();
}
// 外部类
class OutterClass {
public Talker getTalker() {
// 现实该接口的局部内部类
class SomeTalker implements Talker {
public void Talk() {
System.out.println("hello");
}
}
// 创建类实例并作为Talker返回
SomeTalker talker = new SomeTalker();
return talker;
}
}
public class Main {
public static void main(String[] args) {
OutterClass outClass = new OutterClass();
Talker talker = outClass.getTalker();
talker.Talk();
}
}
4. 匿名内部类
匿名内部类的语法如下：
view plaincopy to clipboardprint?
new InterfaceName(){......}; 或 new SuperclassName(){......};
new InterfaceName(){......}; 或 new SuperclassName(){......};
它被认为是InterfaceName的实现者，或是SuperclassName的继承类，匿名内部类没有构建函数，如果SuperclassName有带参数的构造函数，必须在创建匿名内部类时带上这些参数，下面是匿名内部类最常见的使用场合：
view plaincopy to clipboardprint?
// 接口
interface Talker {
public void Talk();
}
// 外部类
class OutterClass {
public void Talk(Talker talker) {
talker.Talk();
}
}
public class Main {
public static void main(String[] args) {
OutterClass outClass = new OutterClass();
// 直接生成一个匿名内部类
outClass.Talk(new Talker(){
public void Talk() {
System.out.println("hello");
}
});
}
}
1. 普通内部类
普通内部类的一个最简单的例子：
view plaincopy to clipboardprint?
// 外部类
class OutterClass {
// 内部类
public class InnerClass {
private int i = 0;
public int getInt(){
return i;
}
}
public void proc(){
InnerClass inClass = new InnerClass();
System.out.println(inClass.getInt());
}
}
public class Main {
public static void main(String[] args) {
OutterClass outClass = new OutterClass();
outClass.proc();
}
}
// 外部类
class OutterClass {
// 内部类
public class InnerClass {
private int i = 0;
public int getInt(){
return i;
}
}
public void proc(){
InnerClass inClass = new InnerClass();
System.out.println(inClass.getInt());
}
}
public class Main {
public static void main(String[] args) {
OutterClass outClass = new OutterClass();
outClass.proc();
}
}
外部类可以访问内部类的私有成员，内部类也可以访问外部类的私有成员：
view plaincopy to clipboardprint?
// 外部类
class OutterClass {
private int mOut = 10;
// 内部类
public class InnerClass {
private int mIn = 0;
public void printOutPrivate(){
// 直接打印外部类的成员
System.out.println(mOut);
}
}
public void printInPrivate(){
InnerClass inClass = new InnerClass();
// 直接打印内部类的私有成员
System.out.println(inClass.mIn);
}
public void printOutPrivate(){
InnerClass inClass = new InnerClass();
inClass.printOutPrivate();
}
}
public class Main {
public static void main(String[] args) {
OutterClass outClass = new OutterClass();
outClass.printInPrivate();
outClass.printOutPrivate();
}
}
// 外部类
class OutterClass {
private int mOut = 10;
// 内部类
public class InnerClass {
private int mIn = 0;
public void printOutPrivate(){
// 直接打印外部类的成员
System.out.println(mOut);
}
}
public void printInPrivate(){
InnerClass inClass = new InnerClass();
// 直接打印内部类的私有成员
System.out.println(inClass.mIn);
}
public void printOutPrivate(){
InnerClass inClass = new InnerClass();
inClass.printOutPrivate();
}
}
public class Main {
public static void main(String[] args) {
OutterClass outClass = new OutterClass();
outClass.printInPrivate();
outClass.printOutPrivate();
}
}
如果外部类的成员变量与内部类的成员变量名字相同，当内部类要访问外部类的该成员时，可以使用“OutClass.this.mem”来区分：
view plaincopy to clipboardprint?
// 外部类
class OutterClass {
private int mMem = 10;
// 内部类
public class InnerClass {
private int mMem = 0;
public void printOutPrivate(){
// 直接打印外部类的成员
System.out.println(OutterClass.this.mMem);
}
}
}
// 外部类
class OutterClass {
private int mMem = 10;
// 内部类
public class InnerClass {
private int mMem = 0;
public void printOutPrivate(){
// 直接打印外部类的成员
System.out.println(OutterClass.this.mMem);
}
}
}
要创建普通内部类，必须先创建相应的外部类：
view plaincopy to clipboardprint?
// 外部类
class OutterClass {
private int mMem = 10;
// 内部类
public class InnerClass {
private int mMem = 0;
public void printOutPrivate(){
// 直接打印外部类的成员
System.out.println(OutterClass.this.mMem);
}
}
}
public class Main {
public static void main(String[] args) {
OutterClass outClass = new OutterClass();
OutterClass.InnerClass inClass = outClass.new InnerClass();
inClass.printOutPrivate();
}
}
// 外部类
class OutterClass {
private int mMem = 10;
// 内部类
public class InnerClass {
private int mMem = 0;
public void printOutPrivate(){
// 直接打印外部类的成员
System.out.println(OutterClass.this.mMem);
}
}
}
public class Main {
public static void main(String[] args) {
OutterClass outClass = new OutterClass();
OutterClass.InnerClass inClass = outClass.new InnerClass();
inClass.printOutPrivate();
}
}
也可以用下面的方式：
view plaincopy to clipboardprint?
// 外部类
class OutterClass {
private int mMem = 10;
// 内部类
public class InnerClass {
private int mMem = 0;
public void printOutPrivate(){
// 直接打印外部类的成员
System.out.println(OutterClass.this.mMem);
}
}
public InnerClass newInnerClass() {
return new InnerClass();
}
}
public class Main {
public static void main(String[] args) {
OutterClass outClass = new OutterClass();
OutterClass.InnerClass inClass = outClass.newInnerClass();
inClass.printOutPrivate();
}
}
// 外部类
class OutterClass {
private int mMem = 10;
// 内部类
public class InnerClass {
private int mMem = 0;
public void printOutPrivate(){
// 直接打印外部类的成员
System.out.println(OutterClass.this.mMem);
}
}
public InnerClass newInnerClass() {
return new InnerClass();
}
}
public class Main {
public static void main(String[] args) {
OutterClass outClass = new OutterClass();
OutterClass.InnerClass inClass = outClass.newInnerClass();
inClass.printOutPrivate();
}
}
2. 静态内部类
普通内部类前面加上static修饰符，就成为静态内部类，静态内部类类似于C++的嵌套类，与普通内部类相比有如下区别：
静态内部类没有指向外部类的引用，外部类对于它来说更像一个名字空间。
普通内部类不能有静态成员，静态方法，或另一个静态内部类；而静态内部类可以有这一切。
静态内部类可以直接创建，不必先创建外部类：
view plaincopy to clipboardprint?
// 外部类
class OutterClass {
private int mMem = 0;
// 静态内部类
static public class InnerClass {
private int mMem = 0;
public void printOutPrivate(){
// 这是错误的
// System.out.println(OutterClass.this.mMem);
}
}
public void printInPrivate() {
InnerClass inClass = new InnerClass();
// 可以直接访问静态内部类的成员
System.out.println(inClass.mMem);
}
}
public class Main {
public static void main(String[] args) {
// 直接创建静态内部类
OutterClass.InnerClass inClass = new OutterClass.InnerClass();
inClass.printOutPrivate();
}
}
// 外部类
class OutterClass {
private int mMem = 0;
// 静态内部类
static public class InnerClass {
private int mMem = 0;
public void printOutPrivate(){
// 这是错误的
// System.out.println(OutterClass.this.mMem);
}
}
public void printInPrivate() {
InnerClass inClass = new InnerClass();
// 可以直接访问静态内部类的成员
System.out.println(inClass.mMem);
}
}
public class Main {
public static void main(String[] args) {
// 直接创建静态内部类
OutterClass.InnerClass inClass = new OutterClass.InnerClass();
inClass.printOutPrivate();
}
}
从上面描述可以看出，静态内部类与一般类没有太大区别，只不过它是放在一个类的里面，这个类相当于它的名字空间，可以防止命名冲突。
3. 局部内部类
Java可以把一个类定义在一个方法里面，甚至是一个{}块里面，它的作用域就在这个块里面：
view plaincopy to clipboardprint?
// 外部类
class OutterClass {
public void testLocalInner() {
if (true)
{
class LocalInner {
public void proc() {
System.out.println("hello");
}
}
// 可以创建使用
LocalInner localInner = new LocalInner();
localInner.proc();
}
// 错误：超出类定义的作用域
LocalInner localInner = new LocalInner();
localInner.proc();
}
}
// 外部类
class OutterClass {
public void testLocalInner() {
if (true)
{
class LocalInner {
public void proc() {
System.out.println("hello");
}
}
// 可以创建使用
LocalInner localInner = new LocalInner();
localInner.proc();
}
// 错误：超出类定义的作用域
LocalInner localInner = new LocalInner();
localInner.proc();
}
}
局部内部类的一般用途是实现某个接口，并作为这个接口传出方法被使用：
view plaincopy to clipboardprint?
// 接口
interface Talker {
public void Talk();
}
// 外部类
class OutterClass {
public Talker getTalker() {
// 现实该接口的局部内部类
class SomeTalker implements Talker {
public void Talk() {
System.out.println("hello");
}
}
// 创建类实例并作为Talker返回
SomeTalker talker = new SomeTalker();
return talker;
}
}
public class Main {
public static void main(String[] args) {
OutterClass outClass = new OutterClass();
Talker talker = outClass.getTalker();
talker.Talk();
}
}
// 接口
interface Talker {
public void Talk();
}
// 外部类
class OutterClass {
public Talker getTalker() {
// 现实该接口的局部内部类
class SomeTalker implements Talker {
public void Talk() {
System.out.println("hello");
}
}
// 创建类实例并作为Talker返回
SomeTalker talker = new SomeTalker();
return talker;
}
}
public class Main {
public static void main(String[] args) {
OutterClass outClass = new OutterClass();
Talker talker = outClass.getTalker();
talker.Talk();
}
}
4. 匿名内部类
匿名内部类的语法如下：
view plaincopy to clipboardprint?
new InterfaceName(){......}; 或 new SuperclassName(){......};
new InterfaceName(){......}; 或 new SuperclassName(){......};
它被认为是InterfaceName的实现者，或是SuperclassName的继承类，匿名内部类没有构建函数，如果SuperclassName有带参数的构造函数，必须在创建匿名内部类时带上这些参数，下面是匿名内部类最常见的使用场合：
view plaincopy to clipboardprint?
// 接口
interface Talker {
public void Talk();
}
// 外部类
class OutterClass {
public void Talk(Talker talker) {
talker.Talk();
}
}
public class Main {
public static void main(String[] args) {
OutterClass outClass = new OutterClass();
// 直接生成一个匿名内部类
outClass.Talk(new Talker(){
public void Talk() {
System.out.println("hello");
}
});
}
}
分享到：
发表评论
相关推荐
java语言基础：内部类2.pdf
java语言基础：内部类2[整理].pdf
摘要 Reflection 是Java被视为动态（或准动态）语言的一个关键性质。这个机制允许程序在运行时透过...读者基础：具备Java 语言基础。 本文适用工具：JDK1.5 关键词： Introspection（内省、内观） Reflection（反射）
计算机后端-Java-Java核心基础-第17章 异常处理 04. 复习：内部类.avi
java基础java内部类
Java语言基础 Java网络编程技术 Java程序设计使用教程 第04章 接口 内部类 java API基础（共56页）.ppt Java语言基础 Java网络编程技术 Java程序设计使用教程 第05章 异常处理（共41页）.ppt Java语言基础 Java网络...
《Java高手真经(编程基础卷):Java核心编程技术》详细讲解了Java语言基础开发中的各种技术，主要内容包括如下。Java开发入门：JDK、JVM、Eclipse、Linux。Java语法基础：类、抽象类、接口、内部类、匿名类、异常、...
《Java高手真经(编程基础卷):Java核心编程技术》详细讲解了Java语言基础开发中的各种技术，主要内容包括如下。Java开发入门：JDK、JVM、Eclipse、Linux。Java语法基础：类、抽象类、接口、内部类、匿名类、异常、...
《Java高手真经(编程基础卷):Java核心编程技术》详细讲解了Java语言基础开发中的各种技术，主要内容包括如下。Java开发入门：JDK、JVM、Eclipse、Linux。Java语法基础：类、抽象类、接口、内部类、匿名类、异常、...
《Java高手真经(编程基础卷):Java核心编程技术》详细讲解了Java语言基础开发中的各种技术，主要内容包括如下。Java开发入门：JDK、JVM、Eclipse、Linux。Java语法基础：类、抽象类、接口、内部类、匿名类、异常、...
【完整课程列表】Java语言基础 Java网络编程技术 Java程序设计使用教程 第01章 java语言概述（共43页）.pptJava语言基础 Java网络编程技术 Java程序设计使用教程 第02章 java语言基础（共112页）.pptJava语言基础 ...
《Java高手真经(编程基础卷):Java核心编程技术》详细讲解了Java语言基础开发中的各种技术，主要内容包括如下。Java开发入门：JDK、JVM、Eclipse、Linux。Java语法基础：类、抽象类、接口、内部类、匿名类、异常、...
完整版 Java初级教程 Java语言程序设计 第6章 内部类和异常类（共22页）.ppt 完整版 Java初级教程 Java语言程序设计 第7章 Java中的常用类（共14页）.ppt 完整版 Java初级教程 Java语言程序设计 第8章 集合框架（共...
第8版针对Java SE 6平台进行了全面更新，囊括了Java 2平台、标准版(J2SE)的全部基础知识，提供了大量完整且具有实际意义的应用实例，详细介绍了Java语言基础知识、面向对象程序设计、接口与内部类、事件监听器模型、...
完整版 Java初级教程 Java语言程序设计 第6章 内部类和异常类（共22页）.ppt 完整版 Java初级教程 Java语言程序设计 第7章 Java中的常用类（共14页）.ppt 完整版 Java初级教程 Java语言程序设计 第8章 集合框架（共...
完整版 Java初级教程 Java语言程序设计 第6章 内部类和异常类（共22页）.ppt 完整版 Java初级教程 Java语言程序设计 第7章 Java中的常用类（共14页）.ppt 完整版 Java初级教程 Java语言程序设计 第8章 集合框架（共...
完整版 Java初级教程 Java语言程序设计 第6章 内部类和异常类（共22页）.ppt 完整版 Java初级教程 Java语言程序设计 第7章 Java中的常用类（共14页）.ppt 完整版 Java初级教程 Java语言程序设计 第8章 集合框架（共...
第七章：类的高级特征 103 学习目标 103 static关键字 104 final关键字 106 内部类 106 实例分析 110 抽象类,接口 115 内容总结 120 独立实践 121 第八章：异常 122 学习目标 122 异常的概念 123 异常的分类 123 ...