CSE 271 Object-Oriented Programming (3 credits)

Catalog description:

The design and implementation of software using object-oriented programming techniques including inheritance, polymorphism, object persistence, and operator overloading. Students will analyze program specifications and identify appropriate objects and classes. Additional programming topics include dynamic memory recursion, using existing object libraries, and binary/ASCII file processing.


CSE 174 (with C- or above) or equivalent

CSE 271 is a second-tier course in the CSE2 "Computer Programming" thematic sequence.

Computer software plays an important role in our daily lives: Our mobile phones, laptop computers, online banking, Internet applications such as YouTube, video games and movies, cars, and almost all aspects of daily life are touched by software. In your personal and professional life you will utilize computer software. It is also likely that you will select, or even influence the design of, software that is used in your professional or personal life. This thematic sequence will give you a deep understanding of how software works and is created, its limitations, and its potential. You will be able to read software and therefore be able to make informed decisions when selecting or participating in the design of business, scientific, or information systems that utilize computer software.

The CSE2 thematic sequence consists of both of the following introductory computer programming courses.

  • CSE 174, Fundamentals of Programming and Problem Solving
  • CSE 271, Object-Oriented Programming

Followed by one of the following courses

  • CSE 274, Data Abstraction and Data Structures
  • CSE 252, Web Application Programming
  • CSE 283, Data Communications and Networks

CSE 271 is a course in which you build upon the programming concepts and techniques learned in CSE 174 to design and implement more sophisticated programs using object-oriented design and programming techniques.

Required Topics (approximate week allocation):

  • Defining classes (3.0)
    • Data members
    • Setters, getters, constructors
    • equals, toString, compareTo
    • Deep vs shallow copies
    • Information hiding and encapsulation
    • Instance vs static
  • Object-Oriented Programming (4.0):
    • Object Oriented Design
    • UML
    • Inheritance
    • Interfaces
    • Polymorphism
    • Composition
    • Overriding and overloading methods
    • Using Javadoc to document a class
  • Development tools (1.0)
    • Using JUnit to test correctness of class definitions
    • Writing JUnit tests
    • Using Git to manage source code.
  • GUI (1.0)
    • Use GUI builders to create a functional user interface
    • Implement event-driven programs within the context of a GUI
  • Exception Handling (0.5)
    • Throwing exceptions
    • Java's exception hierarchy
    • Checked vs unchecked exceptions
  • Recursion (1.5)
    • Analyzing and tracing recursive algorithms
    • Implementing recursive algorithms to process arrays and strings
    • Recursive binary search
  • Recursive sorting algorithms (1.0)
    • Quicksort
    • Mergesort
    • Efficiency of bubble sort vs quicksort vs mergesort
  • Collection Classes (1.0)
    • Sets
    • Iterators
  • Exams (1.0)

Learning Outcomes:


  1. Design and implement computer programs using object oriented programming techniques.
    • Implement a class definition from a given design that incorporates primitive types, 3rd party classes, accessor and mutator methods, constructors, method overloading, static data and methods, and other methods for processing the object
    • Describe object-oriented programming concepts including objects, classes, methods, abstraction, encapsulation, inheritance, and polymorphism
    • Use class libraries to assist in problem solving
    • Write programs that use inheritance, polymorphism, composition, abstract classes, and interfaces
    • Write programs that use collection classes (e.g., HashMap, Set, ArrayList) and iterators
    • Write basic UML class diagrams based on a problem statement
    • Break a programming problem down into an appropriate set of classes, and identify appropriate methods for each class
    • Research and use classes not studied in the course to solve programming problems
  2. Write robust programs
    • Resolve compilation errors, validate program input, use the debugger to locate logic errors, and generate basic test cases as learned in CSE 174
    • Use the JUnit tool, and write JUnit tests to test the correctness of class implementations
    • Use Git to manage source code
    • Use Javadoc to document a class
    • Write code that throws and catches appropriate exception classes, including both checked and unchecked exceptions
  3. Use recursion as a problem solving technique
    • Analyze and trace recursive algorithms
    • Identify problem situations where recursion is appropriate
    • Implement recursive algorithms that implement numeric computations (such as factorial), arrays, and strings
  4. Describe and implement sorting algorithms
    • Review non-recursive sorting algorithms including such as bubble sort, insertion sort, and selection sort
    • Describe and implement recursive sorting algorithms including mergesort and quicksort algorithms
    • Compare sorting algorithms with respect to efficiency
  5. Design and develop applications with a graphical user interface
    • Use GUI builders to create a functional user interface
    • Implement event-driven programs within the context of a GUI