Programming Identifiers and Data Types

Identifiers

• Identifiers can be combinations of letters, digits, underscore (_) and dollar sign ($)
• They must start with a letter, underscore, or dollar sign.
• Avoid using the dollar sign - It can confuse the runtime system.
• It is best practice to start identifiers with a letter.
• Identifier conventions include:
  • Variables and method names should be lowercase, with internal words capitalized (e.g., honkingBigVariableName).
  • Constants should be all uppercase with underscores between internal words (e.g., ANOTHER_HONKING_BIG_INDENTIFIER).
  • Classes names should start with a capital letter and use camel-case for internal words (e.g., HonkingLongClassName).

Data Types

• Primitive Data Types: byte, short, int, long, float, double, boolean, char
  • Use int for integers and double for real numbers.
• Classes and Objects:
  • Pre-defined or user-defined data types containing constructors, methods, and fields.
  • Fields (variables) can be primitive data types or objects.

Java Primitive Data Types

• byte: 8-bit signed integer, range: -128 to 127
• short: 16-bit signed integer, range: -32768 to 32767
• int: 32-bit signed integer, range: -2,147,483,648 to 2,147,483,647
• long: 64-bit signed integer, range: -9,223,372,036,854,775,808 to 9,223,372,036,854,775,807
• float: 32-bit floating-point number, range: +1.4E-45 to +3.4028235E+38
• double: 64-bit floating-point number, range: +4.9E-324 to +1.7976931348623157E+308
• boolean: Represents true or false - Java booleans cannot be converted to or from other data types.
• char: 16-bit Unicode character, range: \u0000 to \uFFFF. Can be mixed with integer types.

Classes and Objects

• Class is the blueprint for the data type.
• Object is an instance of a class - like a variable.
• Classes contain:
  • Implementation details of the data type.
  • Interface for programmers who want to use the data type.
• Objects have:
  • Multiple pieces of internal data.
  • Behaviors carried out via methods.

Name Conventions

• Java is case-sensitive.
• Class names start with a capital letter.
• All other names start with lowercase letters.
• Subsequent words are capitalized (e.g., theBigOne).
• Underscores are not used in names.

Creating and Using Objects

• Declaration: DataType identifier (e.g., Rectangle r1;)
• Creation: Use the new operator and the constructor (e.g., r1 = new Rectangle().
• Behavior: Access methods through the dot operator (e.g., r2.setSize(10, 20);).

Built-in Classes

• Java has a large library of built-in classes with various methods.
• Some examples include:
  • String
  • Math
  • Integer, Character, Double
  • System
  • Arrays
  • Scanner
  • File
  • Object
  • Random

Import Statement

• The import keyword enables the use of classes and packages from other parts of the code.
• It does not import the code itself - this is handled by the compiler.
• Import statements are placed outside the class block, e.g., import java.util.ArrayList;.
• You can import a whole package: import java.util.*;
• Or import specific classes: import java.util.Random;
• The java.lang.* package is automatically imported in all classes, so you don't need to explicitly import classes within that package.

The String Class

• String is a standard Java class with many methods.
• String literals exist, String name = "Mike D.";
• String concatenation uses the + operator, String fullName = firstName + lastName;

Standard Output

• Use System.out.print(expression); to print without a newline.
• Use System.out.println(expression); to print with a newline.
• There is also just System.out.println(); for printing only a newline.

Constants

• Literal Constants are values that remain constant throughout the program, e.g., true, false, null, 'c', "C++", 12, -12, 12.12345.
• Named Constants are declared with the final keyword and follow a naming convention.
  • Scope can be local to a method or to a class.
  • Use named constants for any numerical constant besides -1, 0, 1, or 2.
  • e.g., final int NUM_SECTIONS = 3;

Operators

• Basic Assignment Operator: =
• Arithmetic Operators: +, -, *, /, % (remainder)
• Assignment Operators: +=, -=, *=, /=, %=
• Increment and Decrement Operators: ++, -- (prefix and postfix). Avoid using them within expressions.

Expressions

• Expressions are evaluated based on operator precedence.
• Java automatically converts numerical primitive data types, but results can be surprising, so be careful when mixing integer and floating point numbers in expressions.
• The meaning of an operator is determined by its operands (e.g., / can be integer or floating point division).

Casting

• Casting is the temporary conversion of a variable from its original data type to another.
• Automatic casting occurs if a cast is necessary from a less inclusive data type to a more inclusive data type.
• e.g., double b = a * x + a / x;
• A cast from a more inclusive data type to a less inclusive data type requires explicit casting.
• Failure to do so results in a compile error.
• e.g., int y = (int) a / (int) b;

Primitive Casting Diagram (pg 19)

• The outer ring is the most inclusive data type.
• The inner ring is the least inclusive data type.
• Variables and sub-expressions of less inclusive data types are automatically cast to more inclusive types in expressions.
• Explicit casting is needed when an expression that is more inclusive must be placed into a variable that is less inclusive.

Java Control Structures

• Linear Flow of Control: Statements are executed consecutively, one after the other.
• Decision Making with if-else Statements: Allows execution of different blocks of code based on conditions.
  • if(boolean-expression) statement;
  • if(boolean-expression) { statement1; statement2; statement3; }
  • A statement within an if or else block can be replaced by a statement block enclosed in curly braces {}, which can contain zero or more statements.

Boolean Expressions

• Evaluate to true or false.
• Relational Operators: <, >, <=, >=, == (equal to), != (not equal to)
• Logical Operators: && (AND), || (OR), ! (NOT)

This quiz focuses on the rules and best practices for naming identifiers in programming, including variables, constants, and class names. Additionally, it covers the fundamental data types used in programming, from primitive types to classes and objects. Test your knowledge of these essential concepts in coding.