Improving javascript code

You should construct the object only once, and then re-use it. (That, or use a "static" method.)

$(function () {
    "use strict";
    var calculator = new Calculator('output', 'valOne', 'valTwo');
    $('.button').on('click', function() {
        var operator = $(this).attr('name');
        calculator.calculate(operator);
    });
});

Then, inside the Calculator you would initialize the HTML elements for operand1/operand2/output and provide a method that reads the values and outputs the result.

I would just do the operation directly in the switch. Alternatively, you can do something like: var method, result; if(...) {method = add;} ...; result = method(x, y);

var Calculator = function (outputId, firstOperandId, secondOperandId) {
    "use strict";

    var output = document.getElementById(outputId),
        firstOperand = document.getElementById(firstOperandId),
        firstOperand = document.getElementById(secondOperandId);
    return {
        calculate: function (operator) {
            var num1 = +firstOperand.getAttribute('value'),
                num2 = +secondOperand.getAttribute('value'),
                result;
            switch (operator) {
                case 'add':
                    result = x + y;
                    break;
                case 'sub':
                    result = x - y;
                    break;
                case 'mult':
                    result = x * y;
                    break;
                case 'div':
                    if (y === 0) {
                        //throw new Error('cannot divide by 0');
                        result = 'cannot divide by 0';
                    } else {
                        result = x / y;
                    }
                    break;
                default:
                    // throw new Error("invalid operator '" + operator + "'");
                    result = "invalid operator '" + operator + "'";
            }
            output.innerHTML = result;
            return result;
        }
    };
};

Other remarks:

• Use === instead of ==.
• Inside the if-chain (or switch, YMMV) I would just do the operation directly, instead of calling a one-liner method for it - why make it more complicated than it needs to be?
• I wouldn't default to division, but throw an error instead - maybe write error to the output element?
• The + coerces a numeric value. It's not bullet-proof (" " === 0), but it's better than using parseInt, because with parseInt you need to remember to always send a second param 10 - try parseInt('010') and parseInt('008').

The concept of creating a new Calculator() with a specified operator and then calling calc.init() to actually perform the operation seems a bit strange. I'd probably have any initialisation built into the constructor, and then have a calc.calculate() method that takes the operation as a parameter.

I don't have time now for a detailed analysis of your code, but one thing I would probably do is make the different operation functions methods of an object:

var operations = {
    "addition" : function(x,y) { return setVal(x + y); },
    "subtract" : function(x,y) { return setVal(x - y); },
    "multiply" : function(x,y) { return setVal(x * y); },
    // etc
}

Because then you can eliminate the if/else structure that decides what function to call and just do this:

calculation = function() {
    if (op in operations)
        operations[op](val1, val2);
    else
        // invalid op requested, so show message, throw exception, whatever
}

If you add more operations in the future, say a toThePowerOf() operation, you'd add it to the operations object but wouldn't need to change the calculation() function.