tiene - metodo main java

método no estático no puede ser referenciado desde un contexto estático

Question

Me gustaría entender esto de una vez por todas.

Con esto, disculpen la cantidad de código pegado a continuación, pero no quiero omitir ningún detalle.

Lo único que cambié es la URL cargada. Pero esto no está causando el error.

Me gustaría llamar a mi función " readPosiitons ". Solución fácil, hazlo estático. Solución real, no estoy seguro de.

Ayúdame a comprender mejor cómo resolver este error de la manera correcta.

¡¡Gracias!!

            /*
             * To change this template, choose Tools | Templates
             * and open the template in the editor.
             */

            package PandL;

            import java.io.BufferedReader;
            import java.io.File;
            import java.io.IOException;
            import java.io.InputStreamReader;
            import java.net.MalformedURLException;
            import java.net.URL;
            import java.util.HashMap;
            import java.util.Scanner;
            import toolBox.Secretary;
            import toolBox.Secretary.positionObj;

            /**
             *
             * @author Jason
             *
             */
            public class GarageComm {
                public static void main(String[] args) throws MalformedURLException, IOException{
                    String retStr;
                    String startM;
                    String endM;
                    String myURL;
                    String[] Split1=null;
                    Integer lnCount;
                    HashMap hashPos=new HashMap();
                    hashPos= readPositions("holdingsBU.txt");//the error is here

                    myURL="http://myUrl?s=";

                    URL url = new URL(myURL);
                    BufferedReader in = new BufferedReader(new InputStreamReader(url.openStream()));



                    in.close();
                }

                public HashMap readPositions(String destFile){

                    HashMap<String, Secretary.positionObj> hashPositions=new HashMap<String,positionObj>();
                    Secretary mySecretary=new Secretary();
                    try{
                        File F=new File(destFile);
                        if(F.exists()){
                            System.out.println("File Exists: "+F.exists());
                            System.out.println(destFile);
                            Scanner sC= new Scanner(F);

                            while (sC.hasNext()){
                                String[] Splitter1;
                                Secretary.positionObj position=mySecretary.new positionObj();


                                Splitter1=sC.nextLine().split(",");
                                position.positionDate=Double.parseDouble(Splitter1[0]);
                                position.positionTicker=(Splitter1[1]);
                                position.positionOpen=Double.parseDouble(Splitter1[2]);
                                position.positionPrice=Double.parseDouble(Splitter1[3]);
                                position.positionSMA=Double.parseDouble(Splitter1[4]);
                                position.positionUpdated=Double.parseDouble(Splitter1[5]);
                                position.priceUpdated=Double.parseDouble(Splitter1[6]);
                                position.updateDate=Double.parseDouble(Splitter1[7]);


                                hashPositions.put(position.positionTicker.trim(), position);

                            }


                        }else{
                            System.out.println("File Created: "+ F.createNewFile());
                            System.out.println("----No previous positions----");
                        }

                    }catch (Exception E){
                        System.err.println(destFile + " does not exist.");
                        hashPositions.put("ERROR", null);
                        E.printStackTrace();
                    }
                    return hashPositions;
                }
            }

Answer 1

¿Una solución real? No pongas tantas cosas en el método main() . Eso es para noobs.

Java es un lenguaje orientado a objetos. Ponga la lógica dentro de los métodos asociados con la clase GarageComm . main() debería hacer poco más que instanciar una instancia y llamar a sus métodos.

Cambiarlo así:

            GarageComm gc = new GarageComm();
            hashPos= gc.readPositions("holdingsBU.txt");//the error is here

Answer 2

Debes hacer que tu función sea estática:

public static HashMap readPositions(String destFile) {
...
}

Crear una instancia de GarageComm también funcionaría, pero esta es una mala práctica de programación en Java, ya que ese objeto no tiene estado.

Answer 3

En este caso, es una buena idea hacer el método estático. La otra forma es usar

  new GarageComm().readPositions("holdingsBU.txt")

en lugar.

Entonces, ¿por qué este error?

Un método estático no puede llamar a un método no estático en la misma clase. Suena extraño, pero hay una razón para ello. Considera esto:

• Los métodos no estáticos pueden depender del estado de los objetos, la variable de instancia para decir.

• Los métodos estáticos se pueden llamar desde afuera sin instanciar

Ahora, si permitimos que los métodos estáticos jueguen con un método no estático (y variables no estáticas), pueden fallar. Entonces, es un tipo de prevención.

¿Cuándo debería considerar hacer un método estático?

Ahora, ven, ¿por qué no hacer que el método sea static ? ,

Muy bien, debe hacer que un método sea estático si su funcionalidad no depende del estado del objeto.

Si solo usa los parámetros pasados ​​y algunas cosas estáticas (variable estática, métodos estáticos) y regresa (con / sin resultado, lanzando cualquier excepción), considere la posibilidad de convertirlo en método estático.

actualización: parecía que esta publicación confundió a un par de personas, por lo que actualizó la respuesta.

Answer 4

Este es un maestro mental típico para los nuevos programadores de Java.

Un método static no pertenece a un objeto. Un método no static pertenece a un objeto.

Utiliza la convención main -metodo para iniciar su programa, y ​​se requiere que ese método sea estático.

El truco para pasar de un método static a un método no static , es que debe crear un objeto para poder llamar al método. Es decir, new GarageComm().readPositions(...) . Simplemente no creo que tengas que hacerlo aquí, por lo que sería más simple simplemente marcar readPositions como estático también.

Answer 5

Si un método no es estático, debe llamarse "on" a un objeto. Cuando se llama a un método desde un método no estático, ese objeto está implícito: es el objeto al que se llamó el primer método. Pero al llamarlo desde un método estático, no hay ningún objeto implícito, por lo que para llamar al método, debe proporcionar un objeto:

GarageComm gc = new GarageComm();
hashPos= gc.readPositions("holdingsBU.txt");

Dado que GarageComm no tiene un estado propio, no hay razón para crear un objeto GarageComm , por lo que es mejor marcar el método como estático, por lo que no se requiere ningún objeto para invocarlo.