class Person
{
   String name;
   int age;
  public void speak()
  {
   System.out.println("name="+name+"age="+age);
  }
}
class Student extends Person
{
  
  void study()
  {
   super.speak();
  }
  
}
class Worker extends Person
{
  
  void work()
  {
   super.speak();
  }
  
}
class PersonDemo
{
  public static void main(String[] args)
  { }

   void doit()
   {
    Student s= new Student();
    s.name="张同学";
    s.age=20;
    s.study();
    Worker w = new Worker();
    w.name="于师傅";
    w.age=55;
    w.work();
    }
}

这个还是写得有问题，怎么样让传的值显示出来，还有他在内存中的执行顺序是怎么样的呢

class Person
        {
                 String name;
                 int age;
                public void speak(String name,int age)
                {
                        System.out.println ("name="+name+"age="+age);
                }
        }
        class Student extends Person
        {
               
                void study()
                {
                        super.speak("张同学",23);
                }
               
        }
        class Worker extends Person
        {
               
                void work()
                {
                        super.speak("于师傅",35);
                }
               
        }

       
        class PersonDemo
        {
                public static void main(String[] args)
                {
                        Student s= new Student();
                        Worker w = new Worker();

                        s.study();
                        w.work();
                }
                       
               
        }


刚回去琢磨了下，重新写出来了，谢谢各位的回复，学习了

执行顺序如下：
class Person                                         
{
    String name;                                 
    int age;
   public void speak()                               //1.9输出Student信息                //2.6输出Worker的信息
    {
System.out.println("name="+name+"age="+age);
   }
}
class Student extends Person                //1.3当执行到Student的默认构造方法时先默认调用Person的无参构造方法。如此就有了name和age等属性
{
   
   void study()                                       //1.7
｛
  super.speak();                                    //1.8
｝

}
class Worker extends Person                //2.0 和Student一样在用Worker的构造方法时先默认调用Person的无参构造方法。如此就有了name和age等属性
{
   
   void work()                                     //2.4
      {
   super.speak();                                //2.5
}
  
}
class PersonDemo
{
   public static void main(String[] args)
   {
    new PersonDemo().doit();                     // 1.0
   }
   void doit()                                            // 1.1
    {
     Student s= new Student();                  //1.2
     s.name="张同学";                              //1.4
     s.age=20;                                         //1.5
     s.study();                                        //1.6
     Worker w = new Worker();                //1.9
   w.name="于师傅";                              //2.1
  w.age=56                                           //2.2
  w.work();                                           //2.3
}
}

你本意是想像老师那样（method_123..）把功能封装为方法吧？
封装的时候需要注意：
1、你这里没有加静态修饰符static
   方法需要改为：static void doit(){...}
2、然后，你在主函数下没有调用它。。。
   需要在主函数中调用：
      public static void main(String[] args)
      {
           doit();
      }
最终修改好的应该如下代码：
class Person
{
   String name;
   int age;
  public void speak()
  {
   System.out.println("name="+name+"age="+age);
  }
}
class Student extends Person
{
  
  void study()
  {
   super.speak();
  }
  
}
class Worker extends Person
{
  
  void work()
  {
   super.speak();
  }
  
}
class PersonDemo
{
  public static void main(String[] args)
  {
    doit();
  }
   static void doit()
   {
    Student s= new Student();
    s.name="张同学";
    s.age=20;
    s.study();
    Worker w = new Worker();
    w.name="于师傅";
    w.age=55;
    w.work();
    }
}

内存中的顺序：
1、首先启动这个文件~而随之的静态函数是随着类加载而加载的，也就是内存内同时加载主函数main和doit。
2、然后主函数中有doit();即运行这个方法（前面是加载到内存中，这里才运行）。
3、接着看doit方法里啦：
    这些建立对象引用等。。。相信你都明白~主要是前面那1、2步骤有点晕吧~
大概是这样哈

class Person
{
    String name;
    int age;
   public void speak()
   {
    System.out.println("name="+name+"age="+age);
   }
}
class Student extends Person
{
   
   void study()
   {
    super.speak();
   }
   
}
class Worker extends Person
{
   
   void work()
   {
    super.speak();
   }
   
}
class PersonDemo
{
   public static void main(String[] args)
   {
           new PersonDemo().doit();    //创建PersonDemo类并调用他doit方法
   }

   void doit()
    {
     Student s= new Student();
     s.name="张同学";
     s.age=20;
     s.study();
     Worker w = new Worker();
     w.name="于师傅";
     w.age=55;
     w.work();
     }
}

这样改写后是可以运行的

结果：
name=张同学age=20
name=于师傅age=55

面向对象的特点，高内聚低耦合，尽量把功能细分，你可以在方法中调用方法，但是不要在方法中定义方法。

1. class Person
   
2. {
   
3.    String name;
   
4.    int age;
   
5.    public void speak()
   
6.    {
   
7.                 System.out.println("name="+name+"age="+age);
   
8.    }
   
9. }
   
10. class Student extends Person
    
11. {  
    
12.   void study()
    
13.   {
    
14.         super.speak();
    
15.   }
    
16. }
    
17. class Worker extends Person
    
18. {  
    
19.   void work()
    
20.   {
    
21.    super.speak();
    
22.   }  
    
23. }
    
24. class PersonDemo
    
25. {
    
26.   public static void main(String[] args)
    
27.   {
    
28.          Student s= new Student();
    
29.           s.name="张同学";
    
30.           s.age=20;
    
31.          s.study();
    
32.           Worker w = new Worker();
    
33.          w.name="于师傅";
    
34.          w.age=55;
    
35.         w.work();
    
36.   }
    
37. }

复制代码

你为什么要放在doit()这个函数里呢？我也刚看到这里，相互学习

李盼 发表于 2012-6-15 17:09
你在main方法里面写了一个方法啊，java不允许在方法中定义方法！

是的是的，多写了

你犯了这样一个错误：
public static void main(String[] args)
{
   void doit()｛...｝
}
方法中定义方法，在Java中是不允许的。
具体你可以参看该帖：http://bbs.itheima.com/thread-17120-1-1.html

你在main方法里面写了一个方法啊，java不允许在方法中定义方法！