1. class Demo0706
   
2. {
   
3.         public static void main(String[] args)
   
4.         {
   
5.                 Student stu = new Student("小黑");
   
6.                 System.out.println(stu.name);
   
7.         }
   
8. 
   
9.         class Person
   
10.         {
    
11.                 String name;
    
12.                 Person(String name)
    
13.                 {
    
14.                         this.name = name;
    
15.                 }
    
16.                 void show()
    
17.                 {
    
18.                         System.out.println("father's name :"+name);
    
19.                 }
    
20.         }
    
21.         class Student extends Person
    
22.         {
    
23.                 Student(String name)
    
24.                 {
    
25.                         super(name);
    
26.                 }
    
27.                 void method()
    
28.                 {
    
29.                         super.show();
    
30.                 }
    
31.         }
    
32. }

复制代码

我感觉第5行代码中的new Student()；应该把“小黑”传到Student的构造函数中，然后通过super

(name);把“小黑”传到父类Person中的构造函数中，再对父类初始化，然后对Student初始化；我

这个也没有定义静态的东西，怎么会提示这个错误，希望朋友们帮解释下。

你将 Person和Student类定义在的Demo0706 中
将Person和Student类放到Demo0706外，运行就能通过了。

你定义的两个类，不应该写在主类中。把class Person和class Student extends Person两个类放到class Demo0706
的外面就ok了！
现在等于两个类是内部类，调用内部类的时候要加修饰符的。
假如不移动位置，把两个类前加上public static修饰也ok的。这时，这两个类属于内部类。

这里涉及到外部类 和内部类的问题
现在Person 和 student 都是 Demo0706的内部类
外部类的静态方法访问成员内部类 格式为：
public static void main {
//step1 建立外部类对象
Outer out = new Outer();
//step2 根据外部类对象建立内部类对象
Inner inner = out.new Inner();
//step3 访问内部类的方法
inner.inner_f1();
}


或者 你也可以把 person 类和student 类移到Demo0706 的外面。
格式为：
class Demo0706
{}
class Person
{}
class Student extends
{}

谢谢大家，以解决，以前没有注意过这个问题，呵呵。
以前感觉类和函数差不多，都可以自由嵌套。

李征雪 发表于 2012-3-28 11:52
谢谢大家，以解决，以前没有注意过这个问题，呵呵。
以前感觉类和函数差不多，都可以自由嵌套。 ...

可以嵌套，只是前面要使用修饰符public 调用类是静态的话，引用的类也要加上静态。
任何类或者方法，只能调用比自己权限大的类或者方法。

1. ~~~~~~~~~~~~~~~~~~~~

复制代码

因为主函数是静态方法。。

main是静态的，而name是非静态的，所以你在main方法里没法操作name.

main方法是static静态的，而name没有static修饰是非静态的,静态方法只能操作静态变量
static 修饰的属性和方法，既可以通过类调用，也可以使用实例调用；
没static 修饰的属性和方法，只能使用实例来调用

关于static简单总结如下：
用static 修饰的成员表示它属于这个类共有不使用static修饰的属性和方法，成员属于类的单个实例
特点：
        随着类的加载而加载
        优先于对象存在
        被所有对象所共享
        可以直接被类名调用
使用注意：
        静态方法只能访问静态成员
        静态方法中不可以写this，super关键字
        主方法（main）是静态的
        public static void main(String[] agrs){}

1. class Demo
   
2. {
   
3.         public static void main(String[] args)
   
4.         {
   
5.                 Student stu = new Student("小黑"); //主函数是静态的，调用所属类中的内部成员时，成员也必须是静态的
   
6.                 System.out.println(stu.name);
   
7.         }
   
8. 
   
9.          static class Person
   
10.         {
    
11.                 String name;
    
12.                 Person(String name)
    
13.                 {
    
14.                         this.name = name;
    
15.                 }
    
16.                 void show()
    
17.                 {
    
18.                         System.out.println("father's name :"+name);
    
19.                 }
    
20.         }
    
21.         static class Student extends Person  //此处添加 static ,由于此类中有父类引用，将父类也添加static即可
    
22.         {
    
23.                 Student(String name)
    
24.                 {
    
25.                         super(name);
    
26.                 }
    
27.                 void method()
    
28.                 {
    
29.                         super.show();
    
30.                 }
    
31.         }
    
32. }

复制代码