non-static class cannot be referenced from a static context

Related searches

This question already has answers here:

A non-static nested class in Java contains an implicit reference to an instance of the parent class. Thus to instantiate a Node, you would need to also have an instance of Stack. In a static context (the main method), there is no instance of Stack to refer to. Thus the compiler indicates it can not construct a Node.

If you make Node a static class (or regular outer class), then it will not need a reference to Stack and can be instantiated directly in the static main method.

See the Java Language Specification, Chapter 8 for details, such as Example 8.1.3-2.

Non-static variable cannot be referenced from a static context , A reference cannot be made from a static to a non-static method. Static variables are class variables which belong to the class with only one instance created initially. Whereas, non-static variables are initialized every time you create an object for the class. A non-static variable(instance variable) only exists when there is an instance of an object. A static method/variable belongs to the class itself and a non-static (aka an object instance) method belongs to each object that is generated from that class. You can access member variable of a class directly only by making it as static.

Non-static nested classes (inner classes) have access to other members of the enclosing class, even if they are declared private. Static nested classes do not have access to other members of the enclosing class. As a member of the OuterClass, a nested class can be declared private, public, protected, or package private.

To instantiate an inner class, you must first instantiate the outer class. Then, create the inner object within the outer object with this syntax : OuterClass.InnerClass innerObject = outerObject.new InnerClass();

public static void main(String[] args){
         Stack stack = new Stack();
         Stack.Node node = new Stack().new Node();
    }

public class Stack
{
    private class Node{
        ...
    }
    ...
    ...
    ...  

    public static void main(String[] args){
             Node node = new Stack().new Node(); 
    }
}

“A Non-static method cannot be referenced from a static context” error, Non-static variables are initialized every time you create an object of the class. Now, coming to your question, when you use new() operator we� error: non-static variable N cannot be referenced from a static context As we can see that the above program gives the error. Though in the above code, all the objects names have the same variable name N, if we try to increment N, its giving an error. This error is very common during object oriented programming.

Java has two types of nested member classes: static and non-static (aka inner). The Node class is a non-static nested class. In order to create an instance of a Node you must have an instance of a Stack:

Stack s = new Stack();
Node n = s.new Node();

class Program { int count = 0; public static void main(String[] args) { System.out. println(count) ); ^ How can my class variables get recognized? In Java, static methods belong to the class rather than the instance. This means that you cannot call other instance methods from static methods unless they are called in an instance that you have initialized in that method.

Make your (Node) class static

private static class Node {

You cannot access non-static members from static context. The main method is static while the Node is non-static. So, you can either use an instance of outer class to instantiate the non-static inner member class. But, in this case I think it would make more sense to make it static.

Or you could declare the class Node outside of public class Stack

Like so,

    public class Stack
    {

        public static void main(String[] args){
             Node node = new Node();         
}        
    }  
    class Node{

    }

4 The main method is static meaning that it belongs to the class and not some object. As such, it a static context cannot reference an instance variable because it wouldn't know what instance of Runner it would use if there even was one. In short, the solution is to make your Tasks object static in the Runner class.

Static method cannot be referenced from a non static context - Test Class 2 Location.newInstance method gives error: Method does not exist or incorrect signature: void newInstance(Decimal, Decimal) from the type String

So java compiler not letting the things to be handled at run time resolves at compile time. That's why it is giving you error non-static things can not be referred from static context. You just need to read about Class Level Scope, Instance Level Scope and Local Scope. Answer 6.

A reference cannot be made from a static to a non-static method. To make it clear, go through the differences below. Static variables are class variables which belong to the class with only one instance created initially. Whereas, non-static variables are initialized every time you create an object for the class.

Comments

"Node" should not be an inner class of "Stack". IMHO...
Node x = new Stack().new Node(); is another way to solve this problem, but I find that when I make the Stack class generic -- Stack<Item>, and write code like: Node x = new Stack<String>().new Node();, it it's wrong again with the same error message. Do you know why?
@zbjosh Try typing x as Stack<String>.Node.
@PaulBellora , thanks, it works!! But...what's the problem in it
@Bin The problem is that every time you want a single Node object you are instantiating an entire Stack, which is a waste of resources and garbage collection.
I test it, but it's wrong with the same error message...
"non-static class Node cannot be referenced from a static context", I don't know why ?
I know it, but can you explain it in detail ?
You cannot access non-static members from static context. The main method is static while the Node is non-static. So, you can either use an instance of outer class to instantiate the non-static inner member class. But, in this case I think it would make more sense to make it static. You just need one definition of the Node which can stick with the outer "class" and you will still be able instantiate it whenever need without the need to have an instance of the outer class.