Home / Questions / 104211
Accepted
I likeThatMeow
Asked: 2020-09-22 20:19:58 +0800 CST 2020-09-22 20:19:58 +0800 CST

About a static method in a class

  • 772

In the following class I have the method getName()which I wanted it to be staticbecause I was going to use it inside another method in the same class Person(I wanted to do this: Person.getName()), however when I put it I staticgot the following error: non-static variable name cannot be referenced from a static context, a possible solution would be to remove the privateto variable name,

is there any other solution for this problem?

Could privatethe variable be preserved name?

class Person{

    private String name, gender;

    Person(String name, String gender){
        this.name=name;
        this.gender=gender;
    }

    static String getName(){//si  se le pone static marca error.
        return name;
    }

    String getGender(){
        return gender;
    }

}
java

2 Answers

  1. Static methods can only access static data.

    The data name, genderare variables of an instance of the class Person , you can't know them unless you do anew Person("Pedro","H");

    Imagine in "real life"... you know what a Person is , what would you do if I asked you "Give me the name of the person"... would you ask me which person?
    oh! but there is a person named Michelle and there is another person named Octavio, those are instances of People.

    • 2
  2. Best Answer

    brief explanation

    Non-static members belong to instances/objects of a class. Static members belong to the class. If a getter is declared static, it is general for all instances of the class and not for the specific value for each instance. Since this is inconsistent, the solution to your problem is to not use static getters for your attributes.

    long explanation

    In a class, when you declare a member (attribute or method) as static, it means that the member belongs to the class and not to an instance . This means that these members can be accessed without creating an instance of a class.

    Example:

    public class StringUtil {
    public static final String limpiaEspacios(String cadena) {
        return cadena == null ? null : cadena.trim();
    }
}

public class Principal {
    public static void main(String[] args) {
        //no se necesita crear una instancia de StringUtil
        System.out.println(StringUtil.limpiaEspacios("hola mundo"));
        System.out.println(StringUtil.limpiaEspacios("hola mundo "));
        System.out.println(StringUtil.limpiaEspacios("    hola mundo    "));
    }
}

    Departure

    hola mundo
hola mundo
hola mundo

    Since the static member belongs to the class, it cannot access the instance members, since the instance members belong to a particular instance (object) of the class. Example:

    public class Persona {
    private String name, gender;
    public Persona(String name, String gender) {
        this.name = name;
        this.gender = gender;
    }
    public String getName() { return this.name; }
    public String getGender() { return this.gender; }
}

public class Principal {
    public static void main(String[] args) {
        //se necesita crear una instancia de Persona
        Persona persona = new Persona("Luiggi", "masculino");
        System.out.println(persona.getName() + " " + persona.getGender());
    }
}

    Departure:

    Luiggi masculino

    As you can see, static members can be considered global to all instances of a class, while non-static elements correspond to each instance of a class. Here's an example showing the differences:

    public class Contador {
    //atributo estático
    //global para todas las instancias
    private static int contadorInstancias;

    //atributo no estático
    //pertenece a cada instancia
    private int contador;

    public Contador() {
        contadorInstancias++;
    }

    public static int getContadorInstancias() {
        //ojo, no se puede usar this
        //porque el método es estático y no puede acceder
        //a los atributos no estáticos
        return contadorInstancias;
    }

    public int getContador() {
        return this.contador;
    }

    public void contar() {
        this.contador++;
    }
}

public class Principal {
    public static void main(String[] args) {
        System.out.println("Total de instancias de Contador: " + Contador.getContadorInstancias());

        Contador contador1 = new Contador();
        contador1.contar();
        contador1.contar();
        contador1.contar();

        System.out.println("Valor de contador1: " + contador1.getContador());
        System.out.println("Total de instancias de Contador: " + Contador.getContadorInstancias());

        Contador contador2 = new Contador();
        contador2.contar();
        System.out.println("Valor de contador2: " + contador1.getContador());
        System.out.println("Valor de contador2: " + contador2.getContador());
        System.out.println("Total de instancias de Contador: " + Contador.getContadorInstancias());
    }
}
    • 2