创建一个包含有private的属性和private方法的类。然后创建一个内部类，它有一个方法可用来修改外部类的属性，并调用外部类的方法。在外部类的另一个方法中，创建此内部类的对象，并且调用它的方法.

弄了好久脑袋转不过来弯了  求大神解析!

1. public class Test6 {
   
2.        
   
3.         public static void main(String []args){
   
4.                 OutClass oc = new OutClass();
   
5.                 oc.newClass();
   
6.         }
   
7. }
   
8. class OutClass
   
9. {
   
10.         /*内部类*/
    
11.         class InClass
    
12.         {
    
13.                 public void setName(){
    
14.                         /*修改外部类属性*/
    
15.                         name = "czbk";
    
16.                         /*调用外部类方法*/
    
17.                         printName();
    
18.                 }
    
19.         }
    
20.         /*外部类属性name*/
    
21.         private String name = "liang";
    
22.         /*外部类方法*/
    
23.         public void printName(){
    
24.                 System.out.println(name);
    
25.         }
    
26.         /*外部类方法中创建内部类对象*/
    
27.         public void newClass(){
    
28.                 InClass in = new InClass();
    
29.                 in.setName();
    
30.         }
    
31. }

复制代码

郭利超 发表于 2013-4-2 22:58
this.i=out.i;  请问你的this.i 是哪个i啊    这句是不是把外部i的值赋给内部了?   运行结果是8   这个内 ...

1. class OutDemo
   
2. {
   
3.         private int i=2;
   
4.        
   
5.         private void b()
   
6.         {
   
7.                 System.out.println("test");
   
8.         }
   
9.         void c()
   
10.         {
    
11.                 Inner in = new Inner();
    
12.                 in.a();
    
13.         }
    
14.        
    
15.         class Inner
    
16.         {
    
17.         int i = 6;
    
18.                 void a()                                                     //
    
19.                 {
    
20.                         OutDemo out = new OutDemo();
    
21.                         out.i = i;                                       //此处修改
    
22.                         System.out.println(i);
    
23.                         out.b();
    
24.                 }
    
25.         }
    
26.        
    
27.         public static void main(String args[])
    
28.         {
    
29.                 new OutDemo().c();
    
30.         }
    
31. }

复制代码

这样是不是，就符合要求了呢

1. class Outer1
   
2. {
   
3.         //创建包含private的属性
   
4.         private int x = 3;
   
5.         //创建包含private的方法
   
6.         private void method_1()
   
7.         {
   
8.                 System.out.println("method_1运行。。。"+x);
   
9.         }
   
10.         //创建内部类
    
11.         class Inner
    
12.         {
    
13.                 void method_2()
    
14.                 {
    
15.                         //修改外部类属性，并调用外部类方法
    
16.                         int x = 5;
    
17.                         System.out.println("method_2运行。。。"+x);
    
18.                         method_1();
    
19.                 }
    
20.         }
    
21.         //创建内部类对象并调用方法
    
22.         void function()
    
23.         {
    
24.                 Inner in= new Inner();
    
25.                 in.method_2();
    
26.         }
    
27. }
    
28. class Test5
    
29. {
    
30.         public static void main(String[] args)
    
31.         {
    
32.                 new Outer1().function();
    
33.         }       
    
34. }

复制代码

public class People {

        private String name;
       
        private double money;
       
        private int age;
       
        public double getMoney() {
                return money;
        }

        public void setMoney(double money) {
                this.money = money;
        }

        public String getName() {
                return name;
        }

        public void setName(String name) {
                this.name = name;
        }

        public int getAge() {
                return age;
        }

        public void setAge(int age) {
                this.age = age;
        }


       
        class Heart{
                //内部类可以直接访问外部类的成员变量，也可以修改。
                double s = hasMoney(money);//内部类可以直接访问外部类的成员变量，也可以修改。
                //功能：心跳
                void run(){
                        System.out.println("心脏在跳动,因为有"+s+"元");
                }
               
        }
       
        public void show(){
                //在外部类中建立内部类对象
                Heart heart =  new Heart();
                //在外部类中调用内部类方法
                heart.run();
        }
        //功能：有多少钱
        private double hasMoney(double money){
                return money;
        }
       
        public static void main(String[] args) {
               
                People people = new People();
                people.setMoney(100000);
                people.show();
               
        }

}

黑马_位志国 发表于 2013-4-2 22:32
创建一个包含有private的属性和private方法的类。然后创建一个内部类，它有一个方法可用来修改外部类的属性 ...

还是兄弟你的阅读性强

赵喜平 发表于 2013-4-2 22:34
class OutDemo
{
        private int i=2;

this.i=out.i;  请问你的this.i 是哪个i啊    这句是不是把外部i的值赋给内部了?   运行结果是8   这个内部修改外部的值怎么体现的?

class OutDemo
{
        private int i=2;
       
        private void b()
        {
                System.out.println("test");
        }
        void c()
        {
                Inner in = new Inner();
                in.a(8);
        }
       
        class Inner
        {
        int i;
                void a(int i)
                {
                        OutDemo out = new OutDemo();
                        this.i=out.i;
                        System.out.println(i);
                        out.b();
                }
        }
       
        public static void main(String args[])
        {
                new OutDemo().c();
        }
}


随便写的  仅供参考

创建一个包含有private的属性和private方法的类。然后创建一个内部类，它有一个方法可用来修改外部类的属性，并调用外部类的方法。在外部类的另一个方法中，创建此内部类的对象，并且调用它的方法.

实例：

class Outer{
        //外部类的私有成员
        private int num = 6;
        //内部类
        class Inner{
                public void function(){
                        num = 9;//修改外部类的属性
                        method();//调用外部类的方法
                }
        }
       
        public void show(){
                //创建内部类的对象，并调用该内部类中的方法
                new Inner().function();
        }
        //外部类的私有方法
        private void method(){
                System.out.println("num :: " + num);
        }
       
}

public class Test{
        public static void main(String[] args) {
                new Outer().show();
        }
}

1. class 外部类{
   
2. private 属性；
   
3. private 方法();
   
4. 外部类调用内部类的方法()
   
5. {
   
6.         内部类 xx = new 内部类();
   
7.         xx.内部类方法();
   
8. }
   
9.         class 内部类{
   
10.                 内部类方法()
    
11.                 {
    
12.                         外部类属性 = 修改属性；
    
13.                         外部类方法();
    
14.                 }
    
15.         }
    
16. }
    
17. 
    
18. 大概就是这么个意思吧

复制代码

1. 
   
2. public class Test {
   
3.        
   
4.         private int myField = 0;
   
5. 
   
6.         private void myMethod(){
   
7.                 System.out.println("the method was invoked and myFiled = " + myField);
   
8.         }
   
9.        
   
10.         class Inner{
    
11.                
    
12.                 public void innerMethod(){
    
13.                         myField = 1;
    
14.                         myMethod();
    
15.                 }
    
16.         }
    
17.        
    
18.         public static void main(String[] args) {
    
19.                 Test test = new Test();
    
20.                 Inner inner = test.new Inner();
    
21.                 inner.innerMethod();
    
22.         }
    
23. }
    

复制代码

我刚写个程序，觉得已经符合你的要求了，有点粗陋，只供参考：

class MethodDemo{
        private String name;
        private void show(){
                System.out.println("我被调用了，我的名字是："+name);
        }
        class inner{
                public void change(){
                  name="king";
                  show();
                }
        }
        public  void addMethod(){
                new inner().change();
        }
}
public class Test {
        public static void main(String[] args) {
                new MethodDemo().addMethod();


        }


}
结果：我被调用了，我的名字是：king