Difference between revisions of "CS 1331"

From Georgia Tech Student Wiki
 
(18 intermediate revisions by 8 users not shown)
Line 1: Line 1:
  +
{{DISPLAYTITLE:CS 1331 - Introduction to Object-Oriented Programming}}
== Overview ==
 
  +
[[Category:Courses|^CS^CS]]
[No official Course page]
 
   
  +
'''CS 1331''', formally known as '''Introduction to Object-Oriented Programming''', is a 3-credit Computer Science class taken as a core requirement for College of Computing and Computer Engineering majors. It provides a detailed overview of programming using the Java programming language, going over syntactical details and computing principles not inherent with an extremely high-level programming language such as Python. It is immediately preceded by [[CS 1301]], and immediately succeeded by [[CS 1332]], [[CS 2110]], and [[CS 2340]].
==== Topic List ====
 
CS 1331 basically focuses on Java Programming semantics, a very brief introduction to Data Structures & Algorithms, and also looks into JavaFx basics. The course is slightly fast-paced, but enough time, resources, and attention is given to students who do not have a background in programming to grasp the concepts.
 
   
  +
== Workload ==
# Java Introduction
 
  +
Like most 1000-level CS classes, CS 1331 primarily consists of homework assignments and a set of exams. Some classes also have a participation component.
## Object Oriented Programming
 
  +
## Syntax vs Semantics
 
  +
Homework assignments are non-practical (yet useful) programming exercises that allow the student to apply Java and OOP principles taught in class. A selection of the later homework assignments go over implementations of simple data structures and exceptions.
## Interpreted vs Compiled
 
  +
## What is a class
 
  +
Exams test knowledge of Java syntax through multiple choice, fill-in-the-blank, matching, and free response questions. Due to the nature of the class and how it attempts to assess Java knowledge, exams are known to be a bit on the pickier side and are generally not forgiving.
## Comments
 
  +
## Compilation Process
 
  +
{{Collapsed|
# Variables & Assignment
 
  +
== Topic List ==
## Identifiers
 
  +
|
## Variables
 
  +
As of Spring 2021, the topic list is as follows:
## Constants
 
  +
## Literals
 
  +
# Introduction to Java
##* Numeric
 
  +
## History of Java
##* Strings
 
  +
## Java, the JVM, and Compilation Styles
# Expressions
 
  +
# Variables, Data Types, and Arithmetic
#* Order of Operations
 
  +
## Static vs. Dynamic Variables
# Classes and Objects
 
  +
## Primitive Data Types
## Encapsulation
 
  +
## Primitive Data Type Operations
## Instance Methods
 
  +
# Objects
## Overriding
 
  +
## Reference Data Types
## 'this' operator
 
  +
## Java's Built in Objects
## scope of variables
 
  +
# Loops, Control Flow, and Decision Making
## visibility modifiers
 
  +
## Simple Boolean Logic
##* public
 
##* private
+
## For Loops
  +
## While Loops
##* protected
 
  +
## If/Else Statements
##* default (package private)
 
  +
## Switch Statements
## getters and setters
 
## Constructors
 
##* Default Constructors
 
##* Creating Constructors
 
##* Parameterized Constructors
 
##* Constructor Overloading
 
##* Constructor Chaining
 
##* Copy Constructor
 
##*# Shallow Copy
 
##*# Deep Copy
 
## The Object Class
 
## Object Equality
 
## toString
 
## hashCode
 
# Command Line
 
## Command Line Output
 
## Command Line Input
 
# Program Control Flow
 
#* Branching
 
#*# Conditionals: if, else if, else ladders
 
#*# Logical Operations
 
#*# Logical Operator Precedence
 
#*# Ternary Operator
 
#*# Switch
 
#* Iteration
 
#*# for Loop
 
#*# while Loop
 
#*# Continue and Break
 
#*# do-while loop
 
# Packages and Built In Classes
 
## Random Class
 
## Math Operations
 
# Enumerations
 
# static
 
#* methods
 
#* variables
 
 
# Arrays
 
# Arrays
  +
## The Array Object
#* 1 Dimensional
 
  +
## 1D Arrays
#* 2 Dimensional
 
  +
## 2D Arrays
#* Multi Dimensional
 
  +
# Methods
# Checkstyle / Coding Conventions
 
  +
## The Main Method
# null reference
 
  +
## Writing Static Methods
# Wrapper Classes
 
  +
## String[] args explained
# Abstract Classes and Interfaces
 
## Heirarchies
+
## Overloading
  +
# Classes and Object-Oriented Programming
## Polymorphism & Dynamic Binding
 
  +
## What is OOP?
## Comparable
 
# Exceptions and Error Handling
+
## Classes and Objects
  +
## Writing Classes
# File I/O
 
  +
## Static vs. Non-Static Methods
# Generics
 
  +
# Inheritance and Polymorphism
# ArrayLists
 
  +
## Inheritance
# Asymptotics and Big-O
 
  +
## Inheritance Hierarchies
# Searching and Sorting
 
  +
## Abstract Classes
  +
## Overriding
  +
## Polymorphism
  +
## Dynamic Binding
  +
# Interfaces
  +
## Interfaces
  +
## Interfaces vs. Abstract Classes
  +
## Multiple Inheritance with Interfaces
  +
# Basic Sorting Algorithms and Introduction to Big-O
  +
## Introduction to Algorithms
  +
## Linear Search
  +
## Binary Search
  +
## Selection Sort
  +
## Insertion Sort
  +
## Merge Sort
  +
## Naive Big-O
  +
# File I/O and Exception Handling
  +
## Reading and Writing from Files
  +
## Exceptions and the Exceptions Class
  +
## Types of Exceptions
  +
## Errors
  +
## Writing Exceptions
  +
# ArrayLists and LinkedLists
  +
## The List ADT
  +
## ArrayLists
  +
## LinkedLists
 
# Recursion
 
# Recursion
# JavaFX
+
# JavaFX and GUI Programming
  +
## What is JavaFX?
## Concepts, Graphics and Shapes
 
## Event Driven Programming
+
## GUI Programming Overview
  +
## Writing Graphical Programs
## Layout
 
  +
## Private Inner Classes
## Mouse & Key Events
 
  +
## Lambda Expressions
## GUI Controls
 
  +
}}
## ADTs
 
  +
##* Sets
 
  +
== Prerequisite Knowledge ==
##* Java Collections
 
  +
##* Hashing
 
  +
=== Programming ===
##* Lists, Linked Lists
 
  +
As CS 1331's direct prerequisite is CS 1301, CS 1301 expects basic programming skills in any language. Emphasis is placed on knowing basic programming concepts such as functions, variables, loops, and decision making. While CS 1331 does go over these topics in the context of Java, it does go over it at a much brisker pace.
##* Iterable/ Iterators
 
  +
# Class Design and Interaction
 
  +
== Future Outlook ==
# Software Design & Development [Optional]
 
  +
CS 1331 is one of the most important classes for CS majors. It serves as a prerequisite for CS 1332, which is an important core CS class, CS 2110, the first class of the Systems and Architecture Thread chain, and CS 2340, another important core CS class. Many of these classes are even more embedded in longer prerequisite chains for other threads, and thus, completing CS 1331 as soon as possible is critical.
# Testing, Debugging and IDEs
 
  +
# JavaDocs & Creating your own packages
 
  +
Computer Engineers, while not having many classes that use CS 1331 as a prerequisite, still need to take CS 1331 as soon as possible, especially if they decide to select a CS thread.
  +
  +
== Current Registration Info ==
  +
CS 1331 is NOT a [[linked course]]. You thus only need to register for a lecture section (e.g. A, B, C).
  +
  +
However, there exists an optional second component: [[Recitation]]. You have the option (although its strongly recommended) to register for a corresponding recitation section with the same section but with the 1331R course number (e.g. lecture section: 1331 A will have recitation section 1331R A01, A02, etc.). The recitation is optional, but since attendance is voluntary, it is recommended that you sign up for it.
  +
  +
The course also has a placement test that you can take before the semester begins to test out, known as an ASE. The College of Computing will have more details every July, October, and March about this exam.
  +
  +
=== [https://oscar.gatech.edu/bprod/bwckctlg.p_disp_course_detail?cat_term_in=202108&subj_code_in=CS&crse_numb_in=1331 Prerequisites] ===
  +
At least one of the following:
   
  +
* 4 or Higher on the AP Computer Science A Exam
==== How it fits in the curriculum ====
 
  +
* C or Higher in CS 1301
The course not only touches upon the Java Programming language (3rd most popular according to Stack Overflow), but also introduces many fundamental programming concepts that are universal for any programming language. The course also focuses on Object Oriented Design and JavaFX, which will be emphasized in CS 2340, and also touches ADTs, and Searching & Sorting, which will be built on in CS 1332.
 
  +
* C or Higher in CS 1315
  +
* C or Higher in CS 1371
   
  +
== Resources ==
Most future CS courses have 1331 as either a direct or indirect prerequisite.
 
  +
[https://cs1331.org <s>CS 1331 2019 Website</s>] (Unavailable)<br />
  +
[https://classes.cc.gatech.edu/AY2021/cs1331a_spring/index.html <nowiki>CS 1331 Spring 2021 Section A Website</nowiki>]

Latest revision as of 19:04, 21 August 2022


CS 1331, formally known as Introduction to Object-Oriented Programming, is a 3-credit Computer Science class taken as a core requirement for College of Computing and Computer Engineering majors. It provides a detailed overview of programming using the Java programming language, going over syntactical details and computing principles not inherent with an extremely high-level programming language such as Python. It is immediately preceded by CS 1301, and immediately succeeded by CS 1332, CS 2110, and CS 2340.

Workload[edit | edit source]

Like most 1000-level CS classes, CS 1331 primarily consists of homework assignments and a set of exams. Some classes also have a participation component.

Homework assignments are non-practical (yet useful) programming exercises that allow the student to apply Java and OOP principles taught in class. A selection of the later homework assignments go over implementations of simple data structures and exceptions.

Exams test knowledge of Java syntax through multiple choice, fill-in-the-blank, matching, and free response questions. Due to the nature of the class and how it attempts to assess Java knowledge, exams are known to be a bit on the pickier side and are generally not forgiving.


Topic List

As of Spring 2021, the topic list is as follows:

  1. Introduction to Java
    1. History of Java
    2. Java, the JVM, and Compilation Styles
  2. Variables, Data Types, and Arithmetic
    1. Static vs. Dynamic Variables
    2. Primitive Data Types
    3. Primitive Data Type Operations
  3. Objects
    1. Reference Data Types
    2. Java's Built in Objects
  4. Loops, Control Flow, and Decision Making
    1. Simple Boolean Logic
    2. For Loops
    3. While Loops
    4. If/Else Statements
    5. Switch Statements
  5. Arrays
    1. The Array Object
    2. 1D Arrays
    3. 2D Arrays
  6. Methods
    1. The Main Method
    2. Writing Static Methods
    3. String[] args explained
    4. Overloading
  7. Classes and Object-Oriented Programming
    1. What is OOP?
    2. Classes and Objects
    3. Writing Classes
    4. Static vs. Non-Static Methods
  8. Inheritance and Polymorphism
    1. Inheritance
    2. Inheritance Hierarchies
    3. Abstract Classes
    4. Overriding
    5. Polymorphism
    6. Dynamic Binding
  9. Interfaces
    1. Interfaces
    2. Interfaces vs. Abstract Classes
    3. Multiple Inheritance with Interfaces
  10. Basic Sorting Algorithms and Introduction to Big-O
    1. Introduction to Algorithms
    2. Linear Search
    3. Binary Search
    4. Selection Sort
    5. Insertion Sort
    6. Merge Sort
    7. Naive Big-O
  11. File I/O and Exception Handling
    1. Reading and Writing from Files
    2. Exceptions and the Exceptions Class
    3. Types of Exceptions
    4. Errors
    5. Writing Exceptions
  12. ArrayLists and LinkedLists
    1. The List ADT
    2. ArrayLists
    3. LinkedLists
  13. Recursion
  14. JavaFX and GUI Programming
    1. What is JavaFX?
    2. GUI Programming Overview
    3. Writing Graphical Programs
    4. Private Inner Classes
    5. Lambda Expressions

Prerequisite Knowledge[edit | edit source]

Programming[edit | edit source]

As CS 1331's direct prerequisite is CS 1301, CS 1301 expects basic programming skills in any language. Emphasis is placed on knowing basic programming concepts such as functions, variables, loops, and decision making. While CS 1331 does go over these topics in the context of Java, it does go over it at a much brisker pace.

Future Outlook[edit | edit source]

CS 1331 is one of the most important classes for CS majors. It serves as a prerequisite for CS 1332, which is an important core CS class, CS 2110, the first class of the Systems and Architecture Thread chain, and CS 2340, another important core CS class. Many of these classes are even more embedded in longer prerequisite chains for other threads, and thus, completing CS 1331 as soon as possible is critical.

Computer Engineers, while not having many classes that use CS 1331 as a prerequisite, still need to take CS 1331 as soon as possible, especially if they decide to select a CS thread.

Current Registration Info[edit | edit source]

CS 1331 is NOT a linked course. You thus only need to register for a lecture section (e.g. A, B, C).

However, there exists an optional second component: Recitation. You have the option (although its strongly recommended) to register for a corresponding recitation section with the same section but with the 1331R course number (e.g. lecture section: 1331 A will have recitation section 1331R A01, A02, etc.). The recitation is optional, but since attendance is voluntary, it is recommended that you sign up for it.

The course also has a placement test that you can take before the semester begins to test out, known as an ASE. The College of Computing will have more details every July, October, and March about this exam.

Prerequisites[edit | edit source]

At least one of the following:

  • 4 or Higher on the AP Computer Science A Exam
  • C or Higher in CS 1301
  • C or Higher in CS 1315
  • C or Higher in CS 1371

Resources[edit | edit source]

CS 1331 2019 Website (Unavailable)
CS 1331 Spring 2021 Section A Website