CISC 1115
Introduction to Programming Using Java
Lecture 1
A Whirlwind Tour of Basic Java

What is Programming?

• computer: a machine capable of carrying out a sequence of operations (typically arithmetic and logical)
  • arithmetic and logical because that was the motivation for calculations: census tables, ballistic trajectory tables for canon, nuclear reaction calculations, etc
    • As it turns out ALL computer-based calculations (including sound, image, video, etc) reduce to arithmetic and logical operations
  • The original use of the word computers was for humans … Computer (Occupation
• programming: the act of specifying a sequence of actions/commands to be carried out/executed by a computer
• program: a sequence of such commands
  • A program is also sometimes known as an app
• programmer: a person trained in the field of programming

An Overview of the Programming Process

• Actions (imperatives)
• Decisions (conditionals)
• Repetition (iteration)

• Making an omlette:
  • Breaking the eggs: action
  • Beating the eggs: repetition together with decision (when is it enough)
  • Heating the pan: action together with a decision (hot enough)?
  • Adding the eggs to the pan: action with repetition and decision (keep pouring until cup is empty)
  • Stir eggs until set: action (stir) repetition with decision
  • Add cheese: action
  • flip out of pan: action

Algorithms

• Examples
  • the above omlette recipe
  • calculating your GPA
  • determining youngest person in class

Specifying Computer Algorithms

Unlike a person, a computer cannot fill in missing details, resolve ambiguities, or decide for itself what we probably meant.

We therefore need a formal mechanism for specifying exactly what we want the computer to do. That mechanism is a programming language.

• A programming language is a language that allows to specify algorithms in a manner that can be carried out by a computer

What We Need from a Programming Language

If a programming language is to let us specify algorithms that a computer can carry out, what must it provide?

• Our instructions must be:
  • Unambiguous
    • 3 + 4 * 7 … how do we calculate this expression?
    • we can't permit multiple plausible meanings
  • Precise
    • Print the student's GPA … to haw many places?
    • we must know exactly what to do

  • The above two are quite similar; don't worry about the exact distinctions; the important thing is both properties are required if we're going to write programs that do exactly what we want them to do

• We need to be able to specify:
  • Steps performed in sequence
  • Decisions about which steps to perform
  • Steps that are repeated

• Why more than one language developed; their differences, and their evolution is the subject of later courses, on p[articular a course in programming language history and design.

A Quick Introduction to Java

Basic Java Program Structure

1.		public class <ClassName> {
2.			public static void main(String [] args) {
3. 				…
4.			}
5.			…
6.		}

The Simplest Possible Java Program (App)

public class EmptyApp {
	public static void main(String [] args) {
	}
}

A More Substantial Program

public class HelloWorld {
	public static void main(String [] args) {
		System.out.println("Hello world");
	}
}

Hello world

A Program with a Calculation

• We will use grading as a unifying theme for the programs.

public class ExamAverager {
	public static void main(String [] args) {
		System.out.println((78+86)/2);
	}
}

82

Making the Output More Readable

public class ExamAverager {
	public static void main(String [] args) {
		System.out.println("Gerald Weiss received an 88 and a 92 for an average of " + (88 + 92) / 2); 
	}
}

Gerald Weiss received an 88 and a 92 for an average of 90

Adding a Decision (Conditional)

public class ExamAverager {
     public static void main(String [] args) {
          System.out.println("Gerald Weiss received an 88 and a 92 for an average of " + (88 + 92) / 2);
          if ((88 + 92) / 2 >= 60)
               System.out.println("Gerald Weiss passes");
          else
               System.out.println("Gerald Weiss fails");
     }
}

Gerald Weiss received an 88 and a 92 for an average of 90
Gerald Weiss passes

Introducing Variables and Types

Avoiding Redundant or Repetitious Values

• The above program repeated the student's name, as well as the values of the exams.
• Making a typo would result in us using one value in one place and a different one elsewhere
  • For example, misspelling 'Gerald' in one of the prints, or typing '80' in one place and '88' in another would produce inconsistent and thus incorrect output.
  • Similarly, we wrote the expression for the average twice, again inviting the possibility of making a mistake with one of them, producing inconsistent and incorrect results.

Allowing Different Names and Exam Values

• We typically want to be able to perform the above calculations on on other students with different exam grades
• As an aside, the conditional is almost silly if it is only applied to the grade of 90; in that situation, it will never print fails.

• If the values are hardcoded AND repeated, this quickly becomes a nuisance
• We also might eventually want to run this program once on many successive names and grades; this can't be done with hardcoded values

Making the Code More Readable

• Associated with this is the notion of avoiding putting 'magic numbers' into our code, i.e., numbers that seem to come from nowhere. We will have more to say about this later, when we discuss proper program design and style.

The Exam Averager Program Using Variables, Types, and Declarations

public class ExamAverager {
	public static void main(String [] args) {
		String name = "Gerald Weiss";
		int midterm = 88;
		int finalExam = 92;
		int average = (midterm + finalExam) / 2;
		System.out.println(name + " received an " + midterm + " and a " + finalExam + " for an average of " + average);
		if (average >= 60)
			System.out.println(name + " passes");
		else
			System.out.println(name + " fails");
	}
}

Gerald Weiss received an 88 and a 92 for an average of 90
Gerald Weiss passes

Making Use of the 'Variable' In Variable

• We can now use variables to apply our logic to different values; the question remains however as to populate the variables with those values.
• Even with variables and initialization, the programs — as currently written — have the values hardcoded into the code
  • While its true the values only appear in the initialization of variables (and are thus isolated from the rest of the program) , it is still the case that to change the value requires editing and recompiling the program
• We need some way of providing different sets of values without having to constantly be changing our code
• We do this by having the user supply data; for the moment we're going to do that from the keyboard

Reading Values (Input) From the Keyboard

• One would guess that if there is a System.out.println to print things out, there should also be a System.in.readln (or something like that) to read things in.
• It's close but not quite … a bit more work need to be done to read in values from the keyboard.
• For the moment, we will simply present the code as boilerplate again, but we WILL explain shortly

import java.util.Scanner;

public class <ClassName> {
	public static void main(String [] args) {
		Scanner scanner = new Scanner(System.in);
		…
		String name = scanner.next();		// next reads in text typed at the keyboard (until a blank is encountered or 'return' key is pressed)
		int midterm = scanner.nextInt();	// nextInt reads in an integer typed at the keyboard
		…
	}
}
		

Prompting the User at the Keyboard

• next and nextInt simply wait for the user to enter a value (and press the 'return' (↵) key)
• Without anything further, the user would:
  • be presented with a blinking cursor, but no other inidicatio the system is waiting and thus …
  • … would not realize the system is expecting them to input anything
  • even if they realized the system is waiting, they would have no idea WHAT they are supposed to input (i.,e., a name?, an exam grade?, which exam?)
• To solve this problem, we introduce the notion of a user prompt, i.e., a message displayed to the screen telling (prompting) the user the both input is expected and furthermore, what sort of input.
  • For example, if we wish the user to type in a name, we would code:

System.out.print("Name? ");
String name = scanner.next();

The Exam Grader With Input From the Keyboard

import java.util.Scanner;

public class ExamAverager {
	public static void main(String [] args) {
		Scanner scanner = new Scanner(System.in);

		System.out.print("Name? ");
		String name = scanner.next();
		System.out.print("Midterm? ");
		int midterm = scanner.nextInt();
		System.out.print("Final? ");
		int finalExam = scanner.nextInt();

		int average = (midterm + finalExam) / 2;
		System.out.println(name + " received an " + midterm + " and a " + finalExam + " for an average of " + average);
		if (average >= 60)
			System.out.println(name + " passes");
		else
			System.out.println(name + " fails");
	}
}

Weiss 
88
92

Name? Midterm? Final? Weiss received an 88 and a 92 for an average of 90
Weiss passes

Here is a sample execution of the program.
User input is in bold. Your program should replicate the prompts and output:
Name? Weiss
Midterm? 88
Final? 92
Weiss received an 88 and a 92 for an average of 90
Weiss passes

Adding Repetition

• Now that we have variables that can hold different values, and are able to populate them using input from the keyboard (rather than hardcoded values), we can now introduce the facility to repeat our logic on different values and apply our grading logic to each set of data input

Repeating Sections of Code — the for Loop

• Probably the most powerful feature of programming language is the ability to repeat a section of code an arbitrary number of times: once, twice, ten times, a million times … all with essentially the same (or no) effort on the part of the programmer.
• For the moment we will limit ourselves to a repetition mechanism known as a for loop:

  for (int i = 1; i <= 10; i = i + 1) {
  	…
  }
  		

  • The above causes the code between the { and } to be repeated 10 times.
  • We will again treat this as boilerplate to some degree; i.e., if we want to repeat something 4 times, we will write:.

    for (int i = 1; i <= 4; i = i + 1) {
    	…
    }	
    				

    • you may be able to make sense of the various parts of the loop header (i.e., int i = 1, etc); if not, don't worry, and again, just treat it as boilerplate with a simple modification to change the number of times to repeat the code.
  • Don't forget to:
    • include the closing brace (})
    • indent the lines of code between the { and }
      • this indicates the section of code to be repeated
      • this section of code is called the loop body
      • you can see an example of this indentation in the code below

• Being able to make very simply decisions as well as performing very simple repetitions will make our examples and lab assignments less boring
• It's not a bad idea for you as programmers to occasionally use something you don't immediately understand. These will grow on you as you use them so by the time we really present them they won't seem so strange

The Grading Program for Three Students

import java.util.Scanner;

public class ExamAverager {
	public static void main(String [] args) {
		Scanner scanner = new Scanner(System.in);

		for (int i = 1; i <= 3; i = i + 1) {
			System.out.print("Name? ");
			String name = scanner.next();
			System.out.print("Midterm? ");
			int midterm = scanner.nextInt();
			System.out.print("Final? ");
			int finalExam = scanner.nextInt();

			int average = (midterm + finalExam) / 2;
			System.out.println(name + " received an " + midterm + " and a " + finalExam + " for an average of " + average);
			if (average >= 60)
				System.out.println(name + " passes");
			else
				System.out.println(name + " fails");
		}
	}
}

Weiss 
88
92
Arnow
75
95
Cox
80
100

Name? 
Midterm? 
Final? 
Weiss received an 88 and a 92 for an average of 90
Weiss passes
Name? 
Midterm? 
Final? 
Arnow received an 75 and a 95 for an average of 85
Arnow passes
Name? 
Midterm? 
Final? 
Cox received an 80 and a 100 for an average of 90
Cox passes

The Grading Program: Letting the User Decide How Many Students to Process

• The above for loop program finally illustrates the power of the computer, with a trivial modification we can have the program perform the grading computation for one million students.
• However, a similar problem arises to the one that motivated us to introduce variables: regardless of three, ten, or a million students, our program is again limited; this time to the number of students processed.
• A better approach would be to allow the user to tell us in advance how many students they want to process.
• We will do this by prompting the user to enter how many students and then using that value as the terminating value of our for loop.
• The logic of the loop body does not change whatsoever

public class ExamAverager {
	public static void main(String [] args) {
		Scanner scanner = new Scanner(System.in);

		System.out.print("How many students do you wish to process? ");
		int howMany = scanner.nextInt();

		for (int i = 1; i <= howMany; i = i + 1) {
			System.out.print("Name? ");
			String name = scanner.next();
			System.out.print("Midterm? ");
			int midterm = scanner.nextInt();
			System.out.print("Final? ");
			int finalExam = scanner.nextInt();

			int average = (midterm + finalExam) / 2;
			System.out.println(name + " received an " + midterm + " and a " + finalExam + " for an average of " + average);
			if (average >= 60)
				System.out.println(name + " passes");
			else
				System.out.println(name + " fails");
		}
	}
}

3
Weiss 
88
92
Arnow
75
95
Cox
80
100

How many students do you wish to process? 
Name? 
Midterm? 
Final? 
Weiss received an 88 and a 92 for an average of 90
Weiss passes
Name? 
Midterm? 
Final? 
Arnow received an 75 and a 95 for an average of 85
Arnow passes
Name? 
Midterm? 
Final? 
Cox received an 80 and a 100 for an average of 90
Cox passes

Summary

Files Used in this Lecture

Labs for this Lecture