Course work for Coursera Online class Object Oriented Programming in Java Specialization
1st course of the specialization
BY Duke University
BlueJ Environment
Find genes from string or file.
StorageResource.
CSV Files and Basic Statistics in Java Module
1. Use the open-source Apache Commons CSV package in your own Java programs;
2. Access data from one or many CSV files using Java;
3. Convert strings into numbers;
4. Understand how to use “null” in Java programs (when you want to represent “nothing”);
5. Devise an algorithm (and implement in Java) to answer questions about CSV data; and
Analyze CSV data across multiple CSV files (for example, find maximums, minimums, averages, and other simple statistical results).
mini-project: search and rank babynames in different year
Optional Honors Content: convert images to grayscale and inverted version and save them to the file.
2nd course of the specialization
BY Duke University
BlueJ Environment
Combine Strings using concatenation;
Build Strings within a Java program using StringBuilder;
Use arrays to store and manipulate collections of data;
Refactor your programs for improved organization using object-oriented principles; and
Practice effective algorithm design.
Assignments:
Implement Caesar Cipher with one and two keys
Implement Caesar Ciphar breakers of one and two keys
Implement WordLength to detect the length of words in a file
Implement WordPlay to detect vowels in words and play with them
Program a word frequency counter to analyze any input text file;
Select and substitute words from a list into a document template using both ArrayList and HashMap;
Create new lists to use in templates;
Recognize brittle code; and
Improve code with flexible, object-oriented design.
how web server logs store information about visitors to a website
access information like user IP address, date and time of access, and more
Read information from a web server log;
Count the number of unique visitors to your website; and
Count the number of times each visitor uses your website.
Assignments:
Assignment: Reading Web Logs; complete the WebLogProgram to read and print web logs that was described in the lesson
Assignment: Unique IPs; continue to build on the LogEntry and LogAnalyzer classes in WebLogProgram with more methods
Assignment: Website Visits; continue to build on the LogEntry and LogAnalyzer classes in WebLogProgram.
Breaking the Vigenère Cipher.
Assignments:
Assignment: English Language, Known Key Length
Assignment: English Language, Unknown Key Length
Assignment: Multiple Languages
3rd course of the specialization
BY University of California, San Diego
Course Goal:
Author a class in Java and explain how objects are constructed, how they store data, and how you can define their actions.
Trace the execution of code using memory-models.
Define the scope of variables and methods.
Extend existing libraries to build a medium-sized project.
Implement user interface features.
Build and work with a class hierarchy that has multiple levels.
Explain “is-a” and “has-a” relationships between objects.
Author code which implements an Interface.
Explain the difference between compile-time and run-time decisions when working with polymorphism.
Explain the difference between event-driven programming and imperative programming.
Use searching and sorting to design algorithms for analyzing data.
Search for an element in a sorted and unsorted list and explain the differences.
Explain multiple sorting techniques and performance tradeoffs.
Motivate the use of classes and objects in programming
Create objects and call methods on them
Describe member variables, methods and constructors
Explain how to overload methods in Java and why overloading methods is useful
Describe the meaning of the keywords public and private and their effect on where variables can be accessed
Select and effectively use Java documentation
Generate visual maps using Java code and the Unfolding Maps libraries
Create and draw memory models for reasoning about variable values for primitive and object data types
Apply the basic rules for variable scope and explain how it impacts your code
Practice tracing code using memory models and Java's rules for variable scope
Create and manipulate Graphical User Interfaces (GUIs)
Find and effectively use Java documentation
Use the Processing library in your programs
Customize visual maps using Java code
Use Java to read and parse data files
Organize data into appropriate objects
Describe and use the List data type and the ArrayList class
Describe and use the Map data type
Explain the value of inheritance as a feature in object oriented programming languages
Use the keyword extends
Explain the relationship between a superclass and a subclass
Use UML Diagrams to display class hierarchies
Explain an “is-a” relationship between classes
Describe how Java object construction occurs from the inside out
Use same-class and superclass constructors in class creation
Create methods which override from a superclass
Contrast method overloading and method overriding
Explain the purpose of polymorphism
Step through decisions made at compile time and runtime
Use casting of objects to aid the compiler
Use the keyword "abstract"
Compare and contrast “inheritance of implementation” and “inheritance of interface”
Decide between Abstract Classes and Interfaces
Distinguish between procedural programming and event-driven programming.
Trace event-driven code
Explain how mouse-clicks and keyboard input interact with the program execution
Design user-interface elements
Write code to implement a button and respond to mouse events
Describe inheritance relationships used in the course so far
Distinguish between interfaces and classes in this hierarchy
Motivate the importance of search
Write code to perform a linear search
Explain and implement the binary search algorithm
Explain why binary search is better than linear search
Define sorting
Explain why sorting data can be useful
Explain and implement the selection sort algorithm
Trace code and describe its high-level function
Describe alternate algorithms for sorting
Use pre-defined Java methods to sort
Explain the properties of this built-in sort algorithm
Define and use the Comparable interface in Java
4th course of the specialization
BY University of California, San Diego
Course Goal:
Describe the difference between an abstract data type (ADT) and its implementation.
Work with Java's built-in classes for fundamental data structures including: String, LinkedList, TreeSet, HashSet, and HashMap.
Implement fundamental data structures from scratch including Linked Lists and Tries (yes, we mean Tries rather than trees ... stay tuned to learn about this data structure!).
Analyze the performance of code, using Big-O notation as well as through benchmarking experiments.
Compare and contrast the performance of different data structures to select the most appropriate for a task.
Write JUnit tests to ensure the correctness of your code.
Implement several algorithms for generating and processing text.
Describe how the Flesch Readability Score can be used to determine the readability of text
Describe how Strings are represented in Java
Perform basic operations with Strings in Java
Work with the String class's built-in methods to manipulate Strings
Write regular expressions to match String patterns
Use regular expressions to split strings
Explain why the performance of an algorithm is important
Describe some factors that impact the performance of an algorithm
Explain why asymptotic analysis is useful
Calculate the big-O class of a code snippet
Combine the runtimes of smaller code snippets to analyze the performance of more complicated code
Compute the big-O class of code with nested loops
Analyze the performance of selection sort
Define worst case, average case, and best case performance and describe why each of these is used
State and justify the asymptotic performance for linear search, binary search, selection sort, and insertion sort in the best case and in the worst case
Describe the merge sort algorithm
Explain the use of recursion in merge sort
Use asymptotic analysis to compare merge sort with selection sort and with insertion sort
State the best, worst, and average case performance for insertion sort, selection sort, merge sort, and quick sort
Evaluate situations in which different sorting algorithms are appropriate
Organize big-O classes according to rate of growth
Avoid some common pitfalls in asymptotic analysis
Explain the role of benchmarking in computer science
Identify components of real systems which impact execution time
Use Java timing libraries to measure execution time
Use runtimes from a real system to reason about performance
Explain the idea of abstraction and why it is important
Give an example of abstraction in the real world and in Java
Describe the difference between an Abstract Data Type (ADT) and a Data Structure
Describe and draw the structure of a LinkedList
Describe an advantage of a LinkedList over an ArrayList
Implement Generic classes in Java
Throw Exceptions to indicate errors
Implement a doubly linked list with sentinel nodes in Java
Explain the value of having confidence in your code
Identify ways to build confidence in code correctness
Describe different testing practices
Compare advantages in testing methodologies
Write tests for a LinkedList
Explain how Markov processes can be used to generate text
Distinguish between training on text and generating text
Describe the value of trees
Describe a Tree Data Structure
Author a TreeNode class
Explain the need to visit data in different orderings
Perform and author a preorder traversal
Perform in-order, post-order and level-order traversals
Define a Binary Search Tree
Identify valid Binary Search Trees
Perform Search in a Binary Search Tree
Insert an item into a Binary Search Tree
Delete an item from a Binary Search Tree
Explain the running time performance to find an item in a BST
Compare the performance of linked lists and BSTs
Explain what a trie data structure is
Describe the algorithm for finding keys in and adding keys to a trie
Compare the time to find a key in a BST to a trie
Implement a trie data structure in Java
Describe why hash tables are valuable
Describe the role of a hash function
Describe alternative methods for handling collisions in a Hash Table
Identify other challenges associated with Hash Tables
Explain the difference between a Hash Set and a Hash Map
Describe a detailed algorithm for generating spelling suggestions for misspelled words
Define the notion of edit distance
Describe a naïve algorithm for calculating the edit distance between two strings
Describe how pruning can be used to reduce the problem space