【java开发系列】—— 嵌套类与内部类

嵌套类与内部类在java中使用的很广泛，为了避免难以理解，这里用了几个小例子，说明它的用法。

　　嵌套类与内部类的结构如下图

　　静态嵌套类　　

　　静态嵌套类，是一种在类之外声明的嵌套类，由于是静态的，所以不经过初始化，就可以通过类名，直接调用。

1 class out1{
2     private static String name = "xingoo";
3     static class info{
4         void print(){
5             System.out.println("name："+name);
6         }
7     }
8 }

　　使用样例

package testClass;
class out1{private static String name = "xingoo";static class info{void print(){System.out.println("name："+name);}}
}
class out2{private static String name = "xingoo test 2";static class info{String name = "inner infomation!";void printInner(){System.out.println("name:"+name);}void printOuter(){System.out.println("name:"+out2.name);}}
}
/*** 静态嵌套类* @author xingoo**/
public class test1 {public static void main(String[] args){//创建对象时，以xxx.yyy这种格式创建out1.info oi = new out1.info();oi.print();out2.info oi2 = new out2.info();oi2.printInner();oi2.printOuter();}
}

　　成员内部类

　　成员内部类，即该类作为另一个类的成员，因此只有引用另一个类，才能创建这个类。

1 class outer{
2     private String name = "xingoo";
3     class inner{
4         void print(){
5             System.out.println(name);
6         }
7     }
8 }

　　通常也用于隐藏的实现某个接口，如下面所示，第一种是传统的实现方式，第二种是隐藏了实现接口的实现方式。

 1 interface Printer{
 2     void print(String name);
 3 }
 4 class outerImpl1 implements Printer{
 5     @Override
 6     public void print(String name) {
 7         System.out.println(name);
 8     }
 9 }
10 class outerImpl2{
11     private class inner implements Printer{
12         @Override
13         public void print(String name) {
14             System.out.println(name);
15         }
16     }
17     public Printer getPrinter(){
18         return new inner();
19     }
20 }

　　使用样例

package testClass;
/*** 简单测试成员内部类* @author xingoo**/
class outer{private String name = "xingoo";class inner{void print(){System.out.println(name);}}
}
interface Printer{void print(String name);
}
class outerImpl1 implements Printer{@Overridepublic void print(String name) {System.out.println(name);}
}
class outerImpl2{private class inner implements Printer{@Overridepublic void print(String name) {System.out.println(name);}}public Printer getPrinter(){return new inner();}
}
/*** 成员内部类* @author xingoo**/
public class test2 {public static void main(String[] args){//创建一个外部类的对象，通过调用这个对象的new方法创建其内部类的对象outer o = new outer();outer.inner i = o.new inner();i.print();//内部类实现接口隐藏Printer out1 = new outerImpl1();out1.print("xingoo test1");outerImpl1 out1trans = (outerImpl1)out1;//支持向下转换
        Printer out2 = (new outerImpl2()).getPrinter();out2.print("xingoo test2");//无法向下转换，因为inner是private类型的，这样就实现了接口的隐藏
    }
}

　　局部内部类

　　局部类的声明之作用与某个代码块内，因此如果某个声明的类仅仅被一段程序所使用，其他地方再也用不到，就可以用这种实现方式。·

 1 interface Logger{
 2     public void log(String message);
 3 }
 4 public class test3 {
 5
 6     String startTime = (new Date()).toString();
 7     /**
 8      * 局部内部类，从定义上来讲，不属于任何其他的类，因为是声明在这个类内部的。与匿名内部类不同的就是它有名字。
 9      * @return
10      */
11     public Logger getLogger(){
12         //由于LoggerImpl只在 getLogger内部使用，因此把它定义在函数内部，相对来说更安全一些
13         class LoggerImpl implements Logger{
14             @Override
15             public void log(String message) {
16                 System.out.println(startTime + ":" + message);
17             }
18         }
19         return new LoggerImpl();
20     }
21
22     public static void main(String[] args){
23         test3 test = new test3();
24         Logger logger = test.getLogger();
25         logger.log("hello xingoo!");
26     }
27 }

　　匿名内部类

　　在使用new创建对象时，直接在后面创建它的实现类。

 1 abstract class Printable{
 2     public void print(String name){
 3
 4     }
 5 }
 6 /**
 7  * 就是跟在new创建对象之后，直接定义它的类实现
 8  * @author Administrator
 9  */
10 public class test4 {
11     public static void main(String[] args){
12         Printable printer = new Printable(){
13             public void print(String name){
14                 System.out.println(name);
15             }
16         };//注意因为这其实是一个new语法，因此要加上分号;
17         printer.print("hello!xingoo!");
18     }
19 }

参考资料：《JAVA 7程序设计》

from: http://www.cnblogs.com/xing901022/p/3966609.html

【java开发系列】—— 嵌套类与内部类相关推荐

java嵌套类与内部类
一.嵌套类(Nested Classes) 使用嵌套类减少了命名冲突,一个内部类可以定义在一个类中,一个方法中甚至一个表达式中. (1)定义 A nested(嵌套) class is any cla ...
kotlin学习之嵌套类和内部类（六）
目录 1. Java中的内部类和嵌套类 2. kotlin中的嵌套类和内部类 1. Java中的内部类和嵌套类 //内部类,内部类持有了外部类的引用,所以在内部类中可以调用外部类的方法 public ...
【Java 面向对象】基础、Java程序的内存划分、嵌套类（内部类、静态嵌套类）、局部类、接口的升级问题（默认方法、静态方法）、instanceof
面向对象对象的内存复杂对象的内存对象数组的内存思考:方法存储在哪里? Java程序的内存划分 this.super 注解(Annotation) 访问控制(Access Control) to ...
Java基础篇：介绍嵌套类和内部类
在另一个类中定义的类就是嵌套类(nested classes).嵌套类的范围由装入它的类的范围限制.这样,如果类B被定义在类A之内,那么B为A所知,然而不被A的外面所知. 嵌套类可以访问嵌套它的类的成 ...
Java 嵌套类和内部类演示样例lt;二gt;
嵌套类(nested class)是一个在还有一个类或接口内部声明的类. 嵌套类分为两种:静态内部类(static inner class)和非静态嵌套类(non-static nested clas ...
Java进阶07 嵌套类
作者:Vamei 出处:http://www.cnblogs.com/vamei 欢迎转载,也请保留这段声明.谢谢! 到现在为止,我们都是在Java文件中直接定义类.这样的类出现在包(package) ...
【java开发系列】—— JDK安装
前言作为一个java开发者,安装JDK是不可避免的,但是配置路径却总是记不住,百度也有很多参考例子.这里仅仅当做以后参考的笔记记录. 说到JDK,就不得不提JRE.他们到底是什么呢? 通常我们进行j ...
JAVA学习3-抽象类、内部类、数组、Object、System、String、基本包装类型
21.类之间的关系 is a:继承关系 has a : 关联关系,通常以属性的形式存在 like a:实现关系,通常是类与接口的关系; 22.抽象类与接口的区别抽象类是半抽象的,接口是完全抽象的: ...
【java开发系列】—— 自定义注解
之前在开发中,就总纳闷,为什么继承接口时,会出现@Override注解,有时候还会提示写注解@SuppressWarnings? 原来这是java特有的特性,注解! 那么什么是注解呢? 注解就是某种注 ...