黑马程序员技术交流社区

标题: 内部类和外部类的区别，和用法 [打印本页]

作者: wdd 时间: 2015-6-18 21:11
提示: 该帖被管理员或版主屏蔽

作者: 杰可可 时间: 2015-6-18 21:11
外部类调用成员内部类，并使用内部类中方法示例：
   //======创建一个Sample类，并在在Sample类中定义一个成员内部类Inner======
public class Sample {
   public int id;
   private String  name;
   static String type;
   public Sample(){
   id=4545;
   name="苹果";
   type="水果";
   }

   //========定义的成员内部类=========
   class Inner{
   private String msg="该内部类包含以下属性：";
   public void print(){
   System.out.println(msg);
   System.out.println("编号："+id);
   System.out.println("名称："+name);
   System.out.println("类别："+type);
   }
   }
}

接下来的这个类示外部的类，用来调用Sample类中的成员内部类：
示例：
//Test类是用来调用Sample类中的成员内部类Inner，并使用Inner内部类的方法
public class Test {

public static void main(String[] args) {
Sample sample=new Sample();                //这里创建Sample类的对象
            Sample.Inner inner=sample.new Inner(); //创建成员内部类对象
            inner.print();                                              //成员内部类对象调用其方法
}
}

=========不知道楼主有没有理解外部类对内部类的调用具体思路===================

作者: cyd1058 时间: 2015-6-18 21:31
内部类包括成员内部类，静态内部类，和方法内部类

作者: hellowo_ccLiv 时间: 2015-6-18 21:34
再看看视频。把问题理清楚再问。

作者: wdd 时间: 2015-6-18 21:36
那怎么用呢

作者: 洪伟 时间: 2015-6-18 21:50
在我的新浪里有一篇关于内部类的介绍你可以去看看其他你的也看看把对你应该有帮助地址 http://blog.sina.com.cn/u/2841797967

作者: 洪伟 时间: 2015-6-18 21:55
其实内部类就是定义在另一个类里面的类（即外部类），也可以定义在外部类的方法里，定义的方式和定义普通的类没有任何区别。定义后，就把内部类当作外部类的成员，类成员怎么用，它就怎么用。当然，我说的这个是普通内部类，至于其他几种大体相同，你先把简单的这个弄懂把，其他的以后慢慢了解。一口吃不成胖子

作者: Foundmoon 时间: 2015-6-18 23:41
内部类很少用的，也别把它看得太难，就跟普通类没区别，只是有个格式问题
1.直接创建内部类对象Outer.Inner Oi=new Outer().new Inner();如果内部类被static修饰， Outer.Inner Oi=new Outer.Inner();
2.局部内部类只能访问被final修饰的局部变量。

作者: kalon 时间: 2015-6-19 00:08
多看几遍视频，多咀嚼咀嚼吧，你基础都没搞好怎么玩

作者: 杰可可 时间: 2015-6-19 10:35
内部类：就是在其他类内部定义的子类，它是相对包含它的类说的。
内部类有四种：1、成员内部类；
                     2、局部内部类；
                     3、静态内部类；
                     4、匿名内部类；
成员内部类示例：
                  public class Sample{

                        public int id;    //成员变量
                     class Inner{       //成员内部类

                                    }
         }
局部内部类示例：
   public class Sample{
                  public int id;
                  public void shell(){    //成员方法
                        int price;          //局部变量
                        class Apple{       //内部类，它和局部变量一样，都是在方法内定义的，只能在方法内部有效
                           }
                     }
      }

静态内部类示例：
         public  class Sample{
            static  class Apple{ //静态内部类，用static来修饰。它可以在不创建Sample类情况下直接使用。
                  }
   }

匿名类示例：
比如创建一个匿名的Apple类：
         public class Sample{
                     public static void main (String[] args){
                                    new Apple(){                //匿名类，所谓匿名就是没有名称的内部类
                                          public void introduction(){
                                                   System.out.println("这是一个匿名类！");
                                          }
                                 };
                        }

   }

作者: wdd 时间: 2015-6-19 10:46

杰可可发表于 2015-6-19 10:35
内部类：就是在其他类内部定义的子类，它是相对包含它的类说的。
内部类有四种：1、成员内部类；
...

那相互怎么调用呢

作者: 杰可可 时间: 2015-6-19 10:52

wdd 发表于 2015-6-19 10:46
那相互怎么调用呢

你说的是几种类型的类之间的相互调用？？

作者: 杰可可 时间: 2015-6-19 10:57

wdd 发表于 2015-6-19 10:46
那相互怎么调用呢

内部类一般作用于定义它的类中的相关有效范围，调用它的都是定义它的类间接或直接调用

作者: 伟大的骗子 时间: 2015-6-19 11:20
外部类就是我们经常的用法
class Wai{}
内部类就是字面意思，类中类
class Wai{
class Nei{
}
}
在内部类中调用外部类的方法或者成员变量，没有任何限制，就普通在外部类中调用时一样直接拿来用就好
而如果要在外部类函数中调用内部类方法或变量的话，就像普通调用类那样，通过内部类new一个内部类的对象，然后通过此对象完成对内部类成员的调用，当然类似私有封装的这些限制，此时是正常存在的

作者: 逝....曾经 时间: 2015-6-19 11:51
类名调用

作者: hzw@ql 时间: 2015-6-19 18:56
因为内部类就是在外部内的内部，所以可以直接用用外部类的成员啊，外部类也是可以直接使用内部类中的成员的

作者: 天涯回望 时间: 2015-6-19 19:08
妹纸看着眼熟，是中腾202的吧？

作者: JRT 时间: 2015-6-19 19:48
看到坛友们回复的都太好了，我没话说了

作者: wdd 时间: 2015-6-20 15:32

天涯回望发表于 2015-6-19 19:08
妹纸看着眼熟，是中腾202的吧？

额。。。我还没有去黑马呢:lol

作者: 野驴少东 时间: 2015-6-20 23:37
继续看视频，一起努力中。毕向东讲的很清楚啊，如果你是内部类，你会怎么办？

作者: dcw2015 时间: 2015-6-21 10:01
内部娄可以直接调用外部娄的成员变量和成员方法；外部娄（包含内部娄的娄）调用内部娄则需要创建内部娄对象。格式和平时一样

作者: 342508558 时间: 2015-6-21 11:37
内部类

内部类可以访问外部类相应作用域内的所有数据，包括private；对同一个包内的其他类是隐藏的。

只有内部类内可以声明为private，但在JVM中不存在私有类，内部类在JVM中和普通类没有区别。

内部类在编译的时候，编译器会为内部类创建一个默认的，增加参数为外部类引用的构造方法，通过这个应用，可以访问外部类的数据和方法。

内部类在访问外部类的私有数据时，编译器会为外部类创建一个返回该private数据的方法。可以通过某些方法获得这个方法，造成安全隐患。

内部类访问局部变量时，需要将局部变量声明为final。

作者: 陈化身1 时间: 2015-6-22 15:13
当内部类中定义了静态方法法，该类也必须是静态的
当外部类的静态方法访问内部类时，内部类也必须是静态的

定义匿名内部类的前提是：内部类必须继承一个类或者实现一个接口

作者: 陌上桑 时间: 2015-6-23 10:11
内部类有四种，除了局部内部类有一些特点需要了解。总体上你只需要将内部类当做外部内的成员【包含属性与方法】。局部内部类，只能操作局部终态变量，这类嵌套的限制。至于用法，内部类主要是为了简便，封装，所以，一般功能单一。

作者: 图图_黑马 时间: 2015-6-23 14:50
内部类你看可不可这么理解：

你平时定义类的时候有时候会有一个私有成员为String类型的，你现在在外部类Outer里面定义一个内部类Inner，你可以把它对比为String来看待，只不过将Inner类的实现代码在Outer类里给你看到了是怎么实现的。

内部类简单的看作是一个类对象成员就行。

作者: 黑马无敌 时间: 2015-6-23 15:48
内部类和外部类联系：内部类可以访问外部类所有的方法和属性，如果内部类和外部类有相同的成员方法和成员属性，内部类的成员方法调用要优先于外部类即内部类的优先级比较高（只限于类内部，在主方法内，内部类对象不能访问外部类的成员方法和成员属性），外部类只能访问内部类的静态常量或者通过创建内部类来访问内部类的成员属性和方法
内部类定义的静态常量可以全局访问

作者: 天涯回望 时间: 2015-6-23 23:53

wdd 发表于 2015-6-20 15:32
额。。。我还没有去黑马呢

同在中腾

作者: EnderDBluse 时间: 2015-6-25 14:59
妹子加油啊

作者: wdd 时间: 2015-6-25 19:14

EnderDBluse 发表于 2015-6-25 14:59
妹子加油啊

会的，一起加油吧！:loveliness:

作者: 德艺双馨 时间: 2015-6-26 21:15
外部类访问内部类，先new一个外部类对象，然后再通过外部类对象new一个内部类：new OuterClass().new InnerClass()；外部类访问内部类的成员或方法：new OuterClass().new InnerClass().innerFeild;或者new OuterClass().new InnerClass().innerMethod()；内部类访问外部类的成员变量或方法通过内部类对象直接访问：new InnerClass().outerFeild;或者new InnerClass().outerMethod();

作者: xwdxiaoda 时间: 2015-6-29 11:21
内部类在类里又定义了一个类
1 内部类可以直接访问外部类中的成员，包括私有，之所以可以是因为内部类中持有了外部类的引用，格式外部类名.this.参数名默认省略的；
2 外部类要访问内部类，必须建立内部类对象
注意：当内部类中定义了静态成员，该内部类也必须是静态的
当外部类中的静态成员访问内部类时，内部类也必须是静态的

class Outer{
private int x=3;
class Inter
{
void function(){
Ststem.out.println("inner"+Outer.this.x);
}
}//外部类访问内部类
void method(){

Inter in =new Inter();
in.function();}
}
classInterclass{
public static void mian(String[]args){
Outer.Inter.in=new Outer().new Inter();
in.function();//直接访问内部类成员
}

}
内部类定义在局部时不可以被成员修饰符修饰可以直接访问外部类中的成员，因为还持有外部类中的医用但是不能访问它所在局部中的变量。只能访问被final修饰的局部变量。
class Outer{

int x=3;
void method(final int a){
final int y=4;
class Innter{
void function(){

System.out.println(a)
}
}
new Innter().functon();
}

}
class Innterclass{

public static void mian(String[] args){
Outer out=new Outer();
out.method(7);
out.method(8);}
}
0112
//因为所有的类都是object的子类所以下面的写法是可行的
class InnerTest{
public static void main(String[] args）{
new object(){
public void function(){
System.out.println("nihao ");}

}.function;

}

}

作者: 朙兲 时间: 2015-6-29 20:38
看我的帖子，我写了一些总结

作者: 含笑 时间: 2015-6-29 22:19
内部类作用主要实现功能的隐藏、减少内存开销，提高程序的运行速度

内部类和外部类联系：内部类可以访问外部类所有的方法和属性，如果内部类和外部类有相同的成员方法和成员属性，内部类的成员方法调用要优先于外部类即内部类的优先级比较高（只限于类内部，在主方法内，内部类对象不能访问外部类的成员方法和成员属性），外部类只能访问内部类的静态常量或者通过创建内部类来访问内部类的成员属性和方法
内部类定义的静态常量可以全局访问

创建内部类
第一种方式
假设A是外部类，B是内部类
A a=new A();
A.B b=a.new B();

或者用A类的匿名对象来访问

A.B b=new A().new B();

普通类权限
public和default

而内部类具有四种权限

A.this.name（反射机制创建当前对象）
类优先于字节码文件执行，编译完类才生成字节码文件

字节码文件可以通过反射机制来改变

类中的私有属性可以通过发射机制在类外访问，通过反射机制改变字节码文件中的东西

编译时和运行时

反射机制工作在运行时
静态内部类.
public class StaticInner {
//{
/*static class hello
{
普通代码块内不能定义静态内部类
}*
/
}*/
static
{
class hello
{
//静态代码块内可以定义静态内部类
public void test()
{
System.out.println("it's a inner class");
}
public void practice()//静态代码块内不能定义静态方法
{
System.out.println("it's a demo");
//System.out.println(a);
//method();这两句编译报错，可看出静态内部类不能访问外部类的普通成员和方法
System.out.println(a1);
test1();
//从这两句可以看出，静态内部类只能访问外部类的静态成员和静态方法
}
//从上看出静态内部类可以定义普通方法和静态方法

}
}
private int a;
private void method()
{
System.out.println("hello");
}
private static String a1;
private static void test1()
{
System.out.println("you can access this method,because it is static");
}
//静态内部类
static class Inner{
public void test()
{
System.out.println("it's a inner class");
}
public static void practice()
{
System.out.println("it's a demo");
//System.out.println(a);
//method();这两句编译报错，可看出静态内部类不能访问外部类的普通成员和方法
System.out.println(a1);
test1();
//从这两句可以看出，静态内部类只能访问外部类的静态成员和静态方法
}
//从上看出静态内部类可以定义普通方法和静态方法

}

}
静态内部类创建对象

StaticInner.Inner inn=new StaticInner.Inner();
这里可以把内部类当做外部类的一个静态成员
局部内部类
定义在方法体内
定义在普通代码块内
实例如下
public class Outer {
private int a;
private void practice()
{
System.out.println("This is a outer class method");
}
public void method()
{
int a1;
final int a2=0;
class inner
{
public void test()
{
//能访问外部类任何属性和方法
System.out.println(a);
practice();
//
// System.out.println(a1);//这句话出现编译错误--报错--不能访问外部类方法中定义的变量
System.out.println(a2);//把变量声明为final常量，final的另一用法
//final 提高局部变量的可见性声明时需要同时赋值并初始化
}
}
//类的作用范围为这个方法体内，所以对象的创建在这个类声明以后
inner in=new inner();
{
class a{}//代码块中的内部类
}

}
//inner in=new inner();//因为在方法体之外所以报错
//总结：局部内部类具有普通类的功能
//内部类如果访问它所在方法中的局部变量是无法获取的
//解决办法加上final关键字，提高变量的可见性
//局部内部类的对象只能在该方法体的局部创建只能在局部类定义的后面创建对象
}

匿名内部类
出现背景
经常出现在使用其他技术时，出现接口类的情况，此时无法创建接口类型的实现
实例如下
public interface Fruit {
void seed();
void grow();
}
public class Worker {

public void getFruit(Fruit fruit)
{
System.out.println("this is a no name class");
fruit.grow();
fruit.seed();
}
}
public class Test1 {
public static void main(String[] args) {
Worker w=new Worker();
w.getFruit(new Fruit(){

@Override
public void seed() {
// TODO Auto-generated method stub
System.out.println("the seed is planted");

}

@Override
public void grow() {
// TODO Auto-generated method stub
System.out.println("it's growing");

}});
//1.匿名类没有名字
//2.匿名类是一个子类
//3.匿名类用它父类（接口，抽象）当名字，父接口的名字
//4.执行效率奇高
//多用在android开发中
//匿名类实现父类（接口，抽象）中的方法
}

}
//总结在代码中写了，有错请批评指出，谢谢哈

作者: xiongfangyuan 时间: 2015-6-30 23:28
当内部类定义在在外部类类成员位置上，非私有，可以在外部其他类中直接访问可以被成员修饰符修饰
当内部类定义在局部位置时不可以被成员修饰符修饰，访问他的局部变量时只能访问被final修饰的局部变量
外部类名.内部类名.变量名=外部类对象.内部类对象
Other.Inner in=new Other().new Inner();
在外部类中直接调用非静态方法
new Other.Inner().function()
在外部类中直接调用静态方法
Other.Inner.function()

作者: zhangshuai_123 时间: 2015-7-1 16:41
内部类可以直接访问外部类中的所有成员，包括私有的。
而外部类要想访问内部类中的成员，必须创建内部类的对象

作者: nosbong 时间: 2015-7-3 10:21
1.内部类可以直接访问外部类中的成员，包括私有
之所以可以直接访问外部类中的成员，是因为内部类中持有了一个外部类的引用，格式：外部类名。this
2.外部类要访问内部类，必须建立内部类对象

访问格式：
1.当内部类定义在外部类的成员位置上，而且非私有，可以在外部其他类中。
可以直接建立内部类对象
格式：
外部类名.内部类名变量名= 外部类对象.内部类对象；
Outer.Inner in = new Outer().new Inner();
2.当内部类在成员位置上，就可以被成员修饰符所修饰
比如，private 将内部类在外部类中进行封装
static 内部类就具备了static的特性
当内部类被static修饰后，只能直接访问外部类的static成员，出现了访问局限

在外部其他类中，如何直接访问static内部类的非静态成员呢？
new Outer.Inner().function();

在外部其他类中，如何直接访问static内部类的静态成员呢？
outer.Inner.function();

注意：当内部类中定义了静态成员，该内部类必须是static的
当外部类中的静态方法访问内部类时，内部类也必须是静态方法

作者: a80194367 时间: 2015-7-5 08:17
果断来学习，不解释

作者: chytth 时间: 2015-7-6 22:23
内部类可以使用外部类的所有方法与变量，外部类方法通过new 内部类对象来使用内部类的方法。

作者: wx_HWRW5aF7 时间: 2015-7-8 22:53
1、内部类可以直接访问外部类成员，包括私有。
2、外部类访问内部类，必须建立内部类对象（内部类非私有）。
   直接访问内部类成员例：Outer.Inner in = new Outer().newInner();
3、内部类在成员位置上可以被private、static修饰。
4、静态内部类只能访问外部类中被static修饰的成员。
5、直接访问static内部非静态成员：--------- = new Outer.Inner().function();
   直接访问static内部静态成员：Outer.Inner.function
6、内部类定义了静态成员，该内部类必须是静态的，内部类的静态方法访问内部类中的成员也必须是静态的。
7、匿名内部类的前提是，内部类必须继承一个类或实现接口。
   匿名内部类格式：new 父类或者接口（）{定义子类的内容}；

作者: llo 时间: 2015-7-9 20:46
给你找个内部类怎么调用外部类的方法你看看吧网上这个例子看着比较简单

public class B {
int i = 0;
public void e(){
System.out.println("我是外部内的方法");
}
class C{
public void d(){
e();
}
}
public static void main(String[] args) {
new B().new C().d();
}
}

作者: xiaoqiao 时间: 2015-7-10 14:02
我是观看的啦

作者: 康恒强 时间: 2015-7-12 07:06
长知识了

作者: 编程小黑 时间: 2015-7-19 00:12
暂时无法解决你的问题，老师讲这个的时候我也蒙了，但是我又不想回去复习这部分内容:dizzy:

作者: 潜力良驹 时间: 2015-7-19 21:24
/*
内部类：在A类内部中定义另外一个B类，B类则称作为内部类。

注意：内部类的class文件的命名是：外部类$内部类.class . 这样子的命名意义主要是为了区分开目前内部类是属于哪个外部类的。

内部类的类型:

成员内部类:

成员内部类的访问方式：
方式一：在外部类提供一个方法用于创建内部类的对象，然后进行访问。
方式二：在其他类直接创建内部类的对象。
格式：
外部类.内部类变量名  = new 外部类().new 内部类();

内部类的好处：内部类可以直接访问外部类的任何成员。

内部类的应用场景：
我们在描述一类A事物的时候，发现该A事物内部还具备另外一个事物B，而且B事物需要用到
A事物的一些成员数据，那么这时候B事物我们就可以使用内部类来描述。

比如：
class 人{

氧气

血液

class 心脏{

}
}

内部类要注意的事项：
1. 如果外部类与内部类存在着同名的成员时，在内部类中默认是访问内部类的成员(就近原则)。
如果需要指定访问外部类的成员，可以使用  "外部类.this.成员"格式进行指定访问。
2. 如果一个内部类使用了private修饰，那么该内部类就只能在外部类提供一个方法创建内部类的
对象了，在其他类无法再创建该内部类的对象。
3. 如果内部出现了静态的成员，那么该内部类也必须使用static修饰.

疑问：为什么内部出现了静态的成员，那么该内部类就必须使用static修饰？？

*/

class Outer
{
static int x=4;
static class Inner
{
static int x=3;//如果内部类有静态类型,内部类也要用静态修饰.如果想访问到int=4,注释掉这句,外部类指定的成员变量也要变成静态才能访问.
public  void print(){
System.out.println(x);//如果需要访问静态的同名成员变量,改为Outer.x
} //为什么不能Outer.this.x?因为this是非静态变量,静态不能访问.
}
public void show(){
Inner i=new Inner();
i.print();
}
}
class Demo4
{
public static void main(String[] args)
{
Outer o=new Outer();
o.show();// 结果为3 把x或者this.x,改为Outer,x 结果为4
}
}

作者: pengbin 时间: 2015-7-21 00:12
内部类作用主要实现功能的隐藏、减少内存开销，提高程序的运行速度

内部类和外部类联系：内部类可以访问外部类所有的方法和属性，如果内部类和外部类有相同的成员方法和成员属性，内部类的成员方法调用要优先于外部类即内部类的优先级比较高（只限于类内部，在主方法内，内部类对象不能访问外部类的成员方法和成员属性），外部类只能访问内部类的静态常量或者通过创建内部类来访问内部类的成员属性和方法

内部类定义的静态常量可以全局访问

创建内部类

第一种方式

假设A是外部类，B是内部类

A a=new A();

A.B b=a.new B();

或者用A类的匿名对象来访问

A.B b=new A().new B();

普通类权限

public和default

而内部类具有四种权限

A.this.name（反射机制创建当前对象）

类优先于字节码文件执行，编译完类才生成字节码文件

字节码文件可以通过反射机制来改变

类中的私有属性可以通过发射机制在类外访问，通过反射机制改变字节码文件中的东西

编译时和运行时

反射机制工作在运行时

静态内部类.

public class StaticInner {
//{
/*static class hello
{
普通代码块内不能定义静态内部类
}*
/
}*/
static
{
class hello
{
//静态代码块内可以定义静态内部类
public void test()
{
System.out.println("it's a inner class");
}
public void practice()//静态代码块内不能定义静态方法
{
System.out.println("it's a demo");
//System.out.println(a);
//method();这两句编译报错，可看出静态内部类不能访问外部类的普通成员和方法
System.out.println(a1);
test1();
//从这两句可以看出，静态内部类只能访问外部类的静态成员和静态方法
}
//从上看出静态内部类可以定义普通方法和静态方法

}
}
private int a;
private void method()
{
System.out.println("hello");
}
private static String a1;
private static void test1()
{
System.out.println("you can access this method,because it is static");
}
//静态内部类
static class Inner{
public void test()
{
System.out.println("it's a inner class");
}
public static void practice()
{
System.out.println("it's a demo");
//System.out.println(a);
//method();这两句编译报错，可看出静态内部类不能访问外部类的普通成员和方法
System.out.println(a1);
test1();
//从这两句可以看出，静态内部类只能访问外部类的静态成员和静态方法
}
//从上看出静态内部类可以定义普通方法和静态方法

}

}

静态内部类创建对象

StaticInner.Inner inn=new StaticInner.Inner();

这里可以把内部类当做外部类的一个静态成员

局部内部类

定义在方法体内

定义在普通代码块内

实例如下

public class Outer {
private int a;
private void practice()
{
System.out.println("This is a outer class method");
}
public void method()
{
int a1;
final int a2=0;
class inner
{
public void test()
{
//能访问外部类任何属性和方法
System.out.println(a);
practice();
//
// System.out.println(a1);//这句话出现编译错误--报错--不能访问外部类方法中定义的变量
System.out.println(a2);//把变量声明为final常量，final的另一用法
//final 提高局部变量的可见性声明时需要同时赋值并初始化
}
}
//类的作用范围为这个方法体内，所以对象的创建在这个类声明以后
inner in=new inner();

{
class a{}//代码块中的内部类
}

}
//inner in=new inner();//因为在方法体之外所以报错
//总结：局部内部类具有普通类的功能
//内部类如果访问它所在方法中的局部变量是无法获取的
//解决办法加上final关键字，提高变量的可见性
//局部内部类的对象只能在该方法体的局部创建只能在局部类定义的后面创建对象
}

匿名内部类

出现背景

经常出现在使用其他技术时，出现接口类的情况，此时无法创建接口类型的实现

实例如下

public interface Fruit {
void seed();
void grow();
}

public class Worker {

public void getFruit(Fruit fruit)
{
System.out.println("this is a no name class");
fruit.grow();
fruit.seed();
}
}

public class Test1 {
public static void main(String[] args) {
Worker w=new Worker();
w.getFruit(new Fruit(){

@Override
public void seed() {
// TODO Auto-generated method stub
System.out.println("the seed is planted");

}

@Override
public void grow() {
// TODO Auto-generated method stub
System.out.println("it's growing");

}});
//1.匿名类没有名字
//2.匿名类是一个子类
//3.匿名类用它父类（接口，抽象）当名字，父接口的名字
//4.执行效率奇高
//多用在android开发中

//匿名类实现父类（接口，抽象）中的方法
}

}

作者: guohognbo 时间: 2015-7-23 22:02
内部类
一个类定义到另一个类的内部.对于内部的这个类就被称为内部类(嵌套类).
特点
内部类可以直接访问外部类的成员,
外部类想访问内部类的成员必须创建内部类的对象.

内部类分类及使用
分类:
成员内部类
局部内部类
使用:
内部类使用格式:
外部类名.内部类名变量名 = 外部类对象.内部类对象;
例如: Outer.Inner oi = new Outer().new Inner();

成员内部类
修饰符:
private -- 为了安全.

static -- 为了方便
调用格式:
外部类名.内部类名变量名 = new 外部类名.内部类名();
例如:Outer.Inner oi = new Outer.Inner();

局部内部类:
局部内部类访问外部类的局部变量,变量就需要加final修饰.
原因:延长变量的生命周期.

作者: myself123 时间: 2015-7-24 21:31
外部类没什么好说的，平时使用的类都是外部类，内部类是在外部类中定义的类，可以直接访问外部类中的成员，因为内部类持有了外部类的引用，访问格式：外部类名.this.成员名。而外部类需要访问内部类需要创建内部类的对象。如：class Outer
{
private static int num = 30;

class Inner// 内部类。
{
void show()
{
System.out.println("show run..."+num);
}
/*static void function()//如果内部类中定义了静态成员，该内部类也必须是静态的,即static class Inner()
{
System.out.println("function run ...."+num);
}
*/
}

public void method()
{
Inner in = new Inner();
in.show();
}
}

class InnerClassDemo
{
public static void main(String[] args)
{
Outer out = new Outer();
out.method();
直接访问外部类中的内部类中的成员。
Outer.Inner in = new Outer().new Inner();
in.show();

//如果内部类是静态的。相当于一个外部类
// Outer.Inner in = new Outer.Inner();
// in.show();

//如果内部类是静态的，成员是静态的。
// Outer.Inner.function();

}
}

另一种特殊情况：内部类可以存放在局部位置上，内部类在局部位置上只能访问局部中被final修饰的局部变量。
class Outer
{
int num = 3;
void method()
{
final int x = 9;

class Inner
{
void show()
{
System.out.println("show..."+x);
}
}
Inner in = new Inner();
in.show();
}
}
class InnerClassDemo
{
public static void main(String[] args)
{
new Outer().method();
}
}

作者: 辉大大 时间: 2015-7-24 22:46
/*
内部类：
就是把类Ｂ定义在类Ａ里面，Ｂ就被称为内部类。

内部类的位置：
A:成员位置 - 成员内部类
B:局部位置 - 局部内部类

成员内部类：
如果想在测试类中，直接使用内部类。那么请按照如下格式：
外部类名.内部类名变量 = 外部类对象.内部类对象;
*/
class Outer
{
private int num = 10;

class Inner
{
public void show()
{
System.out.println(num);
}
}

public void method()
{
Inner i = new Inner();
i.show();
}
}

class InnerTest
{
public static void main(String[] args)
{
//Outer o = new Outer();
//o.method();

//我能不能直接使用Inner类呢
//Inner i = new Inner();
//i.show();
//可以用，但是必须加限定。
//格式：
//外部类名.内部类名变量 = 外部类对象.内部类对象;
Outer.Inner oi = new Outer().new Inner();
oi.show();
}
}

作者: 崔宝文 时间: 2015-8-4 00:06
内部类，是在一个类的内部在定义一个新的类，在访问时内部类可以直接访问外部类成员，但是外部类访问内部类时任然要建立内部类对象，通过对象调用。

欢迎光临黑马程序员技术交流社区 (http://bbs.itheima.com/)

黑马程序员IT技术论坛 X3.2