Java program to add two numbers represented by linked lists
Advice 1

Fix your code indentation. Instead of 

public class LLAdd {
...
public static void printList(Node head){
...
}
...
}


you should have

public class LLAd {
    ...
    public static void printList(Node head){
        ...
    }
    ...
}


Advice 2

In method definitions, one, according to common Java coding conventions, must have a single space between parameter-closing ) and a block-opening {. Instead of 

public static void printList(Node head){
    ...
}


you should write 

public static void printList(Node head) {
    ...                                ^-- Space!
}


Advice 3

The class name LLAdd is really poor. Taking a look of what it does, you could come up with the name, say, BigInteger.

Advice 4

static Node head, head1, head2;


This is an anti-pattern since there is only one "instance" of the class. Make these non-static and private instead.

Advice 5

Node new_node ...


Once again, Java coding conventions dictate that the fields/variables are named in CamelCase: 

Node newNode ...


Advice 6

static class Node {
    Node link;
    int data;

    Node(int data){
        this.data = data;
        this.link = null;
    }
}


Make this private and final since most likely you don't want to shine into the entire package, and you hardly need to derive from that class. Also, I would rename link to next. Finally for this advice, you don't need this.link = null;. Java sets all the object fields to null by default.

Advice 7 In principle, I think you should make your BigInteger/LLAdd immutable.

Advice 8

public static Node push(int data, Node head)...


That's is a poor name too. Looking from what it does, I suggest you rename it to prependDigit. Also, I believe you would want to check that data is within the range 0-9 unless you want to allow dealing with arbitrary radices.

Advice 9

Instead of implementing printList, I would override toString.

Alternative implementation

import java.util.Scanner;

public final class BigInteger {

    private static final class Digit {
        Digit next;
        int digit;

        Digit(char ch) {
            this.digit = ch - '0';
        }

        Digit(int digit) {
            this.digit = digit;
        }
    }

    private Digit leastSignificantDigit;

    public BigInteger(String integerText) {
        checkCharacters(integerText);
        leastSignificantDigit = 
                new Digit(integerText.charAt(integerText.length() - 1));
        Digit head = leastSignificantDigit;

        for (int i = integerText.length() - 2; i &gt;= 0; i--) {
            Digit digit = new Digit(integerText.charAt(i));
            head.next = digit;
            head = digit;
        }
    }

    private BigInteger() {

    }

    public BigInteger add(BigInteger other) {
        Digit digit1 = leastSignificantDigit;
        Digit digit2 = other.leastSignificantDigit;
        BigInteger result = new BigInteger();
        Digit headDigit = null;
        boolean carry = false;

        while (digit1 != null || digit2 != null) {
            int intDigit1 = digit1 == null ? 0 : digit1.digit;
            int intDigit2 = digit2 == null ? 0 : digit2.digit;
            int sum = intDigit1 + intDigit2 + (carry ? 1 : 0);
            carry = sum &gt; 9;
            int currentDigit = carry ? (sum - 10) : sum;
            Digit digit = new Digit(currentDigit);

            if (result.leastSignificantDigit == null) {
                result.leastSignificantDigit = digit;
                headDigit = digit;
            } else {
                headDigit.next = digit;
                headDigit = digit;
            }

            if (digit1 != null) {
                digit1 = digit1.next;
            }

            if (digit2 != null) {
                digit2 = digit2.next; 
            }
        }

        if (carry) {
            headDigit.next = new Digit(1);
        }

        return result;
    }

    @Override
    public String toString() {
        StringBuilder stringBuilder = new StringBuilder();

        for (Digit digit = leastSignificantDigit; 
                digit != null; 
                digit = digit.next) {
            stringBuilder.append((char)('0' + digit.digit));
        }

        return stringBuilder.reverse().toString();
    }

    private void checkCharacters(String integerText) {
        for (char ch : integerText.toCharArray()) {
            if (!Character.isDigit(ch)) {
                throw new IllegalArgumentException(
                        "Character '" + ch + "' is not a valid digit.");
            }
        }
    }

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        BigInteger bi1 = new BigInteger(scanner.nextLine());
        BigInteger bi2 = new BigInteger(scanner.nextLine());
        System.out.println(bi1 + " + " + bi2 + " = " + bi1.add(bi2));
    }
}