Are you a university student in KSA diving into the world of Java programming with Y. Liang’s textbook? Mastering Java can feel challenging, but with the right guidance and resources, it’s an opportunity to build strong foundations for academic and professional success.

Our tailored Java sessions provide a bridge between the concepts in Y. Liang's book and real-world applications, focusing on advanced programming techniques like string manipulation, memory management, and multidimensional arrays.

Whether you're preparing for exams or aspiring for a tech career, this class equips you with the tools and confidence to excel in both academia and beyond. Let's unlock the full potential of Java together!

 

Link to the original post featuring the first 32 class resources

 

 

32) Class 33 (21 Nov 24 ) :

 

a) Class Summary:

• Academic and Career Guidance:
  Ahmed and Yazeed discussed Yazeed’s academic progress, future career possibilities, and his upcoming exams. They explored potential roles such as data analyst and teaching assistant, while addressing Yazeed’s uncertainty about specific career paths.

• Technical Concepts and Coding Exercises:
  Ahmed guided Yazeed through coding exercises, including printing a 1D array in reverse, in-place array reversal, and manipulating strings. These exercises emphasized understanding core programming logic and techniques like handling newlines and swapping elements.

• Advanced Programming Topics:
  Topics covered included returning the largest two numbers, memory management, and function execution order in programming. Ahmed used analogies and examples to clarify complex ideas like temporary variable elimination and memory allocation.

• Problem Solving and Debugging:
  The session involved debugging code and addressing specific challenges in string manipulation and element reversal in arrays. Ahmed emphasized the importance of logic understanding over rote execution, ensuring Yazeed grasped the underlying principles.

• Personal Advice for Yazeed:

  • Practice Regularly: Dedicate time daily to practice coding, focusing on loops, data structures, and debugging skills.
  • Seek Clarification: Don’t hesitate to ask questions or revisit concepts until fully understood.
  • Set Goals: Define short-term and long-term objectives for both academics and programming skills.
  • Stay Consistent: Manage time effectively to balance studies and coding practice.
  • Leverage Support: Continue seeking guidance from mentors like Ahmed and utilize additional resources to strengthen weak areas.

 

b) Video (Thrusday): (1 hour 24 min)

- Part 1: Advanced Coding and Career Preparation: Practical Insights and Techniques 

 

d) Files:

-  n/a

e) Class Code:

- n/a

f) Exercises:

- Reverse an Array In-Place Without Using a New Array

 

g) HomeWork Solutions Posting (FB) :

-  post answers or link to answer files  

 

33) Class 34 (26 Nov 24 ) : 

 

a) Class Summary:

• Coding Challenges and Solution Exchange: Ahmad and Yazid focused on a variety of coding challenges, including array reversal and debugging errors. They exchanged ideas on how to handle coding problems more effectively and improve problem-solving strategies.

• Memory Addresses and Manipulation: The concept of memory addresses and how to manipulate them in programming was explored. Ahmad emphasized the importance of understanding the relationship between data and memory addresses and how to alter memory content without affecting the original variables directly.

• Code Restructuring and Understanding Basic Operations: They discussed the difference between creating new lists and modifying existing ones in place. The main takeaway was to focus on understanding the core concepts behind the code rather than getting caught up in minute implementation details.

• Collaborative Debugging and Code Improvement: While working through a coding error, Ahmad and Yazid collaborated to analyze and fix the code, reflecting the importance of teamwork and peer collaboration in improving coding skills and achieving better results.

• Personal Advice for Improving Programming Skills: If you're struggling with some programming concepts, don't hesitate to seek help or change your approach. Try breaking down problems into smaller parts and solving them step by step. Take time to deeply understand the basic concepts before moving on to more complex details, and you’ll see significant improvements in your coding abilities.

 

b) Video (Monday): (1 hour 4 min)

- Part 1: Programming Solutions & Memory Management | Understanding Complex Concepts

 

d) Files:

-  Understanding Array Copying by Reference

e) Class Code:

- n/a

f) Exercises:

- Counting Number Occurrences

g) HomeWork Solutions Posting (FB) :

-  post answers or link to answer files  

 

34) Class 35 (2 Dec 24 ) : 

 

a) Class Summary:

• User Input and Frequency Counting: The class focused on creating a program to count the frequency of numbers entered by the user between 1 and 100, ensuring that each number's occurrence is tracked accurately.

• Storing Numbers in Memory: Ahmed guided Yazid through storing numbers in memory, emphasizing the importance of breaking down complex tasks and improving the efficiency of the code by avoiding redundancy.

• Code Logic and Best Practices: They discussed key programming concepts, including loops, conditionals, and the use of variables, while Ahmed clarified the logic behind the code with examples.

• Optimizing Data Storage and Retrieval: Ahmed and Yazid brainstormed ways to optimize the program by organizing the data storage to avoid repetition, and explored automation possibilities for future enhancements.

• Personal Advice and Class Title: For improving understanding, it’s vital to focus on breaking down complex problems and practicing coding regularly.

 

b) Video (Monday): (1 hour 30 min)

- Part 1: Mastering Frequency Counting and Data Optimization in Programming: A Guided Coding Session

 

d) Files:

-  complete solution to the 'Count Occurrence of Numbers' exercise

e) Class Code:

- n/a

f) Exercises:

- Analyze Student Scores' exercise

g) HomeWork Solutions Posting (FB) :

-  post answers or link to answer files  

 

35) Class 36 (5 Dec 24 ) : 

 

a) Class Summary:

• User Input and Average Calculation:

  • Ahmed and Yazeed worked on a programming task to calculate the average of a set of numbers entered by the user. They discussed how to take input from the user, sum the numbers, and divide by the count to find the average. Ahmed emphasized how to properly handle the input and perform the calculation.

• Array Handling and Indexing:

  • The lesson covered manipulating arrays, particularly indexing and updating array elements. Yazeed was guided on how to access specific elements in an array, and the importance of correctly managing indexes was explained.

• Error Handling and Debugging:

  • Ahmed explained how to handle errors and debug the program by ensuring that the logic is clear and concise. They discussed strategies for identifying and fixing mistakes in the code, particularly when handling user inputs and working with arrays.

• Programming Logic and Code Structure:

  • The session included discussion of loops, especially while loops, and how to structure code effectively. Ahmed stressed the importance of maintaining clarity and simplicity in code and how logical thinking helps in programming.

• Personal Guidance for Yazeed:

  • Improvement Areas:
    • Yazeed should continue practicing array indexing and updating elements in arrays.
    • He should focus on refining his understanding of error handling and debugging techniques to write more robust code.
    • Reviewing code structure and organization will help improve Yazeed's overall programming skills.

b) Video (Thrusday): (1 hour 17 min)

- Part 1: Working with Arrays and Indexing in Java

 

d) Files:

-  Solution for Analyze Scores Exercise

e) Class Code:

- n/a

f) Exercises:

- Prime and Distinct Numbers Exercises

g) HomeWork Solutions Posting (FB) :

-  post answers or link to answer files  

 

36) Class 37 (12 Dec 24 ) : 

 

a) Class Summary:
 

• Matrix Operations and Nested Loops:
  Ahmed introduced Yazid to advanced programming concepts, including matrix operations and the use of nested loops for iterating through rows and columns. Practical examples were provided to clarify the implementation.

• SQL Table Analysis and Data Storage:
  They reviewed a spreadsheet containing distances between U.S. counties, explaining how data is stored and accessed in a 2D array. Yazid demonstrated an understanding of row and column indexing for data manipulation.

• Space Reservation System:
  Ahmed and Yazid discussed a system for reserving spaces, focusing on user inputs for rows and columns. The session covered logistical challenges in data entry and how to manage them programmatically.

• Collaborative Coding and Debugging:
  Ahmed worked with Yazid on data input, storage, and printing tasks, emphasizing the importance of accurate data handling. Yazid faced challenges with language barriers and coding errors, but Ahmed guided him patiently through solutions.

• Personal Development and Next Steps:
  Ahmed advised Yazid to practice working with arrays, loops, and data storage methods, complete assigned homework, and prepare for upcoming classes by focusing on clarity and consistency in coding.

b) Video (Thrusday): (1 hour 22 min)

- Part 1: Mastering Matrix Operations, Nested Loops, and Collaborative Coding

 

d) Files:

-  Practice Working with 2D Arrays in Java

e) Class Code:

- n/a

f) Exercises:

- Suming 2D array elements 

 

37) Class 38 (16 Dec 24 ) : 

a) Class Summary:

• Key Concepts Covered:

  • Variables, loops, algorithms, and data structures.
  • Hands-on problem-solving for mathematical and real-world coding challenges.

• Practical Exercises:

  • Modified irrigation system code with technical improvements.
  • Solved exercises like finding the maximum value in arrays.

• Student Development:

  • Yazid practiced step-by-step coding and improved his understanding of loops and algorithm design.
  • Visualization techniques were employed to simplify complex problems.

• Session Outcomes:

  • Enhanced understanding of mathematical problem-solving.
  • Prepared Yazid to implement key coding techniques independently.

• Personal Advice for Yazid:

  • Allocate dedicated time to study loops and array manipulations in depth.
  • Practice regularly to enhance problem-solving speed and accuracy.
  • Communicate coding challenges promptly to maximize support.
  • Maintain consistency in planning for better preparation before sessions.
  • Focus on mastering foundational concepts to build confidence in complex topics.

b) Video (Thrusday): (1 hour 20 min)

- Part 1: Solving Maximum Row & Column Sums in 2D Arrays and Optimizing System Code

 

d) Files:

-  n/a

e) Class Code:

- n/a

f) Exercises:

- Shuffling Two Dimensional Array

 

38) Class 39 (19 Dec 24 ) : 

 

a) Class Summary:

• Prime Number Verification Algorithm:

  • Explored an efficient method for identifying prime numbers by dividing them only by numbers up to their square root.

• Array Manipulation and Indexing:

  • Discussed techniques for storing and accessing values in arrays with proper indexing to avoid errors.

• Improving Coding Logic and Debugging Skills:

  • Worked through common coding challenges, such as avoiding duplicate entries and validating input.

• Practical Programming Applications:

  • Demonstrated the implementation of helper functions to simplify coding tasks and enhance reusability.

• Personal Advice for Yazid:

  • Practice coding exercises regularly to strengthen understanding of arrays and prime number algorithms.
  • Focus on improving sleep habits to ensure better concentration during lessons.
  • Review and rewrite previous code to reinforce key concepts and identify areas of improvement.
  • Develop systematic debugging techniques, such as using print statements, to troubleshoot errors efficiently.
  • Stay consistent and precise when working on projects to build accuracy and confidence in programming.

b) Video (Thrusday): (1 Hour)

- Part 1: Exploring Prime Number Logic, Arrays, and Programming Accuracy

 

d) Files:

-  n/a

e) Class Code:

- n/a

f) Exercises:

• n/a (focus on completing the previous homework)

 

39) Class 40 (23 Dec 24 ) : 

a) Class Summary:

• Unique Data Storage and Retrieval

  • Discussed methods to ensure the storage of unique numbers in code.
  • Highlighted processes to validate and confirm data uniqueness.

• Using Variables Effectively

  • Explored a "counter" variable for tracking inputs and a secondary variable for time tracking.
  • Addressed issues with variable initialization and implementation.

• Maximizing Array Operations

  • Practiced finding the maximum value in an array, emphasizing comparison logic.
  • Introduced the concept of iterative value updates to optimize the process.

• Focus, Contracts, and Structured Thinking

  • Highlighted the importance of maintaining focus and seeking guidance in coding and life.
  • Discussed breaking tasks into manageable "contracts" for effective project management.

• Personal Development Advice

  • Stay consistent and patient while learning programming concepts.
  • Embrace mistakes as learning opportunities and maintain a balanced mindset.
  • Remember the value of teamwork and clear communication when collaborating.

b) Video (Monday): (1 Hour and 25 min)

- Part 1: Mastering Unique Data Handling and Coding Fundamentals

 

d) Files:

-  n/a

e) Class Code:

- n/a

f) Exercises:

• Correct the errors in the 1D array shuffling code.

 

---> New patch

40) Class 41 (3 Jan 25 ) : 

a) Class Summary:

• Academic Progress and Exam Preparation:

  • Ahmed and Zaid discussed Zaid’s academic progress, upcoming exams, and strategies for managing multiple finals. They also touched on Cartesian structures and their potential relevance to AI applications.

• Debugging and Code Analysis:

  • They worked on identifying and resolving an error in a piece of code. Ahmed guided Zaid through debugging, emphasizing variable initialization and logic tracing to pinpoint issues.

• Understanding Randomization Concepts:

  • The session covered controlling random numbers through adjustable parameters (min and max values) and implementing random number shuffling methods. Practical uses, such as in gaming (excluding gambling), were also discussed.

• Reinforcement Learning Environment Design:

  • Ahmed explained creating a reinforcement learning environment with randomized scenarios to promote generalized learning rather than memorization. Concepts like random state and action representation were introduced.

• Personal Advice for Improvement:

  • Ahmed advised Zaid to focus on understanding code logic deeply, especially with complex topics like 2D arrays. He encouraged consistent practice, thoughtful preparation for exams, and leveraging hands-on exercises for better retention.

b) Video (Thrusday): (1 Hour and 20 min)

- Part 1: Advanced Programming Techniques: Randomization, Reinforcement Learning, and Matrix Manipulations

 

d) Files:

• not updated

e) Class Code:

- n/a

f) Exercises:

• Shuffling Two Dimensional Array

 

41) Class 42 (6 Jan 25 ) : 

a) Class Summary:

• Resolving Coding Errors and Fundamentals:
  Ahmed guided Yazeed through debugging array indexing errors and emphasized the importance of adhering to coding instructions to avoid errors.

• Distance Calculation Algorithm:
  The session focused on implementing an algorithm to calculate the minimum distance between points, using maximum and minimum values for accuracy.

• Improving Variable Naming and Code Clarity:
  Ahmed advised Yazeed on the significance of meaningful variable names to enhance code readability and maintainability.

• Practical Applications of Distance Algorithms:
  Ahmed outlined real-world scenarios where distance calculation algorithms are used, encouraging Yazeed to connect coding theory with practical use cases.

• Encouragement and Focus on Basics:
  Ahmed reassured Yazeed to focus on mastering the basics and consistent practice, highlighting the importance of patience and steady progress in coding.

b) Video (Monday): (1 Hour and 20 min)

• Part 1: Coding Challenges and Distance Calculation Techniques

d) Files:

• not updated

e) Class Code:

- n/a

f) Exercises:

• Closest Pair of Points Exercise (PDF) 

 

42) Class 43 (16 Jan 25 ) : 

a) Class Summary:

• Foundations of Object-Oriented Programming (OOP): Learn how to use classes and objects to model real-world entities, with examples like cars and circles, focusing on attributes and methods.
• Solving Coding Challenges: Develop skills for tackling problems like calculating the shortest distance between points and dynamic user input handling.
• Redis for Data Management: Explore Redis as a data structure for fast and efficient data storage and retrieval, demonstrated through circle-related data management.
• Debugging and Recovery Techniques: Gain insights into recovering deleted files, troubleshooting errors, and iterating solutions to resolve technical issues.
• Applying Programming to Real-World Scenarios: Understand how programming concepts bridge the gap between technical solutions and practical applications, fostering deeper engagement and understanding.

b) Video (Thrusday): (1 Hour and 25 min)

• Part 1: Object-Oriented Programming, Data Structures, and Problem-Solving Techniques

d) Files:

• not updated

e) Class Code:

- n/a

f) Exercises:

• Enhanced Circle Class Exercise

 

43) Class 44 (20 Jan 25 ) : 

a) Class Summary:

• Understanding Object-Oriented Programming: Learn the principles of OOP through practical examples, such as designing a reusable circle class to calculate properties like area and circumference.
• Debugging Red Errors in Code: Explore step-by-step troubleshooting for syntax and runtime errors, emphasizing the importance of systematic debugging practices.
• Code Troubleshooting Techniques: Master strategies for solving issues related to file creation, modification, and iterative problem-solving approaches.
• Class and Object Initialization: Understand how constructors work, the difference between class definitions and instances, and the role of constants in programming.
• Bridging Programming and Reality: Discover how programming models real-world scenarios, reinforcing concepts with relatable examples like television channels and household design preferences.

b) Video (Monday): (1 Hour and 19 min)

• Part 1: Exploring Object-Oriented Programming and Real-World Code Troubleshooting

d) Files:

• Liang Book: Object-Oriented Programming (Pages 322-327)

e) Class Code:

- n/a

f) Exercises:

• Simplified TV Exercise: Channel Control

g) HomeWork Solutions Posting (FB) :

-  post answers or link to answer files  

 

44) Class 45 (10 March 25 ) : 

a) Class Summary:

• to be updated

b) Video (Monday): (1 Hour and 35 min)

• Part 1: 

d) Files:

• to be updated

e) Class Code:

- n/a

f) Exercises:

• Simplified TV Exercise: Channel Control

 

45) Class 46 (17 March 25 ) : 

a) Class Summary:

• Object-Oriented Programming (OOP) Concepts: Explored key OOP principles such as classes, objects, and inheritance, using real-world examples like banking and automotive design.
• Code Reuse & Efficiency: Discussed how reusing code in OOP saves time, reduces errors, and improves efficiency in software design and development.
• Banking Systems & Data Storage: Clarified how variables like "balance" are used in banking systems to manage multiple accounts, and discussed how transaction data is stored and retrieved.
• Static vs Ordinary Variables: Explained the difference between static variables (shared across all instances) and ordinary variables (unique to each instance), with practical examples from automotive and TV design.
• Inheritance & System Design: Highlighted how inheritance allows subclasses to use methods and variables from parent classes without rewriting code, improving system design in software development.

b) Video (Monday): (1 Hour and 20 min)

• Part 1: Object-Oriented Programming: Classes, Inheritance & Real-World Applications in Banking & Automotive Design

d) Files:

• n/a

e) Class Code:

- n/a

f) Exercises:

n/a

 

46) Class 47 (14 april 25 ) : 

a) Class Summary:

• Upcoming Exam & Study Planning
  Ahmed and Yazid discussed an upcoming exam with four subjects, focusing on preparation strategies and reviewing old tests.

• Understanding Classes and Variables
  Ahmed explained object-oriented programming concepts like classes, instances, naming conventions, and variable types within classes.

• Code Structure & File Separation
  The importance of organizing code into separate files and understanding code architecture was emphasized to improve clarity and maintainability.

• Constructors in Programming
  Ahmed introduced the concept of constructors, demonstrating how they can be overloaded to initialize objects in different ways.

• Code Practice and Independent Study
  The session ended with encouragement for Yazid to continue practicing, take screenshots of code examples, and focus on understanding rather than memorization.

b) Video (Monday): (1 Hour and 15 min)

• Part 1: OOP Programming Basics: Classes, Constructors, and Exam Prep Discussion

d) Files:

• n/a

e) Class Code:

• n/a

f) Exercises:

• Send to whatsapp

 

47) Class 48 (16 april 25 ) : 

a) Class Summary:

• Explained Time2 class from chapter 1

• Constructor Overloading in Java
  Reviewed how to define multiple constructors within a Time class to handle different initialization scenarios, including default and custom inputs.

• Building a Time Class with Display Logic
  Implemented clock functionality in Java, covering logic for formatting time in 24-hour and AM/PM formats with zero-padding for single digits.

• Input Validation & Conditional Checks
  Covered how to handle edge cases like minute/second rollovers and avoid invalid input using if statements and conditional flows.

• Using AI Tools for Coding Support
  Discussed using AI to explain and troubleshoot code, while emphasizing the importance of not over-relying on generated solutions.

• Hands-on Practice & Exam Preparation
  Focused on manual code writing, reinforcing constructor logic and method structure, with the goal of preparing Yazid for an upcoming exam.

b) Video (Wednesday): (1 Hour and 20 min)

• Part 1: Java OOP Practice: Constructors, Time Class

d) Files:

• n/a

e) Class Code:

• n/a

f) Exercises:

• Send to whatsapp

 

48) Class 49 ( 23 April 25 ) : 

a) Class Summary:

• Café System Class Design – Built a class structure representing a café, with drinks, food, and employee roles as subclasses of a main class.

• Inheritance & Reusability – Explored how shared attributes and behaviors are inherited from a base class to reduce code duplication.

• Method Overriding in Java – Discussed how subclasses can override methods for specialized behavior, e.g., salary calculations.

• Understanding final Variables – Clarified how to use the final keyword to declare constants and enforce unchangeable values.

• Class Name vs Object Instantiation – Explained when it’s appropriate to reference class names directly vs creating instances, especially for fixed entities (like D1, D2)

b) Video (Wednesday): (1 Hour and 26 min)

• Part 1: University Java Class (Arabic) – Inheritance, Overriding & Class Hierarchies

d) Files:

• n/a

e) Class Code:

• n/a

f) Exercises:

• n/a

 

49) Class 50 ( 28 April 25 ) : 

a) Class Summary:

• Academic Progress and Planning:

  • Discussed Zaid’s current academic status, including catching up with coursework and future study plans.

• Understanding Programming Concepts:

  • Clarified the difference between classes and objects, the use of static vs non-static variables, and key ideas behind object-oriented programming.

• Inheritance and Constructors in OOP:

  • Explained how inheritance works, the role of constructors, and discussed the possibilities of multi-layer inheritance.

• Organizing Code and File Management:

  • Emphasized the importance of separating each class into its own file and maintaining clean, structured code.

• Study Strategy and Exam Preparation:

  • Advised Zaid to prepare questions on unclear topics, review chapter materials, and focus on self-driven learning with supplemental resources like YouTube videos.

b) Video (Monday): (1 Hour and 31 min)

• Part 1: Object-Oriented Programming, Inheritance, and Academic Progress

d) Files:

• n/a

e) Class Code:

• n/a

f) Exercises:

• sent on whatsapp

 

50) Class 51 ( 3 May 25 ) : 

a) Class Summary:

• Exploring OOP Principles: Ahmed clarified the differences between superclasses and subclasses, inheritance, and how overriding and overloading functions affect program design.

• Commission-Based Payroll System: They designed a payroll structure that includes hourly, salaried, commission-only, and base-plus-commission employee types, integrating logic for overtime and base pay.

• Code Debugging and Structure Refinement: The session addressed real-world debugging issues, highlighting the importance of clean structure, clear documentation, and control in code design.

• Memory Allocation and Object Instantiation: Ahmed introduced the concept of memory use in OOP, emphasizing object reservation and efficient handling of data within the system.

• UML Diagrams & Exam Preparation: The duo reviewed UML concepts, particularly abstract classes and inheritance trees, while planning next steps for further practice and exam readiness.

b) Video (Saturday): (1 Hour and 29 min)

• Part 1: Object-Oriented Programming Concepts & Payroll System Design | Ahmed Elmalla Tutoring Session

d) Files:

• n/a

e) Class Code:

• n/a

f) Exercises:

• sent on whatsapp

 

51) Class 52 ( 6 May 25 ) : 

a) Class Summary:

• Understanding OOP Basics: Ahmed explained how superclasses, subclasses, abstract classes, and interfaces work together to build clean and reusable code structures.

• Real-World Application of OOP: Examples like salary calculation, product categories, and billing were used to connect OOP concepts with relatable scenarios.

• Importance of File Management: Students were advised to delete outdated files and organize current projects for improved clarity and easier navigation.

b) Video (Tuesday): (1 Hour and 05 min) - Yazeed Entered 45 min late

• Part 1: OOP & Interface Concepts Made Simple – Superclass, Abstract Classes, and Project Clarity

d) Files:

• n/a

e) Class Code:

• n/a

f) Exercises:

• sent on whatsapp

 

52) Class 53 ( 7 May 25 ) : 

a) Class Summary:

• Core OOP Concepts in Java: The session focused on object-oriented programming foundations, including classes, objects, inheritance, and abstraction—crucial for mastering Java development.

• Understanding static and final Variables: Ahmed clarified the differences between static (shared among all instances) and final (unchangeable) variables and their roles in Java programming.

• Class Design and Method Implementation: The team discussed refining class structures for a course registration system, emphasizing proper method creation, constructors, and class relationships.

• Debugging and Clean Code Practices: Emphasis was placed on code clarity, context comprehension, and the importance of identifying and fixing syntax and logical errors early.

• Technical Readiness for Remote Learning: Troubleshooting Zoom and internet issues was addressed to ensure smoother future sessions, with advice on maintaining consistent technical access.

b) Video (Wednesday): (1 Hour and 50 min) 

• Part 1: Mastering OOP in Java: Inheritance, Class Design & Debugging Best Practices

d) Files:

• n/a

e) Class Code:

• n/a

f) Exercises:

• sent on whatsapp