java内部类的好处

Ⅰ java内部类的好处

内部类隐藏你不想让别人知道的操作。
每个内部类都能独立的继承一个接口的实现，所以无论外部类是否已经继承了某个(接口的)实现，对于内部类都没有影响。
暂时就想到两个
如有帮助，望采纳

Ⅱ java中的静态内部类有什么特点

特点：
1、静态内部类无需依赖于外部类，它可以独立于外部对象而存在。
2、静态内部类，多个外部类的对象可以共享同一个内部类的对象。
3、使用静态内部类的好处是加强了代码的封装性以及提高了代码的可读性。
4、普通内部类不能声明static的方法和变量，注意这里说的是变量，常量（也就是final static修饰的属性）还是可以的，而静态内部类形似外部类，没有任何限制。

有问题欢迎提问，满意请采纳，谢谢！

Ⅲ Java 语言中使用内部类有什么好处

一个类，要实现两个接口，分别是接口A和接口B，接口A和接口B都有一个名字一样的方法f（）；
此时就可以使用内部类实现接口B，外部类实现接口A。写程序的时候内部类使用还是比较少的，这里只是举个例子而已.内部类的用法还有很多，一般来说，内部类继承自某个类或实现某个接口，内部类的代码操作创建它的外围类的对象。所以可以认为内部类提供了某种进入其外围类的窗口！

Ⅳ Java，内部类有什么特别的好处吗

提起Java内部类（Inner Class）可能很多人不太熟悉，实际上类似的概念在C++里也有，那就是嵌套类（Nested Class），关于这两者的区别与联系，在下文中会有对比。内部类从表面上看，就是在类中又定义了一个类（下文会看到，内部类可以在很多地方定义），而实际上并没有那么简单，乍看上去内部类似乎有些多余，它的用处对于初学者来说可能并不是那么显着，但是随着对它的深入了解，你会发现Java的设计者在内部类身上的确是用心良苦。学会使用内部类，是掌握Java高级编程的一部分，它可以让你更优雅地设计你的程序结构。下面从以下几个方面来介绍：

publicinterfaceContents{
intvalue();
}
publicinterfaceDestination{
StringreadLabel();
}
publicclassGoods{
{
privateinti=11;
publicintvalue(){
returni;
}
}
{
privateStringlabel;
privateGDestination(StringwhereTo){
label=whereTo;
}
publicStringreadLabel(){
returnlabel;
}
}
publicDestinationdest(Strings){
returnnewGDestination(s);
}
publicContentscont(){
returnnewContent();
}
}
classTestGoods{
publicstaticvoidmain(String[]args){
Goodsp=newGoods();
Contentsc=p.cont();
Destinationd=p.dest("Beijing");
}
}

在这个例子里类Content和GDestination被定义在了类Goods内部，并且分别有着protected和private修饰符来控制访问级别。Content代表着Goods的内容，而GDestination代表着Goods的目的地。它们分别实现了两个接口Content和Destination。在后面的main方法里，直接用 Contents c和Destination d进行操作，你甚至连这两个内部类的名字都没有看见！这样，内部类的第一个好处就体现出来了 隐藏你不想让别人知道的操作，也即封装性。

同时，我们也发现了在外部类作用范围之外得到内部类对象的第一个方法，那就是利用其外部类的方法创建并返回。上例中的cont()和dest()方法就是这么做的。那么还有没有别的方法呢？当然有，其语法格式如下：

outerObject=new outerClass(Constructor Parameters);

outerClass.innerClass innerObject=outerObject.new InnerClass(Constructor Parameters);

注意在创建非静态内部类对象时，一定要先创建起相应的外部类对象。至于原因，也就引出了我们下一个话题 非静态内部类对象有着指向其外部类对象的引用，对刚才的例子稍作修改：

publicclassGoods{
privateintvalueRate=2;
{
privateinti=11*valueRate;
publicintvalue(){
returni;
}
}
{
privateStringlabel;
privateGDestination(StringwhereTo){
label=whereTo;
}
publicStringreadLabel(){
returnlabel;
}
}
publicDestinationdest(Strings){
returnnewGDestination(s);
}
publicContentscont(){
returnnewContent();
}
}

在这里我们给Goods类增加了一个private成员变量valueRate，意义是货物的价值系数，在内部类Content的方法value()计算价值时把它乘上。我们发现，value()可以访问valueRate，这也是内部类的第二个好处 一个内部类对象可以访问创建它的外部类对象的内容，甚至包括私有变量！这是一个非常有用的特性，为我们在设计时提供了更多的思路和捷径。要想实现这个功能，内部类对象就必须有指向外部类对象的引用。Java编译器在创建内部类对象时，隐式的把其外部类对象的引用也传了进去并一直保存着。这样就使得内部类对象始终可以访问其外部类对象，同时这也是为什么在外部类作用范围之外向要创建内部类对象必须先创建其外部类对象的原因。

有人会问，如果内部类里的一个成员变量与外部类的一个成员变量同名，也即外部类的同名成员变量被屏蔽了，怎么办？没事，Java里用如下格式表达外部类的引用：

outerClass.this

有了它，我们就不怕这种屏蔽的情况了。

静态内部类

和普通的类一样，内部类也可以有静态的。不过和非静态内部类相比，区别就在于静态内部类没有了指向外部的引用。这实际上和C++中的嵌套类很相像了，Java内部类与C++嵌套类最大的不同就在于是否有指向外部的引用这一点上，当然从设计的角度以及以它一些细节来讲还有区别。

除此之外，在任何非静态内部类中，都不能有静态数据，静态方法或者又一个静态内部类（内部类的嵌套可以不止一层）。不过静态内部类中却可以拥有这一切。这也算是两者的第二个区别吧。

局部内部类

是的，Java内部类也可以是局部的，它可以定义在一个方法甚至一个代码块之内。

publicclassGoods1{
publicDestinationdest(Strings){
{
privateStringlabel;
privateGDestination(StringwhereTo){
label=whereTo;
}
publicStringreadLabel(){
returnlabel;
}
}
returnnewGDestination(s);
}
publicstaticvoidmain(String[]args){
Goods1g=newGoods1();
Destinationd=g.dest("Beijing");
}
}

上面就是这样一个例子。在方法dest中我们定义了一个内部类，最后由这个方法返回这个内部类的对象。如果我们在用一个内部类的时候仅需要创建它的一个对象并创给外部，就可以这样做。当然，定义在方法中的内部类可以使设计多样化，用途绝不仅仅在这一点。

下面有一个更怪的例子：

publicclassGoods2{
privatevoidinternalTracking(booleanb){
if(b){
classTrackingSlip{
privateStringid;
TrackingSlip(Strings){
id=s;
}
StringgetSlip(){
returnid;
}
}
TrackingSlipts=newTrackingSlip("slip");
Strings=ts.getSlip();
}
}
publicvoidtrack(){
internalTracking(true);
}
publicstaticvoidmain(String[]args){
Goods2g=newGoods2();
g.track();
}
}

你不能在if之外创建这个内部类的对象，因为这已经超出了它的作用域。不过在编译的时候，内部类TrackingSlip和其他类一样同时被编译，只不过它由它自己的作用域，超出了这个范围就无效，除此之外它和其他内部类并没有区别。

匿名内部类

java的匿名内部类的语法规则看上去有些古怪，不过如同匿名数组一样，当你只需要创建一个类的对象而且用不上它的名字时，使用内部类可以使代码看上去简洁清楚。它的语法规则是这样的：

new interfacename(){......}; 或 new superclassname(){......};

下面接着前面继续举例子：

publicclassGoods3{
publicContentscont(){
returnnewContents(){
privateinti=11;
publicintvalue(){
returni;
}
};
}
}

这里方法cont()使用匿名内部类直接返回了一个实现了接口Contents的类的对象，看上去的确十分简洁。

在java的事件处理的匿名适配器中，匿名内部类被大量的使用。例如在想关闭窗口时加上这样一句代码：

frame.addWindowListener(newWindowAdapter(){
publicvoidwindowClosing(WindowEvente){
System.exit(0);
}
});

有一点需要注意的是，匿名内部类由于没有名字，所以它没有构造函数（但是如果这个匿名内部类继承了一个只含有带参数构造函数的父类，创建它的时候必须带上这些参数，并在实现的过程中使用super关键字调用相应的内容）。如果你想要初始化它的成员变量，有下面几种方法：

如果是在一个方法的匿名内部类，可以利用这个方法传进你想要的参数，不过记住，这些参数必须被声明为final。

将匿名内部类改造成有名字的局部内部类，这样它就可以拥有构造函数了。

在这个匿名内部类中使用初始化代码块。

为什么需要内部类？

java内部类有什么好处？为什么需要内部类？

首先举一个简单的例子，如果你想实现一个接口，但是这个接口中的一个方法和你构想的这个类中的一个方法的名称，参数相同，你应该怎么办？这时候，你可以建一个内部类实现这个接口。由于内部类对外部类的所有内容都是可访问的，所以这样做可以完成所有你直接实现这个接口的功能。

不过你可能要质疑，更改一下方法的不就行了吗？

的确，以此作为设计内部类的理由，实在没有说服力。

真正的原因是这样的，java中的内部类和接口加在一起，可以的解决常被C++程序员抱怨java中存在的一个问题 没有多继承。实际上，C++的多继承设计起来很复杂，而java通过内部类加上接口，可以很好的实现多继承的效果。

Ⅳ Java 静态内部类作用

1、变值权限修饰作用，在定义内部类的时候，可以在其前面加上一个权限修饰符static。此时这个内部类就变为了静态内部类。

2、在某些特殊的情况下，少了这个静态内部类还真是不行。如在进行代码程序测试的时候，如果在每一个Java源文件中都设置一个主方法(主方法是某个应用程序的入口，必须具有)，那么会出现很多额外的代码。

3、最主要的时这段主程序的代码对于Java文件来说，只是一个形式，其本身并不需要这种主方法。但是少了这个主方法又是万万不行的。在这种情况下，就可以将主方法写入到静态内部类中，从而不用为每个Java源文件都设置一个类似的主方法。

这对于代码测试是非常有用的。在一些中大型的应用程序开发中，则是一个常用的技术手段。

(5)java内部类的好处扩展阅读

例如：

对于两个类，拥有相同的方法：

class People{

run();

}

interface Machine{

run();

}

此时有一个robot类：

class Robot extends People implement Machine.

此时run()不可直接实现。

interface Machine{

void run();

}

class Person{

void run(){

System.out.println("run");

}

}

class Robot extends Person{

private class MachineHeart implements Machine{

public void run(){

System.out.println("heart run");

}

}

public void run(){

System.out.println("Robot run");

}

Machine.getMachine(){returnnew MachineHeart();

}

class Test{

publicstaticvoid main(String[] args){

Robot robot=new Robot();

Machine m=robot.getMachine();

m.run();

robot.run();

}

}

Ⅵ java为什么要用内部类

1.内部类能访问外围类的所有成员，包括私有成员。

当生成一个内部类对象时，此对象与制造它的外围类对象之间就有了一种联系，所以它能访问其外围类对象的所有成员，而不需要任何特殊的条件。如下面代码所示：

[java]view plain

• classOutterClass{

• privateinti=1;

• classInnerClass{

• publicvoiddisplayPrivate(){

• System.out.println(i);

• }

• }

• }

• publicclassMainClass{

• publicstaticvoidmain(String[]args){

• OutterClassoutter=newOutterClass();

• OutterClass.InnerClassinner=outter.newInnerClass();

• inner.displayPrivate();

• }

• }

由上面的代码可以看出，内部类能够访问外部类的私有成员变量。在这段代码中，还需要注意的是

①生成内部类对象，必须要先有外围类对象，具体的做法请见代码；

②内部类能访问外围类的私有成员这一点，C++中的嵌套类是没有这个特性的。

2.内部类与static

①内部类不能含有static方法；

②内部类不能含有static数据成员，除非是static final；

③内部类可以继承含有static成员的类。


3.匿名内部类

匿名内部类，看起来非常奇怪。因为它太简洁了，但这也带来一个好处，用匿名内部类写出来的代码通常比较简洁啦！