Stack Array implementation of Java

Question

This is my array implementation on stack in Java. It involves push, pop, get and growth when limit of array size is reached.

I am a self-taught programmer starting to learn data structures and algorithms.

I am looking for

1. any recommendation on conventions
2. an honest opinion on how bad this piece of code if this is an interview.
3. anything wrong and room for improvement.

I wrote this code myself, not looking at any other similar questions on Code Review.

public class stackAlist{
    int[] data;
    int size;
    static int growthmultipler = 1;

    public stackAlist(){
        data = new int[2*growthmultipler];
        size = 0;
    }

    public void push(int value){
        if(this.size == 0){
            this.data[0] = value;
            this.size += 1;
            this.growthmultipler = 1;
            }
        else if(this.size == 2*growthmultipler){
            growthmultipler += 1;
            stackAlist newlist = new stackAlist();
            newlist.data = new int[2*growthmultipler];
            System.arraycopy(this.data, 0, newlist.data, 0, this.size);
            this.data = newlist.data;
            this.data[size] = value;
            this.size += 1;
        }
        else{
        this.data[size] = value;
        this.size += 1;
        }
    }

    public void pop(){
        this.data[size-1] = 0;
        this.size = this.size-1;
    }

    public void get(){
        int i;
        for(i =0; i < this.size; i++){
            System.out.println(data[i]);
        }
    }

    public static void main(String[] args){
        stackAlist a = new stackAlist();
        a.push(1);
        a.push(2);
        a.get();
        a.pop();
        a.get();
        a.push(3);
        a.push(4);
        a.get();
    }
}

Answer 1

First of all, you are using a static variable (growthmultipler) inside the instance of a class. This is fatal if you have more than one instance of this class. Because you always use 2*growthmultipler, you don't need it. Use +=2 instead.

You don't need to prealloc data in the constructor. It will be done if it's needed.

You don't need to handle "size == 0" separately. You only have to handle "size >= length".

You don't have to create a new class if you want to grow data.

In pop() you should test to not get negative (and throw an exception). And normally a pop function returns the value.

In summary it might look like this:

public class stackAlist{
    int[] data;
    int size;

    public stackAlist(){
        size = 0;
        data = new int[size];
    }

    public void push(int value){
        if(size>=data.length) {
            int [] ndata = new int[data.length+2];
            System.arraycopy(data, 0, ndata, 0, size);
            data = ndata;
        }
        data[size] = value;
        size += 1;
    }

    public int pop() {
        int ret=0;
        if(size>0) {
            size -= 1;
            ret = data[size];
            data[size] = 0;
        }
        return ret;
    }
    .....

Answer 2

A couple things to add:

1. Classes should use CamelCase and should preferably have descriptive names. stackAlist would be better named ArrayStack.
2. You might want to have a Stack interface that ArrayStack implements.
3. You might want to extract the resizing code into a separate method, and optionally make it public and/or take parameters.
4. In your pop method, there's no need to zero out the popped items.