2. Intro To Loops:

Lecture Overview

• Introduction

  • Welcome and purpose of the lecture.

  • Introduced a series of non-graded practice assignments to encourage study between sessions.

• Reason for New Assignments

  • Many students are not accessing materials on Canvas.

  • Practice assignments will help the instructor confirm access to materials.

Review of Previous Materials

• Syllabus Review

  • First week's focus: syllabus and software options.

• Programming Basics

  • Second week covered fundamental programming concepts in Java, particularly using Eclipse.

  • Titles include: "Elementary Programming" from the syllabus.

• Development of Addition Program

  • Created multiple versions of an addition program to solidify understanding.

  • Let's break down some common Java code elements you'd see, imagining they have different colors in an Integrated Development Environment (IDE) like Eclipse:

    • Keywords (often blue or purple): Special words Java reserves for specific functions. Examples include public, static, void, int, double, if, while. You can't use these for your own variable names.

    • Data Types (often blue or purple, like keywords): These specify what kind of data a variable can hold.

      • int (for Integer): Used for whole numbers (e.g., 5, -10, 1000).

      • float (for Floating-point number): Used for numbers with decimal points, but less precise than double (e.g., 3.14f, 0.5f). You often add an 'f' at the end.

      • double (for Double-precision floating-point number): Also for numbers with decimal points, but with much higher precision than float (e.g., 3.14159, 2.718).

      • long (for Long integer): Used for very large whole numbers, larger than what int can hold (e.g., 1234567890123L). You often add an 'L' at the end.

      • char (for Character): Used for single letters, numbers, or symbols, enclosed in single quotes (e.g., 'A', '7', '@').

    • Variables (often black or dark gray): Names you give to storage locations in memory (e.g., num1, result, name). Good variable names are descriptive!

    • Operators (often black or dark gray): Symbols that perform operations, like + (addition), - (subtraction), * (multiplication), / (division), = (assignment).

    • Strings (often red or green): Sequences of characters, like words or sentences, enclosed in double quotes (e.g., "Hello, world!", "Enter a number:").

    • Comments (often gray or light green): Notes in the code that the computer ignores but help humans understand what's happening. They start with // for single-line or /* ... */ for multi-line comments.

  • Discussed the implementation of different data types and covered output and messaging techniques for prompts.

• User Input in Java

  • Implemented keyboard input using the Scanner class. Think of Scanner as a tool that lets your program 'read' what the user types on the keyboard.

    • To use Scanner, you first need to import java.util.Scanner; at the top of your file. This tells Java you want to use a tool from its 'utility' library.

    • Then, you create a Scanner object, usually like this: Scanner input = new Scanner(System.in);. Here, input (often black) is the name of your Scanner tool. new Scanner(System.in) means you're creating a new scanner that reads from the system's input, which is typically the keyboard.

    • To read different types of data, you use specific Scanner methods:

      • input.nextInt(): Reads an integer.

      • input.nextDouble(): Reads a double.

      • input.next(): Reads a single word (a String).

      • input.nextLine(): Reads an entire line of text (a String).

  • Discussed data types applicable for user input.

  • Specific focus on handling division:

    • If you divide an int by an int, Java performs integer division, meaning any decimal part is simply dropped (truncated). For example, 5 / 2 would result in 2, not 2.5.

    • To get a decimal result, at least one of the numbers in the division must be a float or double (e.g., 5.0 / 2 or 5 / 2.0).

  • Addressed the critical issue of division by zero and preventative measures.

  • Important Note: Every statement in Java typically ends with a semicolon (;). This tells Java where one instruction ends and the next begins.

Programming in Eclipse

• Workspace Setup for Projects

  • Recommended to maintain consistent folder structures for organization.

  • Demonstrated how to open and manage files in Eclipse, focusing on navigation and usability.

• Launching Java IDE

  • Explained basic functionalities of Eclipse:

    • Create new files and projects.

    • Save, retrieve, compile, and execute programs.

    • Debugging process: identification and correction of errors.

Introduction of New Programming Topics

• Division Program Development

  • Transition to discussing a division program:

    • Inputs two real numbers.

    • Division and output of the quotient.

  • Issues with division by zero were revisited and discussed extensively.

    • Fundamental Concept: Division by zero is mathematically undefined. In programming, it often leads to a program crash (ArithmeticException) unless handled properly.

  • Emphasized clear understanding of how infinity results from division by zero.

Detailed Mathematical Explanation

• Graphical Representation

  • Taught the relationship of values where as x approaches zero, y approaches infinity in the context of the function (y = \frac{1}{x}).

  • Detailed breakdown of graphing this function in Cartesian coordinates, interpreting inputs to inform the behavior of the graph.

Prevention of Division by Zero

• Practical Implementation

  • Outlined preventative coding practices to manage scenarios with potential zero division errors.

  • Suggested changes in source code to implement checks using conditionals (if statements).

    • An if statement allows your program to make decisions. For example, if (denominator == 0) checks if the value in the denominator variable is equal to 0. Note that == (two equals signs) is for checking equality, while = (one equals sign) is for assigning a value.

  • Discussed effective messaging for user prompts when incorrect inputs are detected.

Enhancements to Division Program

• Versioning Development

  • Created multiple iterations of the division program:

    • Division v2: Simple prevention of division by zero.

    • Division v3: Introduced nested structures for checking validity of input. This means putting an if statement inside another if statement to handle more complex conditions.

    • Division v4: Incorporated while loops for repeated attempts. A while loop (a keyword, often blue) keeps repeating a block of code as long as a certain condition is true. This is great for making users retry input until it's valid.

  • Implementation of loops encouraged more robust error handling and user experience.

User Interaction and Control Flow

• Creating Loops for User Input

  • Introduced nested structures to allow the user multiple attempts before failure or success.

  • Added capability for running the program multiple times based on user choice.

  • Used while loops to control the flow of user input.

• Final Loop Structure

  • Illustrated how to manage loops and conditional statements to ensure effective user engagement:

  • Asking pertinent follow-up questions based on user input, like whether to repeat the operation or not.

Conclusion and Assignment

• Wrap Up

  • Students reminded to prepare for the upcoming practice assignment.

  • Encouraged to conceptualize the program’s logic to troubleshoot problems in future coding instances.

• Future Assignments

  • A practical assignment involving basic user authentication logic related to the coding environment.

  • Reference to future sessions for deeper understanding of logical conjunctions (like && for 'AND') and disjunctions (like || for 'OR') in programming functions. These are used to combine multiple conditions in if statements or while loops.

Additional Notes

• Counting Operations & Variables

  • Discussed the use of counting variables for tracking attempts in user input validation (e.g., int attempts = 0; attempts++;).

• Important Concepts & Techniques in Java

  • Emphasized the distinction between assignment (=) and equality checks (==) in conditions per Java syntax.

  • Always make sure your variable declarations are clear (e.g., double result; or int count = 0;).

• Flowcharting Technique

  • Power of diagramming logic flows helped clarify more complex code structures.