如果A和B类关系紧密&＃xff0c;且A类的主要作用是帮助完成B类的实现&＃xff0c;这时可将A类作为B类的内部类&＃xff0c;两个类可以互相访问各自的私有成员&＃xff0c;这样就方便B类的设计&＃xff0c;使B类更加自给自足(self contained)。http://www.tanhuanyao.com http:// tanhuanyao.com http://www.bianshayao.com/ http://bianshayao.com/这是我理解的内部类产生的原因&＃xff0c;有点类似于C&＃43;&＃43;中的友元类 A类作为B类的内部类&＃xff0c;便是B类的一份子&＃xff0c;地位上和B类的属性和方法相当&＃xff0c;此时A类便有static和非static之分了&＃xff0c;这就是为什么只有内部类的类本身才有static的说法的原因。内部类声明为static和普通类的成员为static的含义一样&＃xff0c;都是表示被声明为static的东西属于类范畴&＃xff0c;不依赖于类的具体对象。如果内部类是非static的&＃xff0c;那么这个内部类就依赖于外部类的具体对象&＃xff0c;在该内部类中可以调用外部类的非static方法&＃xff1b;如果内部类是static的&＃xff0c;即该内部类属于外部类的类范畴&＃xff0c;不依赖于外部类的具体对象&＃xff0c;那么该内部类只能调用外部类的static方法&＃xff0c;因为外部类的非static方法依赖于外部类的具体对象。这和普通类中static方法只能访问static的属性和方法的道理是一样的。那么为什么规定内部类中如果出现了static方法&＃xff0c;该内部类也必须声明为static呢&＃xff1f; 内部类中的static方法表明该方法不依赖于内部类的具体对象&＃xff0c;属于内部类的类范畴&＃xff0c;假设此时内部类为非static的&＃xff0c;那么内部类对象的产生就依赖于外部类对象&＃xff0c;有一个外部类对象&＃xff0c;才能有一个与之对应的内部类对象&＃xff0c;而内部类对象中的static方法不依赖于内部类对象&＃xff0c;所以使用该static方法便没有必要创建具体的内部类对象&＃xff0c;如果该static方法确有其存在的意义&＃xff0c;那就说明该内部类完全没有必要是非static的&＃xff0c;java规定这时该内部类必须是static的。
非静态内部类不能有静态成员&＃xff01;
成员内部类必须先实例化外部类对象然后再实例化成员内部类&＃xff1b;
非static的内部类&＃xff0c;在外部类加载的时候&＃xff0c;并不会加载它&＃xff0c;所以它里面不能有静态变量或者静态方法。
java很多想这类不能共同存在的 一般都与他们的生命周期有关。。。
比如 静态成员和静态方法是随着类的加载而存在的&＃xff0c;也就是说内部类的静态属性是随着类的加载的&＃xff0c;但是内部类的实例 是创建后才存在的&＃xff0c;也就是说其静态属性优先存在于他的类实例的存在 这显然是矛盾的&＃xff0c;所以要把内部类设为静态的 这样他们的生命周期就是相同了&＃xff1b;
如果内部类没有static的话&＃xff0c;就需要实例化内部类才能调用&＃xff0c;说明非static的内部类不是自动跟随主类加载的&＃xff0c;而是被实例化的时候才会加载。
而static的语义&＃xff0c;就是主类能直接通过内部类名来访问内部类中的static方法&＃xff0c;而非static的内部类又是不会自动加载的&＃xff0c;所以这时候内部类也要static&＃xff0c;否则会前后冲突。
java中普通的顶级类是不能使用static关键字修饰的。
只有内部类可以使用static修饰&＃xff0c;或者不使用staitc关键字修饰。
// 顶层类A不能用static修饰
public class A{// 普通内部类B, 可以不用static修饰public class B{ }// 普通内部类C, 也可以用static修饰public static class C{ }}
1、静态内部类&＃xff08;static修饰的内部类&＃xff09;没有对外部类的引用&＃xff0c;所以静态内部类只能访问外部类的静态属性或方法。并且在初始化的时候可以单独存在&＃xff0c;例如&＃xff1a;
StaticClass staticClass &＃61; new StaticClass();
或者&＃xff1a;
Users.StaticClass staticClass2 &＃61; new Users.StaticClass()
二种方式初始化&＃xff0c;建议使用第二种初始化方法&＃xff0c;比较清晰。
2、普通内部类有对外部类的引用&＃xff0c;所以普通内部类不能独立存在&＃xff0c;初始化的时候必须通过外部类的实例。
并且普通内部类可以直接访问外部类的普通属性和函数&＃xff08;包括私有的属性和函数&＃xff09;同时也能访问外部类的静态属性和函数。
普通内部类的实例化如下&＃xff1a;
Users.CommonClass commonClass &＃61; new Users().new CommonClass();
或者&＃xff1a;
Users users &＃61; new Users();
Users.CommonClass commonClass2 &＃61; users.new CommonClass();
public class Outer{int x;class Inner{static int a &＃61; 0;//这样写是不合法的.static final int b&＃61;0;//这样写是合法的}
}
java类加载顺序&＃xff0c;首先加载类&＃xff0c;执行static变量初始化&＃xff0c;接下来执行对象的创建&＃xff0c;如果我们要执行代码中的变量int a 初始化&＃xff0c;那么必须先执行加载外部类&＃xff0c;再加载内部类&＃xff0c;最后初始化静态变量 a ,问题就出在加载内部类上面&＃xff0c;我们可以把内部类看成外部类的非静态成员&＃xff0c;它的初始化必须在外部类对象创建后以后进行&＃xff0c;要加载内部类必须在实例化外部类之后完成 &＃xff0c;java虚拟机要求所有的静态变量必须在对象创建之前完成&＃xff0c; 这样便产生了矛盾。
将class Inner看作外部类的非静态成员&＃xff0c;它属于对象Outer&＃xff08;即new 出来的Outer()&＃xff09;,static int a 属于类Inner 所以先于对象Inner Outer创建出来&＃xff0c;矛盾
而java常量放在内存中常量池&＃xff0c;它的机制与变量是不同的&＃xff0c;编译时&＃xff0c;加载常量是不需要加载类的&＃xff0c;所以就没有上面那种矛盾。
静态的东西需要在编译时分配内存&＃xff0c;而非静态内部类是在实例化的时候才分配内存。所以现在的情况就是有了东西没地方放 static int a 没地方放&＃xff0c;因为class Inner还没有实例化
提起Java内部类&＃xff08;Inner Class&＃xff09;可能很多人不太熟悉&＃xff0c;实际上类似的概念在C&＃43;&＃43;里也有&＃xff0c;那就是嵌套类&＃xff08;Nested Class&＃xff09;&＃xff0c;关于这两者的区别与联系&＃xff0c;在下文中会有对比。内部类从表面上看&＃xff0c;就是在类中又定义了一个类&＃xff08;下文会看到&＃xff0c;内部类可以在很多地方定义&＃xff09;&＃xff0c;而实际上并没有那么简单&＃xff0c;乍看上去内部类似乎有些多余&＃xff0c;它的用处对于初学者来说可能并不是那么显著&＃xff0c;但是随着对它的深入了解&＃xff0c;你会发现Java的设计者在内部类身上的确是用心良苦。学会使用内部类&＃xff0c;是掌握Java高级编程的一部分&＃xff0c;它可以让你更优雅地设计你的程序结构。下面从以下几个方面来介绍&＃xff1a;
public interface Contents {int value();
}
public interface Destination {String readLabel();
}
public class Goods {private class Content implements Contents {private int i &＃61; 11;public int value() {return i;}}protected class GDestination implements Destination {private String label;private GDestination(String whereTo) {label &＃61; whereTo;}public String readLabel() {return label;}}public Destination dest(String s) {return new GDestination(s);}public Contents cont() {return new Content();}
}
class TestGoods {public static void main(String[] args) {Goods p &＃61; new Goods();Contents c &＃61; p.cont();Destination d &＃61; p.dest("Beijing");}
}
在这个例子里类Content和GDestination被定义在了类Goods内部&＃xff0c;并且分别有着protected和private修饰符来控制访问级别。Content代表着Goods的内容&＃xff0c;而GDestination代表着Goods的目的地。它们分别实现了两个接口Content和Destination。在后面的main方法里&＃xff0c;直接用 Contents c和Destination d进行操作&＃xff0c;你甚至连这两个内部类的名字都没有看见&＃xff01;这样&＃xff0c;内部类的第一个好处就体现出来了 隐藏你不想让别人知道的操作&＃xff0c;也即封装性。
同时&＃xff0c;我们也发现了在外部类作用范围之外得到内部类对象的第一个方法&＃xff0c;那就是利用其外部类的方法创建并返回。上例中的cont()和dest()方法就是这么做的。那么还有没有别的方法呢&＃xff1f;当然有&＃xff0c;其语法格式如下&＃xff1a;
outerObject&＃61;new outerClass(Constructor Parameters);
outerClass.innerClass innerObject&＃61;outerObject.new InnerClass(Constructor Parameters);
注意在创建非静态内部类对象时&＃xff0c;一定要先创建起相应的外部类对象。至于原因&＃xff0c;也就引出了我们下一个话题 非静态内部类对象有着指向其外部类对象的引用&＃xff0c;对刚才的例子稍作修改&＃xff1a;
public class Goods {private int valueRate &＃61; 2;private class Content implements Contents {private int i &＃61; 11 * valueRate;public int value() {return i;}}protected class GDestination implements Destination {private String label;private GDestination(String whereTo) {label &＃61; whereTo;}public String readLabel() {return label;}}public Destination dest(String s) {return new GDestination(s);}public Contents cont() {return new Content();}
}
在这里我们给Goods类增加了一个private成员变量valueRate&＃xff0c;意义是货物的价值系数&＃xff0c;在内部类Content的方法value()计算价值时把它乘上。我们发现&＃xff0c;value()可以访问valueRate&＃xff0c;这也是内部类的第二个好处 一个内部类对象可以访问创建它的外部类对象的内容&＃xff0c;甚至包括私有变量&＃xff01;这是一个非常有用的特性&＃xff0c;为我们在设计时提供了更多的思路和捷径。要想实现这个功能&＃xff0c;内部类对象就必须有指向外部类对象的引用。Java编译器在创建内部类对象时&＃xff0c;隐式的把其外部类对象的引用也传了进去并一直保存着。这样就使得内部类对象始终可以访问其外部类对象&＃xff0c;同时这也是为什么在外部类作用范围之外向要创建内部类对象必须先创建其外部类对象的原因。
有人会问&＃xff0c;如果内部类里的一个成员变量与外部类的一个成员变量同名&＃xff0c;也即外部类的同名成员变量被屏蔽了&＃xff0c;怎么办&＃xff1f;没事&＃xff0c;Java里用如下格式表达外部类的引用&＃xff1a;
outerClass.this
有了它&＃xff0c;我们就不怕这种屏蔽的情况了。
和普通的类一样&＃xff0c;内部类也可以有静态的。不过和非静态内部类相比&＃xff0c; 区别就在于静态内部类没有了指向外部的引用。
这实际上和C&＃43;&＃43;中的嵌套类很相像了&＃xff0c;Java内部类与C&＃43;&＃43;嵌套类最大的不同就在于是否有指向外部的引用这一点上&＃xff0c;当然从设计的角度以及以它一些细节来讲还有区别。
除此之外&＃xff0c;在任何非静态内部类中&＃xff0c;都不能有静态数据&＃xff0c;静态方法或者又一个静态内部类&＃xff08;内部类的嵌套可以不止一层&＃xff09;。不过静态内部类中却可以拥有这一切。这也算是两者的第二个区别吧。
是的&＃xff0c;Java内部类也可以是局部的&＃xff0c;它可以定义在一个方法甚至一个代码块之内。
public class Goods1 {public Destination dest(String s) {class GDestination implements Destination {private String label;private GDestination(String whereTo) {label &＃61; whereTo;}public String readLabel() {return label;}}return new GDestination(s);}public static void main(String[] args) {Goods1 g &＃61; new Goods1();Destination d &＃61; g.dest("Beijing");}
}
上面就是这样一个例子。在方法dest中我们定义了一个内部类&＃xff0c;最后由这个方法返回这个内部类的对象。如果我们在用一个内部类的时候仅需要创建它的一个对象并创给外部&＃xff0c;就可以这样做。当然&＃xff0c;定义在方法中的内部类可以使设计多样化&＃xff0c;用途绝不仅仅在这一点。
下面有一个更怪的例子&＃xff1a;
public class Goods2 {private void internalTracking(boolean b) {if (b) {class TrackingSlip {private String id;TrackingSlip(String s) {id &＃61; s;}String getSlip() {return id;}}TrackingSlip ts &＃61; new TrackingSlip("slip");String s &＃61; ts.getSlip();}}public void track() {internalTracking(true);}public static void main(String[] args) {Goods2 g &＃61; new Goods2();g.track();}
}
你不能在if之外创建这个内部类的对象&＃xff0c;因为这已经超出了它的作用域。不过在编译的时候&＃xff0c;内部类TrackingSlip和其他类一样同时被编译&＃xff0c;只不过它由它自己的作用域&＃xff0c;超出了这个范围就无效&＃xff0c;除此之外它和其他内部类并没有区别。
java的匿名内部类的语法规则看上去有些古怪&＃xff0c;不过如同匿名数组一样&＃xff0c;当你只需要创建一个类的对象而且用不上它的名字时&＃xff0c;使用内部类可以使代码看上去简洁清楚。它的语法规则是这样的&＃xff1a;
new interfacename(){…}; 或 new superclassname(){…};
下面接着前面继续举例子&＃xff1a;
public class Goods3 {public Contents cont() {return new Contents() {private int i &＃61; 11;public int value() {return i;}};}
}
这里方法cont()使用匿名内部类直接返回了一个实现了接口Contents的类的对象&＃xff0c;看上去的确十分简洁。
在java的事件处理的匿名适配器中&＃xff0c;匿名内部类被大量的使用。例如在想关闭窗口时加上这样一句代码&＃xff1a;
frame.addWindowListener(new WindowAdapter(){public void windowClosing(WindowEvent e){System.exit(0);}
});
有一点需要注意的是&＃xff0c;匿名内部类由于没有名字&＃xff0c;所以它没有构造函数&＃xff08;但是如果这个匿名内部类继承了一个只含有带参数构造函数的父类&＃xff0c;创建它的时候必须带上这些参数&＃xff0c;并在实现的过程中使用super关键字调用相应的内容&＃xff09;。如果你想要初始化它的成员变量&＃xff0c;有下面几种方法&＃xff1a;
如果是在一个方法的匿名内部类&＃xff0c;可以利用这个方法传进你想要的参数&＃xff0c;不过记住&＃xff0c; 这些参数必须被声明为final 。
将匿名内部类改造成有名字的局部内部类&＃xff0c;这样它就可以拥有构造函数了。
在这个匿名内部类中使用初始化代码块。
为什么需要内部类&＃xff1f;
java内部类有什么好处&＃xff1f;为什么需要内部类&＃xff1f;
首先举一个简单的例子&＃xff0c;如果你想实现一个接口&＃xff0c;但是这个接口中的一个方法和你构想的这个类中的一个方法的名称&＃xff0c;参数相同&＃xff0c;你应该怎么办&＃xff1f;这时候&＃xff0c;你可以建一个内部类实现这个接口。由于内部类对外部类的所有内容都是可访问的&＃xff0c;所以这样做可以完成所有你直接实现这个接口的功能。
不过你可能要质疑&＃xff0c;更改一下方法的不就行了吗&＃xff1f;
的确&＃xff0c;以此作为设计内部类的理由&＃xff0c;实在没有说服力。
真正的原因是这样的&＃xff0c;java中的内部类和接口加在一起&＃xff0c;可以的解决常被C&＃43;&＃43;程序员抱怨java中存在的一个问题 没有多继承。实际上&＃xff0c;C&＃43;&＃43;的多继承设计起来很复杂&＃xff0c;而java通过内部类加上接口&＃xff0c;可以很好的实现多继承的效果。
在一个类中创建另外一个类&＃xff0c;叫做成员内部类。这个成员内部类可以静态的&＃xff08;利用static关键字修饰&＃xff09;&＃xff0c;也可以是非静态的。
一、静态内部类的使用目的。
在定义内部类的时候&＃xff0c;在其前面加上一个权限修饰符static。这个内部类就变为了静态内部类。如在进行代码程序测试的时候&＃xff0c;如果在每一个Java源文件中都设置一个主方法(主方法是某个应用程序的入口&＃xff0c;必须具有)&＃xff0c;那么会出现很多额外的代码。而且最主要的是这段主程序的代码对于Java文件来说&＃xff0c;只是一个形式&＃xff0c;其本身并不需要这种主方法。但是少了这个主方法又是万万不行的。在这种情况下&＃xff0c;就可以将主方法写入到静态内部类中&＃xff0c;从而不用为每个Java源文件都设置一个类似的主方法。这对于代码测试是非常有用的。在一些中大型的应用程序开发中&＃xff0c;则是一个常用的技术手段。
二、静态内部类的使用限制
将某个内部类定义为静态类&＃xff0c;跟将其他类定义为静态类的方法基本相同&＃xff0c;引用规则也基本一致。不过其细节方面仍然有很大的不同。具体来说&＃xff0c;主要有如下几个地方要引起各位程序开发人员的注意。
一是静态成员(包括静态变量与静态成员)的定义。
在非静态内部类中不可以声明静态成员。如现在在一个student类中定义了一个内部类Age&＃xff0c;如果没有将这个类利用static关键字修饰&＃xff0c;即没有定义为静态类&＃xff0c;那么在这个内部类中如果要利用static关键字来修饰某个成员方法或者成员变量是不允许的。在编译的时候就通不过。故程序开发人员需要注意&＃xff0c;只有静态内部类才能够定义静态的成员变量与成员方法。
二是在成员的引用上&＃xff0c;有比较大的限制。
一般的非静态内部类&＃xff0c;可以随意的访问外部类中的成员变量与成员方法。即使这些成员方法被修饰为private(私有的成员变量或者方法)。因为在其他类中是无法访问被定义为私有的成员变量或方法。但是如果一个内部类被定义为静态的&＃xff0c;那么在引用外部类的成员方法或者成员变量的时候&＃xff0c;就会有诸多的限制。如不能够从静态内部类的对象中访问外部类的非静态成员(包括成员变量与成员方法)。这是什么意思呢?如果在外部类中定义了两个变量&＃xff0c;一个是非静态的变量&＃xff0c;一个是静态的变量。静态内部类只能引用外部类中的静态的成员&＃xff08;变量或方法&＃xff09;&＃xff0c;而不能够访问非静态的变量。对于那些非静态的成员变量与成员方法&＃xff0c;在静态内部类中是无法访问的。这就是静态内部类的最大使用限制。在普通的非静态内部类中是没有这个限制的。也正是这个原因&＃xff0c;决定了静态内部类只应用在一些特定的场合。其应用范围远远没有像非静态的内部类那样广泛。
三是在创建静态内部类时不需要将静态内部类的实例绑定在外部类的实例上。
通常情况下&＃xff0c;在一个类中创建成员内部类的时候&＃xff0c;有一个强制性的规定&＃xff0c;即内部类的实例一定要绑定在外部类的实例中。也就是说&＃xff0c;在创建内部类之前要先在外部类中要利用new关键字来创建这个内部类的对象。如此的话如果从外部类中初始化一个内部类对象&＃xff0c;那么内部类对象就会绑定在外部类对象上。也就是说&＃xff0c;普通非静态内部类的对象是依附在外部类对象之中的。通常情况下&＃xff0c;程序员在定义静态内部类的时候&＃xff0c;是不需要定义绑定在外部类的实例上的。也就是说&＃xff0c;要在一个外部类中定义一个静态的内部类&＃xff0c;不需要利用关键字new来创建内部类的实例。
从以上的分析中可以看出&＃xff0c;静态内部类与非静态的内部类还是有很大的不同的。一般程序开发人员可以这么理解&＃xff0c;非静态的内部类对象隐式地在外部类中保存了一个引用&＃xff0c;指向创建它的外部类对象。
牢记两个差别&＃xff1a;
一、如是否可以创建静态的成员方法与成员变量(静态内部类可以创建静态的成员&＃xff0c;而非静态的内部类不可以)
二、对于访问外部类的成员的限制(静态内部类只可以访问外部类中的静态成员变量与成员方法&＃xff0c;而非静态的内部类即可以访问所有的外部类成员方法与成员变量)。
这两个差异是静态内部类与非静态外部类最大的差异&＃xff0c;也是静态内部类之所以存在的原因。了解了这个差异之后&＃xff0c;程序开发人员还需要知道&＃xff0c;在什么情况下该使用静态内部类。如在程序测试的时候&＃xff0c;为了避免在各个Java源文件中书写主方法的代码&＃xff0c;可以将主方法写入到静态内部类中&＃xff0c;以减少代码的书写量&＃xff0c;让代码更加的简洁。
总 之&＃xff0c;静态内部类在Java语言中是一个很特殊的类&＃xff0c;跟普通的静态类以及非静态的内部类都有很大的差异。作为程序开发人员&＃xff0c;必须要知道他们之间的差异&＃xff0c;并在 实际工作中在合适的地方采用合适的类。不过总的来说&＃xff0c;静态内部类的使用频率并不是很高。但是在有一些场合&＃xff0c;如果没有这个内部静态类的话&＃xff0c;可能会起到事倍功半的反面效果。
非静态内部类实例&＃xff1a;
package common.lang;public class Student {private String name;private int age;public String getName() {return name;}public void setName(String name) {this.name &＃61; name;}public int getAge() {return age;}public void setAge(int age) {this.age &＃61; age;}public class Child{private String name1;private int age1;public String getName1() {return name1;}public void setName1(String name1) {this.name1 &＃61; name1;}public int getAge1() {System.out.println(age);return age1;}public void setAge1(int age1) {this.age1 &＃61; age1;}}public static void main(String[] args) {Student s &＃61; new Student();s.setAge(12);s.setName("yao");Child c &＃61; s.new Child();System.out.println(c.getAge1());}
}
静态内部类实例&＃xff1a;
package common.lang;public class Student {private String name;private static int age;public String getName() {return name;}public void setName(String name) {this.name &＃61; name;}public static int getAge() {return age;}public static void setAge(int age) {Student.age &＃61; age;}public static class Child{private String name1;private int age1;public String getName1() {return name1;}public void setName1(String name1) {this.name1 &＃61; name1;}public int getAge1() {System.out.println(age);return age1;}public void setAge1(int age1) {this.age1 &＃61; age1;}}public static void main(String[] args) {Student s &＃61; new Student();Child c &＃61; new Child();}
}
京公网安备 11010802041100号 | 京ICP备19059560号-4 | PHP1.CN 第一PHP社区 版权所有