TT2000: Getting Started with Programming, OO & Java Basics for Non-Developers
About this Course
Learning to program opens up a world of possibilities, whether you are looking to build applications, improve your problem-solving skills, or just understand how software works. Getting Started with Programming, OO, and Java 21 Basics for Non-Developers is a hands-on, expert-led course designed to make coding approachable, even if you have never written a line of code before. You will learn how programs work, how to think like a developer, and how to write and organize Java code in a way that makes sense. With plenty of hands-on practice, you will gain confidence using Java 21’s latest features, working with IDEs, and understanding key concepts like variables, loops, methods, and object-oriented programming.
This course is built for technically-minded beginners who want real coding experience in a structured, supportive environment. Over five days, you will write your own Java programs, explore core programming concepts, and see firsthand how to build applications from the ground up. You will also work with essential Java tools, handle errors, and learn best practices for writing clean, efficient code. With expert guidance and a focus on hands-on learning, you will walk away with practical skills that you can use immediately. Whether you are starting your journey into development, working with technical teams, or just curious about how programming works, this course will give you the foundation you need to get started.
Becoming a modern software developer is like learning a new language; it requires study, practice, and dedication well beyond this course to apply your new skills effectively. While this five day program won’t transform you into an experienced developer, it will lay a solid foundation in coding basics using Java, while teaching you to think like a programmer. Although this course is technical in nature, our instructors will guide you every step of the way, providing a supportive environment for you to explore, ask questions, and prepare for your next learning milestones.
Audience Profile
This course is designed for beginners who want to learn programming from the ground up, whether you are an aspiring developer, a technical professional looking to collaborate with engineers, or someone supporting software projects. No prior programming experience is required, but you should be comfortable using a computer and working with basic software tools.
Please note that although this course is for beginner-level students, it is technical in nature. If you're moving from a truly non-technical role into coding for the first time, please reach out to us for some additional guidance or light course prep suggestions which can really be helpful before you jump into this course head-on. We want your experience to be exciting, challenging and useful, without being overwhelming. We're here to help!
Attendees might include:
Technically-minded attendees who want or who want to begin the process of becoming an OO application developer
Technical team members from non-development roles, re-skilling to move into software and application development roles within an organization
Recent college graduates looking to apply their college experience to programming skills in a professional environment, or perhaps needing to learn the best practices and standards for programming within their new organization
Technical managers tasked with overseeing programming teams, or development projects, where basic coding knowledge and exposure will be useful in project oversight or communications needs
At Course Completion
Learning how to code and become a modern software developer is like trying to learn and become fluent in a new spoken language. Learning any new language takes study, practice, more study, and more practice, to truly be able put your newly learned skills to work in a practical way. This course won't make you an experienced developer in the five days we have with you, but we'll ensure that you're provided with a solid introduction to coding basics, along with real hands-on experience programming in Java. All the while focused on learning how to Think Like a Programmer. Please note that this course is for beginners new to programming, but it is technical in nature. Our instructors are there to guide you through the process and provide you with a trusted platform to dig into something new, ask questions, and leave the class ready to take the next steps in your learning journey.
In this course, you will gain the essential programming skills needed to write, structure, and troubleshoot Java applications with confidence. By the end, you will be able to:
Write and run Java programs using IntelliJ (or Eclipse, if requested) and the Java Development Kit (JDK) to understand how code is compiled and executed.
Use variables, loops, conditionals, and methods to control program flow and manage data efficiently.
Apply object-oriented programming principles, including classes, objects, inheritance, and polymorphism, to design well-structured applications.
Work with Java's core features, such as arrays, strings, exceptions, and collections, to build functional and organized code.
Understand and apply best practices in writing clean, reusable, and maintainable Java code.
Build confidence in troubleshooting errors, debugging programs, and thinking like a developer.
If your team requires different topics, additional skills or a custom approach, our team will collaborate with you to adjust the course to focus on your specific learning objectives and goals.
Outline
Please note that this list of topics is based on our standard course offering, evolved from typical industry uses and trends. We’ll work with you to tune this course and level of coverage to target the skills you need most. Topics, agenda and labs may adjust during live delivery based on audience skill-level, needs and participation.
1. Overview of Computer Programming
Explain what a program is
Explain why there are different types of languages
Explain what a compiler is
Explain what an interpreter is
Lab: Matching Terms
2. Features of a Program
Understand what the entry and exit points of an application are
Explain what variables are
Explain what programming instructions are
Explain what errors and exceptions are
Understand what programming algorithms are
3. Software Development Life Cycle
Explain the purpose of the software development life cycle
Explain what each phase is for
Explain the difference between the software development life cycle and a methodology
4. Thinking in Objects
Understand the difference between a class and an object
Deconstruct an object into attributes and operations
Map an object to a class
Define inheritance
Lab: Designing an Application
5. The Java Platform
Introduce the Java Platform
Explore the Java Standard Edition
Discuss the lifecycle of a Java Program
Explain the responsibilities of the JVM
Executing Java programs
Garbage Collection
Documentation and Code Reuse
6. Using the JDK
Explain the JDK’s file structure
Use the command line compiler to compile a Java class
Use the command line Java interpreter to run a Java application class
Lab: Exploring MemoryViewer
7. The IntelliJ Paradigm
Introduce the IntelliJ IDE
The Basics of the IntelliJ interface
IntelliJ Projects and Modules
Creating and running Java applications
Tutorial: Working with IntelliJ 2023.2 (Community Edition)
8. Writing a Simple Class
Write a Java class that does not explicitly extend another class
Define instance variables for a Java class
Create object instances
Primitives vs Object References
Implement a main method to create an instance of the defined class
Java keywords and reserved words
Lab: Create a Simple Class
9. Adding Methods to the Class
Write a class with accessor methods to read and write instance variables
Write a constructor to initialize an instance with data
Write a constructor that calls other constructors of the class to benefit from code reuse
Use the this keyword to distinguish local variables from instance variables
Lab: Create a Class with Methods
10. Exploring Object-Oriented Programming
Real-World Objects
Classes and Objects
Object Behavior
Methods and Messages
Lab: Define and use a New Java class
11. Inheritance, Abstraction, and Polymorphism
Encapsulation
Inheritance
Method Overriding
Polymorphism
Lab: Define and use Another Java Class
12. Language Statements
Arithmetic operators
Operators to increment and decrement numbers
Comparison operators
Logical operators
Return type of comparison and logical operators
Use for loops
Swtch Expressions
Switch Expressions and yield
Lab: Looping (optional)
Lab: Language Statements
Lab: Switch Expressions
13. Using Strings and Text Blocks
Create an instance of the String class
Test if two strings are equal
Perform a case-insensitive equality test
Contrast String, StringBuffer, and StringBuilder
Compact Strings
Text Blocks
Unicode support
Lab: Fun with Strings
Lab: Using StringBuffers and StringBuilders
14. Fields and Variables
Discuss Block Scoping Rules
Distinguish between instance variables and method variables within a method
Explain the difference between the terms field and variable
List the default values for instance variables
Final and Static fields and methods
Lab: Field Test
15. Specializing in a Subclass
Constructing a class that extends another class
Implementing equals and toString
Writing constructors that pass initialization data to parent constructor
Using instanceof to verify type of an object reference
Pattern matching for instanceof
Overriding subclass methods
Safely casting references to a more refined type
Lab: Creating Subclasses
16. Using Arrays
Declaring an array reference
Allocating an array
Initializing the entries in an array
Writing methods with a variable number of arguments
Lab: Creating an Array
17. Formatting Strings
Format a String using the formatter syntax
Apply text formatting
Use String.format and System.out.printf
Lab: Textblocks
18. Records
Data objects in Java
Introduce records as carrier of immutable data
Defining records
The Canonical constructor
Compact constructors
Lab: Records
19. Java Packages and Visibility
Use the package keyword to define a class within a specific package
Discuss levels of accessibility/visibility
Using the import keyword to declare references to classes in a specific package
Using the standard type naming conventions
Visibility in the Java Modular System
Correctly executing a Java application class
The Java Modular System
Defining Modules
20. Utility Classes
Introduce the wrapper classes
Explain Autoboxing and Unboxing
Converting String representations of primitive numbers into their primitive types
Defining Enumerations
Using static imports
Deprecating classes and methods
Lab: Enumerations
21. Java Date/Time
The Date and Calendar classes
Introduce the new Date/Time API
LocalDate, LocalDateTime, etc.
Formatting Dates
Working with time zones
Manipulate date/time values
22. Inheritance and Polymorphism
Write a subclass with a method that overrides a method in the superclass
Group objects by their common supertype
Utilize polymorphism
Cast a supertype reference to a valid subtype reference
Use the final keyword on methods and classes to prevent overriding
Lab: Salaries - Polymorphism
23. Interfaces and Abstract Classes
Define supertype contracts using abstract classes
Implement concrete classes based on abstract classes
Define supertype contracts using interfaces
Implement concrete classes based on interfaces
Explain advantage of interfaces over abstract classes
Explain advantage of abstract classes over interfaces
Lab: Interfaces
24. Introduction to Exception Handling
Introduce the Exception architecture
Defining a try/catch blocks
Checked vs Unchecked exceptions
Lab: Exceptions
25. Exceptions
Defining your own application exceptions
Automatic closure of resources
Suppressed exceptions
Handling multiple exceptions in one catch
Enhanced try-with-resources
Helpful NullPointerException(s)
Lab: Exceptional
Lab: Helpful Nullpointers
26. Building Java Applications
Explain the steps involved in building applications
Define the build process
Introduce build scripts
Explain the standard folder layout
Resolving project dependencies
Tutorial: Importing code Using Maven
27. Introduction to Generics
Generics and Subtyping
Bounded Wildcards
Generic Methods
Legacy Calls To Generics
When Generics Should Be Used
Lab: DynamicArray
Lab: Adding Generics to Dynamic Array
28. Collections
Provide an overview of the Collection API
Review the different collection implementations (Set, List and Queue)
Explore how generics are used with collections
Examine iterators for working with collections
Lab: Create a simple Game using Collections
Prerequisites
To ensure a smooth learning experience and to gain the most from attending this course, you should have the following incoming skills:
Basic computer literacy: Familiarity with computer operating systems, file management, and general navigation to ensure a smooth learning experience.
Foundational knowledge of IT concepts: Understanding of essential IT terminologies and concepts, such as computer networks, software applications, and data storage.
Analytical thinking: Ability to analyze problems and think critically to develop logical solutions, fostering a programmer's mindset.