Programming Fundamentals

Students will be able to

Review the important terms here

You might have heard about computers many times. You might have questions about how computers perform so many tasks. You might have questions about programming. What is programming? Welcome! If you start to ask all these questions, then you are in the right place to start to learn about programming. We use programming to develop software. A program is a sequence of instructions that specifies how to perform a computation. The computation might be something mathematical, like solving a system of equations or finding the roots of a polynomial. It can be a symbolic computation, like searching and replacing text in a document or compiling a program.

Learning a programming language is similar to learning a foreign language, such as French. The ultimate goal of learning a foreign language is to be able to compose sentences to communicate (the communication problem). Similarly, the ultimate goal of learning to program is to write proper statements that solve a particular problem, such as calculating the volume of a sphere or calculating the projectile of a rocket.

A programming language offers its set of different types of statements for programmers to use.

Before you can write code using a type of statements, you need to learn its syntax and semenatics. For French, syntax is the grammar of the language and semantics is what a sentence means. For programming, when we specify how the code should look like and structural rules, we are talking about syntax. Programming languages, such as Java, have very strict syntax rules, much stricter than a natural language (e.g. French). If your code does not comply with the syntax rules, the compiler (the translator) will not understand your code and therefore cannot translate your code into machine code that can be executed on CPU.

In order to learn how to compose the right sentences in French to convey certain meanings, you will normally first do some reading comprehension exercises to learn how to interpret what sentences mean. Similarly, in order to write code to solve a problem, you first need to read code written by others and understand what that code does. What a piece of code does is similar to the meaning of a sentence in a foreign language. We call this semantics of the code. Only if you understand the semantics (the behavior) of code can you compose the right code to have the desired behaviors.

Through syntax and semantics learning, you will build your tool set of a programming language’s different types of statements. When the times come to write code to solve a problem, you need to pick up the right statements and use them in the right way and right order to achieve the desired behavior.

The semantics of statement (an instruction written in high-level programming language, defined in the section above) is what it does on a computer. We need some very basic understanding and vocabulary in order to be able to state the behavior of a statement.

First, get some understanding of How Computer Works by watching the fun videos on Khan Academy: Khan Academy’s How Computer Works. Please watch the last two videos "CPU, Memory, Input and Output" and "Hardware and Software" (staring Bill Gates and other real technical people).

Second, watch this video on YouTube for a more detailed explanation about how CPU execute instructions in stored in memory: YouTube video (It’s less than 8 mins and please be patient and watch the whole video.)

We can see that memory holds instructions and data. Each memory location has a unique address. Instructions are fetched by CPU and executed by CPU. Besides the instructions, memory also holds data that need to be manipulated by the program.

Computer programs, known as software, are instructions to the computer.

You tell a computer what to do through programs. Without programs, a computer is an empty machine. Computers do not understand human languages, so you need to use computer languages to communicate with them.

Programs are written using programming languages.

Coding Standards

Code Conventions by Oracle

Java is one of the most widely used computer programming languages. According to Hostmann (2016), Java is a well-designed programming language and is an efficient and secure environment with a huge library.

The White Paper Buzzwords

You must first set up the environment to compile and execute java programs. To be able to compile and run programs, you must install the JDK and configure it. Java SE 12.0.1 is the latest release for the Java SE Platform (as of June 09, 2019). Orale JDK

Review the important terms here and here.

Programming is to write code that can be executed by the computer to solve a particular problem. A program consists of instuctions that a computer can execute. We call instructions written in a high-level programming langauge statements. In this chapter, we will learn about statements that get input from user, perform computations, store data and computation results in memory and display messages.

The followin Java program was first introduced in Chapter 1. In fact, it contains only one statement: System.out.println("My First Java!");

We can see that the program MUST contain other lines to conform to Java structure rules (i.e. syntax). The following is the class block or "wrap", containing the class header and class block (i.e. the pair of curly brackets).

The following is the method block or "wrap", containing the method header and method block (i.e. the pair of curly brackets).

We can see that the method block is indented inside the class block. We can also see that the statement is further indented inside the method block. The indentation is for highlighting the structure of a program.

The following is another Java program that contains more statements. We will use it to illustrate some important Java concepts. We can see that the Java file name and the class name have to be the same. Java is case sensitive, which means that upper and lower cases have to match exactly.

As introduced in Chapter 1, data are stored in memroy. Instead of directly using memory addresses, Java uses variables. When the Java compiler translates a program, a variable is given a specific memory location (address).

In the above program MySecondJava.java, studentsPerClass, myWeight, and greeting are variable names, each representing a memory location for storing data.

We want to choose meaninful names for variables, indicating the purpose of each variable. If the name you choose consists of only one word, spell that word in all lowercase letters, such as greeting. If it consists of more than one word, capitalize the first letter of each subsequent word, such as studentsPerClass and myWeight.

For more information, see this site: Java variable name rules and conventions

A program can process different types of data. We will talk about three basic data types in Java: integer, real value, and text. Integers are whole numbers (without a decimal point). Real values are numbers that include decimal places. Texts are sequences of characters, including punctuation, symbols, and whitespace. Every value in Java has a corresponding data type. The table below shows examples of each of the three types.

Note that text data are always surrounded by quotes. Some text may look like numbers, but as long as they are surrounded by quotes, they are treated like text.

Java uses its special key words to represent these data types. There are four integer types.

Note: An integer value as in Table 1 is by default as the int type. To represent a long value, we need to append the value with an L or l (i.e. either upper or lowercase). For example, 2L and 23458907234556L are two long values.

The format to represent real values are called floating point. There are two floating-point data types:

Note that a real value as in Table 1 is by default the double type. To represent a float value, we need to append the value with an F or f (i.e. either upper or lowercase). For example, 2.0F and -2.235f are two values of the float type.

For text, the data type name is String. Note that, the type name is capitalized.

In Java, each variable must be associated with a certain data type. We use declaration statement to specify the data type of a variable. For example, the following statement declares the variable studentsPerClass as an int variable.

The following is also a declaration statement. Besides declaring the variable studentsPerClass as an int variable, it also initialize the variable with an int value 28.

You can also declare multiple variables of the same type in one declaration statement.

After all the declaration statements in MySecondJava.java are executed, the memory looks like below:

The following statements are assignment statements. Note that they are similar to a declaration statement with an initial value, but there is no data type at the left. These variables have already been declared earlier, so no data types are needed on the left.

An assignment statement puts a new value into a variable. The right side of an assignment statement is first evaluated and the result will be put into the variable on the left.

The following describes what happens after each of the statements above is executed.

After these assignment statement are executed, the memory looks like below.

An arithmetic expression (an experssion for numeric values) is often used in an assignment statement. For example, studentsPerClass * 10 and myWeight - 8 are both arithmetic expressions. Please refer to Section 2.5 of Think Java for more information on this topic.

Java also has an operator, %, to get remainder of a division. Please refer to Section 3.8 of Think Java for more information on the remainder operator.

Further, Java alo has String operations. Please refer to Section 2.8 Think Java for more information on String expressions. This section also talk about how String values and numeric values are "added" together.

For a more detailed introduction to floating-point numbers and the associated rounding errors, please read Section 2.6 and 2.7 of Think Java.

Finally, Java can convert a value of one data type to a value of another data type. For example, (int) 123.56 converts a double value 123.56 to an int value 123. (int) is called a type cast operator. Please refer to Section 3.7 of Think Java for more information on this topic.

The current version of MySecondJava.java does not interact with the user who runs the program at all. Variable declarations and assignments all happen in memory. We will extend the program by adding output statements at the end. They communicate with the user by printing information on the screen.

The first output statement will print the value of variable totalStudents, which is 280, on a line. The second output statement will print the value of the variable myTargetWeight, which is 168.3, on the second line. The third output statement will print the result of the String expression greeting + name + "!", which is "Hello, John!" on the third line. Note that the quotation marks are not printed. The following is what the program will print:

In addition to print and println, you can use System.out.printf to format the output. It’s a very useful method and will be used in many of the exercises at the end of the chapter. Please read Section 3.5 of Think Java on how to have more control on output format.

The following program contains comments. Comments are not instructions for the computer to follow, but instead notes for programmers to read. There are two types of comments in Java. Line comments start with //. Anything following //, on the same line, will not be executed. Often, at the very beginning of a program, comments are used to indicate the author and other information. Even though line comments can be used, but for comments that span several line, we usually use block comments, whcih start with /* and end with /. Anything in between / and */ will not be executed. Comments are also used to explain tricky sections of code or disable code from executing.

Now take a look at the program, can we give a guess as to what the program will print? Is it 15 or 105?

Some of you will guess 105. The reasoning might be the following: Even though a starts with 10, but it changes to 100. Since variable sum contains the result of a + b, so sum should be 105 at the end. However, this is INCORRECT.

The statements are executed in the order that they show up in the program. When line sum = a + b; is executed, sum gets the value 15. When line a = 100; is executed, a gets a new value 100. Note that sum is not changed and retains the value 15. The output statement thus prints 15.

Read the following program.

The first statement final double KMS_PER_MILE = 1.609; declares a constant variable KMS_PER_MILE. Note that the keyword final is prepend to the declaration. For a constant variable, an initial value must be assigned to the variable at the declaraion. Also note that, by convention, the name for a constant variable is all capital letters with underscores separating words. However, if a variable’s name is all captical letters, it is not automatically a constant. The keyword final is needed to make a variable constant. Please refer to Section 3.4 of Think Java for more information on constants.

We can see that the program converts 100.0 miles into kilometers. First, variable miles gets a value 100.0. Then the variable kilometers gets a value 160.9. Last the output statement prints the value of the expression miles + " miles = " + kilometers + " kilometers".

Let’s talk about miles + " miles = " + kilometers + " kilometers". It is a mixed-type expression and evaluated to "100 miles = 160.9 kilometers". Please refer to the note below and Section 2.8 Think Java for more information.

Now we understand the program: It converts 100 miles to the corresponding kilometers. However, this program has a big drawback. What is it?

This program can ONLY converts 100.0 miles. If there is a need to convert 200.0 miles, the programer will need to modify 100.0 to 200.0. This basically changes the program itself and the program will need to be recompiled. A user will need to get this new program for converting 200.0 miles.

The following is a program that can get user input for distance in miles and then convert it into the corresponding kilometers. There is no need to modify and recompile the program for converting different values. The program can be run as many times as needed to convert whatever the values to be converted.

The following are three new lines in the above program:

The second line is an output statement that prints a prompt for a user. It tells the user that the program expects a distance in miles to be entered. We will focus on the other two lines. We will talk about the first and thrid line below.

Line 1 java.util.Scanner input = new java.util.Scanner(System.in); looks complicated, but a closer look tells us that it’s a declararion statement with an initial value assigned to the declared variable. The data type isjava.util.Scanner, the variable is input, and the initial value is new java.util.Scanner(System.in);.

The data type java.util.Scanner looks very long, but it really is Scanner. We will rewrite the program above as follows:

We used the import statement import java.util.Scanner; to tell the Java compiler that data type Scanner is defined in the package java.util of the Java installation. A package contains multiple related classes. java.util.Scanner; is the full pathname of the data type Scanner. If we use the import statement, there is no need to use the full name in the remainder of the program. As a result,

java.util.Scanner input = new java.util.Scanner(System.in);

is simplified to

Scanner input = new Scanner(System.in);

Word new is a keyword for creating a new object. The expression new Scanner(System.in) creates a Scanner object that will extract information from System.in (see the note below). This object is assigned to the variable input. Note that when an object is assigned to a variable, the reference (or location) of the object is stored in the variable.

Remember that we can invoke the print and println methods on System.out by System.out.print(…​) or System.out.println(…​) to print information.

Similiarly, we can also invoke different methods on a Scanner object to retrieve different types of information. For example, input.nextInt() will invoke the nextInt method on the Scanner object input and retrieves an integer. See Table 2 for more Scanner methods.

When the statement double miles = input.nextDouble(); is executed, the program will wait and allow the user to enter data. Whatever the user enters will be retrieved and returned by the nextDouble method and then assigned to the variable miles.

See the step-by-step walkthrough of this program at Java Visualizer.

Note that when using nextLine and the other next methods (e.g. next, nextDouble, nextInt) together, there is an unexpected behavor. Please read Section 3.9 of Think Java to understand this phenomenon and how to deal with this issue in your program.

Java designers want to make life easier for Java developers and they designed some short-cut assignment operators to save typing time.

Let’s look at the following three statements. You might say, "Hi, x cannot be equal to x + 5!"

We need to remember, however, that this is not a math equation, but an assignment statement. The right side of an assignment statement, which is always an expression, is first evaluated. The value of the expression will be assigned to the variable on the left.

Assume x's original value is 10, x + 5 is evaluated to 15 and then 15 wil be put into x. After the assignment statement is executed, x's value becomes 15.

For assignment statements that have similar format, Java has a set of augmented assignment operators. For example, the statement on the left of each line below is equivalent to the statement on the right. The operators used in the statements on the right side are the augmented assignment operators +=, -=, *=, /=, %=. Note that there is no space inside the operators.

Note that the format of the orginal assignment statement has to be the following, where both <var>'s refer to the same variable.

If a variable is increased by 1 or reduced by 1, there are ways to further save typing. We can use increment operator ++ and decrement operator --. On each line, all statements are equivalent.

Review important terms here.

In real life, we often encounter situations where we need to make decisions based on certain conditions. For example, based on the student’s numerical grade, we want to determine whether the student is passing or failing the class.

So far, the programs we have been writing do not support different outcomes, such as determining whether a student is passing or failing. They do not support computations that depend on the conditions, and they cannot validate user input. Our programs need to produce different results based on conditions encountered in the program.

This chapter introduces the boolean data type, a primitive type that can hold true or false. We discuss relational and logical operators, build an understanding of boolean expressions (conditions), and introduce conditional statements in Java (if, switch, and the ternary expression).

By the end of this chapter, you should use boolean expression and conditional statement effectively to solve common programming problems. It is important to note that the terms boolean expression and condition are used interchangeably throughout this chapter.

We will start this section by introducing the boolean data type. A variable of boolean data type can have only one of two values, either true or false. The example below shows how to declare and initialize a boolean data type:

Or alternatively, the two steps can be combined in one statement as below:

Relational operators are used to checking conditions. They can be used to check whether two values are equal, not equal, greater than, or less than. The table below list the Java different relational operators along with their mathematical equivalent operators, the result of an operational operator is either true or false (boolean):

Note: == is used to check for equality

Boolean expressions use relational operators to check conditions and to compare variables against certain values. For example, for a student to pass a class, his grade must be greater than or equal to 70; that is, we need to compare the student grade with 70. The boolean expression (condition) that represents this comparison is grade >= 70. A boolean expression will evaluate as either true or false. The figure below shows some examples of boolean expressions:

Sometimes we need to check for two or more conditions to decide or pick an execution path. Logical operators allow us to combine two more conditions. A compound boolean expression consists of two or more boolean expressions joined with logical operators. For example, assume we have a class x that requires two prerequisites class A and class B. To decide whether a student can register for class x or not, we need to verify that the student has passed both class A and class B. In this section, we will cover the logical and operator (&&), the logical or operator (||), the logical negation (not) operator (!) and exclusive or operator "XOR" (^) caret. The four logical operators with their Java symbols are shown in the table below. and, or and exclusive or are binary operators. That is, they take two operands while not is a unary operator. That is, it has only one operand:

The table below shows the truth table for &&, ||, ^ and !, where b1 and b2 stands for boolean expression 1 (condition1) and boolean expression 2 (condition2), respectively:

Referring to the table above we notice the following:

Below are examples of compound boolean expressions:

Java use short circuit evaluation for both && and || operators. In the case of &&, if the first boolean expression (condition) evaluates to false, the result of && is false regardless of whether the second boolean expression evaluates to true or false. In the case of ||, if the first boolean expression (condition) evaluates to true, the result of || is true regardless of whether the second boolean expression evaluates to true or false. To better understand short circuit analysis, assume we have two boolean expressions b1 and b2. In the case of && (b1 && b2), assume b1 is false, java will not evaluate b2 since, since b1 && b2 is false regardless the value of b2. In the case of || (b1 || b2), assume b1 is true, java will not evaluate b2 since, since b1 || b2 is true regardless the value of b2.

The table below shows the operator Precedence from highest to lowest:

In the introduction section, we presented the problem of determining whether a student is passing a class based on its numerical grade. Assuming a passing grade of 70, a student passes the course of his/her grade is greater than or equal to 70. The Java-if-statement is needed to solve this problem. In this section, we will introduce if, if-else, nested if, and multi-branch if-else statements.

A switch statement is multi-branch statement in which the execution path is based on a value of a variable or an expression. Based on the java documentation, the expression or the variable can be byte, short, char, and int primitive data types. Also, it works with String, Character, Byte, Short, Integer, etc.. Unlike the if statement, a switch statement can have several execution paths. The switch’s syntax is shown below, where x and y are values and are not variables. Note that having a default block is optional:

The switch statement works as follow:

Example 7: Write a program that reads the year and month as integers and print the number of days in the entered month. You can assume 1 for January, 2 for February, and so on.

Solution: For January, March, May, July, August, October and December (months 1, 3, 5, 7, 8, 10, 12) all have 31 days. For April, June, September and November (months 4, 6, 9, 11) all have 30 days. For February (month 2) will depend on the year. If the year is leap, it will have 29 days otherwise it will have 28 days.

For a step-by-step execution of the program below click here

In this chapter, we covered the boolean datatype which can store true or false values. We also learned about the relational operators (<, <=, >, >=, ==, !=) and studied boolean expressions the yield either true or false. We also studied the logic operator (&&, ||, ! and ^) and how they are used to combine boolean expressions (conditions) to produce compound boolean expressions. Then we studied the if statement and discussed the need for this statement to write programs that allow us to make decisions based on certain criteria. Finally, we covered the switch statement.

Students will be able to:

Review the important terms here.

Repeating a task multiple times is done using loops in Java. There are three different types of loops:

For loops should be used when we know how many times a task is to be repeated. These are also called as counting loops, as they count the number of times the loop runs. It is useful to know that a for loop can be written as a while loop, but vice-versa is not true. More details about for loop syntax and examples is here.

While loops are used to repeat actions when we do not know how many times a task is to be repeated. In such cases, we should at least know the signal that indicates when the loop should end. For example: Your instructor asks you to clap your hands until (s)he says "STOP". In this case, you won’t know how many times to clap, but you know that the signal to stop clapping is "STOP".

Syntax of the while loop and an example are discussed here.

Do-while loops are similar to while loops, with one difference. The condition of a do-while loop is checked on exit. This ensures that a do-while loop will run at least once. More details on do-while loops syntax and examples is available here.

A comparison of different types of loops is discussed on lynda.com videos here and here.

Two keywords, break and continue can be used to change the flow of a loop in between if needed. The keyword break allowss to break from a loop and exit it. The keyword continue allows to move on to the next iteration. Details and examples are here.

When one loop is placed inside the body of another loop, we have a nested loop. In the following example, a nested loop is used to create a table of "*".

The outer loop runs 4 times and represents 4 rows of the table. For each value of row, the inner loop runs 5 times, generating 5 columns of "*". Such 5 columns are generated 4 times. Result looks as below.

As you see the step-by-step animation here, notice both the output and the changing value of variables.

Refer to https://mathbits.com/MathBits/Java/Looping/NestedFor.htm for a simple example demonstrating how nested loops work.

This youtube video explains the concept of nested loops.

Methods are used for several key purposes in programming. First, they allow us to decompose our problems into smaller parts. When we solve complex problems, trying to grasp the entire problem at one time can easily overwhelm our ability to see the solution.

Second, by moving code into methods, we can use this same code in multiple places without having to re-write this code. This allows us to make changes in the way this code executes as requirements change or to correct defects in a single location.

Third, methods allow us to operate on objects, or more specifically, member variables inside objects. A member variable is a non-static variable that is declared in the class nut not in any method. This variable represent a data member of an object of the class and it can be accessed by all of the non-static methods defined in the class. Even though non-static methods is a topic mostly for the last chapter (Chapter 7), it is helpful to contrast it with static methods.

Methods can either return a value or not return anything. Think Java Chapter 4 discusses void methods, those that don’t return a value. Think Java Chapter 6 discusses value returning methods. A method that returns a value can only return a single item, this item can be an object of a class or some type of data structure that contains multiple values.

Java provides many methods through the Java API. The following are some examples.

We can create our own methods to allow us to separate our code into manageable units. Keep in mind that methods can either return nothing or return values. Note that a method can only return one value.

Here is an example method definition that does not return a value. The method just prints a message.

The following is an example of a value returning method. This method returns a line that a user enters.

We will go over each part of a method definition in this subsection.

You can have two methods that have the same name as long as they have different number or types of parameters. The method name and parameters, the signature, cannot be ambiguous. Keep in mind, the signature is the name and the type and number of the variables not the names of the variables. The following two methods are examples of overloaded methods.

Please use the visualizer below to see what happens in memory when a method is used (or invoked). This will be formally introduced in the next subsection.

The subsections above are about creating (defining) your own methods. To use a method, your program call or invoke a method. The method invocation format is the method name followed by parentheses, inside which are the correct number and type of arguments. For example, the following code will call our example method printString.

Arguments provide values for the parameter variables.To understand how values are passed into a method, it is important to understand how the arguments' values passed onto the parameter values. There are two types of vairables, primitive type and reference type. They have different "behaviors" for information passing.

Methods belong to either the class or an object (or an instance) of the class. Majority of the examples in this chapter are class methods. Chapter 7 will go into more details on instance methods. It is, however, useful to compare these two types of methods.

Arrays and ArrayLists both play an important part in the Object Oriented programming landscape. For both structures, classes with utility methods exist for performing common operations such as sorting and searching. ArrayLists are defined as first class OO objects, with attributes and methods which describe the contents, characteristics and functions of this important class. In a short amount of time, you will frequently be integrating ArrayLists and OO programs in a seamless and very natural manner!

Review the important terms here and here.

Until now, we have dealt with variables that deal primarily with a single value. In many programs, it is helpful to treat similar items as a group. The java programming language provides mechanisms to refer to a group with one variable: arrays and ArrayLists.

Why two? That would take a longer explanation, but we can simplify for now by saying that arrays are more efficient and should be used when efficiency is paramount; ArrayLists are less efficient and as a result easier to program and more flexible.

As mentioned earlier, ArrayLists are similar to Arrays in their functionality. Also noted previously, ArrayLists are not as efficient as arrays, but are much more flexible.

here and here

Object oriented programming allows us to program in a style that can result in code that is suitable for large scale software development projects. In this chapter, we will learn how to create a class, how to instantiate an object, the difference between static and non-static methods, visibility specifiers, and explore a simple program that utilizes more than two classes.

Sometimes it is useful to group related data and functions into one class. By combining these two, we can often simplify programming in many ways. This representation of data and functions into one is called a class. This is called encapsulation. You can find more information on encapsulation here.A running copy of this representation is called an Object. The data that is part of an object is called member variables and the functions are called methods. Member variables are made up of class and instance variables. See Methods to learn about class and instance variables in detail.

Here is a example of a Class in Java.

Almost everything in Java is an object except primitives such as short, int, doubles, char, long and boolean. For example, strings and arrays are examples of objects that we have been using frequently in Java. The new keyword is used to create an object in Java. When creating a class, it is important to make sure that the contents of a class show high cohesion. For example, in the Employee class, all the member variables and methods should be about employees. If a method such as sendChatMessage() which sends a chat message to a coworker would be out of place an lessen the cohesion of the class.

When you create an object using the new keyword, a special method called the constructor is executed. The constructor is used to initialize instance variables and prepare the object which is created in a special space in memory called the heap. The constructor’s name and the class name have to match. If a constructor is not present in the class, class, a default constructor is provided instead. The default constructor has no parameters and initializes member variables as follows: numeric primitives to 0, booleans to false, char to ‘/u0000’ and reference variables to null. When any constructor is created, the default constructor no longer exists. Constructors with different method signatures (constructor overloading) are allowed.

The following is the no argument constructor:

The no argument constructor could be used to set default values such as the following:

The default constructor does not initialize member variables in a meaningful way so a constructor with parameters can be useful.

In the above constructor, we see the this keyword for the first time. The this keyword is a reference to the current object and it can be used to refer to the instance variables of the current object. The this keyword can also be used to call other constructors in the following manner.

For more information about the this keyword, you can read more about it in the Java Tutorial

You may also here these referred to as accessors and modifiers. Both names mean the same thing, a method to either set or get data that is in a class. Getters and setters are the more commonly used terminology.

Information hiding refers to the idea that member variables of a class should be closed for modification from outside of class to prevent unintentional or intentional modification and prevent complexity arising from such unexpected modifications. In Java, the public, private, and protected keywords are used to control access to member variables and methods of a class. You can refer the Java tutorial to learn the details but the public keyword indicates that you can access the variable or method from anywhere and the private keyword indicates that you can access them from only the class.

You can use getters to access private member variables. Getters refer to methods that return the value of private member variables and the convention is to name such methods with the prefix get. Here is an example from Employee class.

Setters are methods that are used to change the value of private member variables. The convention is to name setters with the prefix set. Here is an example from the Employee class.

Instance methods are methods that belong to each object but static methods are methods that belong to a class. For example, the sort() method in the Collection class is an example of a static method. Utility methods such as the sort() method do not need to be included with each object so they are part of a class. All of the methods in the Math class are static since we do not need them to be associated with a particular object. In fact, the main() method is an example of a static method.

In object-oriented programming, it is important not to overuse static methods. When static methods are overused, the programming style can resemble the procedural programming style more than the object-oriented style. Also, static methods/variables must be instantiated before your program executes and there can only be one value stored in a static variable, changing it in one object changes it in all objects. At the beginning of your journey in object-oriented programming, try to minimize the creation and use of static methods in your classes. There is also a memory footprint problem with the overuse of static variables and static methods. This will be covered in ITEC 2150 when you learn about garbage collection. Please see the Methods chapter for more information about static and instance methods.

When using a String in Java, it was necessary to use the equals method to establish the equality of two objects.

The reason is because strings in Java are objects and you cannot use the == operator to test equality. To use the equals() method to test equality, it is necessary to implement the equals() method. The following is equals() method for the Employee class shows that two Employee objects are equal if the name is equal (this is somewhat unrealistic in the real world).

Notice in the previous code, we had to test to see if obj is an Object of the Employee class. We also had to explicitly cast obj to an Employee object before we could use the getName() method. We can avoid this if we write our equals method as follows:

By writing the code in this fashion, we must provide an object of the Employee class as an argument to the Employee equals method. This will prevent us from using the equals method with variables that are not Employee class objects.

Sometimes it is necessary to get the string representation of an object. In Java, the toString() method is used to get the string representation of an object. For the Employee class, we can represent the the Employee object with the name and rank properties.

If you implement the toString() method, you can use it in the System.out.println() method to print the string representation of the object.

Suppose you have a Leadership class which holds an array/ArrayList of employees that are managers.

You can see that an object (ArrayList of employees) can be part of another object (Leadership). In object-oriented programming, we call this relationship a has-a relationship. Object-oriented programming focuses on such relationships among objects and the communication among them.