【java笔试系列一】内部类、外部类和嵌套类
2017-06-26 11:29
369 查看
一、什么是嵌套类及内部类
可以在一个类的内部定义另一个类,这种类称为嵌套类(nested classes),它有两种类型:静态嵌套类和非静态嵌套类。静态嵌套类使用很少,最重要的是非静态嵌套类,也即是被称作为内部类(inner)。嵌套类从JDK1.1开始引入。其中inner类又可分为三种:
[b] 其一、在一个类(外部类)中直接定义的内部类;
其二、在一个方法(外部类的方法)中定义的内部类;
其三、匿名内部类。
[/b]
下面,我将说明这几种嵌套类的使用及注意事项。
二、静态嵌套类
如下所示代码为定义一个静态嵌套类,
在静态嵌套类内部,不能访问外部类的非静态成员,这是由Java语法中"静态方法不能直接访问非静态成员"所限定。若想访问外部类的变量,必须通过其它方法解决,由于这个原因,静态嵌套类使用很少。注意,外部类访问内部类的的成员有些特别,不能直接访问,但可以通过内部类来访问,这是因为静态嵌套内的所有成员和方法默认为静态的了。同时注意,内部静态类Person只在类StaticTest
范围内可见,若在其它类中引用或初始化,均是错误的。
static关键字的作用是把类的成员变成类相关,而不是实例相关,即static修饰的成员属于整个类,而不属于单个对象。由于外部类的上一级程序单元是包,所以static关键字只能修饰内部类,不能修饰外部类。
三、在外部类中定义内部类
1、内部类分为成员内部类、静态嵌套类、方法内部类、匿名内部类。
几种内部类的共性:
A、内部类仍然是一个独立的类,在编译之后会内部类会被编译成独立的.class文件,但是前面冠以外部类的类命和$符号。
B、内部类不能用普通的方式访问。内部类是外部类的一个成员,因此内部类可以自由地访问外部类的成员变量,无论是否是private的。
如下所示代码为在外部类中定义两个内部类及它们的调用关系:
总结:
1、对于内部类,通常在定义类的class关键字前不加public 或 private等限制符,若加了没有任何影响。
2、内部类中可以直接访问外部类的数据成员和方法。
3、另外,就是要注意,内部类Inner及InnterTwo只在类Outer的作用域内是可知的,如果类Outer外的任何代码尝试初始化类Inner或使用它,编译就不会通过。同时,内部类的变量成员只在内部内内部可见,若外部类或同层次的内部类需要访问,需采用示例程序中的方法,不可直接访问内部类的变量。
四、方法内部类
顾名思义,把类放在方法内。
class Outer {
B、方法内部类对象不能使用该内部类所在方法的非final局部变量。
因为方法的局部变量位于栈上,只存在于该方法的生命期内。当一个方法结束,其栈结构被删除,局部变量成为历史。但是该方法结束之后,
在方法内创建的内部类对象可能仍然存在于堆中!例如,如果对它的引用被传递到其他某些代码,并存储在一个成员变量内。
正因为不能保证局部变量的存活期和方法内部类对象的一样长,所以内部类对象不能使用它们。
下面是完整的例子:
五、匿名内部类
匿名内部类也就是没有名字的内部类
正因为没有名字,所以匿名内部类只能使用一次,它通常用来简化代码编写
但使用匿名内部类还有个前提条件:必须继承一个父类或实现一个接口
运行结果:eat something
可以看到,我们用Child继承了Person类,然后实现了Child的一个实例,将其向上转型为Person类的引用
但是,如果此处的Child类只使用一次,那么将其编写为独立的一个类岂不是很麻烦?
这个时候就引入了匿名内部类
运行结果:eat something
可以看到,我们直接将抽象类Person中的方法在大括号中实现了
这样便可以省略一个类的书写
并且,匿名内部类还能用于接口上
运行结果:eat something
由上面的例子可以看出,只要一个类是抽象的或是一个接口,那么其子类中的方法都可以使用匿名内部类来实现
最常用的情况就是在多线程的实现上,因为要实现多线程必须继承Thread类或是继承Runnable接口
2 3 4 5
2 3 4 5
参考:http://blog.csdn.net/hguisu/article/details/7270086
http://www.cnblogs.com/nerxious/archive/2013/01/25/2876489.html
可以在一个类的内部定义另一个类,这种类称为嵌套类(nested classes),它有两种类型:静态嵌套类和非静态嵌套类。静态嵌套类使用很少,最重要的是非静态嵌套类,也即是被称作为内部类(inner)。嵌套类从JDK1.1开始引入。其中inner类又可分为三种:
[b] 其一、在一个类(外部类)中直接定义的内部类;
其二、在一个方法(外部类的方法)中定义的内部类;
其三、匿名内部类。
[/b]
下面,我将说明这几种嵌套类的使用及注意事项。
如下所示代码为定义一个静态嵌套类,
public class StaticTest { private static String name = "javaJohn"; private String id = "X001"; static class Person{ private String address = "swjtu,chenDu,China"; public String mail = "josserchai@yahoo.com";//内部类公有成员 public void display(){ //System.out.println(id);//不能直接访问外部类的非静态成员 System.out.println(name);//只能直接访问外部类的静态成员 System.out.println("Inner "+address);//访问本内部类成员。 } } public void printInfo(){ Person person = new Person(); person.display(); //System.out.println(mail);//不可访问 //System.out.println(address);//不可访问 System.out.println(person.address);//可以访问内部类的私有成员 System.out.println(person.mail);//可以访问内部类的公有成员 } public static void main(String[] args) { StaticTest staticTest = new StaticTest(); staticTest.printInfo(); } }
在静态嵌套类内部,不能访问外部类的非静态成员,这是由Java语法中"静态方法不能直接访问非静态成员"所限定。若想访问外部类的变量,必须通过其它方法解决,由于这个原因,静态嵌套类使用很少。注意,外部类访问内部类的的成员有些特别,不能直接访问,但可以通过内部类来访问,这是因为静态嵌套内的所有成员和方法默认为静态的了。同时注意,内部静态类Person只在类StaticTest
范围内可见,若在其它类中引用或初始化,均是错误的。
static关键字的作用是把类的成员变成类相关,而不是实例相关,即static修饰的成员属于整个类,而不属于单个对象。由于外部类的上一级程序单元是包,所以static关键字只能修饰内部类,不能修饰外部类。
1、内部类分为成员内部类、静态嵌套类、方法内部类、匿名内部类。
几种内部类的共性:
A、内部类仍然是一个独立的类,在编译之后会内部类会被编译成独立的.class文件,但是前面冠以外部类的类命和$符号。
B、内部类不能用普通的方式访问。内部类是外部类的一个成员,因此内部类可以自由地访问外部类的成员变量,无论是否是private的。
如下所示代码为在外部类中定义两个内部类及它们的调用关系:
public class Outer { int outer_x = 100; class Inner{ public int y = 10; private int z = 9; int m = 5; public void display(){ System.out.println("display outer_x:"+ outer_x); } private void display2(){ System.out.println("display outer_x:"+ outer_x); } } void test(){ Inner inner = new Inner(); inner.display(); inner.display2(); //System.out.println("Inner y:" + y);//不能访问内部内变量 System.out.println("Inner y:" + inner.y);//可以访问 System.out.println("Inner z:" + inner.z);//可以访问 System.out.println("Inner m:" + inner.m);//可以访问 InnerTwo innerTwo = new InnerTwo(); innerTwo.show(); } class InnerTwo{ Inner innerx = new Inner(); public void show(){ //System.out.println(y);//不可访问Innter的y成员 //System.out.println(Inner.y);//不可直接访问Inner的任何成员和方法 innerx.display();//可以访问 innerx.display2();//可以访问 System.out.println(innerx.y);//可以访问 System.out.println(innerx.z);//可以访问 System.out.println(innerx.m);//可以访问 } } public static void main(String args[]){ Outer outer = new Outer(); outer.test(); } }
总结:
1、对于内部类,通常在定义类的class关键字前不加public 或 private等限制符,若加了没有任何影响。
2、内部类中可以直接访问外部类的数据成员和方法。
3、另外,就是要注意,内部类Inner及InnterTwo只在类Outer的作用域内是可知的,如果类Outer外的任何代码尝试初始化类Inner或使用它,编译就不会通过。同时,内部类的变量成员只在内部内内部可见,若外部类或同层次的内部类需要访问,需采用示例程序中的方法,不可直接访问内部类的变量。
顾名思义,把类放在方法内。
class Outer {
public void doSomething(){ class Inner{ public void seeOuter(){ } } } }A、方法内部类只能在定义该内部类的方法内实例化,不可以在此方法外对其实例化。
B、方法内部类对象不能使用该内部类所在方法的非final局部变量。
因为方法的局部变量位于栈上,只存在于该方法的生命期内。当一个方法结束,其栈结构被删除,局部变量成为历史。但是该方法结束之后,
在方法内创建的内部类对象可能仍然存在于堆中!例如,如果对它的引用被传递到其他某些代码,并存储在一个成员变量内。
正因为不能保证局部变量的存活期和方法内部类对象的一样长,所以内部类对象不能使用它们。
下面是完整的例子:
class Outer { public void doSomething(){ final int a =10; class Inner{ public void seeOuter(){ System.out.println(a); } } Inner in = new Inner(); in.seeOuter(); } public static void main(String[] args) { Outer out = new Outer(); out.doSomething(); } }
五、匿名内部类
匿名内部类也就是没有名字的内部类
正因为没有名字,所以匿名内部类只能使用一次,它通常用来简化代码编写
但使用匿名内部类还有个前提条件:必须继承一个父类或实现一个接口
实例1:不使用匿名内部类来实现抽象方法
abstract class Person { public abstract void eat(); } class Child extends Person { public void eat() { System.out.println("eat something"); } } public class Demo { public static void main(String[] args) { Person p = new Child(); p.eat(); } }
运行结果:eat something
可以看到,我们用Child继承了Person类,然后实现了Child的一个实例,将其向上转型为Person类的引用
但是,如果此处的Child类只使用一次,那么将其编写为独立的一个类岂不是很麻烦?
这个时候就引入了匿名内部类
实例2:匿名内部类的基本实现
abstract class Person { public abstract void eat(); } public class Demo { public static void main(String[] args) { Person p = new Person() { public void eat() { System.out.println("eat something"); } }; p.eat(); } }
运行结果:eat something
可以看到,我们直接将抽象类Person中的方法在大括号中实现了
这样便可以省略一个类的书写
并且,匿名内部类还能用于接口上
实例3:在接口上使用匿名内部类
interface Person { public void eat(); } public class Demo { public static void main(String[] args) { Person p = new Person() { public void eat() { System.out.println("eat something"); } }; p.eat(); } }
运行结果:eat something
由上面的例子可以看出,只要一个类是抽象的或是一个接口,那么其子类中的方法都可以使用匿名内部类来实现
最常用的情况就是在多线程的实现上,因为要实现多线程必须继承Thread类或是继承Runnable接口
实例4:Thread类的匿名内部类实现
public class Demo { public static void main(String[] args) { Thread t = new Thread() { public void run() { for (int i = 1; i <= 5; i++) { System.out.print(i + " "); } } }; t.start(); } }运行结果:1
2 3 4 5
实例5:Runnable接口的匿名内部类实现
public class Demo { public static void main(String[] args) { Runnable r = new Runnable() { public void run() { for (int i = 1; i <= 5; i++) { System.out.print(i + " "); } } }; Thread t = new Thread(r); t.start(); } }运行结果:1
2 3 4 5
参考:http://blog.csdn.net/hguisu/article/details/7270086
http://www.cnblogs.com/nerxious/archive/2013/01/25/2876489.html
相关文章推荐
- 【java笔试系列一】内部类、外部类和嵌套类
- javaSE_8系列博客——Java语言的特性(三)--类和对象(16)--嵌套类(内部类的示例)
- 【java开发系列】—— 嵌套类与内部类
- Java学习系列(五)Java面向对象之抽象类、接口、内部类、枚举类详解
- Java测试内部类和嵌套类位置的合法性
- java 内部类(内置类,嵌套类)
- Java中的内部类 普通嵌套类 局部内部类 匿名内部类 静态内部类 浅析
- Java面试笔试题(基础)一:内部类及静态块
- 分析java 嵌套类与内部类
- Java深入理解嵌套类和内部类
- Java深入理解嵌套类和内部类
- Java基础复习:嵌套类和内部类
- Java笔试 系列一
- JAVA中内部类访问外部类成员
- 深入理解java嵌套类和内部类、匿名类
- java 内部类 匿名内部类 嵌套类
- Java常见笔试面试题目深度剖析系列之:Java方法参数传递详解
- Java笔试 系列四
- java中的内部类(嵌套类)
- java反编译,内部类调用外部类成员总结