Sesión 7

Main ideas and lessons from the session

Session setup / course logistics (speaker instructions)

• The instructor shares a QR code that grants access to all sessions in the preparatory course.
• Forum reminders:
  • The forum is only for questions specific to the current session.
  • There is no attendance/roll call in the forum or YouTube live comments.
  • Participants do not need to be connected to the forum during the live session (to avoid distractions).
  • Questions posted to the forum that were not answered live (on the Infotec topic) will be answered later.

---

Java content covered (main topics overview)

1. Introduction to Java

   • Basic structure of a Java program
   • Identifiers, reserved words, and naming conventions
   • Primitive data types
   • String type
   • Variables and assignments

2. Expressions and flow control

   • Arithmetic, relational, logical operators
   • Concatenation and basic type conversion
   • Conditionals: if, else if, else, switch
   • Loops: for, while, do while

3. Arrays

   • Declaration and creation
   • Initialization and access via indices
   • Traversal using loops and “for-each”

4. Basic class design

   • Classes, objects, attributes
   • Methods and constructors
   • Access modifiers (private, public)
   • Creating objects using new

---

Detailed methodology / instruction-style lessons (with key points)

1) What public static void main(String[] args) means (and how not to break it)

• Java applications start from the main method.
• The line public static void main(String[] args) is explained piece-by-piece:
  • public: accessible by anyone (no restriction)
  • static: no object is needed to call it; it belongs to the class
  • void: returns no value
  • main: the required method name that serves as the entry point
  • (String[] args): command-line arguments
• Array brackets must be kept exactly:
  • If the signature is altered incorrectly, the program may compile but not start.
• Demonstration lesson:
  • Removing one part (e.g., static) can result in no output, because the program no longer matches the required startup signature.

2) File naming vs public class rule

• If a class is declared public:
  • The file name must match the public class name exactly.
• If the class is not public:
  • File name can be different.
• Main-class requirement clarified:
  • The main class must be public and match the file name.
  • Additional classes may exist without being public.

3) Primitive types vs wrapper types (int vs Integer, string vs String)

• Java has two categories:
  • Primitive types (lowercase keywords), store direct values:
    • Example primitives discussed: int, double, boolean, char (and others mentioned later)
  • Class-based types (uppercase names), stored via classes:
    • Example: String and Integer
• Distinction:
  • int vs Integer:
    • int is primitive for speed and simple numeric operations
    • Integer is a wrapper class used when you need object features (e.g., conversions and methods)
• Wrapper naming and compatibility:
  • Notes that primitive/wrapper assignments became supported transparently from Java 1.5+ (autoboxing/unboxing era).
• “Recipe” guidance given:
  • Use primitive types for quick operations
  • Use wrapper/class types when you need complex operations, conversions, or method support

4) Variables: local vs class vs object scope; initialization requirements

• Three variable levels described:
  • Local variables (inside methods/constructors):
    • Must be explicitly initialized before use
  • Class variables (declared outside methods with static):
    • Have default values if not explicitly initialized
  • Object variables (declared outside methods without static):
    • Also receive default values
• Key rule:
  • Local variables cannot be printed/used unless they were initialized.

5) Identifiers rules and naming conventions

• Java is case-sensitive:
  • age and AGE are different valid variables.
• Good practice:
  • Only class names should use capitalization; variables/methods typically use lowercase (convention).
• Unicode support:
  • Identifiers can include characters like ñ and other Unicode characters.
  • Best practice recommendation: follow English naming conventions for compatibility/clarity.
• Allowed characters in identifiers:
  • Letters, digits, underscore _, and dollar $
  • Cannot start with a digit
• Reserved words:
  • You cannot use Java reserved words (e.g., class) as identifiers.

6) Integer division, modulo (%), and type casting

• Why 5 / 2 becomes 2:
  • If both operands are int, division becomes integer division
  • Decimals are discarded
• If either operand is a decimal type (double, etc.):
  • Result becomes decimal (double)
• Casting note:
  • Casting an int to double makes the result floating-point
• Modulo operator % explained:
  • % returns the remainder after division
  • Example: 5 % 2 = 1
• Multiple variable declarations:
  • You can declare multiple variables on one line separated by commas after a single type (e.g., int sum, quantity;)

7) + operator with strings (left-to-right evaluation)

• + behaves differently depending on operand types:
  • With numbers: performs arithmetic addition
  • With strings: performs concatenation
• Rule emphasized:
  • Evaluation happens left to right
• Example logic shown:
  • 1 + 2 evaluates to 3 first
  • Then 3 + "hello" becomes "3hello"-style concatenation (number converted to string)
• Parentheses to enforce numeric arithmetic:
  • If you want numeric addition first, group with parentheses, e.g., (1 + 2) + "something"

8) Converting between String and numbers

• Convert String → integer using wrapper method:
  • Integer.parseInt(text)
  • Only succeeds if the string contains only digits
  • If string contains non-numeric content (e.g., "hello"), it throws an error
• Convert number → String using wrapper/class method:
  • String.valueOf(numericExpression)
  • Produces a string containing the numeric result
• Important conceptual consequence:
  • Once concatenating with a string, the result becomes a string.

9) = vs == and comparing reference types vs primitive types

• Single =:
  • assignment (store a value into a variable)
• ==:
  • comparison operator
• Primitive types:
  • == compares actual values
• Reference types (e.g., String):
  • == compares references (memory locations), not content
• Correct approach for strings/content comparison:
  • Use equals
  • equals compares character-by-character content
• Additional guidance:
  • For your own classes, implement equals correctly if comparing object content.

10) switch statement and the need for break

• Purpose: choose behavior based on a variable’s value.
• Key concept:
  • If you omit break, execution “falls through” into the next case.
• Instruction:
  • Place break inside each case where you want that case to stop execution.

11) while vs do-while loops (guaranteeing at least one execution)

• while:
  • checks the condition before executing the loop body
  • if condition is false initially: body may never run
• do-while:
  • executes body at least once
  • then checks the condition after the first execution

12) Avoiding infinite loops

• Infinite loop prevention:
  • Ensure the loop condition eventually becomes false
  • Ensure variables used in the condition are updated inside the loop
• Example lesson:
  • If a loop variable never changes, the condition never changes → infinite loop.

13) Arrays: indices, bounds, fixed size, and traversal

Why arrays start at index 0

• Historical reason given:
  • earlier hardware constraints made index 0 cheaper/typical
• Practical rule:
  • For an array of length n, valid indices are 0 to n-1.

IndexOutOfBounds exception (R mentioned)

• Happens when accessing outside valid indices:
  • negative index (e.g., -1)
  • index >= length (e.g., accessing index 3 in a length-3 array)

Array size cannot change

• Arrays have a fixed length once created.
• If you need more space:
  • create a new larger array
  • copy old elements (using a loop)
  • then fill remaining positions

For-loop vs for-each traversal

• for (classic):
  • full control via index:
    • decide start/end
    • control increment
  • can read and also write/modify array elements
• for-each (for (Type x : array)):
  • iterates from beginning to end without exposing indices
  • typically used for read-only traversal
  • no index control over which position you’re currently processing

Traversal does not modify elements (as taught)

• The session states:
  • traversal alone doesn’t change values
  • modification requires a classic for loop (where indices are used).

14) Classes vs objects (object-oriented model)

• Class:
  • a “plan/blueprint” defining how objects should be structured
• Object:
  • an instantiated entity created using new
• Example:
  • A Student class defines fields like name and average.
  • Creating new Student(...) produces objects such as Ana and Luis.

Static vs non-static within a class

• Lesson:
  • If it is static, it belongs to the class.
  • If it is not static, it belongs to the object (instance data).

15) Constructors: default constructor and rules

• Constructor:
  • has the exact same name as the class
  • no return type
• Default constructor:
  • if you don’t define any constructor, Java provides an empty default constructor automatically (not shown in source, but present in compiled bytecode).
• If you define any constructor yourself:
  • the default no-argument constructor is not automatically provided.
• Overloading guidance:
  • Multiple constructors are allowed if their parameter lists differ.

16) Access modifiers: private and how it’s used

• public:
  • accessible from anywhere
• private:
  • access restricted to within the same class
• Encapsulation approach described:
  • keep sensitive fields private
  • provide public methods (e.g., getters/setters or validation methods) for controlled access
• Key rule taught:
  • even though fields are private, methods inside the same class can read/write them.

17) new operator and references/aliasing

• new:
  • reserves memory for an object
  • returns a reference
• Reference aliasing:
  • Assigning one reference variable to another means both point to the same object
  • Example concept:
    • B = A → A and B are aliases for the same object
• Comparing objects:
  • same object (alias) → comparison based on identity/content yields expected sameness
  • different new allocations → different objects (different memory locations)

18) Overloading and anonymous objects (“on the fly”)

• Overloading:
  • multiple constructors with different signatures
• Anonymous objects:
  • created without assigning to a variable reference
  • used immediately to call methods or print outputs
  • example idea:
    • new Student(...).print() (described conceptually)

---

Q&A topics addressed after the main demo

1. Can arrays only be traversed with for?

   • No. Arrays can be traversed with while too, but you must manage indices/termination carefully.

2. Can arrays be of any data type?

   • Yes. Arrays can contain primitives or any class type.

3. Can methods be outside a class and called from the class?

   • Not in the manner described.
   • In Java (object model), methods/variables/constructors generally must belong to a class to be usable.
   • Standalone structures can exist (interfaces/enums), but they are different kinds of elements.

4. What is null?

   • null means no object is assigned to a reference-type variable.

5. When should we use design patterns?

   • When you have a clearly defined recurring problem.
   • Design patterns are reusable, documented solutions (not “pre-created classes” but reusable design/architectural solutions).

6. Difference between for and for-each

   • Classic for: full index control; can read/write by position.
   • For-each: sequential traversal; mostly read operations; no index control.

---

Speakers / sources featured

• Primary speaker/instructor: the session host (name not provided in the subtitles)
• Infotec team: referenced as the group that will answer unanswered forum questions (speaker not individually identified)