revision_13_enthuware-most-missed-mock.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "feb16223",
   "metadata": {},
   "source": [
    "# Revision notes from Enthuware Most Missed Mock"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7862978e",
   "metadata": {},
   "source": [
    "## REMEMBER: when accessing methods & member fields/variables via a reference...\n",
    "...that the methods depend on the type of the __OBJECT__ but the fields/variables depend on the type of the __REFERENCE__."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "ac82c950",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "test.beaker.NewFooInterface"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "package test.beaker;\n",
    "\n",
    "interface NewFooInterface {\n",
    "    int fooNum = 0; // \n",
    "    public void fooMethod();\n",
    "}\n",
    "\n",
    "class NewFooClass implements NewFooInterface {\n",
    "    int fooNum = 5;\n",
    "    public void fooMethod() {\n",
    "        System.out.println(\"Incrementing fooNum...\");\n",
    "        this.fooNum++;\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "de8de44e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Incrementing fooNum...\n",
      "0\n",
      "6\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "null"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "package test.beaker;\n",
    "\n",
    "NewFooInterface nf = new NewFooClass(); // create a NewFooClass object but assign it to a NewFooInterface reference\n",
    "nf.fooMethod(); // calling the .fooMethod() calls that method from the NewFooClass object as methods depend on the type of the OBJECT (a NewFooClass object in this case)\n",
    "System.out.println(nf.fooNum); // printing .fooNum will print 0 since fields/variables depend on the type of the REFERENCE (a NewFooInterface reference in this case)\n",
    "System.out.println(((NewFooClass)nf).fooNum); // To prove that the fooMethod() call above worked we can cast nf to be NewFooClass and print the fooNum field from the object"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "990dd284",
   "metadata": {},
   "source": [
    "## Computed strings, string literals, and string constant across packages & classes\n",
    "Determining whether a string is referring to an existing String object, or a newly created string can be a little tricky especially when you include strings imported from different packages and strings created by concatenating variables & literals. Here are some rules worth remembering:\n",
    "1. Literal strings in the same class and package represent references to the __SAME__ String object\n",
    "2. Literal strings in different classes within the same package represent references to the __SAME__ String object\n",
    "3. Literal strings in different classes in different packages represent references to the __SAME__ String object\n",
    "4. Strings computed by **constant** expressions (for example by concatenating literals) are computed at compile time and treated as if they were literals\n",
    "5. Strings computed at __runtime__ are newly created and thus considered NEW\n",
    "6. Explicitly interning a computed string (using the `.intern()` method) is the same as a String literal (so if that literal already exists then it's the same object and not new)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "7d83c946",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "test.beaker.StringFoo"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "package test.beaker;\n",
    "\n",
    "class StringFoo {\n",
    "    static String myString = \"Hello\";\n",
    "}\n",
    "\n",
    "class StringFu {\n",
    "    static String myString = \"Hello\";\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "81072c5f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "true\n",
      "true\n",
      "true\n",
      "true\n",
      "false\n",
      "true\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "null"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "package test.beaker;\n",
    "\n",
    "String hello = \"Hello\";\n",
    "String hel = \"Hel\";\n",
    "String lo = \"lo\";\n",
    "System.out.println(hello == StringFoo.myString); // TRUE as we're variables holding the same existing string object\n",
    "System.out.println(hello == StringFu.myString); // TRUE same as above\n",
    "System.out.println(StringFoo.myString == StringFu.myString); // TRUE same as above\n",
    "System.out.println(hello == \"Hel\" + \"lo\"); // TRUE as we're comparing the variable holding one string object to a concatenation of two literals which results in the same string object\n",
    "System.out.println(hello == (hel + lo)); // FALSE as we're comparing the result of concatenating to runtime variables which results in a new String\n",
    "System.out.println(hello == (hel + lo).intern()); // TRUE as we're concatenating the variables BUT using .intern() to compare the literal within"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b5425470",
   "metadata": {},
   "source": [
    "## REMEMBER: integral literals with `e` in them are `double`s\n",
    "Scientific notation `e` in the middle of a large number represents a `double` literal."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "3ff86aef",
   "metadata": {},
   "outputs": [
    {
     "ename": "incompatible types",
     "evalue": " possible lossy conversion from double to float",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31mincompatible types: possible lossy conversion from double to float\u001b[0;0m",
      "\u001b[1;31m float f = 21e2\u001b[0;0m",
      "\u001b[1;31m           ^   ^ \u001b[0;0m"
     ]
    }
   ],
   "source": [
    "float f = 21e2; // error as 21e2 is a double literal not float"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b643d247",
   "metadata": {},
   "source": [
    "## REMEMBER: Numbers starting with `0x` are integral literals"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "1780607c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "null"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "char c = 0x12;\n",
    "int i = 0x4200;"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b58eb2d5",
   "metadata": {},
   "source": [
    "## When working with nested classes you can use `<outer-class>.this.<member>` to access the outer class members from within the inner class\n",
    "The `this` keyword is often used within a class method to refer to an instance of the class. However, you can in certain cases also combine `this` with the outer class name to refer to an instance of the outer class from within an inner/nested class."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "id": "8cb1bf6d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "test.beaker.OuterClass"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "package test.beaker;\n",
    "\n",
    "class OuterClass {\n",
    "    private String s = \"Hello\";\n",
    "    \n",
    "    class InnerClass { // this class is nested within OutClass thus, using the `this` keyword would refer to an instance of InnerClass\n",
    "        private String s = \"World\";\n",
    "        \n",
    "        String getS() {\n",
    "            return this.s; // here we use this.<member> to access the private String s\n",
    "        }\n",
    "        \n",
    "        String getOriginalS() {\n",
    "           return OuterClass.this.s; // this method belongs to InnerClass so how can we access the OuterClass' private String? By using OuterClass.this.<member>\n",
    "        }\n",
    "    }\n",
    "    \n",
    "    OuterClass() {\n",
    "        System.out.println( new InnerClass().getS());\n",
    "        System.out.println( new InnerClass().getOriginalS());\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "id": "782f8e37",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "World\n",
      "Hello\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "null"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "package test.beaker;\n",
    "\n",
    "OuterClass oc = new OuterClass();"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "46f578b0",
   "metadata": {},
   "source": [
    "## Lambda expressions do not create a new scope for variables\n",
    "This means that if you already have a variable declared within the same scope as your lambda you cannot re-use the same variable name within your lambda expression to refer to a different variable."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "65afa02c",
   "metadata": {},
   "source": [
    "## A `finally` block will always execute (unless `System.exit()` is called before execution)\n",
    "This means that even if your `try`/`finally` is nested within a loop and `break` is called before the `finally` would execute the finally will still complete."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "id": "719f2f28",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Inside try\n",
      "Inside finally\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "null"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "LOOP: {\n",
    "    try {\n",
    "        System.out.println(\"Inside try\");\n",
    "        break LOOP; // break LOOP within the try block, since the try/catch/finally is nested within LOOP does this prevent finally from execiting?\n",
    "    }\n",
    "    catch(Exception e) {\n",
    "        System.out.println(\"Inside catch\");\n",
    "    }\n",
    "    finally {\n",
    "        System.out.println(\"Inside finally\");\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d5ca3980",
   "metadata": {},
   "source": [
    "## REMEMBER: Implicit narrowing occurs when assigning `int` literals to `short`, `byte`, and `char` providing the int value fits within\n",
    "This also means that a method with a return type of `byte`, `short`, or `char` can return an `int` literal as long as the value fits within the type it's being returned as."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "id": "c81111dd",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "com.twosigma.beaker.javash.bkr4a6125b5.Narrower"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class Narrower {\n",
    "    public byte intToByte() {\n",
    "        return 4; // 4 here is an int literal but the compiler won't object due to implicit narrowing\n",
    "    }\n",
    "    \n",
    "    public short intToShort() {\n",
    "        return 64; // 64 here is an int literal...\n",
    "    }\n",
    "    \n",
    "    public char intToChar() {\n",
    "        return 200; // 200 here is an int literal...\n",
    "    }\n",
    "    \n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9c5ab611",
   "metadata": {},
   "source": [
    "## REMEMBER: When overriding a method, the overriding version of the method must return the __EXACT__ type in the case of primitives\n",
    "Or, co-variant return types in the case of classes/objects."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "id": "0793a96a",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "ename": "ERROR",
     "evalue": " java.lang.IllegalStateException",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31mERROR: java.lang.IllegalStateException: returnLong() in com.twosigma.beaker.javash.bkr4a6125b5.PrimitiveOverrider cannot override returnLong() in com.twosigma.beaker.javash.bkr4a6125b5.PrimitiveReturner\u001b[0;0m",
      "\u001b[0;31m  return type short is not compatible with long\u001b[0;0m",
      "\u001b[0;31m public short returnLong() { return 12; }\u001b[0;0m",
      "\u001b[0;31m ^                                       ^ \u001b[0;0m"
     ]
    }
   ],
   "source": [
    "class PrimitiveReturner {\n",
    "    public long returnLong() {\n",
    "        return 12L;\n",
    "    }\n",
    "}\n",
    "\n",
    "class PrimitiveOverrider extends PrimitiveReturner {\n",
    "    public short returnLong() { // will cause a compile error as we're trying to return a different primitive type to the original method\n",
    "        return 12;\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7e0b2c88",
   "metadata": {},
   "source": [
    "## String's `.charAt()` method can take a `char`, `short`, or `short` as each will be implicitly promoted to `int`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "id": "b1cb8ef6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "H\n",
      "e\n",
      "l\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "null"
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "String s = \"Hello\";\n",
    "char c = 0;\n",
    "byte b = 1;\n",
    "short sh = 2;\n",
    "\n",
    "System.out.println(s.charAt(c));\n",
    "System.out.println(s.charAt(b));\n",
    "System.out.println(s.charAt(sh));"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5ea97803",
   "metadata": {},
   "source": [
    "## REMEMBER: Wrapper-classes constructor will automatically parse a valid string passed\n",
    "Since the wrapper classes have `.parse<type>()` and `.<type>Value()` (e.g. `.parseInteger()`, `.longValue()`)methods it can be easy to think that you must use one of these when passing a string to a wrapper's constructor but the classes include an overloaded constructor for string arguments and thus you can simply pass a valid string directly to the constructor.\n",
    "\n",
    "__NOTE__: `.parse<type>()` methods are *static* and can be called directly from the class but `<type>Value()` are *non-static* and thus require an instance."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "id": "73a49551",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "12\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "null"
      ]
     },
     "execution_count": 85,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "int i = new Integer(\"12\");\n",
    "System.out.println(i);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "97a8a3ec",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Java",
   "language": "java",
   "name": "java"
  },
  "language_info": {
   "codemirror_mode": "text/x-java",
   "file_extension": ".java",
   "mimetype": "",
   "name": "Java",
   "nbconverter_exporter": "",
   "version": "1.8.0_121"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": false,
   "sideBar": false,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": false,
   "toc_window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}