- 浏览: 1502463 次
- 性别:
- 来自: 深圳
文章分类
- 全部博客 (798)
- struts2 (42)
- servlet (20)
- quartz (4)
- jquery & ajax (24)
- tomcat (5)
- javascript (15)
- struts1 (8)
- 搜索关键字及链接 (3)
- fckeditor (3)
- Apache (5)
- spring (22)
- linux (3)
- 企业应用 (8)
- 综合应用 (13)
- 服务器 (2)
- 数据库 (85)
- 性能调优 (21)
- 网络应用 (15)
- 缓存技术 (8)
- 设计模式 (39)
- 面试题 (7)
- 程序人生&前辈程序员 (29)
- java基础 (59)
- hibernate (75)
- log4j (4)
- http (11)
- 架构设计 (28)
- 网页设计 (12)
- java邮件 (4)
- 相关工具 (11)
- ognl (7)
- 工作笔记 (18)
- 知识面扩展 (12)
- oracle异常 (1)
- 正则表达式 (2)
- java异常 (5)
- 项目实践&管理 (1)
- 专业术语 (11)
- 网站参考 (1)
- 论坛话题 (2)
- web应用 (11)
- cxf&webservice (22)
- freemarker (3)
- 开源项目 (9)
- eos (1)
- ibatis (6)
- 自定义标签 (3)
- jsp (3)
- 内部非公开文档(注意:保存为草稿) (0)
- 国内外知名企业 (2)
- 网店 (3)
- 分页 (1)
- 消费者习惯 (2)
- 每日关注 (1)
- 商业信息 (18)
- 关注商业网站 (1)
- 生活常识 (3)
- 新闻 (2)
- xml&JSON (5)
- solaris (1)
- apache.common (3)
- BLOB/CLOB (1)
- lucene (2)
- JMS (14)
- 社会进程 (8)
- SSH扩展 (2)
- 消费心理 (1)
- 珠三角 (1)
- 设计文档 (1)
- XWork&webwork (1)
- 软件工程 (3)
- 数据库及链接 (1)
- RMI (2)
- 国内外知名企业&人物 (1)
最新评论
-
司c马:
简介易懂、
OutputStream和InputStream的区别 -
在世界的中心呼喚愛:
解决我的问题
Java获取客户端的真实IP地址 -
bo_hai:
都是些基本的概念呀!
SSO -
tian_4238:
哥们,你也是搞水利这块的吧。
巧用SQLQuery中的addScalar -
loveEVERYday:
java.util.Date、java.sql.Date、java.sql.Time、java.sql.Timestamp小结
Java内部类(InnerClass)详解
静态成员类可访问外部类的任一静态字段或静态方法 像静态方法或静态字段一样,静态成员类有public/private/default权限修饰符 静态成员类不能与外部类重名 像外部类的静态方法一样,不能直接访问外部类的实例字段和实例方法 静态成员类只能定义于外部类的顶层代码或外部类其它静态成员类的顶层代码中(嵌套定义);不能定义于外部类的某个函数中。 成员类不能与外部类重名 不能在成员类中定义static字段、方法和类(static final形式的常量定义除外)。因为一个成员类实例必然与一个外部类实例关联,这个static定义完全可以移到其外部类中去 成员类不能是接口(interface)。因为成员类必须能被某个外部类实例实例化,而接口是不能实例化的。事实上,如示例代码所示,如果你以成员类的形式定义一个接口,该接口实际上是一个静态成员类,static关键字对inner interface是内含(implicit)的。 如示例代码所示,内部类只在定义它的代码段中可见,不能在它所属代码段之外的代码中使用;因此也就没有public/private/default权限修饰符(无意义) 不能以局部类形式定义一个接口。局部类只在其所属代码段中可见,定义这样的接口无意义 局部类类名不能与其外部类类名重复 该类定义代码段很短 只需要创建该类的一个实例 类的定义代码与类的使用代码紧邻 使用匿名不影响代码的易读性
//just like static method, static member class has public/private/default access privilege levels
//access privilege level: public
public static class Inner1 {
public Inner1() {
//Static member inner class can access static method of outer class
staticMethod();
//Compile error: static member inner class can not access instance method of outer class
//instanceMethod();
}
}
//access privilege level: default
static class Inner2 {
}
//access privilege level: private
private static class Inner3 {
//define a nested inner class in another inner class
public static class Inner4 {
}
}
private static void staticMethod() {
//cannot define an inner class in a method
/*public static class Inner4() {
}*/
}
private void instanceMethod() {
//private static member class can be accessed only in its outer class definition scope
Inner3 inner3 = new Inner3();
//how to use nested inner class
Inner3.Inner4 inner4 = new Inner3.Inner4();
}
}
class Test {
Outer.Inner1 inner1 = new Outer.Inner1();
//Test and Outer are in the same package, so Inner2 can be accessed here
Outer.Inner2 inner2 = new Outer.Inner2();
//Compile error: Inner3 cannot be accessed here
//Outer.Inner3 inner3 = new Outer.Inner3();
}
…;
private static class Entry<E> {
E element;
Entry<E> next;
Entry<E> previous;
Entry(E element, Entry<E> next, Entry<E> previous) {
this.element = element;
this.next = next;
this.previous = previous;
}
}
…;
}
//just like instance method, member class has public/private/default access privilege levels
private int data;
//access privilege level: public
public class Inner1 {
private int data;
private int data1;
public Inner1() {
//member class can access its outer class' instance field directly
data1 = 1;
//itself data field
data = 1;
//its outer class instance field
Outer.this.data = 1;
}
}
//access privilege level: default
class Inner2 {
//can not define static filed, method, class in member class
//static int j = 1;
//but, "static final" compound is allowed
static final int CONSTANT = 1;
}
//access privilege level: private
private class Inner3 {
public class Inner4 {
}
}
//in fact, Inner5 is not a member class but a static member class
interface Inner5 {
}
private static void staticMethod() {
//can not create a member class instance directly in outer class' static method
//Inner1 inner1 = new Inner1();
}
private void instanceMethod() {
//can create a member class instance in outer class' instance method
Inner1 inner1 = new Inner1();
}
}
class Test {
public Test() {
//cannot create member class instance directly in class other than outer class
//Outer.Inner2 inner2 = new Outer.Inner2();
//create a member class instance outside it's outer class
Outer outer = new Outer();
Outer.Inner1 inner1 = outer.new Inner1();
}
}
private class Itr implements Iterator<E> {
………;
}
public Iterator<E> iterator() {
return new Itr();
}
}
private int instanceField;
private static int staticField;
//define a local member class in instance code block
{
int localVirable1 = 0;
final int localVirable2 = 1;
class Inner1 {
public Inner1() {
//can access its outer class' field and method directly
instanceField = 1;
//use OuterClass.this to get its corresponding outer class instance
Outer.this.instanceField = 1;
//can not access the not final local virable in its containing code block
//System.out.print(localVirable1);
//can access the final local virable in its containing code block
System.out.print(localVirable2);
}
}
//local class can not have privilege modifier
/*public class inner2 {
}*/
}
// define a local static member class in static code block
static {
class Inner2 {
public Inner2() {
staticField = 1;
//can not access instance field and method in a local static member class
//intanceField = 2;
}
}
}
public void intanceMethod() {
//define a local class in its out class' instance method
class Inner3 {
}
//local class is visible only in its containning code block
//Outer.Inner2 inner2;
}
private static void staticMethod() {
//define a local static member class in its out class' static method
class Inner4 {
public Inner4() {
staticField = 2;
}
}
//can not define a interface as a local class
/*interface I {
}*/
}
}
public void instanceMethod() {
//define a nonymous class which implements Action interface and creat an instance of it
Action action = new Action() {
public void doAction() {
System.out.println("a simple anonymous class demo");
}};
action.doAction();
//define a nonoymous class which extends BaseClass and create an instance of it
new BaseClass(5) {
public void printData(){
System.out.println("data = " + getData());
}
}.printData(); //"data = 5" will be outputed
}
}
interface Action {
void doAction();
}
class BaseClass {
private int data;
public BaseClass (int data) {
this.data = data;
}
public int getData() {
return data;
}
}
new class-name ( [ argument-list ] ) { class-body }
new interface-name () { class-body }
// Now call the list() method with a single FilenameFilter argument
// Define and instantiate an anonymous implementation of FilenameFilter
// as part of the method invocation expression.
String[] filelist = f.list(new FilenameFilter() {
public boolean accept(File f, String s) { return s.endsWith(".java"); }
}); // Don't forget the parenthesis and semicolon that end the method call!
相关推荐
可以通过"OuterClass.InnerClass"的方式引用静态成员类,如`new Outer.Inner1()`。 6. **使用场景** - 当需要创建一个与外部类紧密相关的辅助类,并且希望这个类在没有外部类实例的情况下也能存在时,可以使用...
Java 内部类详解 Java 内部类是一种高级特性,允许在一个类的定义内部创建另一个类。这种设计模式提供了更灵活的代码组织方式,同时还可以实现特定的封装和访问控制。内部类主要分为四种类型:静态内部类、成员内部...
### Java内部类详解 #### 一、嵌套类概述 在Java编程中,嵌套类是一种重要的面向对象设计工具,它允许程序员在一个类的内部定义另一个类。这种特性极大地增强了Java语言的灵活性和封装能力。 #### 二、嵌套类分类...
Java内部类是Java语言中一个独特且强大的特性,它允许在一个类的定义内定义另一个类。内部类可以分为四种类型:成员内部类、局部内部类、匿名内部类和静态内部类。下面我们将深入探讨内部类的使用方法和优势。 首先...
在Java编程语言中,内部类(也称为嵌套类)是一种强大的工具,它可以提高代码的组织性和可读性。内部类可以直接访问外部类的所有成员,包括私有(private)成员,这使得它们在处理封装和实现特定逻辑时非常有用。...
Java内部类详解 Java内部类是Java语言中的一种特殊类别,它是指定义在另外一个类内部的类。内部类可以访问外部类的所有成员变量和方法,包括私有的变量和方法。内部类可以分为四种:成员内部类、静态嵌套类、方法...
嵌套类主要分为两大类:静态嵌套类(Static Nested Class)和非静态嵌套类(Non-static Nested Class),后者通常被称为内部类(Inner Class)。 - **静态嵌套类**:此类嵌套类被声明为`static`,因此它们与外部类...
例如,`outClassInstance.new InnerClass()`会创建一个新的`InnerClass`实例,关联到`outClassInstance`。请注意,`.new`操作必须使用外围类的实例,而不是类本身。 4. **类型和作用域**: - 静态内部类(也称为...
### Java内部类详解 在Java编程语言中,内部类(Inner Class)是一种非常重要的概念,它使得类的设计更加灵活和高效。本文将详细介绍Java内部类的相关知识点,包括其定义、分类以及应用场景等。 #### 一、Java内部...
### Java内部类(DOC)详解 #### 一、概述 Java内部类是Java语言中一个重要的概念,它指的是那些类定义被嵌套在其他类定义中的类。与之相对应的是顶层类,即那些类定义没有被嵌套在其他类中的类。内部类又可以...
### Java内部类访问规则 #### 一、内部类概述与定义原则 在Java编程中,内部类(Inner Class)是一种特殊类型的类,它被定义在另一个类(外部类)的内部。内部类的一个主要用途是在描述一个外部类的对象时能够包含...
### 浅谈Java内部类的四个应用场景 #### 一、引言 在Java语言中,内部类(Inner Class)作为一种特殊的存在,为开发者提供了更为灵活的面向对象编程方式。通过本文,我们将深入探讨Java内部类的四个典型应用场景,...
### Java内部类详解 #### 一、什么是内部类? 内部类,顾名思义,是在另一个类的内部定义的类。这种独特的结构让内部类能够访问包含它的外部类的私有成员,包括变量和方法。这为Java程序员提供了一种灵活的方式来...
### Java静态内部类(嵌套类)详解 #### 一、静态内部类概念与特性 在Java编程语言中,静态内部类(也被称为嵌套类)是一种特殊的内部类形式,它通过`static`关键字来定义。与普通内部类相比,静态内部类具有以下...
Java 内部类详解及实例 Java 内部类是一种特殊类型的类,它定义在一个类的内部。这种设计模式在 Java 中提供了许多便利,比如封装、抽象和代码复用。以下将详细介绍内部类的种类、特性以及如何使用它们。 1. 成员...
另外,在Java面试中,Anonymous Inner Class(匿名内部类)也是一个重要的知识点。匿名内部类是没有名字的内部类。不能extends(继承)其它类,但一个内部类可以作为一个接口,由另一个内部类实现。 在Java中,还有...
### Java软件开发实战:内部类与包装器 #### 8-1 内部类与包装器 ##### 内部类概述 ...以上内容涵盖了Java内部类和包装器的基础概念及其具体应用,希望能够帮助您更好地理解和掌握这些重要的Java概念。
内部类(Inner Class)自Java 1.1版本引入以来,一直是Java编程语言中的一个重要特性。它允许开发者在一个类的内部定义另一个类,这有助于更好地组织代码并实现更紧密的封装。 #### 二、内部类的分类及特点 内部类...