WeekB Flashcards

Question

interface

Answer 1

``` special type of class that can't be instantiated specify what a class must do but not how it does it lack instance variable * characterized by behavior * can mimic multiple inheritance w/ interfaces * classes can implements interface 0+ * interfaces can extend (inherit) other interfaces 0+ * All variable are implicitly static, public, and final (java8) ```

Answer 2

``` Animal Parent, Fish Child public abstract class Fish extends Animal{ ``` public abstract void swim(); }

Answer 3

``` public interface Hunt { void findPrey(); } ```

Answer 4

public class Shark extends Fish implements Hunt { @Override public void swim() { System.out.println("I'm swimming underwater and I'm terrifying"); } @Override public void breathe() { System.out.println("I breathe underwater, meeeeeegh"); } @Override public void findPrey() { System.out.println("I ate fishes!"); } }

Answer 5

public class Driver { ``` public static void main(String[] args) { Shark shark= new Shark(); shark.breathe(); shark.findPrey(); shark.swim(); ``` } }

Answer 6

Abstraction that either produces or consumes info. Types Character Stream Byte Stream

Answer 7

Human readable | FileReader and FileWriter

Answer 8

Machine readable, byte code, binary data FileInputStream and FileOutputStream For serializing (Serializable marker interface aka “tag”)

Answer 9

converting a Serializable Java object to a byte stream. ObjectInputStream - for serializing ObjectOutputStream - for serializing Serialized ID

Answer 10

keyword that marks a variable that will not be serialized | If there’s a field we don’t want to make Serializable, give it the transient modifier

Answer 11

is a way for Java to inspect itself at runtime * break encapsulation * contains methods for runtime inspection of objects * -Class of objects * -Fields * -methods * -Constructors * This can include private members * can modify and instantiate, call methods etc * java.land.reflect

Answer 12

Working requirement-by-requirement Designing tests to match those requirements Writing methods that will cause those tests to pass

Answer 13

``` For continuous integration (DevOps stuff) Types Service UI Unit Testing ```

Answer 14

A specialized tree structures, Binary tree Binary tree structure is each node has 2 children at most. Max heap is where the root node is the max value. Min heap is where the root node is the min value. There is a HeapSort algorithm.

Answer 15

Looks at the middle indice of the collection and then determine if the value you are looking for is greater than or less than that value, then move to either half depending on that result. Can only be preformed on ordered data structures

Answer 16

A type of polymorphism, parametric polymorphism(compile time) Looks like ArrayListx; x.add(5); Generics provides type safety i.e. it makes type errors occur at compile time rather than failing at runtime. Can have place holders for any type of value Standard conventions for placeholder values are KENTV •K for Key •E for element •N for number •T for Type •V for Value Generics is the ability to parameterize the types declared within the class that makes the class flexible.

Answer 17

``` AKA subtyping, a type of polymorphism(runtime). The ability to declare a variable as the parents type while assigning or instantiating that variable to its child type. Such as List xlist = new ArrayList(); Or Animal mon = new Monkey(); ```

Answer 18

It is an event that occurs during the execution of a program that disrupts the normal flow of the applications logic.

Answer 19

Unlike exceptions, errors are unrecoverable faults/events outside of the programs logic that halts the applicaction. Common Errors: StackOverflow, OutOfMemory

Answer 20

Are fault scenarios that the Java compiler forces you to handle. Examples: IOException, FileNotFoundException, SQLException, ClassNotFoundException

Answer 21

Are exceptions not checked at compile time, and are not forced to be handled by the compiler. It is common behavior in logic that can arise exceptions when executed. Examples: Arithmetic, NullPointer, ArrayIndexOutOfBounds

Answer 22

``` throw - How to manually trigger an Exception. throws - added to the method declaration to "Duck" the responsablitiy of handling a specific exception in that method Throwable- The root class in the exception class Heirarchy ```

Answer 23

* try{//risky logic}catch(Exception e){//recovery logic} * try{//risky logic}catch(Exception e){//recovery logic}finally{//logging and clean up logic} * try{//risky logic}finally{//logging and clean up logic}

Answer 24

it is a build tool and dependancy manager. Each project contains a file called a POM (Project Object Model), which is just an XML file containing details of the project. Some of these details might include project name, version, package type, dependencies, Maven plugins, etc.

Answer 25

``` Comparable interface is used to sort the objects with natural ordering. Comparator in Java is used to sort attributes of different objects. Comparable interface compares “this” reference with the object specified. Comparator in Java compares two different class objects provided. ```

Answer 26

It allows an object to be changed in to a form that allows it to be transfered over a ByteStream or network.

Answer 27

* Anything that can be used as the subject of an for each loop uses an iterator * AKA they implement the Iterable interface * every collection has an iterator that allows traversal between elements and * allows sage removal of elements in place

Answer 28

``` @BeforeClass @AfterClass @Before @After @Test ```

Answer 29

JUnit is a test framework which uses annotations to identify methods that specify a test.

Answer 30

Unit testing increases confidence in changing/ maintaining code. If good unit tests are written and if they are run every time any code is changed, we will be able to promptly catch any defects introduced due to the change. Codes are more reusable. In order to make unit testing possible, codes need to be modular. This means that codes are easier to reuse. The cost of fixing a defect detected during unit testing is lesser in comparison to that of defects detected at higher levels. Debugging is easy. When a test fails, only the latest changes need to be debugged. Codes are more reliable.

Answer 31

is a level of software testing where individual units/ components of a software are tested. A unit is the smallest testable part of any software. It usually has one or a few inputs and usually a single output. The purpose is to validate that each unit of the software performs as designed.

Answer 32

A process or a line of logic

Answer 33

A child process of the main parent thread's logic

Answer 34

concurrently running processies

Answer 35

•Marker - It is an empty interface (no field or methods). Examples of marker interface are Serializable, Clonnable and Remote interface. They provide run-time type information about objects. •Functional - It is an interface that contains only a single abstract (unimplemented) method. A functional interface can contain default and static methods which do have an implementation, in addition to the single unimplemented method.

Answer 36

a process or set of steps to solving a problem

Answer 37

Vectors are similar to ArrayLists in which they can be accessed by get and set methods and size dynamically. The only major differences is Vectors are thread-safe as opposed to ArrayLists. Which are not. Addittionally while an ArrayList increases its size by 50% each time it needs to. A Vector increases its size by 100%

Answer 38

/*methods * Basic Operations: * put,get, remove containsKey, containsValues, size and empty * Bulk Operations: * putAll, clear * Collection Views: * keySet, entrySet and values.

Answer 39

will print in alpha order

Answer 40

poll: returns and removes the element at the head of the container, returns null if empty. remove: will also return the value at the head of the queue and removes it, but will throw an exception if empty peek: allows you to see the head and return null element() method of Queue Interface returns the element at the front the container. It does not deletes the element in the container. This method returns the head of the queue. will throw an exception if empty

Answer 41

List, Set, Queue All interfaces in the Collection WHy? Array object within Java is limited. Mainly that the array is immutable and you're given not many methods to work with. Called a framework (more library), provides interface and classes that allow developers to more easily manage a group of objects. * Advantages: * Reduces effort (provides datastructure and algorithms for you) * Increase performance * Encourages software reuse * * BUT! * convert primitive values into object * ints -> Integer * boolean -> Boolean * byte ->Byte * The process of converting a primitive data types into its wrapper class is called boxing

Answer 42

A interface apart of the Collections API that extends from Queue and is a double ended Queue that can add and remove from both ends, FIFO and LIFO