1. 普通内部类
* 普通内部类的一个最简单的例子:
外部类可以访问内部类的私有成员,内部类也可以访问外部类的私有成员:
如果外部类的成员变量与内部类的成员变量名字相同,当内部类要访问外部类的该成员时,可以使用“OutClass.this.mem”来区分:
要创建普通内部类,必须先创建相应的外部类:
也可以用下面的方式:
2. 静态内部类
普通内部类前面加上static修饰符,就成为静态内部类,静态内部类类似于C++的嵌套类,与普通内部类相比有如下区别:
*静态内部类没有指向外部类的引用,外部类对于它来说更像一个名字空间。
*普通内部类不能有静态成员,静态方法,或另一个静态内部类;而静态内部类可以有这一切。
*静态内部类可以直接创建,不必先创建外部类:
从上面描述可以看出,静态内部类与一般类没有太大区别,只不过它是放在一个类的里面,这个类相当于它的名字空间,可以防止命名冲突。
3. 局部内部类
Java可以把一个类定义在一个方法里面,甚至是一个{}块里面,它的作用域就在这个块里面:
局部内部类的一般用途是实现某个接口,并作为这个接口传出方法被使用:
4. 匿名内部类
匿名内部类的语法如下:
它被认为是InterfaceName的实现者,或是SuperclassName的继承类,匿名内部类没有构建函数,如果SuperclassName有带参数的构造函数,必须在创建匿名内部类时带上这些参数,下面是匿名内部类最常见的使用场合:
转载地址 : [url]http://blog.csdn.net/linzhengqun/archive/2011/03/24/6275586.aspx[/url]
* 普通内部类的一个最简单的例子:
// 外部类
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 {
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”来区分:
// 外部类
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);
}
}
}
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 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++的嵌套类,与普通内部类相比有如下区别:
*静态内部类没有指向外部类的引用,外部类对于它来说更像一个名字空间。
*普通内部类不能有静态成员,静态方法,或另一个静态内部类;而静态内部类可以有这一切。
*静态内部类可以直接创建,不必先创建外部类:
// 外部类
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可以把一个类定义在一个方法里面,甚至是一个{}块里面,它的作用域就在这个块里面:
// 外部类
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();
}
}
局部内部类的一般用途是实现某个接口,并作为这个接口传出方法被使用:
// 接口
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;
}
}
4. 匿名内部类
匿名内部类的语法如下:
new InterfaceName(){......}; 或 new SuperclassName(){......};
它被认为是InterfaceName的实现者,或是SuperclassName的继承类,匿名内部类没有构建函数,如果SuperclassName有带参数的构造函数,必须在创建匿名内部类时带上这些参数,下面是匿名内部类最常见的使用场合:
// 接口
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");
}
});
}
}
转载地址 : [url]http://blog.csdn.net/linzhengqun/archive/2011/03/24/6275586.aspx[/url]