globale variable aus methode heraus?

FireFlyer

Entweder bin ich total dämlich oder ich steh einfach übelst auf dem Schlauch. Das es in Java Globale Variablen gibt hab ich ja kapiert^^
class Test {
public String test = "globale Variable";
}

Die Variable test kann man ja jetzt in jeder Methode auch benutzen. Wie ist es aber wenn man in einer Methode solch eine globale (muss nur innerhalb der Klasse verfügbar sein) benutzen will?

class Test {
public static void neuevariable() {
public String test2 = "globale Variable"; //geht net
}
}

Wie mache ich sowas? Hab jetzt schon ewig gegoogelt aber ich find immer nur Beispiele so wie oben.

**Xenobiologist**

Kannst du das noch mal klarer erläutern?
Suchst du vielleicht nach static ?

leviathan

Also was möchtest du denn genau erreichen?

Wenn du eine Klasse hast und dort oben eine Variable ala public TYP Variablenname; deklarierst ist das ja eine Instanzvariable. Wenn du static davor noch schreibst ist eine statische Variable, also für alle Instanzen dieser Klasse gleich und in einem Block { ...} ohne ein Schlüsselwort wie public oder static ist es eine normale lokale Variable.

Man spricht in diesem Sinne in Java nicht von globalen Variablen, weil dies dem Konzept der OO komplett entgegensprechen würde. Du kannst aber die Variable als public static deklarieren, da sie somit überall sichtbar ist.

Hoffe geholfen zu haben

FireFlyer

Ach wir sollten son Stack machen (abstrakte Datentypen) und das ganze in Java implementieren per Array. Ich wollte es vermeiden das ich nicht jedes mal das Array neu an eine Funktion übergeben muss. Aber nach genauerem hinsehen wird dies in der Aufgabe ehh verlangt. Naja der Code ist net so der tollste (bin net so ganz zufrieden damit :/) aber er funktioniert
folgende Funktionen muss man coden um den Stack zu bearbeiten.

eine um den Stack zu initialisieren
eine um zu prüfen ob der stack leer ist
eine push funktion
eine pop funktion
eine die das letzte element ausgiebt ohne es zu entfernen (top)

Wenn beim push das array voll ist sollen wir es kopieren und es doppelt so groß machen. So in etwa ist die aufgabenstellung.
Hier mein Code. Nicht schön, aber selten

Spoiler anzeigen

Code

public class Stack {


    public static void main(String[] args) {
        int[] stack = emptyStack();


        System.out.println("IsEmpty: "+isStackEmpty(stack));


        stack = push(stack, 1);
        System.out.println("Push: "+toString(stack));


        System.out.println("IsEmpty: "+isStackEmpty(stack));


        stack = push(stack, 2);
        System.out.println("Push: "+toString(stack));


        System.out.println("IsEmpty: "+isStackEmpty(stack));


        stack = pop(stack);
        System.out.println("Pop: "+toString(stack));
        stack = pop(stack);
        System.out.println("Pop: "+toString(stack));


        System.out.println("IsEmpty: "+isStackEmpty(stack));

        stack = push(stack, 1);
        System.out.println("Push: "+toString(stack));
        stack = push(stack, 2);
        System.out.println("Push: "+toString(stack));


        System.out.println("Top: "+top(stack));


        stack = push(stack, 3);
        System.out.println("Push: "+toString(stack));


        System.out.println("Top: "+top(stack));
    }


    public static int[] emptyStack() {
        int[] stack = new int[0];
        return stack;
    }


    public static boolean isStackEmpty(int[] stack) {
        if(getlastIndex(stack) == -1)
            return true;
        else
            return false;
    }


    public static int[] push(int[] stack, int value) {
        int index = getlastIndex(stack);
        if(index < (stack.length-1)) {
            stack[index+1] = value;
            return stack;
        }else{
            int[] newstack = new int[0];
            if(stack.length == 0) {
                newstack = new int[1];
                newstack[0] = value;
                return newstack;
            }else{
                newstack = new int[(stack.length * 2)];
                System.arraycopy(stack, 0, newstack, 0, stack.length);
                newstack[index+1] = value;
                return newstack;
            }
        }
    }


    public static int[] pop(int[] stack) { 
        if(isStackEmpty(stack)){
            return stack;
        }else{
            stack[getlastIndex(stack)] = 0;
            return stack;
        }
    }


    public static int top(int[] stack) {
        if(isStackEmpty(stack))
            return 0;
        else
            return stack[getlastIndex(stack)];
    }


    public static String toString(int[] stack) {
        String ret = "";
        for(int i = 0; i < stack.length; i++)
            ret += stack[i]+",";
        return ret.substring(0, ret.length()-1);
    }


    public static int getlastIndex(int[] stack) {
        for(int i = stack.length-1; i >= 0; i--){
            if(stack[i] != 0)
                return i;
        }
        return -1;
    }
}

Alles anzeigen

FireFlyer

Sooo, ich habe das ganze nochma mit OOP gemacht (ich glaube so ist es nämlich doch gewollt). Und auf einmal ist der Code auch viel schöner
Ich muss sagen diese OOP-Geschichte ist sehr interessant und es beginnt mir in den Fingern zu kribbeln mehr in diese Richtung auszuprobieren. So langsam lerne ich die Reize von Java kennen

Vielen Dank an der Stelle nochmal an levithan der mir einen 1A Support gegeben hat

Hier nochmal der neue Code:

Spoiler anzeigen

Code

public class Stack {
    private int[] stack;
    private int reference;


    public static void main(String[] args) {
        Stack test = new Stack();
        System.out.println(test.isStackEmpty());


        test.push(1);
        System.out.println(test.toString());


        System.out.println(test.isStackEmpty());


        test.push(2);
        System.out.println(test.toString());


        test.push(3);
        System.out.println(test.toString());


        System.out.println(test.top());


        test.pop();
        System.out.println(test.toString());
    }


    //Konstruktor
    public Stack() {
        this.emptyStack();
    }


    public void emptyStack() {
        stack = new int[0];
        reference = -1;
    }


    public boolean isStackEmpty() {
        return reference == -1;
    }


    public void push(int value) {
        reference++;
        if(reference < (stack.length-1)) {
            stack[reference] = value;
        }else{
            if(stack.length == 0) {
                stack = new int[1];
                stack[0] = value;
            }else{
                int[] newstack = new int[(stack.length * 2)];
                System.arraycopy(stack, 0, newstack, 0, stack.length);
                newstack[reference] = value;
                stack = newstack;
            }
        }
    }


    public void pop() {
        if(this.isStackEmpty()) return;
        stack[reference] = 0;
        reference--;
    }


    public int top() {
        if(this.isStackEmpty()) return 0;
        return stack[reference];
    }


    public String toString() {
        if(this.isStackEmpty()) return "Stack is empty.";
        String ret = "";
        for(int i = 0; i < stack.length; i++)
            ret += stack[i]+",";


        return ret.substring(0, ret.length()-1);
    }
}

Alles anzeigen