Java Flashcards

Question

For Each Loop

Answer 1

``` for (int i : myArray){ // i = element not index } ```

Answer 2

java. lang - fundamental classes i.e. String etc. - this package is imported by default java. util - Datastructures java. io - read/write java. net - networking java. sql - databases https://docs.oracle.com/javase/8/docs/api/

Answer 3

naming - reverse domain name | com.foo.application.package

Answer 4

``` wrong way to create strings String s = new String() String s = new String("Hello World.....") ``` recommended way String s = "hello world" => this allows the strings to be stored in the string pool. The pool does not duplicate strings which have the same values, hence saves memory - strings are IMMUTABLE StringBuilder => allows us to mutate strings

Answer 5

``` class A{} => only accessible inside the package public class B{} => accessible inside and outside class ``` ``` class C{ int i; => accessible only inside the class private int j; => accessible only inside the class protected int k; => accessible to package and subclasses public int k; => accessible inside and outside the class } ``` - you can use getters and setters to access variables which are private

Answer 6

Encapsulation | Polymorphism

Answer 7

- useful in situations where all methods are static - so we cannot instantiate the class i. e. Hello.sayHello() can be called ``` class Hello{ private Hello(){} static String sayHell(){} static String greet(){} } ```

Answer 8

static variables - need to be declared at the class level and not method level - can only be - can be accessible from static methods or instance methods static method - can only access static variables

Answer 9

static initializer ``` class MyClass{ static int count; static { count = 100; } MyClass(){ ``` } } ``` instance initializer - java copies this code inside every constructor == class MyClass{ int count; { count = 100; } MyClass(){ ``` } }

Answer 10

- if value is primitive type then value cannot be changed - if value is Class type, then the reference cannot change but the object can change - they cannot have a default value and need to get initialized in constructor ``` final instance variable == class Hello{ final int id; ``` Hello(){ id = 10; } } ``` final local variable == void sayHello(final String name){ name = "fooo"; // compiler error } ``` final static variable == static final int MAX_VAL = 100;

Answer 11

- its value is know at compile time (not at run time) - compiler can replace the variable with the actual value - data type needs to be a primitive or string - initialized when its declared eg. final int i = 4

Answer 12

``` boxing - converting primitive types to class types unboxing - converting class types to primitive ``` boxing void foo(Integer id) foo(10) ``` unboxing void foo(int id){} foo(new Integer(10)) ``` primitives should be used instead of boxed values since they are faster

Answer 13

- class can extend only one other class - multiple inheritance is not possible ``` private - only class can access it, inherited members cannot default - only package classes can access public - anybody can access it protected - like default but also provides access to subclasses outside of the package ``` IS a test - use inheritance HAS a test - use composition

Answer 14

supertype can be assigned to any of its subtype void foo(Employee c){} ``` foo(new Manager()) foo(new Sales()) ``` both sales and manager inherit from Employee ``` Employee e = new Sales() Employee => reference type Sales => object type ``` compiler looks at the reference type when invoking any function first it will try to check is method is available in Sales class if not then it will try its base class, so on and so forth. *** we can only invoke methods that are defined in the superclass i.e. cannot invoke methods that are specific to the subclass

Answer 15

compile time type checking - static type checking | run time checking - dynamic type checking

Answer 16

1. add new behavior 2. extend behavior 3. provide better implementation rules: overriding method needs to have same parameters and return type overriding method cannot be less accessible - static methods cannot be overriden

Answer 17

early binding - compile time binding - static methods late binding - runtime binding - instance methods

Answer 18

``` class Employee{ static A() void B() } ``` ``` class Principal extends Employee { static A() void B() } ``` void foo(Employee e){ e.A() => invokes Employee method e.B() => invokes Principal method }

Answer 19

- mother of all classes - all classes are inherited from this class common methods - toString() - hashCode() - objects memory address - equals(Object) - compares current object with the one which is passed into the method. It used == comparator - final getClass() gets meta information of the class i.e. class name, super class name etc. - this is a final method - protected clone() returns a copy of this object

Answer 20

need to provide a way for sub class constructor to invoke superclass const ``` class Person{ Person(int id){} } ``` ``` class Employee extends Person{ Employee(int id){} } ``` generates compiler error since compiler cannot instantiate default constructor without any id ``` this will fix the issue: == class Employee extends Person{ Employee(int id){ super(id) } } ```

Answer 21

why? - want to keep functionality intact - want to prevent class semantics (invariants) how to == 1. private constructor - all methods need to static, since that class will be non instantiable i.e. Math i.e. could be used in utility classes since it can save heap space because the class will not be instantiated 2. make class final - class will be instantiable but not extendible i. e. String

Answer 22

- cannot be instantiated - can only be extended - subclass needs to provide implementation to all abstract methods or it also needs to be an abstract class - if a class has a single abstract method, the class needs to be marked as abstract - abstract classes can have concrete method ``` abstract class Person{ abstract void foo(); void bar(){ } } ```

Answer 23

- can only have public or default access modifier - all members are public - can only have abstract functions ``` interface Scary { void scarePeople(); } ``` ``` class Ghost implements Scary{ void scarePeople(){ ``` } } Types: 1. Representative - provides core functionality 2. Mixins - provides additional functionality

Answer 24

Abstract - provide core functionality with state | Interface - provide additional behavior

Answer 25

``` void foo(ArrayList l) void foo(List l) => this is better implementation since now we can pass any class which inherits List i.e. LinkedList, TreeList etc ```

Answer 26

- they do not have any method declaration - useful to suggest to user that this class does something i.e. Serializable, Cloneable etc. you can check if a class is implementing a particular interface using the following. myClass isInstanceOf Serializable

Answer 27

- methods implemented in interface so classes don't have to implement them. - mostly used if you want to change interface after it has been implemented interface foo{ default void bar(){} }