Welcome, coding educators and students! Today's lesson is akin to safeguarding the precious answers to the final exam, but in the world of coding. We're delving into the concept of Encapsulation in Object-Oriented Programming (OOP), a fundamental principle designed to protect the integrity of our data. To bring this concept closer to home, let's design a critical piece of software that every student and teacher knows all too well: a grade book. 📚✨

Encapsulation: The Vault of Your Grade Book

Encapsulation is like having a vault in your classroom that only the teacher has the key to. It allows us to control access to the data within our classes, ensuring that only valid, appropriate interactions occur. Just as you wouldn't want anyone tampering with exam scores, encapsulation helps prevent misuse of the class internals in your code.

Access Modifiers

Java offers four access modifiers to control the visibility of class members: public, private, protected, and default (no modifier). These are the keys to our vault, dictating who can access the grade book's data.

• private: Only the class itself can access this data. It's the most restrictive and safe key, keeping the data secure from external tampering.
• public: Anyone can access this data. It's like leaving the vault open on the school's front lawn.
• protected and default: These offer levels of access between private and public, useful in specific scenarios, such as when working with subclasses or classes in the same package.

The Grade Book Example: Encapsulation in Action

Let's design a simple GradeBook class that encapsulates student grades, ensuring that grades are only modified through controlled methods.

class GradeBook {
    private Map<String, Integer> grades; // Private: Accessible only within this class

    public GradeBook() {
        grades = new HashMap<>();
    }

    // Public method to add or update a grade: Controlled access
    public void setGrade(String student, Integer grade) {
        // Validation logic here (e.g., grade must be between 0 and 100)
        if (grade >= 0 && grade <= 100) {
            grades.put(student, grade);
        } else {
            System.out.println("Invalid grade. Please enter a value between 0 and 100.");
        }
    }

    // Public method to get a grade: Controlled access
    public Integer getGrade(String student) {
        return grades.get(student);
    }
}

In this GradeBook, grades are stored in a private map, meaning they cannot be accessed or modified directly from outside the class. To interact with the grades, we provide public methods setGrade and getGrade, which act as the controlled gateways. This ensures that grades can only be modified in a valid, predefined way, protecting the integrity of our data.

Access and Inheritance

When it comes to inheritance, encapsulation still plays a crucial role. For instance, if we had a SpecialGradeBook class extending GradeBook, it could not directly access the private grades map of its parent. This reinforces the concept of controlled access, even within a family of classes.

Conclusion: The Power of Encapsulation

Encapsulation in OOP, demonstrated through our GradeBook example, is akin to a teacher controlling access to the grade vault. It ensures that data remains valid, secure, and is manipulated only through well-defined pathways. By using access modifiers as keys, we can protect our data from misuse, much like how a teacher protects the integrity of grades.

As we wrap up today's lesson, remember that encapsulation isn't just about hiding data; it's about safeguarding the mechanisms by which our code's data interacts with the outside world. It's a fundamental principle that, when used wisely, can make our code more robust, secure, and trustworthy.

So, next time you're coding up a storm, consider encapsulation to be your personal vault, keeping your data safe and sound. Happy coding, and may your digital grade books always reflect the true, hard-earned achievements of your students!

Welcome back coders! Today, we're taking a closer look at how inheritance works in Object-Oriented Programming (OOP) and diving into the concept of overriding—a vital skill that allows subclasses to express their uniqueness. Let’s start our lesson in two familiar places within our school: the Office and the Classroom. 🏫🚪

Understanding Simple Inheritance with the Office

In the vast, interconnected hallways of our school, every room inherits basic traits from the SchoolRoom class. Think of SchoolRoom it as the school building blueprint—it defines the basic structure every room follows: walls, doors, and windows.

The Office: A Subclass Example

The Office is a simple yet perfect example to illustrate basic inheritance. It inherits the foundational features from SchoolRoom, but doesn't need to change or add much. Here's how it looks in code:

class SchoolRoom {
    int numberOfWalls = 4;
    int numberOfDoors = 1;
    int numberOfWindows;
    
    void roomDescription() {
        System.out.println("This room has " + numberOfWalls + " walls, " 
                           + numberOfDoors + " door, and " 
                           + numberOfWindows + " windows.");
    }
}

class Office extends SchoolRoom {
    // Inherits everything from SchoolRoom without any changes
}

The Office, by default, will have 1 door, as defined by its superclass, SchoolRoom. This straightforward inheritance shows how subclasses automatically acquire their superclass's characteristics without extra coding.

Overriding in Action with the Classroom

Now, let's step into the Classroom, where the real magic of overriding comes to life. Unlike the Office, the Classroom has a unique feature: it has two doors instead of one. This is where it starts to differ from the SchoolRoom blueprint, demonstrating the power of overriding.

The Classroom: Overriding the Superclass

To accommodate this difference, the Classroom subclass overrides the numberOfDoors attribute inherited from SchoolRoom. This is how we explicitly define what makes a Classroom unique:

class Classroom extends SchoolRoom {
    // Overriding the numberOfDoors attribute
    int numberOfDoors = 2;
    String subject;

    void subjectInfo() {
        System.out.println("This is a " + subject + " classroom.");
    }

    // Overriding the roomDescription() method to include subject information
    @Override
    void roomDescription() {
        super.roomDescription(); // Calls the superclass method
        System.out.println("This classroom is for " + subject + " and has " + numberOfDoors + " doors.");
    }
}

By setting numberOfDoors to 2, we override the original property from SchoolRoom, tailoring the Classroom to our specific needs. Furthermore, we override the roomDescription() method to include the basic description and add specific information about the subject and the unique number of doors.

This illustrates a crucial aspect of OOP: subclasses can modify inherited properties (attributes) and behaviors (methods) to reflect their specific characteristics, enhancing the versatility and reusability of code.

Bringing It All Together

When we create a Classroom object and call its roomDescription() method, we'll see how it maintains the structure of SchoolRoom but adds its personalized touch, showcasing the concept of overriding in a simple, relatable manner.

public class School {
    public static void main(String[] args) {
        Classroom mathClass = new Classroom();
        mathClass.numberOfWindows = 3;
        mathClass.subject = "Math";
        mathClass.roomDescription();
        // Output will illustrate the overridden number of doors and the added subject description
    }
}

Our journey through the Office and Classroom within our code school has shed light on two pivotal concepts in OOP: inheritance and overriding. Through inheritance, subclasses gain the traits of their superclass, ensuring a consistent foundation across different types of rooms (classes). Overriding allows these subclasses to express their unique features and behaviors, tailoring the inherited blueprint to fit their specific needs.

Just as every room in a school serves a distinct purpose while adhering to the overall architecture, inheritance and overriding enable our code to be both uniform and uniquely specialized. So, next time you're coding, remember the lessons from our school of code. Let the principles of inheritance and overriding guide you to create flexible, reusable, and efficient code structures. Happy coding, and may your code be as organized and adaptable as the (best) planned school!

Hello, fellow coders! Today, we're diving into a topic that's as thrilling as sneaking a peek at your Instagram during a particularly snooze-worthy lecture. You know the drill: the art of swiping your MacBook screen from Instagram to IntelliJ with the stealth of a ninja as the teacher patrols the classroom. But, let's pivot from our expert-level social media evasion tactics to something equally engaging—the world of Object-Oriented Programming (OOP), specifically classes and objects, through the lens of a simplified Instagram user profile. 📱✨

OOP: Your Social Media for Code

In the vast universe of programming, we've been accustomed to sequential instructions—the coding equivalent of a straight line from point A to B. However, OOP introduces us to a reality where programs are a bustling social network of objects. Imagine each object as an Instagram profile, encapsulating attributes (like your bio, followers count, and posts) and behaviors (like posting a new photo or sending a DM).

OOP gifts us a world where programs are more reliable, easier to understand, and reusable.

Classes: The Bio Template of Your Insta Profile

A class in Java is like the template for your Instagram profile. It defines the structure—your bio, posts, followers, and following count—but doesn't hold the details. That's for the object, or the actual profile, to fill in. It's your blueprint, the DNA of your digital persona.

Here's how a class might look in our Instagram analogy:

class InstagramProfile {
    String username;
    int followers;
    int following;
    int posts;

    void postPhoto() {
        // code to post a new photo
    }
}

In this Instagram universe, our class doesn't need a main method. It's not the star of the show, but the behind-the-scenes director, setting the stage for the profiles (objects) to shine.

Objects: Your Unique Insta Profile

Creating an object from our class is like setting up your Instagram profile. You fill in the details—username, followers, and so on, making it uniquely yours.

InstagramProfile myProfile = new InstagramProfile();

Now, myProfile is an object, an instance of the InstagramProfile class. It's your corner of the Instagram universe, defined by the template but unique in its content.

Interacting with Your Profile

Once your profile (object) is set, you can start interacting with it. Want to increase your follower count or post a new photo? Your object's methods are at your disposal, ready to bring your digital social interactions to life.

myProfile.postPhoto();

This is the essence of using objects - they encapsulate data and behaviors, making your code more modular, understandable, and, dare we say, fun!

So there you have it! Remember that understanding classes and objects is like mastering the art of the perfect Instagram profile. It's about creating a blueprint (class) and then filling it with your unique content (object) to share with the world (or, in our case, the program).

So, the next time you're about to switch tabs from Instagram to your Java homework, remember: you're not just moving from one task to another. You're transitioning from one world of objects to another, each with its own set of rules, interactions, and opportunities for creativity.

Hey there, KISJ coders! Are you ready to dive into the matrix? I mean, the world of 2D arrays in Java? Trust me, it's as thrilling as trying to sneak to the deli without a teacher, and this is the last concept to learn before the long good winter break.

What's a 2D Array? A Maze of Numbers!

Picture this: A 2D array is like having a stack of bento boxes, each box filled with delicious numbers instead of sushi! 🍱

Declaring a 2D Array in Java

Declaring a 2D array in Java is easier than convincing STUCO members to smile during assembly. 😅 Here's how you do it:

int[][] coolArray = new int[3][6];

This line is like saying, "Hey Java, give me a 3×6 grid of numbers!" It is similar to how we declare a 1D array, but with extra "[]" to tell we are making a 2D array.

Initializing a 2D Array

Now, let's fill this array like we're cramming knowledge before a pop quiz (or a 🎁). It's like setting up your own little number buffet.

int[][] coolArray = {
	{1, 2, 3},
	{4, 5, 6}
};

Accessing Data in a 2D Array

Accessing data in a 2D array is like finding a teacher that you have never heard of in school. In that case, you will email them to know about what floor and what room they are in. Similarly, in a 2D array, we need to give two indexes—the first one for selecting the array within the array we want to search, and the second one to find the element in the second array.

coolArray[0][2]

This is like saying, "In the first row, give me the third number." Sneaky, right?

Looping Through a 2D Array

Looping through a 2D array is like the endless loop of reassessment requirements if you don't do your homework. (no assignments == no reassessment 😲) Here's how you loop:

int coolSum = 0;
for (int i = 0; i < coolArray.length; i++) {
	for (int j = 0; j < coolArray[i].length; j++) {
		coolSum += coolArray[i][j];
	}
}

Since we need two indexes, we need to use two for loops to loop through all the elements in the 2D array.

So there you have it! 2D arrays in Java are not so different from 1D array. They might seem complicated at first, like figuring out the new grading policy, but once you get the hang of it, it's a piece of cake (or a piece of kimchi if you prefer).

Keep coding, and maybe one day you'll write an AI to automate STUCO presentations—with genuine smiles! 😄👩‍💻👨‍💻

Hey KISJ coders! 🚀As we continue to explore the vast landscape of computer science, it's important to appreciate the role of mathematics in developing our logical reasoning. Here, we're going to focus on a key aspect that often goes unnoticed but is vital for clear communication in our field: mathematical symbols. These symbols are not just for mathematicians; they're essential tools for all of us in computer science—and don't forget calculus—to express complex ideas succinctly and precisely. Let's take a closer look at the notations that streamline our algorithms and proofs.

Basic Logical Connectives

• ∧ (AND): (p ∧ q) means both p and q must be true.
• ∨ (OR): (p ∨ q) means either p is true, q is true, or both are true.
• ¬ (NOT): ¬p means p is not true.
• → (Implication): (p → q) means if p is true, then q must also be true.
• ↔ (Equivalence): (p ↔ q) means p is true if and only if q is true.

Quantifiers

• ∀ (For all): ∀x ∈ ℝ, x² ≥ 0 means for all real numbers x, the square of x is non-negative.
• ∃ (There exists): ∃x ∈ ℝ, x² = 2 means there exists a real number x such that x squared equals 2.
• ∃! (There exists exactly one): ∃!n ∈ ℕ, n + 5 = 10 means there exists exactly one natural number n such that n plus 5 equals 10.

Set Theory

• ∈ (Element of): 3 ∈ ℕ means 3 is an element of the set of natural numbers.
• ∉ (Not an element of): 2/3 ∉ ℕ means 2/3 is not an element of the set of natural numbers.
• ⊂ (Subset of): ℕ ⊂ ℤ means the set of natural numbers is a subset of the set of integers.
• ⊆ (Subset or equal to): ℤ ⊆ ℤ means the set of integers is a subset of or equal to itself.
• ⊄ (Not a subset of): {2, 3.5} ⊄ ℕ means the set containing 2 and 3.5 is not a subset of the natural numbers.
• ∪ (Union): {1, 2} ∪ {2, 3} = {1, 2, 3} means the union of the sets {1, 2} and {2, 3} is {1, 2, 3}.
• ∩ (Intersection): {1, 2} ∩ {2, 3} = {2} means the intersection of the sets {1, 2} and {2, 3} is {2}.
• ∅ (Empty set): ∅ is the set containing no elements.

Relations

• = (Equality): sin²(θ) + cos²(θ) = 1 is the Pythagorean identity in trigonometry.
• ≠ (Inequality): x² ≠ -1 for any x ∈ ℝ since squares of real numbers are non-negative.
• < (Less than): e^x < e^(x+1) for all x ∈ ℝ.
• > (Greater than): n! > n for any n ∈ ℕ where n > 1.
• ≤ (Less than or equal to): x ≤ x² for all x ∈ [1, ∞).
• ≥ (Greater than or equal to): x² ≥ 0 for all x ∈ ℝ.
• ≈ (Approximately equal to): π ≈ 3.14159.
• ≡ (Identical to or congruent): 7 ≡ 3 (mod 4) means 7 is congruent to 3 modulo 4.

Proof Notation

• ∴ (Therefore): ∀x ∈ ℝ, x² ≥ 0 ∴ x² + 5 ≥ 5.
• ∵ (Because): x² - 9 = 0 ∵ x = ±3.
• ⇒ (Implies): (x² = 4) ⇒ (x = ±2).
• ⇐ (Implied by): (x = ±2) ⇐ (x² = 4).
• ⇔ (If and only if): (n² is even) ⇔ (n is even) for any n ∈ ℤ.
• ∎ (End of proof): After demonstrating a proof, we conclude with ∎.

Miscellaneous

• ... (Ellipsis): Used in sequences, e.g., 1, 1/2, 1/4, 1/8, ... converges to 0.
• : (Such that): {x ∈ ℝ : x > 0} is the set of all x in ℝ such that x is greater than 0.
• ∞ (Infinity): lim (1/n) as n → ∞ = 0.
• ∼ (Is similar to or has the property of): f(x) ∼ g(x) as x → ∞ means f(x) is asymptotically similar to g(x).

Hey KISJ warriors! 🕵️‍♀️🕵️‍♂️ Remember that one time when you thought cramming the night before an exam was a good idea? It seemed simple until it wasn't. Well, in the digital world, algorithms sometimes face similar problems, and that's where the enigmatic Big O comes into play.

What is Big O Notation

• Think of Big O Notation like a fortune-teller for algorithms, predicting their future behavior without getting bogged down in the nitty-gritty.

The Ladder of Complexity

• Constant O(1): This one's chill. No matter how much data, it's like, "I got this."
• Linear O(n): More data, more time. Like standing in line at your favorite boba place.
• Logarithmic O(log n): The brainy one. It handles more data without breaking a sweat.
• Quadratic O(n^2): Things start heating up. More data means much more time.
• Cubic O(n^3): Like quadratic's big, intimidating cousin.
• Exponential O(2^n): The drama queen. A little more data, and it throws a major fit.

A Glimpse at Selection Sort

Picture sorting your playlist, dragging the best song to the start of the playlist and the second best to the second one and so on. That's kind of what Selection Sort does with data.

Steps:

1. Scout the Smallest: Hunt down the tiniest number.
2. Swap & Slide: Move it to the start.
3. Rinse & Repeat: Do it again until everything’s sorted.

It’s like organizing your shoes but without the extra boxes. Everything gets swapped right where it is.

In this case, the complexity of this algorithm is O(n^2), so not the fastest when the party gets big. We will learn more "fancy" ones later!

Wrapping It Up

Just like understanding why your Wi-Fi turns into a sloth sometimes, getting the hang of algorithm complexity and champs like Selection Sort is key in the computing world. It's about being smart, efficient, and ready to tackle the big (and small) data challenges. So gear up because your coding journey's about to get a whole lot more interesting! 🚀👩‍💻👨‍💻

We're exploring five epic algorithms. It's like the Avengers, but for data! But do we need them for the AP exam? No. But do you need 'em to flex in university or even AP Computer Science Students? Absolutely! Oh, and yeah, they're in the CSA curriculum, so there’s that. 🧐

Introduction: Binary Search

Picture this: you're in a vast library, searching for that one book with the meme-worthy quote. How would you find it? By turning the place upside down, or strategizing?

Binary search is that strategy:

• Data Structure: Think of a shelf with sorted books (or memes).
• Objective: Find "The One" (book or number, not Neo from the Matrix).

Plan:

1. Split the shelf into two halves.
2. Use your detective skills to deduce which side your desired book is on.
3. Zero in on that half, and split it again!
4. Continue until you've got your book or realized you maybe lent it to someone.

The Perk of Being Organized:

Being sorted isn’t just a neat-freak's thing! With sorted data:

• Searching becomes super efficient! Imagine searching for your memes not by endlessly scrolling, but by smartly jumping from section to section.
• And this, my friend, is the magic trick behind binary search!

Up Next: Sorting Algorithms' Spotlight

So that was a simple introduction of why sorting algorithm is important, and from now,

• Get ready to unravel the mysteries of Algorithm Complexity and the enigmatic Big O.
• Dance with algorithms like Selection, Insertion, and the bubbly Bubble Sort, and finally deep with the elite duo: Merge Sort & Quick Sort, which you will actually use.

So, prep your coding capes and get ready to sort your life out, one algorithm at a time! 🚀👩‍💻👨‍💻

Hey KISJ Tech Wizards and Future Code Masters! 🌟 Ready to take a break from the wild ride of navigating KISJ's email labyrinth, where emails about using a room after school seem to enter the Bermuda Triangle only to reappear weeks later from a teacher you didn't even know existed? Well, buckle up because we're diving into something just as mysterious and awe-inspiring: Recursion in Computer Science!

Recursion: The Magic Mirror of Code

Picture this: You’re trying to email a teacher about using a room for an after school party, and the email keeps getting forwarded...to itself. Sounds like a nightmare, right? Well, that’s what recursion is like in computer science, but in a cool way! It's when a method in your code decides to be a bit self-loving and calls itself. Yes, it’s the ultimate self-love story in the world of programming. 💌

Example: Factorial

Remember the time when your math teacher brought up factorials, and you felt like vanishing into an alternate universe? Well, recursion is about to turn that feeling on its head!

In mathematics, factorials are like the ultimate test of patience. Calculating 4! (which is 4x3x2x1) is fine, but imagine doing 10! Without dozing off. This is where recursion comes in! Here's why recursion and factorials are a match made in coding heaven:

It's Like a Matryoshka Doll!

Recursion in factorials is like opening those Russian nesting dolls (Click here to fall into this rabbit hole). You start with the biggest doll (the original number), and inside it, there's a smaller doll (the number minus one), and it keeps going until you reach the smallest doll (the base case).

Recursive Factorial in Java

Let's see how this magic works in code:

public static int factorial(int n) {
    if (n > 1) {
        // Here's the recursion: the method calls itself!
        return n * factorial(n-1);
    } else {
        // Base case: No more smaller dolls.
        return 1;
    }
}

In this scenario, using recursion is great because:

1. Simplicity: Instead of writing loops and keeping track of all the multiplications, recursion elegantly simplifies it. Just like replacing a whole paragraph with a witty emoji. 🌟
2. Clarity: It mirrors the mathematical definition of a factorial. It's like reading a novel in its original language, rather than struggling with a bad translation.
3. Efficiency: With each recursive call, the problem becomes smaller, like chipping away at a giant block of cheese until you’re left with a bite-sized piece.

So, recursion transforms the tedious task of calculating factorials into a seamless and almost hypnotic process!

Essential Concepts of Recursion

1. Recursive Call: Like when you ask your friend a question, and they say, “I don’t know, ask her,” and she says the same, until someone finally has the answer.
2. Simplification: Breaking down a giant pizza into bite-sized pieces because let’s face it, no one can eat a whole pizza in one bite (or can they?).
3. Base Case: The superhero who stops the endless loop of "Ask her." It’s like that teacher who finally replies to your room booking email with a clear "Yes" or "No."

Caution: Missing a base case in recursion is like forgetting to set an alarm for school. You’re going to wake up in a world of “stack overflow” errors, where your code runs amok with no end in sight.

So there you have it, KISJ folks! Recursion is like a magical, self-reflecting method that brings a touch of elegance and brain gymnastics to coding. It's the secret sauce that can turn a complex problem into a sleek, neat solution, much like how you somehow manage to get through those confusing email threads and end up booking the room for your club events. Now, go ahead and add some recursion magic to your coding spells and watch the wonders unfold! 🧙‍♂️💻🔮

Hey there, KISJ 11th graders (or 12th)! 🙌 So, we've had our fair share of spicy topics. Remember how that last fire drill felt like a never-ending loop with no exit condition? Yeah, we all wished for a 'break' statement there. Well, now let’s embark on a journey through the world of Java methods. They’re like those legendary cram sessions we have the night before the big test. Efficient, (hopefully) organized, and crucial!

Why Java Methods are the Real MVPs

1. Modularity: Methods are like breaking down your math homework problems. Sure, you could try to tackle that huge problem all at once, but why not break it down step-by-step? Trust me, it's easier, and your future self will thank you.

2. Readability: Let’s be real. We’ve all tried reading someone's handwritten notes and wondered if it’s some ancient language. Methods? They're like that one classmate's notes that are so clean, you’d think they used a ruler for every line. It just makes sense!

3. Organization: Think of methods like sorting your music playlist. You could put everything into one (and risk getting a ballad in the middle of your workout), or you could group them into pop, ballads, and rap breaks. The structure is just like that!

4. Reduction of Redundancy: Ever felt like every day is a repetition of the last (looking at you, quarantine)? Methods are here to say, “Let's NOT do that with our code.” The DRY (Don't Repeat Yourself) principle is the golden rule, and methods are its loyal guardian.

Methods: Because Who Likes Déjà vu?

Methods help us avoid the “Didn't I just write this?” feeling. Organizing your code with methods is like organizing your Google Drive—you know exactly where your scary scary U.S. history documents are.

Documenting Methods: When Memory Fails, Notes Prevail

Remember the time you thought you’d remember what your friend whispered during advisory, but forgot by lunchtime? Documentation is the lifesaver here!

The Javadoc Magic

Javadoc is like that genius friend who takes notes in every class and then turns them into beautiful, readable summaries (which is me 🤓). And just like there are rules for passing notes without getting caught, there are rules for Javadoc:

Class Header: A Quick Intro

/**
 * Think of this as the “Hi, my name is...” sticker at a school event.
 *
 * @author Jay Suh (Because credits!)
 * @version 1.0 (The 'How many times have I tried to explain this' counter)
 */

Method Header: The Blueprint

/**
 * Because how else would you know that the method doesn't divide by zero?
 *
 * @param dividend The numerator of our fraction.
 * @param divisor The denominator. Don't make this zero. Just don't.
 * @return The answer, if we didn't break math.
 * @throws ArithmeticException if you dared to make divisor 0.
 */

Pre- and Post-Conditions: Like Class Expectations, but for Code

• Preconditions: The rules before you begin. Like how we must be awake (or at least look awake) during Mr. Mangat’s class.
• Postconditions: What you should expect after. Like, knowledge . . .  hopefully.

And a quick PSA from Mr. Mangat: for the AP CSA exam, understanding these conditions is like remembering to bring your calculator to the math exam. Essential!

In conclusion, methods are the unsung heroes of our code world, ensuring everything runs as smoothly as the school Wi-Fi on a good day (hey, we can dream). May your methods always be efficient and your coffee strong! 🚀📝

Hey KISJ warriors! 🚀 Remember that spicy topic about the grading policy and how students suddenly became allergic to doing assignments unless there's an apparent threat of reassessment? Let’s dive into a new topic which is just as spicy (if not more)—Arrays in Java! You know, those things that are a bit like when STUCO gathers everyone for assembly, and tries to fit everyone's attention into a tight space? Yep, those!

What's an Array?

Arrays are basically like those school assemblies. A bunch of similar things (like us students) crammed into one space. But just like the school rule about trips to the deli, where you apparently need a chaperone (seriously, we're not 1st graders), arrays in Java come with their own rule: They ain’t flexible in size. Once you decide how big it’s going to be, it stays that way!

Starting Off with Arrays

Let’s consider our school. If we wanted to store everyone's student numbers, it'd go something like this:

int[] studentNumbers; // Declaring an array. This is like saying, "Hey, we need a space for student numbers!"
studentNumbers = new int[10]; // Allocating space for 10 student numbers. Imagine cramming 10 STUCO members on stage.

You know how some of us multitask during advisory? (Texting, cramming, or the classic ‘strategic eye-closing’). In Java, you can multitask in initializing arrays:

The Efficient One-Liner (because who has the time?)

dataType[] arrayRefVar = new dataType[arraySize];

The “I know who’s in my squad” Declaration:

dataType[] arrayRefVar = {value0, value1, …, valuek};

Array Techniques

Accessing and modifying elements in an array is like checking who sent you that latest meme during advisory:

studentNumbers[0] = 380; // Assigning a number to the first student.
System.out.println(studentNumbers[0]); // Revealing the number (or the meme source).

Got a list of memes and want to find the spiciest one? Arrays got you:

if (myList[i] > max) max = myList[i]; // Finding the dankest meme.

Arrays & Methods: Like Texting during Advisory

We've all shared memes in a group chat and realized that what's seen cannot be unseen. Similarly:

public static void printArray(int[] array) {
    for (int i = 0; i < array.length; i++) {
        System.out.print(array[i] + " ");
    }
}

Passing an array to a method in Java is like sending a meme in a group chat. Once it’s there, everyone has access to it, and you can't really take it back without consequences. So, pro-tip: Think before you share (or modify arrays within methods)!

In summary, arrays in Java are like those classic KISJ moments. They’re a mix of rules, quirks, and trying to find the best way to fit everything in. And just like the “spicy” debate on assignments, they come with their set of challenges and fun. So, dive into Java, make some arrays, and maybe sneak in a meme or two. 😉 Happy coding! 🎉👩‍💻👨‍💻

Hey KISJ warriors! 🚀 Before we dive in, a big shoutout to everyone for the recent formative! Whether you aced it or faced some challenges, remember it covered a lot from Day 1 to 5. So, kudos for navigating through it! Now, remember those days when you'd loop around the cafeteria trying to decide if today's lunch was edible or if you'd be better off with a snack from the deli? Well, Java's loops are kinda like that, but without the disappointment. Let's dive deeper!

Counted Loops: The Cafeteria Rounds

Just like how you might circle the cafeteria a few times before choosing a meal, counted loops in Java let your program run a set of instructions multiple times.

Back in the day, with only the do-while loop, our code looked like someone lost in the cafeteria:

int x = 0;
do {
    // Pondering lunch choices here
    x += 1;
} while (x < 10);

But thanks to the counted loop, we've got a more efficient way to make our rounds:

The 'For' Loop: The Lunch Line Strategy

for (int count = 0; count < 10; count++) {
    // Picking food items here
}

With the for loop, the variable count is like that friend who only joins you for lunch and disappears afterward. It exists only within the loop's scope.

• The for statement has a counter, kind of like counting how many times you've been disappointed by the lunch menu.
• You can use the counter value inside the loop, like tallying up the number of decent meals.
• The counter variable doesn't linger around after the for statement, just like that mystery meat from last week.

'For' Loop Examples: The Lunch Menu

Counting to 10 (like counting the number of veggies on your plate):

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

Counting to 10 with 2 added (like adding two extra fries because why not):

for (int c = 0; c < 10; c = c + 2) {}

Looping 'num' times (like checking the dessert corner num times):

for (int i = 0; i < num; i++) {}

Decreasing counter (like counting down the minutes until lunch is over):

for (int i = 100; i >= 10; i--) {}

Break, Continue, and System.exit(): The Lunchtime Escape Tactics

Sometimes, you just want to leave school on lunch. Here's how you can do it in Java:

• Use break; when you spot that unidentifiable dish and want to exit the loop.
• Use continue; when you want to skip over the salad and see what's next.
• And System.exit()? That's like seeing the lunch line and deciding to just go home.

But remember, just like ditching lunch isn't always the healthiest choice, using these commands can make your code less efficient. Java likes to plan ahead, and using break or continue can mess up its game plan.

That's it for today's lesson on Java loops! If you've missed our previous lessons, don't worry. They're more accessible than the deli during lunchtime rush. Dive in, and remember: Java loops might be more predictable than tomorrow's lunch menu. 😉 Happy coding! 🎉👩‍💻👨‍💻

Hey KISJ coders! 🚀 Ever worked on a group project itin Google Slides and someone just accidentally deleted your masterpiece? Or maybe you've been the one to accidentally revert the whole doc, wiping out everyone's work? If you've been there, done that, then Git is about to become your new BFF. Let's dive in!

Git Init: The Group Chat Creation

Starting a new Git repository is like creating a new group chat for a project. It's where all the action happens.

git init

This command initializes a new Git repository and begins tracking an existing directory. It's like saying, "Hey, let's start a group chat for our project!"

Git Commit: The Project Milestone

Imagine you've just finished a slide in your group presentation. You're proud of it. It's got bullet points, images, and even a meme. You want to save this moment forever. In Git, this is a commit.

git add .
git commit -m "Added the best slide ever"

• git add . : The . means you're adding all the changed files in the current directory to the staging area. If you want to add only specific files, replace the . with the file name like git add myAwesomeSlide.txt.
• git commit -m "message" : The -m allows you to add a message describing the commit. Replace "message" with something descriptive like "Fixed all the typos" or "Added memes for comic relief".

Git Pull: Catching Up on the Group Chat

You know when you leave the group chat for an hour and come back to 100 messages? That's what git pull is for. It updates your local repository with any changes made in the group project while you were gone.

git pull origin master

This is like scrolling up in the group chat to see what you missed. Now you're all caught up!

• origin is the default name of the remote repository.
• master is the branch name you're pulling from. Replace master with the branch you want to update from if it's different.

Git Push: Sharing Your Genius

You've just created the most amazing slide ever. It's so good, you need to share it with your group ASAP. In Git, you'd use git push.

git push origin master

This pushes your changes to the repository. It's like sending your slide into the group chat and saying, "Feast your eyes on this, mortals!"

• origin is, again, the default name of the remote repository.
• master is the branch you're pushing to. If you're working on a different branch, replace master with your branch name.

Git Remote: The Cloud Storage

Just like how your Google Docs are stored in the cloud, Git repositories are often stored on a remote server.

git remote add origin <repository_url>

This is like choosing where to save your Google Doc. Except, with Git, multiple people can work on the project without accidentally deleting each other's work.

• add is the command to add a new remote.
• origin is the default name you're giving to this remote.
• <repository_url> is the URL where your remote repository is stored. Replace it with your actual repository URL.

Git Branch: The Slide Design Sub-Committee

We all know that one person who doesn't follow the agreed slide design. In Git, you can create a branch to experiment without messing up the main project.

git checkout -b new-slide-design

This creates a new branch where you can mess around with slide designs all you want without affecting the main presentation.

• checkout -b creates a new branch and switches you to it.
• new-slide-design is the name of the new branch. Feel free to replace it with something like experimental-design or why-are-we-still-here.

Basic Conflict Solving: The Group Chat Argument

When a conflict occurs, Git will mark the areas of the conflict in the file. You'll see something like this:

<<<<<<< HEAD
Slide with memes
=======
Slide without memes
>>>>>>> branch-name

You'll have to manually edit the file to resolve the conflict. Delete the lines you don't want, along with the conflict markers (<<<<<<<, =======, >>>>>>>).

After resolving, run:

git add .
git commit -m "Resolved conflict"

And there you have it! Now you're not just pushing buttons; you're making informed decisions. It's like choosing your seat in class based on maximum visibility for web surfing and minimum visibility to the teacher. 🎉👩‍💻👨‍💻

Hello again, KISJ masterminds! 🚀 Remember how we connected the sneaky seating arrangements to the Java ‘if’ statements? Today, we’ll associate a few more hilarious school antics with Java's while and do-while loops. Fasten your seatbelts because coding just got funnier!

The "While" Loop: Dancing on the Edge of 10 LLBs

Java's 'while' loop echoes that heart-thumping moment as the LLBs pile up. Remember those daredevils teetering on 9 LLBs? This loop keeps on trucking as long as its condition is met.

For instance, tracking your LLBs might look a bit like:

int LLBCount = 0;
while (LLBCount < 10) {
    // some "accidental" Korean chatter or a sneaky meme share
    LLBCount++;
    System.out.println("LLBs so far: " + LLBCount);
}

That's the thrill of living on the edge!

Do-While Loop: The Teacher's Growing Impatience

You know when you're deep in a Korean convo, and the teacher keeps warning you before they randomly snap? Here's how it'd go down in Java:

do {
    System.out.println("Continuing the Korean chat...");
    teacherAnger = my Random.nextint(20) + 1;
} while (teacherAnger < 15);

System.out.println("That's it! You’ve earned an LLB!");

This snippet keeps chatting in Korean until teacher randomly got angry and gives a student a LLB.

Break and Continue: Java's Interpretation of LLB Clutch

Break is Like getting your 9th LLB and hitting the brakes hard.

int LLBCount = 0;
while (LLBCount < 10) {
    if (LLBCount == 9) {
        System.out.println("Code red! Abandon mischief!");
        break;
    }
    LLBCount++;
}

By using break, you can break out of look like some students focusing in class after reciving 9th LLB and breaking out of their "loop of mischief."

Continue is like Momentarily goofing off (maybe a sneaky doodle?) but resuming focus quickly when teacher is around.

int funTimes = 0;
while (funTimes < 10) {
    if (funTimes == 5) { // Oops, teacher's radar pinged!
        System.out.println("I am working!");
        continue;
    }
    funTimes++;
}

By using continue, it will return to the start of the code without breaking out of the loop: like jumping web surfing routine when the teacher is watching you on the back.

However, the use of break and continue statements can make your code harder to read and debug if not used judiciously.

In conclusion, today's Java looping lessons might've felt like the thrill of accumulating LLBs at KISJ. Here's hoping both your loops and LLBs stay manageable! Keep coding, and see you next time! 🚀

Hey KISJ champs! 🚀 Remember those times when you'd strategically pick a seat so your laptop screen wouldn't face the teacher? And then swiftly "swipe your MacBook" when the teacher approached? Well, Java's 'if' statements are kinda like that, but without the sneaky part. Let's dive in!

Java's 'If' Statement: The Digital Seat Picker

Just like how you decide where to sit based on the teacher's location, Java's 'if' statement lets your program make decisions:

int distanceFromTeacher = 7;
if (distanceFromTeacher > 5) {
    System.out.println("Safe zone! Perfect for a quick game.");
} else {
    System.out.println("Danger zone! Better pay attention.");
}

In the above code, Java will decide if the seat we choose is great for quick web surfing sessions depending on the distance from the teacher. 👨‍🏫

'Else If': The Seating Upgrade

Sometimes, the first seat you pick isn't the best. That's where 'else if' comes in:

int distanceFromExit = 3;
if (distanceFromExit < 2) {
    System.out.println("Quick escape for those bathroom breaks!");
} else if (distanceFromExit < 5) {
    System.out.println("Not too shabby, a few steps and you're out!");
} else {
    System.out.println("You're in for the long haul.");
}

The True or False Seat Checker

Remember those moments when you had to quickly decide if a seat was prime real estate or not? Booleans in Java work the same way:

boolean seatFacingAwayFromTeacher = true;
if (seatFacingAwayFromTeacher) {
    System.out.println("Perfect! Time for some discreet multitasking.");
} else {
    System.out.println("Uh-oh! Better stay on task today.");
}

In this code, Java will decide if the seat you've chosen is ideal for those sneaky off-task moments or if you're in the direct line of sight of the teacher. Choose wisely! 👀🪑

Boolean Operations: The Advanced Seating Strategy

For those times when you need a super advanced strategy to pick the perfect seat. For complex decision-making, use Boolean operations like AND (&&), OR (||), and NOT (!).

int seatDistanceFromTeacher = 7;
boolean isLaptopFacingTeacher = false;  // Assuming the laptop isn't facing the teacher for this value
boolean isCloseToPowerOutlet = true;    // Assuming the seat is close to a power outlet for this value

if (!isLaptopFacingTeacher && isCloseToPowerOutlet && seatDistanceFromTeacher > 5) {
    System.out.println("Hidden from the teacher's view, near a power outlet, AND at a safe distance? Ultimate Jackpot!");
} else if (!isLaptopFacingTeacher || isCloseToPowerOutlet || seatDistanceFromTeacher > 5) {
    System.out.println("You've got at least one advantage going for you. Not bad!");
} else {
    System.out.println("Better luck next time.");
}

Now, the code checks 💻:

1. If your laptop isn't facing the teacher, you're close to a power outlet, and you're seated at a distance greater than 5 units from the teacher, you're in the ultimate spot.
2. If at least one of those conditions is true, you're still in a decent position.
3. If none of the conditions are true, well, maybe try to get to class a bit earlier next time!

Variable Scope: The Classroom Whisper Network

Just like how some whispers only travel within a certain group in class, in Java, some variables only exist within certain blocks:

public static void main(String[] args) {
    int x = 5;
    if (x == 5) {
        int y = 10;
        System.out.println("Inside the whisper network: x is " + x + " and y is " + y);
    }
    // y doesn't exist here, it's like a secret only the inner circle knows
    System.out.println("Outside the network: x is " + x);
}

Here, just like how outsiders can't hear the whispers that go around within a certain group, the value y within the variable scope cannot be accessed outside. But, like the lecture that our teachers almost shout at us—in this case, certain group who are whispering can also hear what teacher is talking.

That's it for today's lesson on Java's decision-making prowess! If you've missed our previous lessons, don't worry. They're more accessible than finding that perfect seat in class where you can both see the board and hide your screen. Dive in, and remember: Java might be easier to master than the art of classroom seating strategy. 😉 Happy coding! 🎉👩‍💻👨‍💻

Hello again, KISJ legends! 🚀 Remember when the school got flooded and we had to use sandbags and towels? Well, in Java, we have something called the Scanner class that's way more reliable than our school's "can we walk outside" weather evaluation. Let's dive in!

Java's Scanner Class: The Digital Deli

Just like how the deli is our only hope for decent snacks (despite the overpriced monopoly), the Scanner class is Java's way of getting some tasty user input.

Importing the Scanner Class

Before you can use the Scanner, you've got to invite it in. Think of it as giving the deli VIP access to your program:

import java.util.Scanner;

Crafting a Scanner

Creating a Scanner object is like setting up a booth in the school hallway where students can spill the beans about those advisory "activities" we all love (or not):

Scanner input = new Scanner(System.in)

Engaging with Users

The Scanner has a bunch of methods that let you ask users all sorts of questions.

For instance:

System.out.println("How many advisory videos have you actually watched?");
int advisoryCount = input.nextInt();
System.out.println("Really? You've watched " + advisoryCount + " videos?");

And just like we wait for the school to end, you should close the scanner when you're done:

input.close();

Strings: More Than Just Yarn

Strings in Java are like the rumors in school: they can be long, short, combined, and even sliced up.

Seeking User's Name:

Here's how you can get the latest scoop, or just someone's name:

System.out.println("What is your name?")
String name = input.nextLine();
System.out.println("Hello, " + name + "!");

Manipulating Strings:

• Length:
• Concatenation:
• Substring:
• Character Fetch: Find out the first letter of someone's name, or maybe the first letter of a secret code?

Length: Find out how long a rumor... I mean, a string is.

int length = name.length();

Concatenation: Combine two pieces of gossip into one mega rumor.

String megaRumor = "Lasy sunday, " + gossip1 + "and" + gossip2;
System.out.println(megaRumor);

Substring: Extract the juiciest part of a story. Like we live to do it with rumor, AP exams love this! Mastering it is crucial.

String phrase = "Java rocks!";
String extract = phrase.substring(5, 10); 
System.out.println(extract);

Character Fetch: Find out the first letter of someone's name, or maybe the first letter of a secret code?

char firstLetter = name.charAt(0);

That's a wrap for today's lesson on Java's Scanner and Strings! If you've missed our previous lessons, don't worry. They're more accessible than the deli during lunchtime rush. Dive in, and remember: Java might be easier to understand than our school's weather policy. 😉 Happy coding! 🎉👩‍💻👨‍💻