package com.itheima;
class Outer
{
        private int x=3;
        private void function()
        {
                System.out.println(x);
        }
        class Inner
        {
                Inner in=new Inner();
                System.out.println("inner"+x);
               
        }
       
}
public class Test8
{
   public static void main(String[] args)
   {
          
   }
}
怎么样创建一个内部类它有一个方法可用来修改外部类的属性，并调用外部类的方法。在外部类的另一个方法中，创建此内部类的对象，并且调用它的方法。

哥们你是不是把黑马考试题扔上来了？？？

内部类的访问规则：
1，内部类可以直接访问外部类中的成员，包括私有。
        之所以可以直接访问外部类中的成员，是因为内部类中持有了一个外部类的引用，格式 外部类名.this
2，外部类要访问内部类，必须建立内部类对象。

访问格式：
1,当内部类定义在外部类的成员位置上，而且非私有，可以在外部其他类中。
可以直接建立内部类对象。
格式
        外部类名.内部类名  变量名 = 外部类对象.内部类对象;
        Outer.Inner in = new Outer().new Inner();

2,当内部类在成员位置上，就可以被成员修饰符所修饰。
        比如，private：将内部类在外部类中进行封装。
                static:内部类就具备static的特性。
                当内部类被static修饰后，只能直接访问外部类中的static成员。出现了访问局限。

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

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

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



       
当描述事物时，事物的内部还有事物，该事物用内部类来描述。
因为内部事务在使用外部事物的内容。

class Body
{
        private class XinZang
        {

        }

        public void show()
        {
                new XinZang().
        }
       
}





*/
class Outer
{
        private static  int x = 3;

       
        static class Inner//静态内部类
        {
                static void function()
                {
                        System.out.println("innner :"+x);
                }
        }

        static class Inner2
        {
                void show()
                {
                        System.out.println("inner2 show");
                }
        }

        public static void method()
        {
                //Inner.function();
                new Inner2().show();
        }

}


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

1 内部类就是放在别的类的里面的类。可以放在成员位置上 以及 函数的局部。
2 内部类可以直接访问外部类的成员数据和方法。
3 外部类要访问内部类就必须先建立内部类的对象。创建对象时要记得加外部类名。

贾飞雨 发表于 2012-8-27 00:25
哥们你是不是把黑马考试题扔上来了？？？

:lol......

黄树人 发表于 2012-8-27 01:27
内部类的访问规则：
1，内部类可以直接访问外部类中的成员，包括私有。
        之所以可以直接访问外部类中的成员 ...

恩。。。明白了

这是我的基础测试题的第六题，是我做的，比较简单。可以参考下：

1. package com.itheima;
   
2. /*
   
3. * 6、 创建一个包含有private的属性和private方法的类。然后创建一个内部类，
   
4. * 它有一个方法可用来修改外部类的属性，并调用外部类的方法。在外部类的另一
   
5. * 个方法中，创建此内部类的对象，并且调用它的方法。
   
6. */
   
7. public class Test6 {
   
8. 
   
9.         public static void main(String[] args) {
   
10.                 A a = new A();
    
11.                 a.play2();
    
12.         }
    
13. 
    
14. }
    
15. 
    
16. class A {
    
17.         //创建一个包含有private的属性
    
18.         private int age;
    
19.         //创建一个包含有private的方法
    
20.         private void play1() {
    
21.                 System.out.println("I has been invoked!");
    
22.         }
    
23.         class B {
    
24.                 public void changeValue(int value) {
    
25.                         age = value;
    
26.                         System.out.println("age="+age);
    
27.                         play1();
    
28.                 }
    
29.         }
    
30.         
    
31.         public void play2(){
    
32.                 B b = new B();
    
33.                 b.changeValue(10);
    
34.         }
    
35. }

复制代码