methods vs. non methods

[Latanyar]

I know there are many advantages on using methods. I am just trying to understand the meaning on why would we use method vs. a non method. I am new at java and it's is definitely like learning a second language. Ex. In my book it shows an example of a greatest common divisor by a non method way and a method way. Why wouldn't I be able to reuse the GCD by other programs by using the the non method way? I am confused by that concept. Could someone provide me with some other examples as well as why methods are beneficial? Should I always use methods vs non methods? In my book it says using a method isolates the problem for computing the GCD from the rest of the code in the main method. Thus, the logic becomes clear and the program easier to read. It also says it narrows the scope of debugging. Could someone explain that to me in a little more detail and with examples?

[pbrockway2]

Perhaps you could post the two gcd examples. The term "non method" is non standard.

[Zack]

Agreed with pbrockway. I've never heard of any way of doing Java without methods... unless you just stuff EVERYTHING into one method (the main method), but that's... silly, at best.

[Ronin]

The whole purpose of methods is to recycle code, providing flexability to your application and minimizes redundancy. It also splits the code into more managable chunks where each one can be tested for functionality and make debugging simpler.

For example:

public static void main(String[] args)
{[INDENT]// Do stuff...
// Do same stuff...
// Do same stuff again...[/INDENT]
}

This is ok if the stuff done was only one or two lines of code but if you are dealing with twenty, thirty or even more lines of code, then you can see it getting very repeatitive. Whilst cut and paste will work, it is not good coding.

Instead:

public static void main(String[] args)
{[INDENT]doStuff(); // A loop may be more appropriate here.
doStuff();
doStuff();[/INDENT]
}

public void doStuff()
{[INDENT]// Do lots of stuff[/INDENT]
}

Regards.

[Ronin]

Going back to what I said about reusablilty, you could create classes which provided functionality you want to use in multiple projects. From here all you would have to do is create new instances of the class and call the required method.

For example:

Class class = new Class();
class.methodName(); // Performs the required functionality

Note that the names used above are for example purposes only and should not be copied directly. You will have to modify the code to suit your particular application.

Regards.

[Ronin]

A more suitable alternative to the above may be to declare the reused methods as static. This allows the method to be used without creating an instance of the class.

Regards.

[Latanyar]

Perhaps you could post the two gcd examples. The term "non method" is non standard.

Here is an example:

public class getPentagonalNumber
{
    public static void main(String[] args)
    {
        //Assigning a variable
       int n;
       
       //for loop to call getPentagonalNumber method and print out table
       for(n=1; n <=100; n++)
       {
          System.out.print(getPentagonalNumber(n));
          if (n % 10 == 0) 
          {
                System.out.println();
          } 
          else 
          {
                System.out.print("\t");
          }
       }
    }

       
    //method for getPentagonalNumber
    public static int getPentagonalNumber(int n)
    {
        
        return n *(3*n - 1)/2;
        
    }
}

Is there a way I could write this program without adding this method?

//method for getPentagonalNumber
    public static int getPentagonalNumber(int n)
    {
        
        return n *(3*n - 1)/2;
        
    }

Are should I use this format at all times?

I am sorry I'm such a newbie. I am still learning the java language.

[Zack]

You'd want to do something like this:

int pentagonal = n *(3*n - 1)/2;

Then use that instead of the getPentagonalNumber call.

Usage is really up to the designer of the software. If you think you'll be getting pentagonal numbers more than once, it might as well be a method. There's little to no overhead or downfall to using methods so you might as well recycle the code as Ronin's first post suggests.

[Latanyar]

Thanks you guys for the examples.

[somanayr]

It is considered bad form and practice to not use methods, just FYI. It is also considered bad form to start classes with lowercase, fields with UPPERCASE (except constants), and methods with UPPERCASE. It's also considered bad form to not annotate, as other may or may not read your code in the future, especially if it's open sources. (I can tell you, I've read some pretty YUCKY code before :P)

[DarrylBurke]

Some more bad form:
-- a class name that's a verb. Class names should be nouns.
-- a class with a method of the same name. Highly misleading.

db