↓ Skip to main content
sudoRunner
sudoRunner

IST 240: Introductory Java Programming & OOP Lab Progression

Software Foundations Case Study

This portfolio-safe case study summarizes selected IST 240 Introduction to Computer Languages lab work focused on introductory Java programming, class design, object-oriented programming, constructors, methods, encapsulation, inheritance, abstract classes, arrays, ArrayLists, search logic, and model/data separation.

Course IST 240
Project Type Introductory Java Lab Progression
Focus Java · OOP · Classes · Inheritance · Collections
Concepts Constructors · Getters/Setters · toString · Arrays · ArrayLists
Publishing Level Portfolio-Safe / No Raw Source Published
Professional Angle Programming Foundations for Cybersecurity and Automation

Overview
#

IST 240 introduced computer languages and programming fundamentals through a sequence of Java labs.

The lab progression started with a simple ZipCode class and gradually expanded into a small object-oriented model involving addresses, people, players, sports-specific subclasses, arrays, ArrayList usage, rating calculations, search methods, and a separate model/data class.

This page presents the work as a portfolio-safe summary. It does not publish raw source code, complete assignments, private academic materials, or full lab submissions.

The strongest portfolio angle is programming foundation. While this is not an advanced cybersecurity project, it supports the technical base behind later work in data structures, software engineering, scripting, security automation, malware analysis, and cybersecurity tooling.

Why This Project Matters
#

Cybersecurity professionals benefit from understanding how software is structured.

Even when a role is not primarily software development, programming foundations help with:

  • reading code
  • writing automation scripts
  • understanding object models
  • parsing structured data
  • debugging logic
  • understanding application behavior
  • reviewing software security issues
  • communicating with developers
  • building small tools
  • understanding how data moves through classes and methods

IST 240 helped build that foundation through repeated Java practice and incremental lab development.

Portfolio-Safe Publishing Approach
#

Security and academic integrity note: This case study summarizes introductory Java lab work without publishing raw source code, complete lab solutions, private course materials, or full academic submissions.

This page excludes:

  • raw source code
  • full lab submissions
  • complete project files
  • private course instructions
  • private academic records
  • complete assignment answers
  • copy-paste-ready solutions

Instead, it presents:

  • programming concepts practiced
  • class design progression
  • portfolio-safe summaries
  • lessons learned
  • professional relevance
  • how the course supports later cybersecurity work

Lab Progression Summary
#

Lab Stage
Portfolio-Safe Summary
Concept
Zip Code Formatting
Built an introductory Java class for ZIP code representation, including five-digit and plus-four formatting behavior.
Class Basics
Display and String Logic
Expanded class behavior with output methods and substring-based display logic for prefix and area-style ZIP code components.
Methods
Address Modeling
Added an Address class with number, street name, street type, state, PO box, and ZipCode object composition.
Composition
Encapsulation
Refined classes using private fields, getters, setters, constructor overloads, and controlled state updates.
Encapsulation
Person and Player Models
Introduced Person and Player classes to model shared attributes such as name, address, number, sport, and games played.
OOP Modeling
Inheritance
Created sports-specific subclasses such as FootballPlayer and SoccerPlayer to extend the shared Player model with specialized attributes and rating logic.
Inheritance
Abstract Classes
Used an abstract Player class to represent shared behavior while allowing child classes to implement sport-specific details.
Abstraction
Arrays and Lists
Practiced storing player objects in arrays and ArrayLists, then iterating through records to find values, compare ratings, and search names.
Collections
Model Data Class
Separated sample data and search logic into a ModelData class, making the main application cleaner and more organized.
Separation of Concerns

Major Concepts Practiced
#

Java Class Design
#

The labs progressed from a simple class into multiple related classes with fields, constructors, methods, and formatted output behavior.

Java Basics

Encapsulation
#

The work used private fields, getter and setter methods, constructor overloads, and controlled object state management.

Encapsulation

Object Composition
#

Address objects used ZipCode objects, showing how one class can contain and coordinate with another class.

Composition

Inheritance
#

The Player model expanded into specialized FootballPlayer and SoccerPlayer classes, showing class hierarchy and shared behavior reuse.

Inheritance

Abstract Classes
#

The Player class became an abstract parent model, allowing common fields and behavior while supporting specialized subclasses.

Abstraction

Collections and Search Logic
#

The later labs used arrays and ArrayLists to store objects, loop through records, find highest values, and search by exact or partial name.

Arrays / ArrayList

Technical Workflow
#

1

Build a Simple Class
#

Started with a ZipCode class and practiced constructor behavior, string formatting, and output methods.

Class Basics

2

Add Object Composition
#

Expanded the model with Address objects that contained ZipCode objects and represented structured address data.

Composition

3

Encapsulate State
#

Refined object fields using getters, setters, private variables, and constructor overloads to control data access.

Encapsulation

4

Build an Inheritance Hierarchy
#

Added Person, Player, FootballPlayer, and SoccerPlayer classes to model shared and specialized behavior.

Inheritance

5

Use Arrays and Collections
#

Stored player objects in arrays and ArrayLists, then iterated through the data to search, compare, and calculate ratings.

Collections

6

Separate Model Data
#

Moved sample data and search functions into a ModelData class, improving organization and separating application logic from data setup.

Model Layer

Object Model Summary
#

The later labs developed a small object model around people, addresses, and players.

Class / Component
Purpose
Concept
ZipCode
Represented five-digit and plus-four ZIP code formatting and basic display behavior.
Formatting
Address
Modeled address components and used ZipCode as a composed object.
Composition
Person
Represented shared person-level attributes such as name and address.
Base Model
Player
Represented shared player attributes such as number, sport, and games played; later used as an abstract parent class.
Abstraction
FootballPlayer
Extended Player with football-specific fields such as yards and minutes played, plus rating behavior.
Subclass
SoccerPlayer
Extended Player with soccer-specific fields such as goals and yellow cards, plus rating behavior.
Subclass
ModelData
Loaded sample player records and supported search, rating comparison, and data retrieval methods.
Model Layer

Programming Skills Demonstrated
#

Skill
Evidence from IST 240
Status
Java Syntax and Structure
Used Java classes, main methods, object creation, method calls, fields, constructors, and formatted output.
Completed
Constructors and Overloading
Used default constructors and parameterized constructors to initialize objects in different ways.
Completed
Getter and Setter Methods
Practiced encapsulation by controlling access to private fields through accessor and mutator methods.
Completed
String Handling
Used string formatting, substring logic, conditional display behavior, and custom toString methods.
Completed
Inheritance and Abstraction
Built a Person/Player hierarchy and extended Player into sport-specific subclasses with specialized fields and rating logic.
Completed
Arrays and ArrayLists
Stored groups of objects, iterated through collections, compared values, searched for names, and retrieved matching records.
Completed
Separation of Concerns
Separated sample data and lookup methods into a ModelData class instead of keeping all logic inside the main application class.
Completed

Difference from IST 311
#

IST 240 and IST 311 both support software foundations, but they represent different levels of maturity.

Course
Main Portfolio Angle
Best Evidence Type
IST 240
Introductory Java programming, object-oriented basics, class design, constructors, methods, inheritance, arrays, and ArrayLists.
Programming Foundations
IST 311
More advanced Java, data structures, object-oriented design, software engineering foundations, Big-O, testing, debugging, UML/CRC, and Git workflow.
Software Engineering

Together, they show progression from introductory programming to more structured software engineering and data-structure work.

Cybersecurity Relevance
#

This project supports cybersecurity work indirectly by building programming fluency.

The relevant cybersecurity value is not that this was a security lab. The value is that it supports the ability to:

  • read Java code
  • understand object-oriented program structure
  • reason about application state
  • understand how data models are built
  • write small tools or scripts
  • debug logic
  • understand software behavior
  • communicate with developers
  • transition into security automation or secure software review
  • better understand later coursework involving tools, parsers, logs, malware, and data structures

Programming fundamentals are part of the technical base for cybersecurity analysis and engineering.

What I Learned
#

This course reinforced several foundational lessons:

  • small programs become easier to manage when code is organized into classes
  • constructors define how objects are created and initialized
  • getter and setter methods help control access to object state
  • toString methods make objects easier to inspect and debug
  • inheritance helps reduce duplicated behavior across related classes
  • abstract classes can represent shared concepts while leaving details to subclasses
  • arrays and ArrayLists make it possible to work with groups of objects
  • search and comparison logic are easier when data is organized consistently
  • separating model data from application logic improves readability and maintainability
  • introductory programming skills support later cybersecurity and software engineering work

Professional Relevance
#

This project supports roles and tasks involving:

  • cybersecurity analysis
  • ServiceNow SecOps consulting
  • scripting and automation foundations
  • software troubleshooting
  • secure software awareness
  • data parsing
  • log analysis preparation
  • vulnerability management support
  • communicating with developers
  • understanding application behavior

It also supports my ServiceNow SecOps direction because ServiceNow work often benefits from understanding object models, tables, fields, scripts, data relationships, workflow logic, and structured troubleshooting.

Portfolio-Safe Redaction Notes
#

This case study intentionally excludes:

  • raw Java source code
  • complete lab solutions
  • full project ZIP contents
  • private course instructions
  • private academic records
  • complete assignment answers
  • copy-paste-ready implementation details

The goal is to show programming progression and software-foundation development without publishing raw academic work.

Related Portfolio Areas#

Software Foundations
#

This work supports Java, class design, object-oriented programming, constructors, methods, collections, and model/data organization.

Programming Foundations

Cybersecurity Analysis
#

Programming fluency supports log parsing, scripting, tool usage, malware analysis foundations, and understanding how applications behave.

Cybersecurity-Relevant

ServiceNow SecOps
#

ServiceNow work benefits from understanding objects, fields, relationships, workflow logic, data handling, and structured troubleshooting.

SecOps-Relevant

IST 311 Progression
#

IST 240 provides the introductory foundation that later supports IST 311 software engineering and data structures work.

Academic Progression

Next Steps
#

This project can later be connected to:

  • the software foundations capability section
  • the IST 311 project page
  • the academic evidence map
  • a programming foundations review path
  • a ServiceNow scripting-readiness note
  • a cybersecurity automation foundations section

For now, this page serves as the main portfolio-safe summary of my IST 240 introductory Java programming and object-oriented programming lab progression.