Introduction to Java Programming

• Java is a programming language and computing platform, first released by Sun Microsystems in 1995
• Problem solving is a key aspect of programming in Java
• Getting started involves creating, compiling, and running Java applications

Characteristics of Java

• Simple and easy to learn, with a straightforward syntax that eliminates complex features
• Object-oriented programming (OOP) paradigm promotes modular and reusable code based on objects and interactions
• Supports the creation of distributed applications, where different parts run on different systems in a network, using tools and libraries like RMI and CORBA
• Java code is compiled into bytecode, an intermediate form, making run independent by the Java Virtual Machine (JVM)
• Robust, with features like early error checking, exception handling, garbage collection, and memory management to prevent memory leaks
• Includes built-in security features like the Java Security API, sandboxing, and bytecode verification to protect against unauthorized code execution
• Architecture-neutral as Java bytecode is platform-independent due to the JVM
• Portable programs due to the architecture-neutral nature and JVM, which allows bytecode to run on various systems
• Performance is optimized through Just-In-Time (JIT) compilation in modern JVMs, providing competitive performance despite being slower than low-level languages
• Multithreaded, allowing developers to create programs that perform multiple tasks simultaneously
• Dynamic, Java is capable of dynamically loading new classes and resolving methods at runtime, allowing adaptability to changing environments

Getting started with Java programming includes

• Creating a simple Java application
• Compiling programs
• Executing applications

Anatomy of a Java Program

• Comments: Explanatory notes that are ignored by the compiler, preceded by // for a single line or enclosed between /* and */ for multiple lines
• Reserved words: Keywords that have a specific meaning to the compiler (e.g., class, public, static, void)
• Modifiers: Reserved words that specify properties of data, methods, and classes (e.g., public, private, static, final, abstract, protected)
• Statements: Actions or a sequence of actions, each ending with a semicolon (;)
• Blocks: Group program components using braces {}
• Classes: Essential Java constructs, serving as a template or blueprint for objects
• Methods: Collections of statements that perform a sequence of operations, like system.Out.Println
• Main method: Provides the control of program flow, acting as the entry point for java interpreter to execute the application
• Exit method: Terminates the application

Primitive Data Types and Operations

• Introduction to programming is done through examples
• Includes identifiers
• Declaration of variables and assigning identifiers.
• Consists of primitive data types.
• Expressions are a combination of these data types and operators.
• Consists of the following primitive types: byte, short, int, long, float, double, char, and boolean.
• Involves operators, precedence, associativity, and operand evaluation order: ++, --, *, /, %, +=, -=, *=, /=, %=, ^, &, |, +, -

Identifiers

• A sequence of characters composed of letters, digits, underscores (_), and dollar signs ($)
• Must start with a letter, underscore (_), or dollar sign ($), but not a digit
• Cannot be a reserved word
• Cannot be true, false, or null
• Can be of any length

Variables

• Variables are declared with the syntax: datatype identifier; (e.g., int x;)
• Numerical Data Types vary in size: Byte (8 bits), Short (16 bits), Int (32 bits), Long (64 bits), Float (32 bits), Double (64 bits)
• Use the following syntax to assign variable identifiers: variable = value; (e.g., X = 1;)

Constants

• Use final keyword, syntax: final datatype CONSTANTNAME = VALUE;
• final double PI = 3.14159;

Operators

• Common arithmetic operators include +, -, *, /, and %
• Performing division (/) between integers yields an integer result (e.g., 5/2 yields 2)
• Dividing a floating-point number by an integer yields a floating-point value (e.g., 5.0/2 yields 2.5)
• The modulo operator (%) returns the remainder of a division (e.g., 5 % 2 yields 1)
• Result of 5.0 % 2 is undefined, modulo is defined only for integers

Floating-Point Number Precision

• Calculations involving floating-point numbers are approximated due to storage limitations
• Calculations with integers yield precise integer results

Compiling and Running a Java Program

• Java source code (.java files) is compiled into bytecode (.class files)
• Java code can run on most systems due to the java virtual machines (vms) presence
• Bytecode can be converted into machine language by a just-in-time compiler (JIT)

Steps to compile and run a program

• Create java file in editor
• Compile java file from command line using javac addition.Java
• Run the new Class file Java addition

Arithmetic Expressions

• (3+4x)/5 - 10(y-5)(a+b+c)/x + 9(4/x + (9+x)/y) is an arithmetic expression

Shortcut Assignment Operators

• Perform an operation and assignment in one step
• +=: i += 8 is equivalent to i = i + 8
• -=: f -= 8.0 is equivalent to f = f - 8.0
• *=: i *= 8 is equivalent to i = i * 8
• /=: i /= 8 is equivalent to i = i / 8
• %=: i %= 8 is equivalent to i = i % 8

Increment and Decrement Operators

• Used to increase or decrease the value of a variable by 1
• Postfix increment (++): x++ (same as x = x + 1)
• Prefix increment (++): ++x (same as x = x + 1)
• Postfix decrement (--): x-- (same as x = x - 1)
• Prefix decrement (--): --x (same as x = x - 1)

Considerations When Using Increment and Decrement Operators

• These may make expressions complex and difficult to read.
• Avoid side effects.
• Avoid using these operators in expressions that modify multiple variables, or the same variable for multiple times

Assignment Expressions

• Prior to Java 2, all expressions could be used as statements
• The only expressions that can be statements are: variable op= expression; // where op is +, -, *, /, or % OR ++variable; OR Variable++; OR --Variable; OR Variable--;

Numeric Type Conversion rules

• Byte -> Long k = i*3+4;
• Casting: Double -> int, int x = k; //(wrong)
• Or Long k = x; //(fine,implicit casting)

Type Conversions

• Widening (implicit casting), an example is Double d = 3;
• Narrowing (explicit casting), an example is Int i = (int)3.0; and you would use Int x = (int) 5/2.0;

Character Data Type

• Each are are assigned as an ASCII number value: Char letter = 'A';
• Can reference a unicode: Char letter = '\u0041';
• Common special characters include: Char tab = '\t';

Unicode common value assignments

• Backspace: \b, equates to \u0008
• Tab: \t, equates to \u0009
• Linefeed: \n, equates to \u000a
• Carriage return: \r, equates to \u000d

Common examples for Boolean Type and Operators

• Booleans types are: Boolean lightson = true; OR Boolean lightson = false;
• Declare a conditional check using a boolean: Boolean b = (1 > 2);
• AND && (1 < x) && (x < 100)
• OR || (lightson) || (isdaytime)
• NOT ! !(isstopped)

Compairison Operators

• Less than <
• Less than or Equal to <=
• Greater than >
• Greater than or equal to >=
• Equal to ==
• Not equal to !=

Boolean Operatos

• The word not, is declared in Java as a "!"
• Not's truth table is: if true, become false. if false, become true
• And is: &&,
• Or is ||

Operator Precedence

• Common precedence to evaluate is 3 + 4 * 4 > 5 * (4 + 3) - ++I
• Followed by: VAR++, VAR--, +, - with (UNARY PLUS AND MINUS), ++VAR,--VAR, (TYPE) CASTING, ! (NOT), *, /, % (MULTIPLICATION, DIVISION, AND MODULUS), +, - (BINARY ADDITION AND SUBTRACTION), <, <=, >, >= (COMPARISON), ==, !=; (EQUALITY), & (UNCONDITIONAL AND), (EXCLUSIVE OR), | (UNCONDITIONAL OR), && (CONDITIONAL AND) SHORT-CIRCUIT AND, || (CONDITIONAL OR) SHORT-CIRCUIT OR, =, +=, -=, *=, /=, %= (ASSIGNMENT OPERATOR)

Programming Style and Documentation

• Important to include appropriate comments
• Follow general naming conventions
• Proper use of Indentation and Spacing
• Use End-Of-Line blocks style for declaring braces

Programming Errors

• Syntax Errors are detected by the compiler
• Runtime Errors causes the program to abort
• Logic Errors produces an incorrect result