JALC CPS206 Course Notes, Code Examples, Homeworks, and Labs
Introduce the 4 pillars of OOP (Encapsulation, Abstraction, Inheritance, and Polymorphism), cover when, where, and why, and how to leverage the pillars, and introduce professional coding standards and concepts found in many enterprise systems.
- Command line usage will be required.
- Expect to write lots of code.
- You will be tested on application of theory. Memorization of code is useless. Writing code is the only way you will learn to apply the theory. All topics taught in this class can be applied to any OOP language, project, etc. Feel free to experiment with your own ideas. It will only make you better.
- While I understand your fundamentals are new to you, you will be expected to be competent enough to reference material, e.g. google, when a language construct eludes you. Of course you may ask for help.
- Work in teams. Work in teams. Work in teams. Did I emphasize you should work in teams? This doesn't mean you copy off one another, but it does mean you work as a team. This doesn't mean you copy off one another, but it does mean you work as a team - many folks don’t know what team means in a software dev team. Most have no concept of working on tasks individually that make up the sum of the feature or exercise to get to the desired outcome. Planning together as a team, breaking up the work as a team, and getting together often so to analyze the outcome makes up a team.
- Git is not required, but I cannot emphasize enough that you should use it. Assuming the IT department approves the install, commit your work often. If you decide to use git and version your code, you will soon realize the benefits of advanced topics such as branching, forking, and merging. As you become competent with the basics of commit, add, push, pull, I can introduce you to those more advanced topics on a one-to-one basis.
- I am demanding. I want you to succeed. I firmly believe that upon completion of cps215 you are qualified enough for an entry level software engineer position. If you decide to take your degree further, you will be the top of your class if you buy into my expectations and principles.
- The depth I will take this course will be on theory alone. There will be many nuances that probably will not be covered. This is my caveat to you. I figured out a long time ago that trying to memorize every feature of every topic is nearly impossible and in a week you, or I, will totally forget it. So it is a lose-lose for me to waste time teaching every nook and cranny and you memorizing just to forget. My approach instead is a win-win. I will give you more than enough to write spectacular code, you will write plenty of code to learn those nuances on your own. By you writing lots of code, you become a great programmer. That is a win-win for sure.
We will reveiw CPS176 in full. Then we will cover the following are the core topics to OOP while learning standard enterprise patterns of behavior. Finally, if time permits, we will cover advanced java topics applying the skills you have learned throughtout the semester.
Review of CPS176 (1 to 3 weeks)
- Reviews basic language constructs from data types to arrays.
- Introduces Git and Github for code versioning using commit, pull, push.
- Git and Github are not required for this course, but it is highly suggested you signup for github and start to use basic versioning for your source code.
- Exceptions, Recursion, generic classes and Iterators, and leveraging existing java 8 API.
- Introduces UML for the purpose of swarming a programming problem/feature.
- Introduction to unit testing with JUnit (pending software approval from school).
Basic Classes (1 week)
- Covers keywords, basic theory such as encapsulation, construction, and using.
Advanced Classes (1 week)
- Covers principles of declarative programming, Single use purpose, Open/Closed principle, DRY, immutable vs mutable objects, singleton classes.
Basic Inheritance (2 to 3 weeks)
- How to extend objects enforcing the DRY principle by leveraging proper abstractions
Introduction to Polymorphism (1 week)
- What is polymorphism and when and why to use it.
Advanced Inheritance (2 to 3 weeks)
- Leveraging Object inheritance for the purpose of polymorphism
Basic Interfaces (1 week)
- How to create and when to use interfaces.
Advanced Interfaces (2 to 3 weeks)
- How to use interfaces in polymorphism, applying the Interface segregation principle, and using java 8 lambdas in interfaces.
Advanced OOP Survey if time permits (0 to 4 weeks)
- Topics may include exciting concepts such as socket i/o, web, or modern tools such as 3rd party queues, Software-as-a-Service (Saas).