Java Programming Basics#

Learning What's What

Overview#

• Objects, variables, and classes (in Java) make up our programs. We define, modify, and use these variables and objects to make our programs run.
• Programs use key words to define characteristics of variables or objects. Basic keywords:
  • public - an object accessible by other classes (files)
  • private - an object only accessible by its containing class (file).
  • protected - like private but can be seen by subclasses
  • return - value to return or give back after method execution (run).
  • void - a method that returns no value
  • null - a value that means empty or nothing

Classes#

• Classes are the files that contain our programming
• A program can be made up of one class but can also be made up of many classes
  • All programs run a main class that can optionally load additional classes either directly or indirectly

  • Example

    main loads class1, class1 loads class2
• Classes are made up of variables and methods and are often used to separate and organize your code.
• Classes can also call (use) variables or methods of other classes if those have been set to public.

Constructors#

• Classes can also have a constructor which is a special type of method that has the same name (case sensitive) as the class file
  • Constructors are always called when the class is loaded into the program for the first time. This is often the only time they are called.
  • Constructors are called when trying to access the class in other files.
  • They can be called again if the class is programmed to be unloaded (destroyed) and reloaded.
  • Calls to methods, and assignment of values, within the constructor will run as soon as the class is called (loaded) in the code.
  • The new operator creates an object of a type of class using a constructor

  • Example

    classObject = new className();

Methods#

• Methods, also known as functions, can be thought of as subprograms or routines that run inside of your main program.
• Methods are used when you want to run the same code multiple times. Copying and pasting code is BAD! Use methods instead!
• Methods are also useful to access only certain parts or functions of another class.
• Methods can also have their own variables (local) or use variables available throughout the whole class (global variables), this will be explained more in the scope section.
• Methods can call (use) other methods, even multiple times.

int value;
void increment(){
    value++;
}

Parameters#

• Parameters are variables that are passed (sent) to a method for it to use.
• You can pass more than one parameter but order matters when calling the method.

// Example of a method with a parameter
double half(int num1){ 
    double multiplier = 0.5;
    return num1*multiplier; 
}

int newNumber = half(12); // <---- Method being called (used) in code

Variables#

• Variables are objects that contain data, they are characterized by data types
• Variables are assigned names and data types on creation
  • Names can be anything with the exception of pre-existing keywords such as public or int
• Data types define what type of data is being stored in the variables:
  • int - integers (whole numbers)
  • double - double precision floating point (fractional/decimal values)
  • boolean - true or false (true = 1 or false = 0) values.
  • string - text values contained in parentheses

  • Example: int sum;

    A variable that can hold whole number values

  • Example: boolean isFull = true;

    A variable can either hold a true or false value and is being assigned a true value

Constants#

Most variables can have their values assigned or reassigned at any point elsewhere in your program. To avoid having a variable change its value during runtime you can make it a constant

• In Java you can create constants using the static final keywords together in front of the data type of the variable
  • The static modifier causes the variable to be available without loading the class where it is defined.
  • The final modifier causes the variable to be unchangeable.
  • Java constants are normally declared in ALL CAPS. Words in Java constants are normally separated by underscores.

  • Example: public static final double PI_VALUE = 3.14159;

    A variable that cannot be modified during code run time.

Scope#

• When creating a variable, where you create it matters. This is known as the scope of a variable.
• The scope is where a variable can be seen within a class
  • A variable created in a method can only be seen in that method. This is a local variable.
  • A variable created outside a method can be seen in all methods of that class (file). This is a global variable.
    • It is good practice to put them all at the top before your first method.

public int testMethod() {
    int example = 12; // Inside of method
    example = example + 1;
    return example
}

int example = 12; // Outside of method
public void testMethod() {
    example = example + 1;
    return example
}

Comments#

• Comments are a programmer-readable explanation or annotation in the source code of a program.
• Comments do not affect what the code does.
• Comments are often used to leave notes or explanations of what methods or classes are doing so that it is easier to understand the code.

// This is what a single line comment looks like

// You can also have multiple
// single line comments in a row

/* 
This is what a
multiline comment
looks like 
*/

/**
 * This is a doc comment
 * 
 * <ul>
 * <li>They can be viewed by hovering over code they are attached to</li>
 * <li>They can be formatted with HTML</li>
 * </ul>
*/

Conventions#

• There are also many different conventions when programming, this ensures that programs are readable between different people.
• A common naming convention:
  • Programming is often done in CamelCase or lowerCamelCase
  • Instead of adding spaces, capitalize the first letter of each word

  • Example

    ThreeMotorDrive, driveForward, setSpeed