Question

我已经搜索过这个问题，但仍未找到任何解决方案。

我宣布了这个简单的程序：

print df['sentiment']

#0    {u'neg': 0.0, u'neu': 0.919, u'pos': 0.081, u'...
#1    {u'neg': 0.0, u'neu': 0.256, u'pos': 0.744, u'...

print type(df['sentiment'][0])

#<type 'dict'>

print pd.DataFrame(x for x in df['sentiment'])

#   compound  neg    neu    pos
#0    0.4404    0  0.919  0.081
#1    0.4404    0  0.256  0.744

但它一直给我错误：

错误：非静态变量，无法从静态上下文引用

public class Test{
  public abstract class Person {
      public void talk(){
        System.out.print("I am a person");
      }
      public abstract void display();
  }

  public class Student extends Person {
    public void talk(){
        System.out.println("I am a student");
    }

    public void display(){
        System.out.println("Nice to meet you");
        super.talk();
    }
  }

  public static void main(String args[])
  {
    Student s = new Student();
    s.display();
  }
}

我一直都是这样声明对象的！我不知道今天发生了什么。

我需要了解我在这里做错了什么？

Answer 1

声明内部类时：

class Outer {
  class Inner {
  }

  void doSomething() {}
}

对Outer的每个实例所拥有的Inner类的实例有一个隐式引用。这意味着您可以在内部类中编写以下内容以引用外部实例：

Outer.this.doSomething();

实际上，您通常可以简单地编写doSomething() - 如果内部类也有一个名为Outer.this的方法，您只需要doSomething()，并且需要消除歧义。

这样做的长短之处在于您确实需要Outer的实例来创建Inner的实例：

Outer outer = new Outer();
Inner inner = outer.new Inner();

如果您实际上不需要在Outer内引用Inner的实例（例如，您永远不需要致电doSomething()），那么最简单的解决方案就是制作内部类static：

class Outer {
  static class Inner {}

  void doSomething();
}

事实上，我建议你总是让你的内部类是静态的，除非真的需要它们是非静态的。

Answer 2

使您的Person和Student Classes静态

OR

首先创建测试对象以在main方法中创建Student对象。

Student s = new Test().new Student();

原因：由于Person / Student类是非静态的，因此没有Test Object就不能存在。因此，要么这些类应该是静态的，要么首先创建Test（）来创建Student。

Answer 3

从Test类中删除个人和学生：

public abstract class Person { 
    public void talk(){ 
        System.out.print("I am a person"); 
    }
    public abstract void display();
} 

public class Student extends Person    { 
    public void talk(){ 
        System.out.println("I am a student"); 
    }     
    public void display(){ 
        System.out.println("Nice to meet you");
        super.talk(); 
    } 
}

public class Test{ 
    public static void main(String args[]) { 
        Student s = new Student();    
        s.display(); 
    }
 }

Answer 4

这很好用：

     abstract class Person {
        public void talk(){
            System.out.print("I am a person");
        }
        public abstract void display();
    }

     class Student extends Person {
         public void talk() {
             System.out.println("I am a student");
         }

         public void display() {
             System.out.println("Nice to meet you");
             super.talk();
         }
     }

    public class Test {


        public static void main(String args[]) {
            Student s = new Student();
            s.display();
        }
    }

来自静态上下文的非静态变量引用（Java）

4 个答案: