Forem: Greg Ross

OOP Principles

Greg Ross — Wed, 17 Nov 2021 17:23:38 +0000

oop outline

Building Blocks

Objects

An object is an entity that has states and behaviors.

Classes

A class is a template or blueprint from which objects are created.

Main Principles

Encapsulation

Encapsulation is a process of wrapping code and data together into a single unit.

Inheritance

Inheritance is a mechanism in which one object acquires all the states and behaviors of a parent object.

Abstraction

Abstraction is a process of hiding the implementation details and showing only functionality to the user.

Interface

An interface is a blueprint of a class.

Polymorphism

Polymorphism is the ability of an object to take on many forms.

Method overloading

If a class has multiple methods that have same name but different parameters, this is known as method overloading.

Method overriding

If a subclass has the same method as declared in the super class, this is known as method overriding.

Collections

Greg Ross — Wed, 10 Nov 2021 03:15:55 +0000

General idea without bloat of additional coding methods

Structures of Data

Ways to store information in an ordered manner so the data can be called upon when needed. The values can be referenced by index or iterated over where additional processing could be performed.

Common Sequences

Arrays

int[] wholeNumbers = new int[5]; // [item, item, item, item, item]            
String[] words = new String[5];  // [item, item, item, item, item]

Lists

import java.util.List;
import java.util.ArrayList;

List<String> listOfideas = new ArrayList<>();
listOfideas.add("serendipity");
listOfideas.add("synchronicity");
listOfideas.add("determinism");
System.out.println(listOfideas);

List<Integer> listOfWholeNumbers = new ArrayList<>(); 
listOfWholeNumbers.add(5);
listOfWholeNumbers.add(15);
listOfWholeNumbers.add(51);
System.out.println(listOfWholeNumbers);

Documentation

List Interface
ArrayList Class

Associative Arrays

Using key:value pairs. Values can be accessed by calling the key of the associated value. Versus where you could need to loop over the entire collection to find the desired value.

import java.util.Map;
import java.util.HashMap;

Map<String, Boolean> animals = new HashMap<String, Boolean>();

animals.put("dog", true);
animals.put("libera", false);
animals.put("girazelle", false);
animals.put("cat", true);

System.out.println(animals);

Documentation

Map Interface

Others

Beyond the scope of my journal

Stack<T>, Queue<T>, Set<T>

Loops

Greg Ross — Thu, 04 Nov 2021 05:14:35 +0000

Computer science concepts in my lingo.

Iterate

What makes computers useful is the ability to perform repetitive tasks. Repeatable conditions to do time and time again while something is true.

int condition = 0;
do {
  System.out.println(condition);
  condition++;
}
while (condition < 5);

int condition = 0;
while (condition < 5) {
  System.out.println(condition);
  condition++;
}

Self perpetuating machine

Knowing what your looking for but do not know exactly how many times or possibilities exist while searching? No worries the collection length or size can realize the unknown to find what you are checking for.

int[] nums = {5, 10, 15, 20};
for (int iterator = 0; iterator < nums.length; iterator++) {
  System.out.println(iterator);
}

String[] people = {"Roy", "Gee", "Biv", "Mazza"};
for (String eachPerson : people) {
  System.out.println(eachPerson);
}

Practical Use Case

  int[] trackGrades = {89, 93, 65, 68}; 

  int sum = 0; // the sum of all the grades

  for(int i = 0; i < trackGrades.length; i++) {
      sum = sum + trackGrades[i];  // add each grade to sum
    }

  int average = sum / trackGrades.length;

  System.out.println(average);

Conditional Logic

Greg Ross — Wed, 03 Nov 2021 03:58:15 +0000

Computer science concepts in my words.

If this, then that

Evaluating data based on a defined reason either allows the information to undergo additional computation or bypasses that circumstance until a certain condition is met or else. Pun intended.

if (condition) {
    run code 
}

if (condition) {
    run code
} else {
    run code
}

Checks

Maintaining sanity in a chain of commands starts with prioritizing the most important first. The data can be cascaded from one block to another until nothing checks true.

if (condition) {
    run code
} else if (other condition) {
    run code
} else if (other condition 2) {
    run code
} else {
   run code
}

Statements

The conditions that are checked are evaluated based on the expressions stated. An oversimplification would be a simple yes or no. Meaning true or false. Yes you can pass or no do not pass.

boolean lessThan = a < b; 
boolean lessThanOrEqual = a <= b;

boolean greaterThan = a > b;
boolean greaterThanOrEqual = a >= b;

boolean equal = a == b;
boolean notEqual = a != b;

More Complex

In addition to a daisy chain of if/else blocks. The conditions being evaluated can be intrinsically linked together and complicated.

int ohThis = 7; 
int that = 13; 

boolean and = (ohThis == 7 && that == 13); 
boolean or = (ohThis == 7 || that == 13); 

boolean isTrueAndTrue = (ohThis >= 10 && ohThis <= 15) && (that >= 10 && that <= 15);
boolean isTrueOrFalse = (ohThis >= 10 && ohThis <= 15) || (that >= 10 && that <= 15);

Data Types

Greg Ross — Sun, 31 Oct 2021 16:29:08 +0000

Declaring Information

New to Java and statically typed languages. So needing to declare every single instance of data was a foreign concept at first. Conceptually this approach is logical. You need to know exactly the type of data you want to call and exactly what kind of data you want to return.

int numberOfToads = 5; 
double costOfGroceries = 23.21;
boolean isReal = false;
String letters = 'info'; 
char lastLetter = 'o';

Type Casting

Changing one data's value into another data type.

int wholeNumber = 8; 
double decimalNumber = wholeNumber; // 8.0

Two styles of casting

1 Widening: automatic conversion from small to larger type

// byte -> short -> char -> int -> long -> float -> double

2 Narrowing: manual conversion from larger to smaller type

// double -> float -> long -> int -> char -> short -> byte

Evaluate Expressions

Performing calculations on data. Fundamental math rules apply.

int total; 
total = 4 + 4;     // addition
total = total - 3; // subtraction
total = total * 5; // multiplication
total = total / 5; // division 
total = total % 3; // remainder of

Real Use Case

int player1 = 75;
int player2 = 87;
int player3 = 92;

int averagePoints = (player1  + player2  + player3 ) / 3;  
double averagePoints = (player1  + player2  + player3 ) / 3.0;

Imposter Syndrome

Greg Ross — Sat, 30 Oct 2021 03:55:46 +0000

Healthy Imagination

Not sure why developers struggle feeling like fakes. All people pretend till they become what they imagine. If no creative action is taking then it’s just fantasy.

Willingness

The dedication developers put into understanding abstract computer science concepts is so admirable. From recognizing patterns to abstracting away implementations of interfaces for returning possible values. People capable of explaining their thoughts and ideas in syntax foreign to the common person.

Definitely Real

We are not imposters. There’s nothing delusional about taking actionable advances to become the idea you hold in your head about yourself.

Change

Expressing the concerns, worries, and fears along the way makes me believe your anything but an imposter.

418 I'm a teapot

Greg Ross — Fri, 29 Oct 2021 03:32:34 +0000

Status Codes

Learned of the 418 response error today. Better known as “I’m a teapot”.

Pranksters

A reference to Hyper Text Coffee Pot Control Protocol where if the server denies a request to brew coffee. It is in fact definitely a teapot.