What is the generally structure/form/outline of a Java code?

[Justin Robbins]

Hello all!

Could some detail the basic structure and outline that Java code follows. I know that Java code opens with a class and a bracket then after the class comes the main and a bracket then a lot of 'stuff' follows which I do not understand yet. Generally speaking, what sort of code goes immediately after the class bracket? And generally speaking, what sort of code goes after the main method bracket?


Thank you

[Les Morgan]

I generally go with the following, though it is mostly my style, I ask my teams to do the same:

//package
//includes in alphabetical order segregated by package
//class
  //class variables in alphabetical order by variable type
  //instance variables in alphabetical order by variable type
  //constructors in alphabetical order
  //main method keep as short as possible--no significant programming to be done here.
  //other methods (in alphabetical order)
  //inner classes in alphabetical order
//other classes to include in same file in alphabetical order

I do not encourage anonymous classes, as they quite often are missed or not understood by new programmers. Indentation at 2 spaces per indent, no empty lines except to separate significant logic and process.

[Justin Robbins]

@Les Morgan That's great set up! and from what I've been reading a lot of code seems to go in that order. So generally speaking, all the static and instance variables go within that area right after that first class bracket? then the constructor. Then the Main method, I understand that to be the entry point of the program, or the starting point. Are the methods generally after the main method? I may be mistaken here but I think I've seen them possibly declared right after the class bracket? Could you explain what constructors and inner classes are?

Thank you!

[Nick Smithson]

I'm currently in Java II, but when I started in Java I the professor told us to use "buckets" to keep things organized.

The first is variables
Second is input
Third is calculations
Fourth is output

For the first few assignments we had to make comments separating each 'bucket' as best we could.

Here's an old assignment in which I used that method:

//finds the scanner class in the Java library to make it available to this program
import java.util.Scanner;

//Defines the class name, must match txt file name
public class IncomeCalculator
{
	public static void main(String[] args)
	{


	/* ~~~~~~~~~~~~~~~~~~~(DECLARE VARIABLES)~~~~~~~~~~~~~~~~~~~*/
		String name; //String variable to store user-defined name
		int age; //integer variable to store user-defined age
		double income; //double variable to store user-defined income
		final double TAXRATE = 0.25; //constant double variable to store the decimal equivalent of 25%
		double incomeTax; //double variable to store results of income * TAXRATE;
		double takeHomePay; //double variable to store results of income - incomeTax;	


	/* ~~~~~~~~~~~~~~~~~~~(OBTAIN INPUT)~~~~~~~~~~~~~~~~~~~*/
//Creates a new scanner to allow user to enter input
		Scanner keyboard = new Scanner(System.in);

//Prompts the user to input their name
		System.out.print("What is your name? ");
		name = keyboard.nextLine();

//Prompts the user to input their age
		System.out.print("What is your age? ");
		age = keyboard.nextInt();

//Prompts the user to input their income
		System.out.print("What is your income? ");
		income = keyboard.nextDouble();


	/* ~~~~~~~~~~~~~~~~~~~(PERFORM CALCULATIONS)~~~~~~~~~~~~~~~~~~~*/
// Multiplies the amount stored in the user-defined income variable with the TAXRATE constant, results are stored in the incomeTax variable */
		incomeTax = income * TAXRATE;

/* Subtracts the amount stored in the user-defined income variable from the post-calculation amount
stored in the incomeTax varaible, results are stored in the takeHomePay variable */
		takeHomePay = income - incomeTax;


	/* ~~~~~~~~~~~~~~~~~~~(DISPLAY RESULTS)~~~~~~~~~~~~~~~~~~~*/
/* Starts a new line in order to separate output from input, then displays the user-defined name in lowercase letters, 
the user-defined age on a new line and the user-defined income with a dollar sign on a new line */
	System.out.println("\n[Name] " + name.toLowerCase() + "\n[Age] " + age + "\n[Income] $" + income);

// Prints the income tax post-calculations on a new line, then creates a new line to display the takeHomePay post-calculations
	System.out.println("[Income Tax] $" + incomeTax + "\n[Take Home Pay] $" + takeHomePay);
	}
}

Not sure if this helps, but I suppose it could be useful if you're just starting out.

[Les Morgan]

Yes, after the class header the static variables are listed first, then the instance variables.
Java is a little more free style in it's layout than I care for--yes, I'm a control freak--so as I said the layout that I showed is mainly my style that I have come to settle upon. I have seen things laid out in a few ways, but I like to see what I'm going to use before I get there or have a logical and predefined way of looking for things.

Constructors are special methods that shape the class when it is instantiated. You can do any initialization you need here or customizations as need to the resulting object.

inner classes are classes that are defined as a whole inside another class. They inherit the environment of the parent class, as they are, in actuality, part of that parent class.

Justin Robbins wrote:@Les Morgan That's great set up! and from what I've been reading a lot of code seems to go in that order. So generally speaking, all the static and instance variables go within that area right after that first class bracket? then the constructor. Then the Main method, I understand that to be the entry point of the program, or the starting point. Are the methods generally after the main method? I may be mistaken here but I think I've seen them possibly declared right after the class bracket? Could you explain what constructors and inner classes are?

Thank you!

[Justin Robbins]

Les Morgan wrote:Yes, after the class header the static variables are listed first, then the instance variables.
Java is a little more free style in it's layout than I care for--yes, I'm a control freak--so as I said the layout that I showed is mainly my style that I have come to settle upon. I have seen things laid out in a few ways, but I like to see what I'm going to use before I get there or have a logical and predefined way of looking for things.

Constructors are special methods that shape the class when it is instantiated. You can do any initialization you need here or customizations as need to the resulting object.

inner classes are classes that are defined as a whole inside another class. They inherit the environment of the parent class, as they are, in actuality, part of that parent class.

Thank you!

Ok, class header is the part with the brackets. Then comes the static first and then instance variables. I actually like this style, and may have come to it naturally actually. I've seen a lot of YouTubers use it. The inner classes part, so we set up the environment of one class say it's cats and it has the static variable hair and legs, don't know if I am saying that right. But then after that we subsequently create a new class on the very same page called dog, so since cats and dogs share similar things we can sort of branch off and take bits and pieces of the static parts of cat and apply them to dogs? Is that right? Still a little confused on the basics.

[Justin Robbins]

Nikki Smith wrote:I'm currently in Java II, but when I started in Java I the professor told us to use "buckets" to keep things organized.

The first is variables
Second is input
Third is calculations
Fourth is output

For the first few assignments we had to make comments separating each 'bucket' as best we could.

Here's an old assignment in which I used that method:

//finds the scanner class in the Java library to make it available to this program
import java.util.Scanner;

//Defines the class name, must match txt file name
public class IncomeCalculator
{
	public static void main(String[] args)
	{


	/* ~~~~~~~~~~~~~~~~~~~(DECLARE VARIABLES)~~~~~~~~~~~~~~~~~~~*/
		String name; //String variable to store user-defined name
		int age; //integer variable to store user-defined age
		double income; //double variable to store user-defined income
		final double TAXRATE = 0.25; //constant double variable to store the decimal equivalent of 25%
		double incomeTax; //double variable to store results of income * TAXRATE;
		double takeHomePay; //double variable to store results of income - incomeTax;	


	/* ~~~~~~~~~~~~~~~~~~~(OBTAIN INPUT)~~~~~~~~~~~~~~~~~~~*/
//Creates a new scanner to allow user to enter input
		Scanner keyboard = new Scanner(System.in);

//Prompts the user to input their name
		System.out.print("What is your name? ");
		name = keyboard.nextLine();

//Prompts the user to input their age
		System.out.print("What is your age? ");
		age = keyboard.nextInt();

//Prompts the user to input their income
		System.out.print("What is your income? ");
		income = keyboard.nextDouble();


	/* ~~~~~~~~~~~~~~~~~~~(PERFORM CALCULATIONS)~~~~~~~~~~~~~~~~~~~*/
// Multiplies the amount stored in the user-defined income variable with the TAXRATE constant, results are stored in the incomeTax variable */
		incomeTax = income * TAXRATE;

/* Subtracts the amount stored in the user-defined income variable from the post-calculation amount
stored in the incomeTax varaible, results are stored in the takeHomePay variable */
		takeHomePay = income - incomeTax;


	/* ~~~~~~~~~~~~~~~~~~~(DISPLAY RESULTS)~~~~~~~~~~~~~~~~~~~*/
/* Starts a new line in order to separate output from input, then displays the user-defined name in lowercase letters, 
the user-defined age on a new line and the user-defined income with a dollar sign on a new line */
	System.out.println("\n[Name] " + name.toLowerCase() + "\n[Age] " + age + "\n[Income] $" + income);

// Prints the income tax post-calculations on a new line, then creates a new line to display the takeHomePay post-calculations
	System.out.println("[Income Tax] $" + incomeTax + "\n[Take Home Pay] $" + takeHomePay);
	}
}

Not sure if this helps, but I suppose it could be useful if you're just starting out.

Thank you so much Nikki! I copied this and put it in my Eclipse workspace for future reference. I wish my teacher would make us outline things like this. The whole idea of buckets is wonderful. Cannot imagine what else he taught you guys. Any other tips/tricks he showed you when learning Java I? Still ify about the difference between Static variables/methods and Instance variables/methods and exactly what they do.

[Nick Smithson]

The only other thing he makes us do, aside from documentation in the header, is make pseudo code for every assignment. He tells us to make that first so that we can make sure we actually understand what we're going to do and how we plan to do it. This is the pseudo code I made for the code I posted above.

Purpose - calculate the take home pay after income tax is subtracted

Input - User is prompted to input their name, age and income

Process - The name and age are each stored in separate variables that are
returned as-is except that the name is displayed in lowercase
income * taxRate finds the income tax ammount and stores it in incomeTax
takeHomePay = income - incomeTax

Output - Users name, age, income, income tax and take home pay are displayed



simple pseudocode:
create keyboard scanner to obtain input
obtain input name, age, income
calculate incomeTax = income * taxRate;
calculate takeHomePay = income - incomeTax;
display user-defined name, age, income and post-calculation income tax amount and take home pay

detailed pseudocode:
create keyboard scanner to obtain input
prompt user for their name
obtain user name
prompt user for their age
obtain user age
prompt user for their income
obtain user income
determine incomeTax = income * taxRate;
determine takeHomePay = income - incomeTax;
display user-defined name, age, income and post-calculation income tax
amount and take home pay on separate lines

We also had to learn 9 steps listed out in our book as a helpful guide of sorts
The book we're using is "Starting Out With Java - From Control Structures Through Objects - 6th edition"

The 9 steps it lists are as follows:

1) Clearly define what the program is to do
2) Visualize the program running on the computer
3) Use design tools to create a model of the program
4) Check the model for logical errors
5) Enter the code and compile it
6) Correct any errors found during compilation and repeat steps 5 and 6 as necessary
7) Run the program with test data for input
8) Correct any runtime errors found while running the program and repeat steps 5 through 8 as necessary
9) Validate the results of the program


All through Java I he only allowed us to use plain old MS Notepad text editor for coding to make us work harder to find our errors and not have the luxury of auto-complete or anything like that. In Java II we can use any editor we chose.

[Les Morgan]

Nope, that is generally not how it works.

import java.awt.Color;

public class Cat{
  Color static furColor = Color.GRAY;
  int final age;
  public Cat(int final age){
    this.age = age;
  }
  public void main(String args){
    Cat cat = new Cat();
    cat.neow();
  }
  public void meow(){
    System.out.println("MEOW!");
  }
  class Leg{
    Color legColor;
    public Leg(){
      legColor = furColor;
    }
    public void meow(){
      System.out.println("Ha, ha. Legs don't meow.");
    }
} //end Cat

public void Dog{
}

OK... everything in Cat is part of Cat. Leg inherits furColor from Cat, but legColor is in the class Leg which is an inner class of Cat. Dog is a separate class from Cat, but contained in the same file.

Please NOTE: none of the code was run through any checks, so it may or may not be totally accurate.

[Nick Smithson]

Les Morgan wrote:Nope, that is generally not how it works.

import java.awt.Color;

public class Cat{
  Color static furColor = Color.GRAY;
  int final age;
  public Cat(int final age){
    this.age = age;
  }
  public void main(String args){
    Cat cat = new Cat();
    cat.neow();
  }
  public void meow(){
    System.out.println("MEOW!");
  }
  class Leg{
    Color legColor;
    public Leg(){
      legColor = furColor;
    }
    public void meow(){
      System.out.println("Ha, ha. Legs don't meow.");
    }
} //end Cat

public void Dog{
}

OK... everything in Cat is part of Cat. Leg inherits furColor from Cat, but legColor is in the class Leg which is an inner class of Cat. Dog is a separate class from Cat, but contained in the same file.

Please NOTE: none of the code was run through any checks, so it may or may not be totally accurate.

I've never seen classes within classes like that, so I'm not really sure about that. When we have to make programs and use classes we have to spread it out across several different files. Usually the main file thats called is usually titled SomethingDemo and then each of the classes we make for the Demo are different files with related names. My book describes classes as "A blueprint". Basically you can set up a class in a generic way and then you can use it anytime and anywhere you need it rather than having to keep typing the same code over and over in different places in the same file.

One of our assignments was to create a CoinDemo and a Coin class.

Basically the CoinDemo class is where all the user input was sent through arguments and parameters to Coin and from there it made a new coin based on input.
The CoinDemo prompted the user to enter input and created new instances of the Coin class.

So each time the user entered a value and gave it a name, it made a new coin through the Coin class and each one had it's own value and name. The Coin class made coin objects. It was a blank coin 'blueprint'.
With the program I could input "Penny" for the name and ".01" for the amount and then I could make another and name it "Shiny" and give it a value of ".007"

Coin would then create two objects, one for "Penny" which was worth ".01" and one for "Shiny" with the value of ".007"

The Oracle website has an example using Bicycle and BicycleDemo.

[Tushar Goel]

Also, main method should be in separate class.

[Les Morgan]

Classes inside of classes are very common, at some point you are going to have to progress past the static framework of working in the main method, and when you do, you are going to see Java come alive.

Here is just a little tidbit that I like to play with for animation. The basic game container is made of a class with an inner class and the ships (not completed) are listed in the same file, but not as part of the same class.

import java.awt.event.ActionListener;
import java.awt.event.ActionEvent;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.image.BufferedImage;
import java.awt.Point;
import java.awt.Shape;
 
import java.util.ArrayList;
 
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.Timer;
  
public class JAnimation implements ActionListener{
  static final int FPS = 40; //this is how many frames per second you would like to display.
  static final int TIMER = 1000/FPS; //you choose the FPS and this gives the timer delay to fire FPS times per second
  static final int P_WIDTH  = 512;   //display panel width
  static final int P_HEIGHT = 512;   //display panel height
  static final int O_WIDTH = 60;     //oval width
  static final int O_HEIGHT = O_WIDTH/3; //oval height--I like the 3x1 ratio of width to height--personal preference
  int x = (P_WIDTH-O_WIDTH)/2;  //x starting position (center of screen)
  int y = (P_HEIGHT-O_HEIGHT)/2; //y starting position (center of screen) 
  char key = 'g'; //this variable gets the value when a key is pressed (from KeyListener)
  Timer t = null; //this timer activates the ActionListener and makes everything work--basic animation loop timing
  JFrame f = null; //top level display container
  MyJPanel p = null; //display area
  JAnimation(){
    t = new Timer(TIMER, this); //set up the Timer, notice that "this" is a reference to ActionListener--JForumAnimationJunk implements ActionListener
    f = new JFrame(); //top level display container
    f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); //makes it so you can close the app by clicking the X
    f.setTitle("JForumAnimationJunk 1.0"); //title in the JFrame
    p = new MyJPanel(); //create new display area--notice MyJPanel is an inner classs so it has visibility of all parent attributes and methods
    f.add(p); //pout the display area into the top level display container
  }
  public static void main(String[] args){
    JAnimation jfaj = new JAnimation(); //get an instance
    jfaj.f.pack(); //pack it all so it displays correctly
    jfaj.f.setVisible(true); //make it visible so you can see it
    jfaj.t.start(); //start the timer--note: if you don't start the timer, nothing works: no animation loop is started
  }
  @Override
  public void actionPerformed(ActionEvent e){ //ActionListener triggered by Timer
    p.repaint(); //request a repaint--this is what makes the animation happen, requests a screen repaint every 1000/FPS times per second.
  }
  class MyJPanel extends JPanel{ //display container--where the animation takes place--the screen referenced in the p.repaint() request
    private ArrayList<MyGameObjects> al = new ArrayList<MyGameObjects>();    
    MyJPanel(){
      this.setPreferredSize(new Dimension(P_WIDTH, P_HEIGHT)); //the size of this screen
      this.setForeground(Color.RED); //set the forground--the color the oval will be rendered with
    }
    public void add(MyGameObjects o){ //as long as your objects extend MyGameObjects, they can be loaded into the container and they can be rendered to the screen.
      al.add(o);
    }
    @Override
    public void paintComponent(Graphics g){ //this is where the user controlled painting is supposed to take place this is what p.repaint() triggers
      super.paintComponent(g); //initializes the graphics context appropriately (does the defualt stuff before the override) like clear the screen
      for(MyGameObjects o: al) o.paint(g);
    }
  }
}
abstract class MyGameObjects{
  Point location = null;
  final BufferedImage bi;
  final Shape s;
  public MyGameObjects(Point p, BufferedImage bi, Shape s){
    this.location = p;
    this.bi = bi;
    this.s = s;
  }
  abstract public void paint(Graphics g);
}
class Barrier extends MyGameObjects{  // does not need to move
  public Barrier(Point p, BufferedImage bi, Shape s){
    super(p, bi, s); 
  }
  @Override
  public void paint(Graphics g){
    g.drawImage(bi, location.x, location.y, null);
  }
}
class Ship extends MyGameObjects{  // needs to move
  public Ship(Point p, BufferedImage bi, Shape s){
    super(p, bi, s); 
  }
  private void move(){ // where you put your move code
    //code to move goes here
  }
  @Override
  public void paint(Graphics g){
    move(); //move before rendering
    g.drawImage(bi, location.x, location.y, null);
  }
}

[Campbell Ritchie]

You will find suggestions about order of where you write your code here and here (latter link very dated).
Agree about restricting the number of empty lines. One empty line to separate succesive methods, etc. Number of spaces per indent: depends which book you have read. Google require 2 spaces.

Disagree.
Don't write your methods in alphabetical order, but group them by type. So if you have pairs of getXXX and setXXX methods put them together.
getXXX setXXX getYYY setYYY getZZZ setZZZ
Don't put classes in the same file in alphabetical order but group them logically. If you have any difficulty grouping them, they should not be in the same file.

Disagree.
Don't write lots of comments which simply repeat what the code says. String name followed by a comment to say that you have a String to store the name is a waste of keystrokes an should not be written. Nearly all those comments in NS' example ought to be deleted because they only tell you what you know already. Comments should be as long or as short as is necessary and they should always explain things which are not already obvious. Avoid multiple symbols in comments, unless you intend them to be displayed on screen. No /*-----------comments-------------*/ please. // comments must be very short because they need to fit at the end of the line.

None of you has written any documentation comments. You may not have time to write documentation comments if you are writing a class in a teaching session, but all non‑private class members and constructors should be preceded by /** comments */. Writing documentation comments is a skill in itself. You can find about it here and in Effective Java™ by Joshua Bloch.

[Winston Gutkowski]

Justin Robbins wrote:Thank you so much Nikki! I copied this and put it in my Eclipse workspace for future reference. I wish my teacher would make us outline things like this. The whole idea of buckets is wonderful.

I don't want to criticise Nikki or her teacher, but I feel I ought to point out that the system has a acronym: IPO (for Input-Process-Output), and dates back to the 1960's, when programs were usually large, monolithic blocks of code.

And while I have no problem with any methodology that helps you organise, or forces you to think before you code, I'm not sure that it's the best fit for an Object-Oriented language like Java. It's essentially a way to think about processes or 'functions', and Java tends to work best with objects.

While you're starting out, it's perhaps not a bad discipline to use; but IMO Nikki's example main() method is at least five times as big as it should be (not counting comments), and is missing at least two classes - the main one being Person (or WageEarner).

So: by all means use it to organise your thoughts and document your code - both of which are extremely important - but if you're writing methods that are so big that they need this sort of organisation, then they are almost certainly TOO big.

HIH

Winston