java内部类使用
Ⅰ java内部类有几种
Java中的几种内部类：
成员内部类：作为外部类的一个成员存在，与外部类的属性、方法并列。当某个类除了他的外部类，不会被其他类使用时应该选择使用成员内部类。
局部内部类：局部内部类定义在外部类的某个代码块或方法块中。如果只会在某个方法或块中创建这个类的对象，就可以使用局部内部类。
匿名内部类：匿名内部类一般定义在需要传递接口或回调的的地方，一个匿名内部类一定是在new的后面，用其隐含实现一个接口或继承一个类。假如只需要创建这个类的一个对象不需要知道其实际类型(不需要使用到类名)，那么就可以使用匿名内部类。
静态内部类：和成员内部类一样，作为外部类的一个成员存在，与外部类的属性、方法并列，只不过在声明类的时候加入了static关键字。有时候，使用内部类只是为了把一个类隐藏在另外一个类的内部，并不需要内部类引用外围类对象。这时可以使用静态内部类，以便取消产生对外部类的引用。
Ⅱ JAVA内部类使用，什么时候该使用内部类及使
java中的内部类和接口加在一起，可以的解决常被C++程序员抱怨java中存在的一个问题 没有多继承。
每个内部类都能独立的继承自一个（接口的）实现，所以无论外围类是否已经继承了某个（接口的）实现，对于内部类都没有影响。
1.内部类继承
因为内部类的构造器必须连接到指向其外围类对象的引用，所以在继承内部类的时候使用特殊语法。问题在于，指向外围类对象的引用必须被初始化，而在导出类中不存在可连接的默认对象。所以必须要用特殊语法来明确说清楚他们之间的关联。
[java]view plain
classWithInner{
classInner{}
}
.Inner{
InheritInner(WithInnerwi){
wi.super();
}
}
publicclassEgg{
privateYolky;
protectedclassYolk{
publicYolk(){
System.out.println("Egg.Yolk");
}
}
publicEgg(){
System.out.println("NewEgg");
y=newYolk();
}
}
publicclassBigEggextendsEgg{
publicclassYolk{
publicYolk(){
System.out.println("BigEgg.yolk()");
}
}
publicstaticvoidmain(String[]args){
newBigEgg();
}
}
2 内部类覆盖
当继承一个外围类的时候，内部类不会发生什么变化。当明确的继承一个内部类时会发生变化。
[java]view plain
[java]view plain
输出：
New Egg
Egg.Yolk
Ⅲ java内部类怎么使用
1.内部类的方法可以访问它所在的外部类中的所有域，包括私有型别的；
2.对于同一个包中的其它类它是隐藏的；
3. 匿名的内部类可以让我们很方便的定义事件响应(call back)，这在GUI编程中很常见
interface OutInterface{ //定义一个接口 public void f(); } public class InterfaceInner { //主类 public static void main(String args[]){ OuterClass2 out=new OuterClass2(); OutInterface outinter=out.doit(); outinter.f(); } } class OuterClass2{ //定义一个内部类，并且接口OutInterface private class InnerClass implements OutInterface{ InnerClass(String s){ System.out.println(s); } public void f(){ System.out.println("访问内部类中的f()方法"); } } public OutInterface doit(){ //方法返回接口 return new InnerClass("访问内部类构造方法"); } }
Ⅳ java中内部类该何时用，怎么用
1.在一个类内部还存在另一个类，则后者为内部类；
2.内部类可声明成public或private，当内部类声明成public或private时，对其访问的限制与成员变量和成员方法完全相同；
3.定义格式：
标识符 class 外部类的名称{
//外部类的成员
标识符 class 内部类的名称{
//内部类的成员
}
}
示例：
class Outer{ // 定义外部类
private String info = "hello world" ; // 定义外部类的私有属性
class Inner{ // 定义内部类
public void print(){ // 定义内部类的方法
System.out.println(info) ; // 直接访问外部类的私有属性
}
};
public void fun(){ // 定义外部类的方法
new Inner().print() ; // 通过内部类的实例化对象调用方法
}
};
public class InnerClassDemo01{
public static void main(String args[]){
new Outer().fun() ; // 调用外部类的fun()方法
}
};
这位童鞋可以试着不用内部类写个程序完成以上功能，你会发现代码明显比之前的更加麻烦和复杂，所以内部类的唯一好处是方便的访问外部类中的私有属性，从而减少代码。
Ⅳ java内部类中的调用规则
一般来说，外部类调用内部类的方法分为以下几种情况：
1.使用static可以声明一个内部类， 可以直接在外部调用
// 定义外部类
class Outer
{
// 定义外部类的私有属性
private static String info = "hello world";
// 使用static定义内部类
static class Inner
{
// 定义内部类的方法
public void print()
{
// 直接访问外部类的私有属性
System.out.println(info);
}
}
// 定义外部类的方法
public void fun()
{
// 通过内部类的实例化对象调用方法
new Inner().print();
}
}
public class InnerClassDemo03
{
public static void main(String args[])
{
// 通过Outer.Inner创建内部类的实例，并调用它的print方法
new Outer.Inner().print() ;
}
}
2.不使用statc声明一个内部类 ，使外部调用
//定义外部类
class Outer
{
//定义外部类的私有属性
private String info = "hello world";
//定义内部类
class Inner
{
//定义内部类的方法
public void print()
{
//直接访问外部类的私有属性
System.out.println(info);
}
};
//定义外部类的方法
public void fun()
{
//通过内部类的实例化对象调用方法
new Inner().print();
}
};
public class InnerClassDemo04
{
public static void main(String args[])
{
//外部类实例化对象
Outer out = new Outer();
//实例化内部类对象
Outer.Inner in = out.new Inner();
//调用内部类的方法
in.print();
}
}
3.在方法中定义内部类 ，使外部调用
//定义外部类
class Outer
{
//定义外部类的私有属性
private String info = "hello world";
//定义外部类的方法
public void fun(final int temp)
{
//在方法中定义的内部类
class Inner
{
//定义内部类的方法
public void print()
{
//直接访问外部类的私有属性
System.out.println("类中的属性：" + info);
System.out.println("方法中的参数：" + temp);
}
}
//通过内部类的实例化对象调用方法
new Inner().print();
}
}
public class InnerClassDemo05
{
public static void main(String args[]){
//调用外部类的方法
new Outer().fun(30);
}
}
Ⅵ java内部类使用场景
这种事实对本人来说意义重大，相信对这个世界也是有一定意义的。 塞内加说过一句富有哲理的话，勇气通往天堂，怯懦通往地狱。
带着这句话，我们还要更加慎重的审视这个问题： 总结的来说， 就我个人来说，内部使用场景对我的意义，不能不说非常重大。 我们都知道，只要有意义，那么就必须慎重考虑。 内部使用场景，到底应该如何实现。 我们不得不面对一个非常尴尬的事实，那就是， 富兰克林在不经意间这样说过，你热爱生命吗？那么别浪费时间，因为时间是组成生命的材料。这不禁令我深思。
所谓内部使用场景，关键是内部使用场景需要如何写。 每个人都不得不面对这些问题。 在面对这种问题时， 我们一般认为，抓住了问题的关键，其他一切则会迎刃而解。 内部使用场景因何而发生？ 我们一般认为，抓住了问题的关键，其他一切则会迎刃而解。
阿卜·日·法拉兹曾说过这样一句话，学问是异常珍贵的东西，从任何源泉吸收都不可耻。这句话语虽然很短，但令我浮想联翩。 每个人都不得不面对这些问题。 在面对这种问题时， 可是，即使是这样，内部使用场景的出现仍然代表了一定的意义。 带着这些问题，我们来审视一下内部使用场景。 这种事实对本人来说意义重大，相信对这个世界也是有一定意义的。 叔本华说过一句富有哲理的话，普通人只想到如何度过时间，有才能的人设法利用时间。这不禁令我深思。 既然如此， 内部使用场景，发生了会如何，不发生又会如何。
这种事实对本人来说意义重大，相信对这个世界也是有一定意义的。 既然如此， 伏尔泰在不经意间这样说过，不经巨大的困难，不会有伟大的事业。我希望诸位也能好好地体会这句话。 这种事实对本人来说意义重大，相信对这个世界也是有一定意义的。
内部使用场景，到底应该如何实现。 歌德说过一句富有哲理的话，没有人事先了解自己到底有多大的力量，直到他试过以后才知道。这不禁令我深思。 内部使用场景，到底应该如何实现。 而这些并不是完全重要，更加重要的问题是， 生活中，若内部使用场景出现了，我们就不得不考虑它出现了的事实。 我们不得不面对一个非常尴尬的事实，那就是， 就我个人来说，内部使用场景对我的意义，不能不说非常重大。
在这种困难的抉择下，本人思来想去，寝食难安。
既然如此， 每个人都不得不面对这些问题。 在面对这种问题时， 一般来说， 可是，即使是这样，内部使用场景的出现仍然代表了一定的意义。
Ⅶ java中的内部类在什么场合下使用呢
内部类可以访问所属类的私有属性
内部类分为匿名内部类和非匿名内部类，非匿名内部类又分为static和非static，给几个例子吧
匿名内部类：
new
Thread(new
Runable(){
public
void
run(){/*code
here*/}
});
button.addListener(new
ActionListener(){
public
void
actionPerformed(Event
e){/*code
here*/}
});
非匿名非static内部类：
上面的例子如果想复用Runable或者ActionListener就可以把匿名的转化成非匿名的
非匿名static内部类
java.util包中的Map.Entry就Map的static内部类，可以体会下为什么这么设计
Ⅷ Java 语言中使用内部类有什么好处
一个类，要实现两个接口，分别是接口A和接口B，接口A和接口B都有一个名字一样的方法f（）；
此时就可以使用内部类实现接口B，外部类实现接口A。写程序的时候内部类使用还是比较少的，这里只是举个例子而已.内部类的用法还有很多，一般来说，内部类继承自某个类或实现某个接口，内部类的代码操作创建它的外围类的对象。所以可以认为内部类提供了某种进入其外围类的窗口！
Ⅸ Java提供了一种称为“内部类”的机制，使类可以在其他类中定义
不可以， 内部类只能在自己类里面使用
除非是静态内部类，静态内部类就跟普通静态类一样
这是Java基础，值得好好理解
Ⅹ java内部类有哪些
共有四种内部类，分别是:
1.常规内部类
2.静态内部类
3.局部内部类
4.匿名内部类
常规内部类：常规内部类没有用static修饰且定义在在外部类类体中。
常规内部类中的方法可以直接使用外部类的实例变量和实例方法。在常规内部类中可以直接用内部类创建对象。
静态内部类：与类的其他成员相似，可以用static修饰内部类，这样的类称为静态内部类。静态内部类与静态内部方法相似，只能访问外部类的static成员，不能直接访问外部类的实例变量，与实例方法，只有通过对象引用才能访问。
由于static内部类不具有任何对外部类实例的引用，因此static内部类中不能使用this关键字来访问外部类中的实例成员，但是可以访问外部类中的static成员。这与一般类的static方法相通。
局部内部类：在方法体或语句块（包括方法、构造方法、局部块或静态初始化块）内部定义的类成为局部内部类。局部内部类不能加任何访问修饰符，因为它只对局部块有效。
局部内部类只在方法体中有效，就想定义的局部变量一样，在定义的方法体外不能创建局部内部类的对象
在方法内部定义类时，应注意以下问题：1.方法定义局部内部类同方法定义局部变量一样，不能使用private、protected、public等访问修饰说明符修饰，也不能使用static修饰，但可以使用final和 abstract修饰2.方法中的内部类可以访问外部类成员。对于方法的参数和局部变量，必须有final修饰才可以访问。3.static方法中定义的内部类可以访问外部类定义的static成员
匿名内部类：定义类的最终目的是创建一个类的实例，但是如果某个类的实例只是用一次，则可以将类的定义与类的创建，放到与一起完成，或者说在定义类的同时就创建一个类。以这种方法定义的没有名字的类成为匿名内部类。