- 浏览: 1064572 次
- 性别:
- 来自: 南京
文章分类
- 全部博客 (501)
- dwr (6)
- javascript (84)
- oracle (66)
- jsp/servlet (18)
- ant (3)
- 基础知识 (12)
- EXT (10)
- My SQL (10)
- java (71)
- spring (37)
- 学习的对象 (2)
- Linux (24)
- 面试 (1)
- HTML/CSS (11)
- tomcat (11)
- 收藏夹 (2)
- Power Designer (2)
- struts.xml配置文件 (1)
- sturts2 (3)
- myeclipse (8)
- eclipse (7)
- Maven (34)
- SVN (3)
- SAP JCO (2)
- JBOSS (11)
- webservice (8)
- word (1)
- 敏捷开发 (1)
- sybase (4)
- Nexus (3)
- EhCache (3)
- log4j (3)
- Cookie (4)
- Session (4)
- CXF (7)
- AXIS (2)
- SSO (1)
- LDAP (1)
- velocity (2)
- Jquery (5)
- redis (2)
- http (4)
- dojo (1)
- Linux资源监控软件mnon的安装与运用 (1)
- notepad++ (1)
- EA (1)
- UML (1)
- JasperReports (1)
- 权限 (0)
- freemarker (4)
- Spring MVC (1)
- JMS (1)
- activeMQ (1)
- hession (3)
- 安全 (1)
- ibatis (2)
- log (1)
- nginx (1)
最新评论
-
winhbb:
我刚好遇到了一个问题(在可以依赖注入的场合有效):有两个模块A ...
解决Maven项目相互依赖/循环依赖/双向依赖的问题 -
nanjiwubing123:
long3ok 写道你好 XmlOutputFormatter ...
用XStream转换复杂XML -
zhoujianboy:
另外一个方法实现eclipse tomcat 热部署:http ...
eclipse下实现maven项目在tomcat容器热部署方法 -
long3ok:
你好 XmlOutputFormatter 请问这个类是在什么 ...
用XStream转换复杂XML -
ganbo:
总结的好,文章给力。
解决Maven项目相互依赖/循环依赖/双向依赖的问题
文章分类:Java编程
一、 定义
放在一个类的内部的类我们就叫内部类。
二、 作用
1.内部类可以很好的实现隐藏,也就是封装性。一般的非内部类,是不允许有 private 与protected权限的,但内部类可以
2.内部类拥有外围类的所有元素的访问权限
3.可是实现多重继承
4.可以避免修改接口而实现同一个类中两种同名方法的调用
三、 例子
1.实现隐藏
平时我们对类的访问权限,都是通过类前面的访问修饰符来限制的,一般的非内部类,是不允许有 private 与protected权限的,但内部类可以,所以我们能通过内部类来隐藏我们的信息。可以看下面的例子
Java代码
package beyondx;
public class Example {
private class InsideClass implements InterfaceTest
{
public void test()
{
System.out.println("这是一个测试");
}
}
public InterfaceTest getIn()
{
return new InsideClass();
}
}
package beyondx;
public class Example {
private class InsideClass implements InterfaceTest
{
public void test()
{
System.out.println("这是一个测试");
}
}
public InterfaceTest getIn()
{
return new InsideClass();
}
}
上面的InsideClass就是一个内部类,访问修饰符是private
客户端程序
Java代码
package insidecategory;
public class TestExample {
public static void main(String args[])
{
Example a=new Example();
InterfaceTest a1=a.getIn();
a1.test();
}
}
package insidecategory;
public class TestExample {
public static void main(String args[])
{
Example a=new Example();
InterfaceTest a1=a.getIn();
a1.test();
}
}
从这段代码里面我只知道Example的getIn()方法能返回一个InterfaceTest 实例但我并不知道这个实例是这么实现的。而且由于InsideClass 是private的,所以我们如果不看代码的话根本看不到这个具体类的名字,所以说它可以很好的实现隐藏。
2.可以无条件地访问外围类的所有元素
Java代码
package beyondx;
public class TagBean {
private String name="luffyke";
private class InTest
{
public InTest()
{
System.out.println(name);
}
}
public void test()
{
new InTest();
}
public static void main(String args[])
{
TagBean bb=new TagBean();
bb.test();
}
}
package beyondx;
public class TagBean {
private String name="luffyke";
private class InTest
{
public InTest()
{
System.out.println(name);
}
}
public void test()
{
new InTest();
}
public static void main(String args[])
{
TagBean bb=new TagBean();
bb.test();
}
}
看上面name这个变量是在TagBean里面定义的私有变量。这个变量在内部类中可以无条件地访问System.out.println(name);
3.可以实现多重继承
这个特点非常重要,个人认为它是内部类存在的最大理由之一。正是由于他的存在使得Java的继承机制更加完善。大家都知道Java只能继承一个类,它的多重继承在我们没有学习内部类之前是用接口来实现的。但使用接口有时候有很多不方便的地方。比如我们实现一个接口就必须实现它里面的所有方法。而有了内部类就不一样了。它可以使我们的类继承多个具体类或抽象类。大家看下面的例子。
类一
Java代码
package beyondx;
public class Example1 {
public String name()
{
return "luffyke";
}
}
package beyondx;
public class Example1 {
public String name()
{
return "luffyke";
}
}
类二
Java代码
package beyondx;
public class Example2 {
public int age()
{
return 25;
}
}
package beyondx;
public class Example2 {
public int age()
{
return 25;
}
}
类三
Java代码
package beyondx;
public class MainExample
{
private class test1 extends Example1
{
public String name()
{
return super.name();
}
}
private class test2 extends Example2
{
public int age()
{
return super.age();
}
}
public String name()
{
return new test1().name();
}
public int age()
{
return new test2().age();
}
public static void main(String args[])
{
MainExample mi=new MainExample();
System.out.println("姓名:"+mi.name());
System.out.println("年龄:"+mi.age());
}
}
package beyondx;
public class MainExample
{
private class test1 extends Example1
{
public String name()
{
return super.name();
}
}
private class test2 extends Example2
{
public int age()
{
return super.age();
}
}
public String name()
{
return new test1().name();
}
public int age()
{
return new test2().age();
}
public static void main(String args[])
{
MainExample mi=new MainExample();
System.out.println("姓名:"+mi.name());
System.out.println("年龄:"+mi.age());
}
}
大家注意看类三,里面分别实现了两个内部类 test1,和test2 ,test1类又继承了Example1,test2继承了Example2,这样我们的类三MainExample就拥有了Example1和Example2的方法和属性,也就间接地实现了多继承。
四、 避免修改接口而实现同一个类中两种同名方法的调用。
大家假想一下如果,你的类要继承一个类,还要实现一个接口,可是你发觉你继承的类和接口里面有两个同名的方法怎么办?你怎么区分它们??这就需要我们的内部类了。看下面的代码
接口
Java代码
package beyondx;
public interface Incrementable
{
void increment();
}
package beyondx;
public interface Incrementable
{
void increment();
}
类 MyIncrement
Java代码
package beyondx;
public class MyIncrement {
public void increment()
{
System.out.println("Other increment()");
}
static void f(MyIncrement f)
{
f.increment();
}
}
package beyondx;
public class MyIncrement {
public void increment()
{
System.out.println("Other increment()");
}
static void f(MyIncrement f)
{
f.increment();
}
}
大家看上面加黑的部分,两个方法都是一样的。在看下面这个类要继承这两个类
如果不用内部类
Java代码
package beyondx;
public class Callee2 extends MyIncrement implements Incrementable
{
public void increment()
{
//代码
}
}
package beyondx;
public class Callee2 extends MyIncrement implements Incrementable
{
public void increment()
{
//代码
}
}
想问一下大家increment()这个方法是属于覆盖MyIncrement这里的方法呢?还是Incrementable这里的方法。我怎么能调到MyIncrement这里的方法?显然这是不好区分的。而我们如果用内部类就很好解决这一问题了。看下面代码
Java代码
package beyondx;
public class Callee2 extends MyIncrement
{
private int i=0;
private void incr()
{
i++;
System.out.println(i);
}
private class Closure implements Incrementable
{
public void increment()
{
incr();
}
}
Incrementable getCallbackReference()
{
return new Closure();
}
}
package beyondx;
public class Callee2 extends MyIncrement
{
private int i=0;
private void incr()
{
i++;
System.out.println(i);
}
private class Closure implements Incrementable
{
public void increment()
{
incr();
}
}
Incrementable getCallbackReference()
{
return new Closure();
}
}
我们可以用内部类来实现接口,这样就不会与外围类的方法冲突了。
【转载地址】
http://www.360doc.com/content/10/0515/11/1040993_27691263.shtml
一、 定义
放在一个类的内部的类我们就叫内部类。
二、 作用
1.内部类可以很好的实现隐藏,也就是封装性。一般的非内部类,是不允许有 private 与protected权限的,但内部类可以
2.内部类拥有外围类的所有元素的访问权限
3.可是实现多重继承
4.可以避免修改接口而实现同一个类中两种同名方法的调用
三、 例子
1.实现隐藏
平时我们对类的访问权限,都是通过类前面的访问修饰符来限制的,一般的非内部类,是不允许有 private 与protected权限的,但内部类可以,所以我们能通过内部类来隐藏我们的信息。可以看下面的例子
Java代码
package beyondx;
public class Example {
private class InsideClass implements InterfaceTest
{
public void test()
{
System.out.println("这是一个测试");
}
}
public InterfaceTest getIn()
{
return new InsideClass();
}
}
package beyondx;
public class Example {
private class InsideClass implements InterfaceTest
{
public void test()
{
System.out.println("这是一个测试");
}
}
public InterfaceTest getIn()
{
return new InsideClass();
}
}
上面的InsideClass就是一个内部类,访问修饰符是private
客户端程序
Java代码
package insidecategory;
public class TestExample {
public static void main(String args[])
{
Example a=new Example();
InterfaceTest a1=a.getIn();
a1.test();
}
}
package insidecategory;
public class TestExample {
public static void main(String args[])
{
Example a=new Example();
InterfaceTest a1=a.getIn();
a1.test();
}
}
从这段代码里面我只知道Example的getIn()方法能返回一个InterfaceTest 实例但我并不知道这个实例是这么实现的。而且由于InsideClass 是private的,所以我们如果不看代码的话根本看不到这个具体类的名字,所以说它可以很好的实现隐藏。
2.可以无条件地访问外围类的所有元素
Java代码
package beyondx;
public class TagBean {
private String name="luffyke";
private class InTest
{
public InTest()
{
System.out.println(name);
}
}
public void test()
{
new InTest();
}
public static void main(String args[])
{
TagBean bb=new TagBean();
bb.test();
}
}
package beyondx;
public class TagBean {
private String name="luffyke";
private class InTest
{
public InTest()
{
System.out.println(name);
}
}
public void test()
{
new InTest();
}
public static void main(String args[])
{
TagBean bb=new TagBean();
bb.test();
}
}
看上面name这个变量是在TagBean里面定义的私有变量。这个变量在内部类中可以无条件地访问System.out.println(name);
3.可以实现多重继承
这个特点非常重要,个人认为它是内部类存在的最大理由之一。正是由于他的存在使得Java的继承机制更加完善。大家都知道Java只能继承一个类,它的多重继承在我们没有学习内部类之前是用接口来实现的。但使用接口有时候有很多不方便的地方。比如我们实现一个接口就必须实现它里面的所有方法。而有了内部类就不一样了。它可以使我们的类继承多个具体类或抽象类。大家看下面的例子。
类一
Java代码
package beyondx;
public class Example1 {
public String name()
{
return "luffyke";
}
}
package beyondx;
public class Example1 {
public String name()
{
return "luffyke";
}
}
类二
Java代码
package beyondx;
public class Example2 {
public int age()
{
return 25;
}
}
package beyondx;
public class Example2 {
public int age()
{
return 25;
}
}
类三
Java代码
package beyondx;
public class MainExample
{
private class test1 extends Example1
{
public String name()
{
return super.name();
}
}
private class test2 extends Example2
{
public int age()
{
return super.age();
}
}
public String name()
{
return new test1().name();
}
public int age()
{
return new test2().age();
}
public static void main(String args[])
{
MainExample mi=new MainExample();
System.out.println("姓名:"+mi.name());
System.out.println("年龄:"+mi.age());
}
}
package beyondx;
public class MainExample
{
private class test1 extends Example1
{
public String name()
{
return super.name();
}
}
private class test2 extends Example2
{
public int age()
{
return super.age();
}
}
public String name()
{
return new test1().name();
}
public int age()
{
return new test2().age();
}
public static void main(String args[])
{
MainExample mi=new MainExample();
System.out.println("姓名:"+mi.name());
System.out.println("年龄:"+mi.age());
}
}
大家注意看类三,里面分别实现了两个内部类 test1,和test2 ,test1类又继承了Example1,test2继承了Example2,这样我们的类三MainExample就拥有了Example1和Example2的方法和属性,也就间接地实现了多继承。
四、 避免修改接口而实现同一个类中两种同名方法的调用。
大家假想一下如果,你的类要继承一个类,还要实现一个接口,可是你发觉你继承的类和接口里面有两个同名的方法怎么办?你怎么区分它们??这就需要我们的内部类了。看下面的代码
接口
Java代码
package beyondx;
public interface Incrementable
{
void increment();
}
package beyondx;
public interface Incrementable
{
void increment();
}
类 MyIncrement
Java代码
package beyondx;
public class MyIncrement {
public void increment()
{
System.out.println("Other increment()");
}
static void f(MyIncrement f)
{
f.increment();
}
}
package beyondx;
public class MyIncrement {
public void increment()
{
System.out.println("Other increment()");
}
static void f(MyIncrement f)
{
f.increment();
}
}
大家看上面加黑的部分,两个方法都是一样的。在看下面这个类要继承这两个类
如果不用内部类
Java代码
package beyondx;
public class Callee2 extends MyIncrement implements Incrementable
{
public void increment()
{
//代码
}
}
package beyondx;
public class Callee2 extends MyIncrement implements Incrementable
{
public void increment()
{
//代码
}
}
想问一下大家increment()这个方法是属于覆盖MyIncrement这里的方法呢?还是Incrementable这里的方法。我怎么能调到MyIncrement这里的方法?显然这是不好区分的。而我们如果用内部类就很好解决这一问题了。看下面代码
Java代码
package beyondx;
public class Callee2 extends MyIncrement
{
private int i=0;
private void incr()
{
i++;
System.out.println(i);
}
private class Closure implements Incrementable
{
public void increment()
{
incr();
}
}
Incrementable getCallbackReference()
{
return new Closure();
}
}
package beyondx;
public class Callee2 extends MyIncrement
{
private int i=0;
private void incr()
{
i++;
System.out.println(i);
}
private class Closure implements Incrementable
{
public void increment()
{
incr();
}
}
Incrementable getCallbackReference()
{
return new Closure();
}
}
我们可以用内部类来实现接口,这样就不会与外围类的方法冲突了。
【转载地址】
http://www.360doc.com/content/10/0515/11/1040993_27691263.shtml
发表评论
-
个人草稿使用
2017-08-19 09:02 0深入理解JVM: http://www.cnblogs.co ... -
Thread.setDaemon详解
2015-04-24 21:31 904java中线程分为两种类型:用户线程和守护线程。通过Threa ... -
怎么使用 ConcurrentHashMap 才能是线程安全的?
2015-04-13 11:54 1508public class test { public ... -
21,tomcat关闭钩子
2014-12-31 10:36 727在很多环境下,在关闭应用程序的时候需要做一些清理工作。问题在于 ... -
Java NIO使用及原理分析 (一) 【转载】
2014-10-24 00:04 490【转载】: http://blog.csdn.net/wuxi ... -
Java 两个集合取交集
2014-10-14 21:16 3136public static Set intersectionS ... -
Calendar类roll和add的区别
2014-10-10 22:28 495import java.text.SimpleDateForm ... -
Gson通过借助TypeToken获取泛型参数的类型的方法
2014-09-30 00:26 631[size=medium]最近在使用Goo ... -
HashMap的遍历效率讨论
2014-09-27 20:41 834经常遇到对HashMap中的key和value值对的遍历操作, ... -
Java 泛型
2014-06-26 12:44 858关键字说明 ? 通配符类型 <? extends T&g ... -
Java泛型集合的理解
2014-06-26 00:05 508[size=medium]什么是泛型? 泛型(Generic ... -
关于java字节码框架ASM的学习
2014-06-19 19:22 891一、什么是ASM ASM是一个java字节码操纵框架, ... -
Java动态代理详解
2014-06-19 17:41 862Java动态代理详解: http: ... -
Java内存,字符串文章收集
2014-06-18 16:24 733java--String常量池问题的几个例子 . http:/ ... -
Java内存解析
2014-06-18 11:48 780栈、堆、常量池等虽同 ... -
Java的堆与非堆内存
2014-01-07 10:59 720堆(Heap)和非堆(Non-heap)内存 按照官方的说法: ... -
JMX 资料收集
2014-01-07 10:53 461JavaSky的专栏 http://blog.csdn.net ... -
JAVA 注解示例 详解
2013-11-12 09:36 826注解(Annotation) 为我们在代码中天界信息提供了 ... -
Java 泛型详解
2013-11-11 22:35 822http://www.360doc.com/content/1 ... -
Java中的Enum的使用与分析
2013-11-09 12:49 822enum枚举类型:在实际问 ...
相关推荐
- Java中存在静态嵌套类(Static Nested Class)和非静态内部类(Non-static Inner Class)。主要区别在于,静态嵌套类不依赖于外部类的实例,而内部类则可以访问外部类的私有成员。此外,静态嵌套类在编译时会被...
这里不仅有Java基础知识的详细介绍,还有高级特性的深入解析,是Java开发者深入了解Java内部机制的首选之地。 ### 2. CN-Java 网址:http://www.cn-java.com/ CN-Java是一个专注于Java技术的中文社区,提供了丰富...
JavaEye新闻月刊2009年3月第13期内容涉及了当时软件开发领域内的一系列重要话题,包括IBM拟收购Sun Microsystems公司的新闻报道、Java社区对此的看法以及各种编程语言、开发工具和技术的新动态。 首先,新闻月刊...
每个可执行的Java程序必须包含一个主类,该类中有`public static void main(String[] args)`方法作为入口点。 #### 二、Java语法基础 - **关键字与保留字**: - **关键字**:Java语言中具有特定意义的词汇,例如`...
在学习BCEL时,我们可以参考"Java 编程的动态性,第 7 部分 用 BCEL 设计字节码 - - JavaEye技术网站.mht"这篇文章。这篇文章会详细讲解如何使用BCEL来分析和生成Java字节码。通过实例,我们可以了解如何加载已有的...
根据2010年10月的TIOBE编程语言排行榜显示,尽管Java仍然保持着其在编程语言中的领先地位,但其市场份额的波动表明了Java生态系统内部存在着一定的不稳定性。这种不稳定性可能源于多个方面,例如新兴语言的竞争、...
Javaeye创始人分享的这份“java缓存技术深入剖析”旨在帮助开发者更好地理解和应用缓存机制。以下是对该主题的详细阐述: 一、缓存的基本概念 缓存是一种存储技术,用于临时存储常用数据,以减少对主存储器(如硬盘...
标题中的“好久没有来JavaEye了,再回来看看老朋友”可能是指作者很久没访问过JavaEye这个平台,现在回归并分享一些与Java相关的技术知识或经验。JavaEye是一个曾经非常活跃的Java开发者社区,这里汇聚了大量的Java...
Java Eye Communicator的源码开放,意味着用户可以自由查看、修改和学习其内部实现机制,这对于开发者而言是一个宝贵的学习资源,可以借此提升自身的编程技能,同时也能根据项目需求进行定制化开发。 “工具”标签...
文件名中的“bluestar”可能是一个作者或贡献者的别名,而“JavaEye技术网站”则可能是一个讨论技术问题的社区论坛。 总结来说,`jmap`、`jstat`和`jconsole`是Java性能诊断的重要工具,它们能够帮助我们有效地监控...
JavaEye论坛是一个知名的Java技术交流平台,这意味着庖丁解牛工具可能有深厚的Java技术背景,开发者可以在这里找到相关的技术支持和社区资源。 综上所述,庖丁解牛2_0_0版本的发布对于企业级中文分词应用是一次重要...
【标签】:“源码”意味着讨论可能深入到C3P0和Hibernate的内部实现,包括它们的工作原理、关键类和方法。而“工具”标签则暗示可能涉及的是实际开发中的应用和配置步骤,比如如何在项目中引入C3P0库,以及如何在IDE...
- 分享了Facebook内部使用Hadoop的经验和技术挑战。 2. **LexemeTech博客**:`http://www.lexemetech.com/2007/09/java-servlet-for-thrift.html` - 介绍了如何在Hadoop环境中使用Thrift进行RPC通信。 3. **...
"oracle字符集的更改 - Java-Jinguo - JavaEye技术网站.htm"这篇文章可能详细介绍了Oracle字符集的更改步骤。在Oracle中,字符集决定了数据库能支持哪些字符,包括ASCII、Unicode等。更改字符集涉及到多个层面,如...
1. "TOMCAT中配置JNDIRealm实现用户认证 - Tomahawk - JavaEye技术网站.mht" 这个文件可能包含一个关于如何在 Apache Tomcat 服务器中配置 JNDI Realm 来利用 LDAP 进行用户认证的教程。JNDI (Java Naming and ...
【学习笔记】这篇压缩包包含了多个关于IT领域的学习...这些资料覆盖了从Web前端到后端Java开发的多个方面,对于提升IT技能和理解相关技术有极大帮助。无论是初学者还是经验丰富的开发者,都能从中获得有价值的知识。
其内部采用了独特的“正向迭代最细粒度切分算法”,能够在不影响准确性的前提下实现高速处理,速度可达50万字/秒。此外,该工具包还采用了多子处理器分析模式,能够支持多种类型的分词处理,包括但不限于: - 英文...