CS A170: Java Programming 1

Course Outline of Record
Item	Value
Eff Term	Fall 2026
Curriculum Committee Approval Date	12/03/2025
Top Code	070600 - Computer Science (Transfer)
Units	3 Total Units (Lecture Units 1.5; Lab/Other Units 1.5)
Hours	108 Total Hours (Lecture Hours 27; Lab Hours 81)
Total Outside of Class Hours	54
Total Student Learning Hours	162
Course Credit Status	Credit: Degree Applicable (D)
Material Fee	No
Basic Skills	Not Basic Skills (N)
Repeatable	No
Open Entry/Open Exit	No
Grading Policy	Standard Letter (S), Pass/No Pass (B)
Associate Arts Local General Education (GE)	Area 2 Mathematical Concepts and Quantitative Reasoning (OMTH)
Associate Science Local General Education (GE)	Area 2 Mathematical Concepts and Quantitative Reasoning (OMTH)

Course Description

Introduction to fundamental concepts and techniques for writing software in Java. Students will build Java applications that focus on the syntax and semantics of data types, expressions, input/output, exception handling, functions and parameter passing, control structures (decision and repetition), and arrays, as well as object-oriented programming with classes, inheritance, polymorphism, and recursion. ADVISORY: CIS A090; and CIS A100 or CIS A111. Transfer Credit: CSU; UC. C-ID: COMP 122.C-ID: COMP 122.

Course Level Student Learning Outcome(s)

Students will be able to design, implement, test, and debug Java programs that use input/output, decision and repetition structures, functions with parameter passing, and exception handling.
Students will be able to create one- and two-dimensional arrays to store, manipulate, and retrieve data.
Students will be able to construct object-oriented programs in Java using classes, inheritance, and polymorphism, and implement recursive functions to solve appropriate problems.

Course Objectives

Summarize the evolution of programming languages.
Use Java tools to create, compile, and run syntactically correct Java programs.
Use the fundamental concept of sequence and input–processing–output (IPO).
Demonstrate proficiency in writing programs that use logic and selection statements.
Demonstrate proficiency in using iteration and loops to process strings and arrays.
Demonstrate proficiency in calling methods with arguments, and defining methods and parameters of different types.\\n
Solve accumulation, counting, and other fundamental algorithms using arrays and lists from the standard Java Class Libraries.
Use the Java Class Library documentation to create objects with constructors and call methods.
Define classes and make proper use of encapsulation.
Apply the concept of inheritance to solve various problems.

Lecture Content

Introduction to Programming
1. Java Mechanics: edit, compile, run and test Java programs.
2. Computers and Memory: hardware and how data is stored in memory.
3. Software and the CPU: types of software; how the CPU works.
4. History of Programming: machine, assembly and high-level languages.
5. What about Java? History of Java and why it is important.
Data and Output
1. Java Syntax Basics: language rules for Java programs.
2. Console Output and escape sequences.
3. Variables and Values: how to declare variables and fill them with values.
4. Numbers: introduction to the primitive integer and real number types.
Objects, Input and Processing
1. Interactive Programs: create programs that accept user input.
2. Processing Data: use arithmetic operators to perform calculations.
3. Math Functions: learn how to use functions, starting with the Math class.
4. Objects and methods: create objects of different types.
5. Difference between reference types and value types.
6. Calling accessor and mutator methods on objects.
Characters, Strings and Functions
1. Side Effects: casting and the shorthand assignment operators.
2. Characters and Strings: the char primitive type and the String class type.
3. Strings and Methods: use the Java API Javadocs, starting with simple String functions.
4. Parsing and Formatting: convert between Strings and numbers and format output.
Procedures and Functions
1. Writing Procedures: learn syntax of procedures, technique of functional decomposition.
2. Passing Parameters: write procedures that modify behavior based on passed arguments.
3. Writing Functions: learn to write methods that calculate and return a value.
4. Syntax Errors: learn techniques for avoiding common compiler errors.
5. Style Rules: learn about the conventions used for formatting Java programs.
Introducing Computer Logic
1. True & False: learn how to use Java's boolean type to compare numbers.
2. Object & String Relationships: learn about different ways to compare objects and Strings.
3. Introducing Selection: make decisions with the if, else and conditional operators.
4. OOP Concepts: vocabulary and principles underlying Object-Oriented Programming.
More on Logic
1. Logical Operators: combine Boolean expressions using Java's logical operators.
2. Multiple Choice: make decisions involving multiple outputs.
3. Using the switch statement and the conditional operator.
4. Applying selection to data validation.
Learning About Loops
1. Writing Loops: learn a strategy for writing loops that are correct.
2. The for Loop: learn how to use Java's for statement to create counter-controlled loops.
3. The while Loop: write loops that use a counter and those that test a condition.
4. More Indefinite Loops: using do-while, managing necessary and intentional bounds.
5. Java Jumps: using break and continue to fine-tune a loop.
Loops, Arrays & Files
1. Iterators and Limits: use iterators to process files and Strings with limit-bound loops.
2. Primitive Arrays: how to create and initialize one-dimensional primitive arrays.
3. Arrays and Methods: learn how arrays are stored and how to write methods to process them.
4. Fundamental array algorithms: counting, accumulating, extreme values.
Arrays and Application
1. Arrays, Pictures and Sound: use arrays to modify digital images or to process sound files.
2. Partially-filled Arrays: learn how to insert and delete elements from an array.
3. Object and 2D Arrays: create arrays that contain rows and columns.
4. More Array Topics: process the command-line and variable-length parameter lists.
User-Defined Types
1. Defining Fields: learn how to create new types and use the data elements they contain.
2. Defining Methods: learn to add actions to classes by defining instance methods.
3. Encapsulation: using private data and writing methods that provide safe access.
4. Constructors: defining constructors to initialize your object's private data.
5. Writing Classes: some larger case study.
Bugs and Testing
1. Scope and Static Methods: writing class methods and implementing shared data elements.
2. Runtime Errors: learn to recognize runtime errors, throw exceptions and use assertions.
3. Unit Tests: learn how to create and use unit tests (JUnit framework).
4. Debugging: learn how to use your IDE's debugger and a debugging strategy.
Inheritance and Composition
1. Introduction to Inheritance: learn how to create new classes by extending existing classes.
2. Inheritance at Work: practical examples of using inheritance.
3. Composite Objects: learn the technique of combining objects to create new classes.
4. Enumerated Types: create user-defined single-value types.
5. ArrayLists: use Java's generic ArrayList class to process collections of elements.
Interfaces and Exceptions
1. Specification Inheritance: create and use abstract classes with abstract methods.
2. Interface Inheritance: use pure specification by defining and implementing interfaces.
3. Events and Interfaces: learn how to work with event interfaces and event adaptors.
4. Inner Classes: create inner classes and anonymous objects.
5. Handling Exceptions: learn to use try-catch and to create your own exception types.
Recursion
1. Recursively defined problems: understand how problems can be expressed in terms of smaller subproblems.
2. Recursive vs. iterative implementations: compare advantages, limitations, and efficiency of recursive solutions against loops.

Lab Content

The following programming labs and exercises are designed to help students master the topics learned by providing hands-on practice for a comprehensive understanding of the material:

A. Working with Console Programs
1. Simple console output using System.out.print and println
2. Interactive programs: produce programs that receive input, process it, and produce output (e.g., FeetToMeters, CelsiusToFahrenheit)
3. Using Math functions: write IPO programs with functions and constants in the Math class (e.g., CircleStats, FutureValue, PresentValue)
4. Formatted output: print results in columns and control numeric formatting
B. Working with Graphical Programs
1. Graphical output: produce text output using graphics
2. Fonts and colors: use different fonts and change colors
3. Graphical shapes and output: draw and fill shapes (e.g., pie chart)
4. Basic animation: create a PacMan, bouncing ball, or similar program
Writing Procedures and Functions
1. Decompose a program into separate procedures
2. Using string functions: rearrange a sentence into words with the String class
3. Writing string functions: examine string input and return a new string
Decision Making and Selections
1. Logic with if and if-else: write functions using simple selection
2. Combining decisions: write functions using logical operators
3. Multiway branching: write functions using sequential or nested if statements
E. Iteration and Repetition
1. Counter-controlled for loops: process strings with for loops
2. Counting and finding: process strings to count or find values or categories
3. Using the while loop: process strings and numbers with while loops
4. Sentinel and flag-controlled loops: use indefinite loops
5. Working with the ArrayList class: compare and contrast with arrays
Iterators and Processing Files
1. Process a file to produce statistics (e.g., count words, add numbers)
Processing Arrays
1. Arrays and methods: write functions that take, return, and modify arrays
2. Arrays and loops: write functions that process arrays with loops
3. Arrays and fundamental algorithms: calculate sums, averages, counts, extremes, and adjacent values
4. Working with 2D arrays: create, traverse, and manipulate two-dimensional arrays
Defining Classes
1. Creating a basic class: instance variables, accessor and mutator methods, constructors
2. Overriding methods in the Object class: toString and equals
3. Testing classes: manual unit tests with expected vs. actual results
Inheritance, Composition and Enumeration
1. Extending a class without constructor chaining
2. Extending a class with overriding and constructor chaining
Recursion
1. Writing recursive functions for factorial and Fibonacci
2. Comparing recursive and iterative search algorithms
3. Solving problems with recursive traversal (e.g., directory or maze search)

Method(s) of Instruction

Lecture (02)
DE Live Online Lecture (02S)
DE Online Lecture (02X)
Lab (04)
DE Live Online Lab (04S)
DE Online Lab (04X)

Instructional Techniques

Lecture, demonstration, and in-class programming exercises.

Reading Assignments

Students will spend a minimum of 3 hours per week reading the textbook and/or other reading material assigned. Students will be expected to follow along with the exercises in the reading material.

Writing Assignments

Students will spend a minimum of 5 hours per week writing code.

Out-of-class Assignments

Students will spend a minimum of 4 hours per week completing weekly programming assignments.

Study Non-Contact Hours Recommended

Methods of Student Evaluation

Midterm Exam
Final Exam
Short Quizzes
Written Assignments
Objective Examinations
Projects (Individual/Group)
Problem Solving Exercises
Skills Demonstration

Demonstration of Critical Thinking

Written examinations, programming proficiency examinations, and in-class guided exercises.

Required Writing, Problem Solving, Skills Demonstration