- 浏览: 988518 次
- 性别:
- 来自: 上海
文章分类
- 全部博客 (1441)
- 软件思想&演讲 (9)
- 行业常识 (250)
- 时时疑问 (5)
- java/guava/python/php/ruby/R/scala/groovy (213)
- struct/spring/springmvc (37)
- mybatis/hibernate/JPA (10)
- mysql/oracle/sqlserver/db2/mongdb/redis/neo4j/GreenPlum/Teradata/hsqldb/Derby/sakila (268)
- js/jquery/jqueryUi/jqueryEaseyUI/extjs/angulrJs/react/es6/grunt/zepto/raphael (81)
- ZMQ/RabbitMQ/ActiveMQ/JMS/kafka (17)
- lucene/solr/nuth/elasticsearch/MG4J (167)
- html/css/ionic/nodejs/bootstrap (19)
- Linux/shell/centos (56)
- cvs/svn/git/sourceTree/gradle/ant/maven/mantis/docker/Kubernetes (26)
- sonatype nexus (1)
- tomcat/jetty/netty/jboss (9)
- 工具 (17)
- ETL/SPASS/MATLAB/RapidMiner/weka/kettle/DataX/Kylin (11)
- hadoop/spark/Hbase/Hive/pig/Zookeeper/HAWQ/cloudera/Impala/Oozie (190)
- ios/swift/android (9)
- 机器学习&算法&大数据 (18)
- Mesos是Apache下的开源分布式资源管理框架 (1)
- echarts/d3/highCharts/tableau (1)
- 行业技能图谱 (1)
- 大数据可视化 (2)
- tornado/ansible/twisted (2)
- Nagios/Cacti/Zabbix (0)
- eclipse/intellijIDEA/webstorm (5)
- cvs/svn/git/sourceTree/gradle/jira/bitbucket (4)
- jsp/jsf/flex/ZKoss (0)
- 测试技术 (2)
- splunk/flunm (2)
- 高并发/大数据量 (1)
- freemarker/vector/thymeleaf (1)
- docker/Kubernetes (2)
- dubbo/ESB/dubboX/wso2 (2)
最新评论
内部类详解
1、定义
一个类的定义放在另一个类的内部,这个类就叫做内部类。
Java代码 复制代码 收藏代码
1.public class First {
2.public class Contents{
3. public void f(){
4. System.out.println("In Class First's inner Class Contents method f()");
5. }
6.}
7. }
像这样的,Contents就叫做内部类
内部类了解外围类,并能与之通信(后面详细讲)
2、链接到外围类
创建了内部类对象时,它会与创造它的外围对象有了某种联系,于是能访问外围类的所有成员,不需任何特殊条件。
Java代码 复制代码 收藏代码
1. public class First {
2.public class Contents{
3. public void getStr(){
4. System.out.println("First.str="+str);
5. }
6.}
7.private String str;
8. }
9.
在内部类Contents中,可以使用外围类First的字段str。
那么,它是如何实现的呢?
是这样的,用外围类创建内部类对象时,此内部类对象会秘密的捕获一个指向外围类的引用,于是,可以通过这个引用来访问外围类的成员。
通常,这些都是编译器来处理,我们看不到,也不用关心这个。
正是因为如此,我们创建内部类对象时,必须与外围类对象相关联。
注:嵌套类(后面会讲到)除外。
3、使用关键字.this与.new
内部类中得到当前外围类对象的引用,可以使用.this关键字,注意与new的区别
Java代码 复制代码 收藏代码
1. private int num ;
2.public Test2(){
3.
4.}
5.
6.public Test2(int num){
7. this.num = num;
8.}
9.
10.private class Inner{
11. public Test2 getTest2(){
12. return Test2.this;
13. }
14.
15. public Test2 newTest2(){
16. return new Test2();
17. }
18.}
19.
20.public static void main(String [] args){
21. Test2 test = new Test2(5);
22. Test2.Inner inner = test.new Inner();
23. Test2 test2 = inner.getTest2();
24. Test2 test3 = inner.newTest2();
25. System.out.println(test2.num);
26. System.out.println(test3.num);
27.}
28.
输出结果为5 0
使用.this后,得到时创建该内部类时使用的外围类对象的引用,new则是创建了一个新的引用。
.new关键字
如果想直接创建一个内部类对象,而不是通过外围类对象的方法来得到,可以使用.new关键字
形式是这样的:
Java代码 复制代码 收藏代码
1.OutClass.InnerClass obj = outClassInstance.new InnerClass();
必须是外围类对象.new,而不能是外围类.new
Java代码 复制代码 收藏代码
1. public class First {
2.public class Contents{
3. public void f(){
4. System.out.println("In Class First's inner Class Contents method f()");
5. }
6. public void getStr(){
7. System.out.println("First.str="+str);
8. }
9.}
10.
11.public static void main(String [] args){
12. First first = new First();
13. First.Contents contents = first.new Contents();
14. contents.f();
15.}
16. }
17.
必须通过外围类First的对象first来创建一个内部类的对象
而且需要注意的是,在创建外围类对象之前,不可能创建内部类的对象(嵌套类除外)。
4、内部类与向上转型
将内部类向上转型为基类型,尤其是接口时,内部类就有了用武之地。
Java代码 复制代码 收藏代码
1. public interface Shape {
2.public void paint();
3. }
4. public class Painter {
5.
6. private class InnerShape implements Shape{
7. public void paint(){
8. System.out.println("painter paint() method");
9. }
10.}
11.
12.public Shape getShape(){
13. return new InnerShape();
14.}
15.
16. public static void main(String []args){
17. Painter painter = new Painter();
18. Shape shape = painter. getShape();
19. shape.paint();
20.}
21. }
22.
此时,内部类是private的,可以它的外围类Painter以外,没人能访问。
这样,private内部类给累的设计者提供了一种途径,通过这种方式可以完全阻止任何依赖于类型的编码,并完全隐藏实现的细节。
5、方法内的类
可以在方法内创建一个类。
Java代码 复制代码 收藏代码
1.public void test(){
2.ass Inner{
3. public void method(){
4.ystem.out.println("在方法内创建的类");
5. }
6.
7.}
值得注意的是:方法内创建的类,不能加访问修饰符。
另外,方法内部的类也不是在调用方法时才会创建的,它们一样也被编译了(怎么知道的?后面会有讲解)。
6、匿名内部类
Java代码 复制代码 收藏代码
1. public class Painter {
2.ublic Shape getShape(){
3.return new Shape(){
4. public void paint(){
5. System.out.println("painter paint() method");
6. }
7.};
8.
9. public static void main(String [] args){
10. Painter painter = new Painter();
11. Shape shape = painter.getShape();
12. shape.paint();
13. }
14. }
15. public interface Shape {
16.ublic void paint();
17. }
注意,匿名内部类后面的分号不可缺少!
匿名类,顾名思义,就是没有名称。
getShape()方法里,就使用了匿名内部类。
看上去很奇怪,不符合传统的写法?
第一眼看上去确实是这样的。
这样写,意思是创建了一个实现了Shape的匿名类的对象。
匿名类可以创建,接口,抽象类,与普通类的对象。创建接口时,必须实现接口中所有方法。
这是无参的,如果需要参数呢?
可以直接传。
Java代码 复制代码 收藏代码
1. public class B {
2.public A getA(int num){
3. return new A(num){
4.
5. };
6.}
7. }
8. public class A {
9.private int num;
10.public A(int num){
11. this.num = num;
12.}
13.public A(){
14.
15.}
16. }
17.
Ok,在这个例子中,可以为A的构造方法传入一个参数。在匿名内部类中,并没有使用到这个参数。
如果使用到了这个参数,那么这个参数就必须是final的。
Java代码 复制代码 收藏代码
1. public class B {
2.public A getA(final int num){
3. return new A(num){
4. public int getNum(){
5. return num;
6. }
7. };
8.}
9. }
10. public class A {
11.private int num;
12.public A(int num){
13. this.num = num;
14.}
15.public A(){
16.
17.}
18. }
19.
如果不是final的,编译器就会提示出错。
另外,还可以在匿名内部类里定义属性
由于类是匿名的,自然没有构造器,如果想模仿构造器,可以采用实例初始化({})
Java代码 复制代码 收藏代码
1. public A getA(){
2.return new A(){
3. int num = 0;
4. String str;
5. {
6. str = "javaeye";
7. System.out.println("hello robbin");
8. }
9.};
10. }
11.
匿名内部类通过实例初始化,可以达到类似构造器的效果~
另外可以通过匿名内部类来改造工厂方法。
Java代码 复制代码 收藏代码
1. public interface Service {
2.public void method1();
3. }
4. public interface ServiceFactory {
5.Service getService();
6. }
7. public class Implemention1 implements Service{
8.public void method1(){
9. System.out.println("In Implemention1 method method1()");
10.}
11.
12.public static ServiceFactory factory = new ServiceFactory(){
13. public Service getService(){
14. return new Implemention1();
15. }
16.};
17. }
18. public class Implemention2 implements Service {
19.public void method1(){
20. System.out.println("in Implemention2 method method1()");
21.}
22.
23.public static ServiceFactory factory = new ServiceFactory(){
24. public Service getService(){
25. return new Implemention2();
26. }
27.};
28.
29. }
30. public class Test {
31.public static void main(String []args){
32. service(Implemention1.factory);
33. service(Implemention2.factory);
34.
35. ServiceFactory factory1 = Implemention1.factory;
36. Service service1 = factory1.getService();
37. service1.method1();
38.
39. ServiceFactory factory2 = Implemention1.factory;
40. Service service2 = factory2.getService();
41. service2.method1();
42.}
43. }
在Implemention1和2中匿名内部类用在字段初始化地方。
这样定义的工厂方法,代码上看起来是不是优雅一些?
7、嵌套类
static的内部类就叫做嵌套类
前面提到了很多次,嵌套类是个例外
使用嵌套类时有两点需要注意:
a、创建嵌套类对象时,不需要外围类
b、在嵌套类中,不能像普通内部类一样访问外围类的非static成员
Java代码 复制代码 收藏代码
1. public class StaticClass {
2.private int num;
3.private static int sum = 2;
4.private static class StaticInnerClass{
5. public int getNum(){
6. //只能访问sum,不能访问num
7. return sum;
8. }
9.}
10. }
11. public class Test {
12.public static void main(String [] args){
13. //可以直接通过new来创建嵌套类对象
14. StaticClass.StaticInnerClass inner = new StaticClass.StaticInnerClass();
15. inner.getNum();
16.}
17. }
另外,嵌套类还有特殊之处,就是嵌套类中可以有static方法,static字段与嵌套类,而普通内部类中不能有这些。
8、内部类标识符
我们知道每个类会产生一个.class文件,文件名即为类名
同样,内部类也会产生这么一个.class文件,但是它的名称却不是内部类的类名,而是有着严格的限制:外围类的名字,加上$,再加上内部类名字。
前面说到得定义在方法内的内部类,不是在调用方法时生成,而是与外围类一同编译,就可以通过查看.class文件的方式来证明。
9、为何要内部类?
a、内部类提供了某种进入外围类的窗户。
b、也是最吸引人的原因,每个内部类都能独立地继承一个接口,而无论外围类是否已经继承了某个接口。
因此,内部类使多重继承的解决方案变得更加完整。
在项目中,需要多重继承,如果是两个接口,那么好办,接口支持多重继承。
如果是两个类呢?这时只有使用内部类了。
Java代码 复制代码 收藏代码
1. public interface One {
2.public void inOne();
3. }
4. public interface Two {
5.public void inTwo();
6. }
7. //两个接口,用普通类就可实现多重继承
8. public class CommonClass implements One,Two {
9.public void inOne(){
10. System.out.println("CommonClass inOne() method");
11.}
12.
13.public void inTwo(){
14. System.out.println("CommonClass inTwo() method");
15.}
16. }
17. public abstract class Three {
18.public abstract void inThree();
19. }
20. public abstract class Four {
21.public abstract void inFour();
22. }
23. //两个抽象类,使用普通类无法实现多重继承
24.
25. //使用内部类可以实现
26. public class Contents extends Three {
27.public void inThree(){
28. System.out.println("In Contents inThress() method");
29.}
30.
31.public class InnerFour extends Four{
32. public void inFour(){
33. System.out.println("In Contents");
34. }
35.
36.}
37. }
38.
另外,还有好多地方可以使用内部类。读过hibernate源代码的同学,应该可以发现,里面有好多内部类。
最常见的内部类,应该是Map.Entry了,可以看看源代码~
总结:
内部类的特性大致就是上述了,特性很直观,了解了之后,使用也很简单。
但是,何时使用我说的并不是很明确,因为本人知识有限,使用内部类也不是很多。项目中很少用,好像就是ActiveMQ那里用了一些。
1、定义
一个类的定义放在另一个类的内部,这个类就叫做内部类。
Java代码 复制代码 收藏代码
1.public class First {
2.public class Contents{
3. public void f(){
4. System.out.println("In Class First's inner Class Contents method f()");
5. }
6.}
7. }
像这样的,Contents就叫做内部类
内部类了解外围类,并能与之通信(后面详细讲)
2、链接到外围类
创建了内部类对象时,它会与创造它的外围对象有了某种联系,于是能访问外围类的所有成员,不需任何特殊条件。
Java代码 复制代码 收藏代码
1. public class First {
2.public class Contents{
3. public void getStr(){
4. System.out.println("First.str="+str);
5. }
6.}
7.private String str;
8. }
9.
在内部类Contents中,可以使用外围类First的字段str。
那么,它是如何实现的呢?
是这样的,用外围类创建内部类对象时,此内部类对象会秘密的捕获一个指向外围类的引用,于是,可以通过这个引用来访问外围类的成员。
通常,这些都是编译器来处理,我们看不到,也不用关心这个。
正是因为如此,我们创建内部类对象时,必须与外围类对象相关联。
注:嵌套类(后面会讲到)除外。
3、使用关键字.this与.new
内部类中得到当前外围类对象的引用,可以使用.this关键字,注意与new的区别
Java代码 复制代码 收藏代码
1. private int num ;
2.public Test2(){
3.
4.}
5.
6.public Test2(int num){
7. this.num = num;
8.}
9.
10.private class Inner{
11. public Test2 getTest2(){
12. return Test2.this;
13. }
14.
15. public Test2 newTest2(){
16. return new Test2();
17. }
18.}
19.
20.public static void main(String [] args){
21. Test2 test = new Test2(5);
22. Test2.Inner inner = test.new Inner();
23. Test2 test2 = inner.getTest2();
24. Test2 test3 = inner.newTest2();
25. System.out.println(test2.num);
26. System.out.println(test3.num);
27.}
28.
输出结果为5 0
使用.this后,得到时创建该内部类时使用的外围类对象的引用,new则是创建了一个新的引用。
.new关键字
如果想直接创建一个内部类对象,而不是通过外围类对象的方法来得到,可以使用.new关键字
形式是这样的:
Java代码 复制代码 收藏代码
1.OutClass.InnerClass obj = outClassInstance.new InnerClass();
必须是外围类对象.new,而不能是外围类.new
Java代码 复制代码 收藏代码
1. public class First {
2.public class Contents{
3. public void f(){
4. System.out.println("In Class First's inner Class Contents method f()");
5. }
6. public void getStr(){
7. System.out.println("First.str="+str);
8. }
9.}
10.
11.public static void main(String [] args){
12. First first = new First();
13. First.Contents contents = first.new Contents();
14. contents.f();
15.}
16. }
17.
必须通过外围类First的对象first来创建一个内部类的对象
而且需要注意的是,在创建外围类对象之前,不可能创建内部类的对象(嵌套类除外)。
4、内部类与向上转型
将内部类向上转型为基类型,尤其是接口时,内部类就有了用武之地。
Java代码 复制代码 收藏代码
1. public interface Shape {
2.public void paint();
3. }
4. public class Painter {
5.
6. private class InnerShape implements Shape{
7. public void paint(){
8. System.out.println("painter paint() method");
9. }
10.}
11.
12.public Shape getShape(){
13. return new InnerShape();
14.}
15.
16. public static void main(String []args){
17. Painter painter = new Painter();
18. Shape shape = painter. getShape();
19. shape.paint();
20.}
21. }
22.
此时,内部类是private的,可以它的外围类Painter以外,没人能访问。
这样,private内部类给累的设计者提供了一种途径,通过这种方式可以完全阻止任何依赖于类型的编码,并完全隐藏实现的细节。
5、方法内的类
可以在方法内创建一个类。
Java代码 复制代码 收藏代码
1.public void test(){
2.ass Inner{
3. public void method(){
4.ystem.out.println("在方法内创建的类");
5. }
6.
7.}
值得注意的是:方法内创建的类,不能加访问修饰符。
另外,方法内部的类也不是在调用方法时才会创建的,它们一样也被编译了(怎么知道的?后面会有讲解)。
6、匿名内部类
Java代码 复制代码 收藏代码
1. public class Painter {
2.ublic Shape getShape(){
3.return new Shape(){
4. public void paint(){
5. System.out.println("painter paint() method");
6. }
7.};
8.
9. public static void main(String [] args){
10. Painter painter = new Painter();
11. Shape shape = painter.getShape();
12. shape.paint();
13. }
14. }
15. public interface Shape {
16.ublic void paint();
17. }
注意,匿名内部类后面的分号不可缺少!
匿名类,顾名思义,就是没有名称。
getShape()方法里,就使用了匿名内部类。
看上去很奇怪,不符合传统的写法?
第一眼看上去确实是这样的。
这样写,意思是创建了一个实现了Shape的匿名类的对象。
匿名类可以创建,接口,抽象类,与普通类的对象。创建接口时,必须实现接口中所有方法。
这是无参的,如果需要参数呢?
可以直接传。
Java代码 复制代码 收藏代码
1. public class B {
2.public A getA(int num){
3. return new A(num){
4.
5. };
6.}
7. }
8. public class A {
9.private int num;
10.public A(int num){
11. this.num = num;
12.}
13.public A(){
14.
15.}
16. }
17.
Ok,在这个例子中,可以为A的构造方法传入一个参数。在匿名内部类中,并没有使用到这个参数。
如果使用到了这个参数,那么这个参数就必须是final的。
Java代码 复制代码 收藏代码
1. public class B {
2.public A getA(final int num){
3. return new A(num){
4. public int getNum(){
5. return num;
6. }
7. };
8.}
9. }
10. public class A {
11.private int num;
12.public A(int num){
13. this.num = num;
14.}
15.public A(){
16.
17.}
18. }
19.
如果不是final的,编译器就会提示出错。
另外,还可以在匿名内部类里定义属性
由于类是匿名的,自然没有构造器,如果想模仿构造器,可以采用实例初始化({})
Java代码 复制代码 收藏代码
1. public A getA(){
2.return new A(){
3. int num = 0;
4. String str;
5. {
6. str = "javaeye";
7. System.out.println("hello robbin");
8. }
9.};
10. }
11.
匿名内部类通过实例初始化,可以达到类似构造器的效果~
另外可以通过匿名内部类来改造工厂方法。
Java代码 复制代码 收藏代码
1. public interface Service {
2.public void method1();
3. }
4. public interface ServiceFactory {
5.Service getService();
6. }
7. public class Implemention1 implements Service{
8.public void method1(){
9. System.out.println("In Implemention1 method method1()");
10.}
11.
12.public static ServiceFactory factory = new ServiceFactory(){
13. public Service getService(){
14. return new Implemention1();
15. }
16.};
17. }
18. public class Implemention2 implements Service {
19.public void method1(){
20. System.out.println("in Implemention2 method method1()");
21.}
22.
23.public static ServiceFactory factory = new ServiceFactory(){
24. public Service getService(){
25. return new Implemention2();
26. }
27.};
28.
29. }
30. public class Test {
31.public static void main(String []args){
32. service(Implemention1.factory);
33. service(Implemention2.factory);
34.
35. ServiceFactory factory1 = Implemention1.factory;
36. Service service1 = factory1.getService();
37. service1.method1();
38.
39. ServiceFactory factory2 = Implemention1.factory;
40. Service service2 = factory2.getService();
41. service2.method1();
42.}
43. }
在Implemention1和2中匿名内部类用在字段初始化地方。
这样定义的工厂方法,代码上看起来是不是优雅一些?
7、嵌套类
static的内部类就叫做嵌套类
前面提到了很多次,嵌套类是个例外
使用嵌套类时有两点需要注意:
a、创建嵌套类对象时,不需要外围类
b、在嵌套类中,不能像普通内部类一样访问外围类的非static成员
Java代码 复制代码 收藏代码
1. public class StaticClass {
2.private int num;
3.private static int sum = 2;
4.private static class StaticInnerClass{
5. public int getNum(){
6. //只能访问sum,不能访问num
7. return sum;
8. }
9.}
10. }
11. public class Test {
12.public static void main(String [] args){
13. //可以直接通过new来创建嵌套类对象
14. StaticClass.StaticInnerClass inner = new StaticClass.StaticInnerClass();
15. inner.getNum();
16.}
17. }
另外,嵌套类还有特殊之处,就是嵌套类中可以有static方法,static字段与嵌套类,而普通内部类中不能有这些。
8、内部类标识符
我们知道每个类会产生一个.class文件,文件名即为类名
同样,内部类也会产生这么一个.class文件,但是它的名称却不是内部类的类名,而是有着严格的限制:外围类的名字,加上$,再加上内部类名字。
前面说到得定义在方法内的内部类,不是在调用方法时生成,而是与外围类一同编译,就可以通过查看.class文件的方式来证明。
9、为何要内部类?
a、内部类提供了某种进入外围类的窗户。
b、也是最吸引人的原因,每个内部类都能独立地继承一个接口,而无论外围类是否已经继承了某个接口。
因此,内部类使多重继承的解决方案变得更加完整。
在项目中,需要多重继承,如果是两个接口,那么好办,接口支持多重继承。
如果是两个类呢?这时只有使用内部类了。
Java代码 复制代码 收藏代码
1. public interface One {
2.public void inOne();
3. }
4. public interface Two {
5.public void inTwo();
6. }
7. //两个接口,用普通类就可实现多重继承
8. public class CommonClass implements One,Two {
9.public void inOne(){
10. System.out.println("CommonClass inOne() method");
11.}
12.
13.public void inTwo(){
14. System.out.println("CommonClass inTwo() method");
15.}
16. }
17. public abstract class Three {
18.public abstract void inThree();
19. }
20. public abstract class Four {
21.public abstract void inFour();
22. }
23. //两个抽象类,使用普通类无法实现多重继承
24.
25. //使用内部类可以实现
26. public class Contents extends Three {
27.public void inThree(){
28. System.out.println("In Contents inThress() method");
29.}
30.
31.public class InnerFour extends Four{
32. public void inFour(){
33. System.out.println("In Contents");
34. }
35.
36.}
37. }
38.
另外,还有好多地方可以使用内部类。读过hibernate源代码的同学,应该可以发现,里面有好多内部类。
最常见的内部类,应该是Map.Entry了,可以看看源代码~
总结:
内部类的特性大致就是上述了,特性很直观,了解了之后,使用也很简单。
但是,何时使用我说的并不是很明确,因为本人知识有限,使用内部类也不是很多。项目中很少用,好像就是ActiveMQ那里用了一些。
发表评论
-
20180222积累
2018-02-22 09:34 4271. mybatis如何通过接口查找对应的mapper. ... -
20180208积累
2018-02-08 10:28 407临时表与永久表相似,但临时表存储在 tempdb 中,当不 ... -
行业应用
2018-01-30 16:30 436git clone的时候用上面那个IP地址,下面栏中的不能 ... -
SQLite 数据库
2018-01-29 22:57 717android: SQLite创建数据 ... -
java里面获取map的key和value的方法
2018-02-01 11:29 2074获取map的key和value的方法分为两种形式: ma ... -
Eclipse中Maven WEB工程tomcat项目添加调试以及项目发布细节记录
2018-02-23 21:11 670一、建立一个maven WEB项目 1、file-&g ... -
错误:HttpServlet was not found on the Java
2018-02-23 21:12 333我们在用Eclipse进行Java web ... -
使用 java8 实现List到Array的转换
2018-02-23 21:13 2864开发中需要调用第三方的库,有些 API 的入参要求是 do ... -
Java8 利用Lambda处理List集合
2018-01-11 09:58 5559Java 8新增的Lambda表达式,我们可以很方便地并行操 ... -
java中string与json互相转化
2018-01-11 09:40 1023在Java中socket传输数据时,数据类型往往比较难选择。 ... -
JSON 数据格式
2018-01-11 09:37 416JSON(JavaScript Object Notatio ... -
java怎么读取json格式的数据
2018-01-11 09:46 1017java可以使用JSONObject和JSONArray来操作 ... -
Java8-如何将List转变为逗号分隔的字符串
2018-01-10 10:13 1919Converting a List to a String ... -
eclipse maven 打war包的两种方式
2018-02-23 21:25 650第一种:利用pom.xml文件打包。 右键pom.xml ... -
Annotation(三)——Spring注解开发
2018-02-28 09:21 380Spring框架的核心功能IoC(Inversion o ... -
Spring自定义注解
2018-02-28 09:32 523java注解:附在代码中的一些元信息,用于在编译、运行时起 ... -
Java项目
2018-01-08 10:56 0这两种解决办法已经能完全解决问题,不过值得注意的一点是,我 ... -
解决Eclipse建立Maven项目后无法建立src/main/java资源文件夹的办法
2018-03-22 10:41 1090在Eclipse中建立好一个Maven项目后,如果Java ... -
Java @override报错的解决方法
2018-01-07 12:56 0有时候Java的Eclipse工程换一台电脑后编译总是@ove ... -
Java 8 配置Maven-javadoc-plugin
2018-01-07 09:07 978在升级JDK至1.8之后,使用Maven-javadoc- ...
相关推荐
java内部类详解共10页.pdf.zip
Java内部类详解.pdf
从Java1.1开始引入了内部类以来,它就引起了人们的激烈争论。其实任何优秀的语言特性用得不好就是滥用,内部类用得不好就会导致代码像迷宫一样,导致出现毫无重用的综合征。...本文档讲述Java内部类的规则及应用
内部类在 Java 里面算是非常常见的一个功能了,在日常开发中我们肯定多多少少都用过,这里总结一下关于 Java 中内部类的相关知识点和一些使用内部类时需要注意的点。
主要介绍了JAVA 内部类详解及实例的相关资料,需要的朋友可以参考下
java类修饰词和内部类详解java类修饰词和内部类详解
java内部类的详细应用总结,也是对java多一些了解,希望对初学java的有用,也有所启发
主要介绍了java 内部类详解及实例代码的相关资料,需要的朋友可以参考下
内部类详解--Java
主要对java中的匿名内部类的详细总结,需要的朋友可以参考下
内部类详解,帮助学习Java的同学更好的理解相关知识点。
java-内部类(InnerClass)详解.pdf
主要介绍了Java中的静态内部类详解及代码示例,具有一定参考价值,需要的朋友可以了解下。
在知识的讲解上,《Java Web开发详解——XML+DTD+XML Schema+XSLT+Servlet3.0+JSP2.2深入剖析与实例应用》采用理论与实践相结合的方式,从程序运行的内部机制进行分析讲解,并通过大量的实例和实验来验证并运用本书...
主要介绍了Java嵌套类和内部类详解,本文讲解了什么是嵌套类及内部类、静态嵌套类、在外部类中定义内部类、在方法中定义内部类、匿名内部类等内容,需要的朋友可以参考下
031301_【第13章:Java类集】_认识类集、Collection接口笔记.pdf 031302_【第13章:Java类集】_List接口笔记.pdf 031303_【第13章:Java类集】_LinkedList类笔记.pdf 031304_【第13章:Java类集】_Set接口笔记.pdf ...
JAVA CLASS内部类,嵌套类等
非常精简的匿名内部类详解