Is private void the wrong thing to be using here?

[ajhampson]

Something I notice from your text is that you really don't seem to understand what public, private, and protected are. Also, void seems fuzzy to you.

In Java, methods normally have return types (int, double, String, etc.) As you saw, this is how you get results from your method back to the method that called it. When a method has a defined return type, it must return something of that type. The keyword void is used if there is no need for a return type. In this case, it simply tells the compiler the method doesn't need to return a value.

Class members in Java have something called access levels or visibility. This describes how other classes are going to be able to see the parts of your class. If you make something private, only members in your class will be able to see it. So your public run() method can be seen from outside your class, but your sqrt(), xquadpulus(), and xquadminus() would not.

In object oriented design, we use this feature to prevent access to parts of the class that others shouldn't use. For example, say everything in your class was public:

public class Quadratic extends ConsoleProgram 
{
	public void run(){...}
	public double sqrt(int a, int b, int c){...}
	public double xquadplus(double sqrt, int a, int b){...}
	public double xquadminus(double sqrt, int a, int b){...}
	public void solutions(double sqrt, double xquadplus, double xquadminus, int a, int b, int c){
		if ((b*b)-(4*a*c)<0){
			println ("The result is not real because the value under the square root is less than 0");	
		} else {
			println ("The first solution is: "+ xquadplus +".");
			println ("The second solution is: "+ xquadminus +".");
		}

	}	
}

If you decide to change the implementation of solutions(), and no longer need xquadplus() and xquadminus(), you would still have to keep them around because they are part of the public interface of your class (usually, they'd be deprecated).

However, if you defined some of your class as private:

public class Quadratic extends ConsoleProgram 
{
	public void run(){...}
	private double sqrt(int a, int b, int c){...}
	private double xquadplus(double sqrt, int a, int b){...}
	private double xquadminus(double sqrt, int a, int b){...}
	public void solutions(double sqrt, double xquadplus, double xquadminus, int a, int b, int c){
		if ((b*b)-(4*a*c)<0){
			println ("The result is not real because the value under the square root is less than 0");	
		} else {
			println ("The first solution is: "+ xquadplus +".");
			println ("The second solution is: "+ xquadminus +".");
		}

	}	
}

Now, classes outside yours can see or use the private methods. This means that you can change the implementation of solutions() and not have to worry if you no longer need some of the other methods. The only class that can use them is yours.

One other important use of visibility is for member variables. Normally class level variables are declared private so they can't be accessed from outside the class. Those that need to be accessed are given getters and setters to allow this.

public class WrkComments
{
    private String commentator;
    private String commentDetail;
 .
 .
 .
    //
    // getters and setters
    //
    public String getCommentator()
    {
        return commentator;
    }
    public void setCommentator(String commentator)
    {
        this.commentator = commentator;
    }
    public String getCommentDetail()
    {
        return commentDetail;
    }
    public void setCommentDetail(String commentDetail)
    {
        this.commentDetail = commentDetail;
    }
}

Sorry this is so long, but the topic is important and you really need to understand how it works for good OO design. You can check the Java Tutorials for more information.