Calculating unknown parts of a right triangle
Keep it simple


        numOfSides=0;
        numOfAngles=0;

        sideA=a; if(sideA&gt;0){numOfSides++;}
        sideB=b; if(sideB&gt;0){numOfSides++;}
        sideC=c; if(sideC&gt;0){numOfSides++;}

        alpha=A; if(alpha&gt;0){numOfAngles++;}
        beta=B; if(beta&gt;0){numOfAngles++;}

        if(numOfAngles&lt;2)
        {
            findMissingAngles();
        }

        if(numOfSides&lt;3)
        {
            findMissingSides();
        }



This seems more complicated than necessary.  Why have numOfAngles and numOfSides at all?  You could just say 

        sideA = a;
        sideB = b;
        sideC = c;

        alpha = A;
        beta = B;

        findMissingAngles();

        findMissingSides();


And then modify 


        if(numOfAngles==1)



in calcAlpha to say 

        if (beta &gt; 0)


That saves two object fields that exist just for construction purposes.  

Be careful of false modularity


    private void calcBeta()
    {
        beta=90-alpha;
    }



This only works if you calculate alpha first.  That's the programming logic here, but nothing enforces it.  So why have a separate method to do an assignment based on one subtraction?  You could change 


        if(beta==0)
        {
            calcBeta();
        }



to say 

        if (beta==0)
        {
            beta = 90 - alpha;
        }


instead.  Then you could get rid of calcBeta.  

This also avoids the problem of calling calcBeta without testing that beta doesn't already have a value.  

Alternately, you could change calcBeta to be more like calcAlpha where it calculates alpha from beta if beta exists or from two sides otherwise.  

Similarly, all the calcSide methods assume that alpha exists.  And calcSideB and calcSideC assume that sideA exists.  If any of that is not true, then you'll get weird results.  

Exceptional circumstances


    private boolean isPossible()
    {
        return ((alpha+beta+90)==180 &amp;&amp; Math.abs(Math.sqrt(Math.pow(sideA, 2) + Math.pow(sideB, 2)) - sideC) &lt; 1);
    }



Why not change (alpha+beta+90)==180 to just (alpha + beta) == 90?  

Why is 1 the acceptable error?  Why not .1 or .03 or something else?  

Are negative values acceptable?  Because you accept them if they have the right magnitude.  For example, -95 and 185 are a valid pair of angles.  And -3, -4, 5 are valid side values.