深刻理解java嵌套类和内部类、匿名类
1、什么是嵌套类及内部类前端
能够在一个类的内部定义另外一个类，这种类称为嵌套类（nested classes），它有两种类型：静态嵌套类和非静态嵌套类。静态嵌套类使用不多，最重要的是非静态嵌套类，也便是被称做为内部类（inner）。嵌套类从JDK1.1开始引入。其中inner类又可分为三种：
其1、在一个类（外部类）中直接定义的内部类；
其2、在一个方法（外部类的方法）中定义的内部类；
其3、匿名内部类。
java
下面，我将说明这几种嵌套类的使用及注意事项。ide
2、静态嵌套类this
以下所示代码为定义一个静态嵌套类，
spa
public class StaticTest { .net
private static String name = "javaJohn"; orm
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 范围内可见，若在其它类中引用或初始化，均是错误的。
3、在外部类中定义内部类
以下所示代码为在外部类中定义两个内部类及它们的调用关系：
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();
}
}
以上代码须要说明有，对于内部类，一般在定义类的class关键字前不加public 或 private等限制符，若加了没有任何影响，同时好像这些限定符对内部类的变量和方法也没有影响（？）。另外，就是要注意，内部类Inner及InnterTwo只在类Outer的做用域内是可知的，若是类Outer外的任何代码尝试初始化类Inner或使用它，编译就不会经过。同时，内部类的变量成员只在内部内内部可见，若外部类或同层次的内部类须要访问，需采用示例程序中的方法，不可直接访问内部类的变量。
4、在外部类中定义内部类
匿名类就是没有名字的内部类，是内部类的一种特殊状况。？？？？？？？？？ 这句话对吗？？？
前端时间在写.net项目中，一直错将.cs里的两个class看成内部类，原来是一个文件里的两个类而已，这让我想起了Java中的内部类，比较内部类，那么还有两个类，那就是匿名类和匿名内部类。今天我想就Java中的这三种类进行个比较。
咱们知道在Java语言规范中能够作不少事，例如一个类或一个接口中能够声明一个类或接口，在一个方法中能够声明一个类，类与接口声明能够嵌套任意深度等。
匿名类：
一、new <类或接口><类的主体>，匿名类的声明是在编译时进行的，实例化是在运行时进行的，因此在for循环中一个new语句会建立相同匿名类的几个实例，而不是建立几个不一样匿名类的一个实例。
二、若是要执行的对象须要一个对象，但却不值得建立全新的对象（多是由于该对象只在一个方法内部使用），在这个时候使用匿名类就会很是合适，因此说，匿名类通常会在swing程序中快速建立事件处理程序。
Java代码 
firstButton.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
getTxtValue().setText("第一个按钮触发的事件！");
}
});
三、从技术上说，匿名类能够被看做非静态的内部类，因此他们具备方法内部声明的非静态内部类相同的权限和限制。
内部类：
内部类顾名思义就是在一个类的内部还有一个类
Java代码
package com.iflytek.innerclass;
/**
* @author xudongwang 2012-1-11
*
* Email:xdwangiflytek@gmail.com
*/
public class InnerClassDemo {
public static void main(String[] args) {
new Outer().fun();
}
}
class Outer {
private String name = "Hello 内部类";
class Inner {
public void print() {
System.out.println("name = " + name);
}
};
public void fun() {
new Inner().print();
}
}
内部类生成的.class文件名为：Outer$Inner.class，从上面的结构发现内部类的的缺点是“结构很是的混乱”。
Java代码
package com.iflytek.innerclass;
/**
* @author xudongwang 2012-1-11
*
* Email:xdwangiflytek@gmail.com
*/
public class InnerClassDemo02 {
public static void main(String[] args) {
new Outer02().fun();
}
}
class Outer02 {
private String name = "Hello 内部类";
public void fun() {
new Inner02(this).print();
}
public String getName() {
return this.name;
}
};
class Inner02 {
private Outer02 out;
public Inner02(Outer02 out) {
this.out = out;
}
public void print() {
System.out.println("name = " + this.out.getName());
}
};
从上能够看出内部类的优势是“能够方便的访问外部类中的私有成员”；
若是要在外部直接使用内部类的实例化对象：
外部类.内部类 内部类对象 = 外部类实例.new 内部类实例();
Java代码
package com.iflytek.innerclass;
/**
* @author xudongwang 2012-1-11
*
* Email:xdwangiflytek@gmail.com
*/
public class InnerClassDemo03 {
public static void main(String[] args) {
Outer03 out = new Outer03();//外部类实例
Outer03.Inner inner = out.new Inner();//实例化内部类对象
inner.print();
}
}
class Outer03{
private String name = "Hello 内部类";
class Inner {
public void print() {
System.out.println("name = " + name);
}
}
}
一个内部类若是使用static关键字声明的话，则此内部类就将成为外部类，能够直接经过外部类.内部类的形式访问
Java代码
package com.iflytek.innerclass;
/**
* @author xudongwang 2012-1-11
*
* Email:xdwangiflytek@gmail.com
*/
public class InnerClassDemo04 {
public static void main(String[] args) {
Outer04.Inner inner = new Outer04.Inner();// 实例化内部类对象
inner.print();
}
}
class Outer04 {
private static String name = "Hello 内部类";
static class Inner {
public void print() {
System.out.println("name = " + name);
}
}
}
内部类能够在任意的地方使用，例如方法中声明
Java代码
package com.iflytek.innerclass;
/**
* @author xudongwang 2012-1-11
*
* Email:xdwangiflytek@gmail.com
*/
public class InnerClassDemo05 {
public static void main(String[] args) {
new Outer05().fun();
}
}
class Outer05 {
private static String name = "Hello 内部类";
public void fun() {
class Inner {
public void print() {
System.out.println("name = " + name);
}
}
new Inner().print();
}
}
在方法中定义的内部类，能够直接访问外部类中的各个成员，可是若是要访问方法中的参数，则须要在参数上加上final关键字声明；
Java代码
package com.iflytek.innerclass;
/**
* @author xudongwang 2012-1-11
*
* Email:xdwangiflytek@gmail.com
*/
public class InnerClassDemo06 {
public static void main(String[] args) {
new Outer06().fun(20);
}
}
class Outer06 {
private static String name = "Hello 内部类";
public void fun(final int temp) {
class Inner {
public void print() {
System.out.println("temp = " + temp);
System.out.println("name = " + name);
}
}
new Inner().print();
}
}
匿名类与内部的联系与区别：
按所在位置能够分为两大类：
一、在类的方法中
特色：
a、能够访问宿主类的全部元素 ；
b、保存宿主类对象的引用，建立对象时必须有宿主类对象；
c、 不能有静态数据；
继续划分：
A、本地内部类；
B、匿名内部类
二者的区别在于本地内部类有构造方法，而匿名内部类只能实例初始化；
二、在类或接口做用域中；
继续划分：
A、普通内部类
B、静态内部类
匿名内部类：
匿名内部类是在抽象类和接口的基础之上发展起来的。
Java代码
package com.iflytek.innerclass;
/**
* @author xudongwang 2012-1-11
*
* Email:xdwangiflytek@gmail.com
*/
public class NoNameClass01 {
public static void main(String[] args) {
new X().fun2();
}
}
interface A {
public void fun();
}
class B implements A {
public void fun() {
System.out.println("Hello 准备匿名内部类");
}
}
class X {
public void fun1(A a) {
a.fun();
}
public void fun2() {
this.fun1(new B());
}
}
经过上面的Demo，若是如今假设B类只使用一次，那么还有必要将其定义成一个单独的类么？
呵呵，此时就可使用匿名内部类：
Java代码
package com.iflytek.innerclass;
/**
* @author xudongwang 2012-1-11
*
* Email:xdwangiflytek@gmail.com
*/
public class NoNameClass02 {
public static void main(String[] args) {
new XX().fun2();
}
}
interface AA {
public void fun();
}
class XX {
public void fun1(AA a) {
a.fun();
}
public void fun2() {
this.fun1(new AA() {
public void fun() {
System.out.println("Hello 准备匿名内部类");
}
});
}
}
其实在真正的项目开发中匿名内部类使用的很是之少，通常在Java的图形界面和如今的Android中使用的比较多点。
最后给一个内部类实现的简单链表：
Java代码
package com.iflytek.innerclass;
/**
* @author xudongwang 2012-1-11
*
* Email:xdwangiflytek@gmail.com
*/
public class LinkDemo {
public static void main(String args[]) {
Link link = new Link();
link.add("A");
link.add("B");
link.add("C");
link.add("D");
link.add("E");
link.print();
}
};
class Link {
class Node {
private String name;
private Node next; // 单向链表，每一个节点指向下一个节点
public Node(String name) {
this.name = name; // 经过构造方法为name属性赋值
}
public void addNode(Node newNode) { // 增长节点
if (this.next == null) {
this.next = newNode; // 保存节点
} else {
this.next.addNode(newNode); // 继续向下查找
}
}
public void printNode() { // 输出节点
System.out.println(this.name);
if (this.next != null) { // 此节点以后还存在其余的节点
this.next.printNode();
}
}
};
private Node root; // 链表的头
public void add(String name) { // 增长节点
Node newNode = new Node(name); // 定义一个新的节点
/*
* 若是是第一个节点，则确定是根节点， 若是是第二个节点，则确定放在根节点next中 若是是第三个节点，则确定放在第二个节点的next中
*/
if (this.root == null) {
this.root = newNode; // 将第一个节点设置成根节点
} else {
// 确定要放在最后一个节点以后
// 经过节点.next来不断的判断
this.root.addNode(newNode);
}
}
public void print() {
if (this.root != null) { // 若是根节点为空了，则没有任何内容
this.root.printNode();
}
}
};
- 1. java6内部类------嵌套类、局部类、匿名类、lambda
- 2. 嵌套类和内部类
- 3. Java 内部类与匿名内部类
- 4. Java 中的内部类和匿名类
- 5. 【java】内部类和匿名类
- 6. java内部类和匿名类
- 7. 内部类和匿名内部类
- 8. java中内部类和嵌套类
- 9. Java内部类和静态嵌套类
- 10. 详解Java嵌套类与内部类
- 更多相关文章...
- • PHP 匿名类 - PHP 7 新特性
- • Eclipse 创建 Java 类 - Eclipse 教程
- • Kotlin学习（二）基本类型
- • ☆技术问答集锦（13）Java Instrument原理
-
每一个你不满意的现在，都有一个你没有努力的曾经。
- 1. java6内部类------嵌套类、局部类、匿名类、lambda
- 2. 嵌套类和内部类
- 3. Java 内部类与匿名内部类
- 4. Java 中的内部类和匿名类
- 5. 【java】内部类和匿名类
- 6. java内部类和匿名类
- 7. 内部类和匿名内部类
- 8. java中内部类和嵌套类
- 9. Java内部类和静态嵌套类
- 10. 详解Java嵌套类与内部类