revision_11_enthuware-mock-6.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "9ed83b92",
   "metadata": {},
   "source": [
    "# Revision notes from Enthuware Mock Test 6"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6940625c",
   "metadata": {},
   "source": [
    "## `Period`'s `of...` methods are *static*\n",
    "The `Period` class has methods such as `.ofMonths()` and `.ofDays()` but these are *static* methods and cannot be chained. So, for example `Period.ofMonths(2).ofDays(12)` will return `12 days` only as that's the last method called on the class."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "68ebbe94",
   "metadata": {},
   "source": [
    "## To get a period of multiple inputs (days *and* months *and* years) you can use the `.of(int years, int months, int days)` method\n",
    "This method will provide an *instance* based on the passed arguments."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "19a96402",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2011-01-17\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "null"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import java.time.*;\n",
    "\n",
    "LocalDate ld = LocalDate.of(2010, 11, 5);\n",
    "ld = ld.plus(Period.of(0, 2, 12));\n",
    "System.out.println(ld);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "99589bf4",
   "metadata": {},
   "source": [
    "## Exceptions are a mechanism for...\n",
    "...among other things:\n",
    "- Determining what to do when something unexpected happens\n",
    "- Logging unexpected behaviour"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "57ac5768",
   "metadata": {},
   "source": [
    "## Any exception thrown in a *static initializer block* will be wrapped into an `ExceptionInInitializerError` which will then be thrown\n",
    "So, even if you get a `RuntimeException` in your initializer block the exception output will actualy be an `ExceptionInInitializerBlock`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "887f6128",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "test.beaker.InitErrorExample"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "package test.beaker;\n",
    "\n",
    "class InitErrorExample {\n",
    "    static int[] ia = new int[0];\n",
    "    static int x;\n",
    "    static {x=ia[1];} // cause an ArrayIndexOutOfBounds error within the static initializer\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "d890c335",
   "metadata": {},
   "outputs": [
    {
     "ename": "ERROR",
     "evalue": " java.lang.ExceptionInInitializerError",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31mERROR: java.lang.ExceptionInInitializerError\u001b[0;0m"
     ]
    }
   ],
   "source": [
    "package test.beaker;\n",
    "\n",
    "InitErrorExample iee = new InitErrorExample(); // even though the error raised in the initializer was ArrayIndexOutOfBounds the output will show ExceptionInInitializerError"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "46fcae0c",
   "metadata": {},
   "source": [
    "## *static* and *instance* initializer blocks can only throw `RuntimeException`s by default\n",
    "If you try to throw a checked exception from within an a initializer block your code will not compile.\n",
    "\n",
    "However, you can throw a checked exception from an *instance* initializer __IF__ you first declare that the constructor(s) of the class `throw` that exception."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "81808383",
   "metadata": {},
   "source": [
    "## If the the left-hand operand of a binary operator completes abruptly, no part of the right-hand operand will be evaluated\n",
    "If you're assigning the outcome of an operation to a variable and the left-hand side of the operation ends abruptly (e.g. due to an exception) then any operations in the right-hand part will not complete."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "330e5c09",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "null"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "int a = 0; // assign a to be zero\n",
    "try {\n",
    "    int b = (5/a) + (++a); // increment a as part of the right hand side of the operation\n",
    "}\n",
    "catch (Exception e) { // catch the exception thrown by zero division in the above operation\n",
    "    System.out.println(a); // print a to see if it was successfully incremented\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7d60a3a8",
   "metadata": {},
   "source": [
    "## `protected` variables are inherited by any class which extends the original in a different package...\n",
    "..but it cannot be modified via an instance of the original class (it CAN be modified via an instance of the child class though). The protected variable can also be modified from any class within the same package."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ea480151",
   "metadata": {},
   "source": [
    "## The `.equals()` method of wrapper-classes will always return `true` if passed the same instance on which it's called\n",
    "For example, if you have an `Integer` `a` and you call `a.equals(a);` the output will always be `true`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "593ef8f0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "true\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "null"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Integer i = new Integer(5);\n",
    "System.out.println(i.equals(i));"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "833d108c",
   "metadata": {},
   "source": [
    "## The `.equals()` method of wrapper-classes will return `false` if the refernces being compared refer to...\n",
    "..instances of *different* classes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "3f6d035e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "false\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "null"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "byte b1 = 1;\n",
    "Byte b = new Byte(b1);\n",
    "Float f = new Float(1f);\n",
    "System.out.println(b.equals(f));"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9e0b77c8",
   "metadata": {},
   "source": [
    "## The *access-modifer* and *non-access modifer* keywords can be used in any order\n",
    "Java will not object if you switch the order. For example, both `public static void main` and `static public void main` are perfectly fine."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "78fd3ac9",
   "metadata": {},
   "source": [
    "Q53"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b7f5c511",
   "metadata": {},
   "source": [
    "## Java allows *multiple inheritance of type* but NOT *multiple inheritance of state*\n",
    "Multiple inheritance of *type* refers to the fact that a class can implement multiple interfaces (interfaces are a *type*). However, interfaces do not have any *state* as they can't be instantiated. Only classes contain *state* and you cannot extend multiple classes. Therefore, Java only allows *single inheritance of state*."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cea8f4f4",
   "metadata": {},
   "source": [
    "## Passing an `int` to `StringBuilder`'s constructor will create an empty stringbuilder with an initial capacity of the int value\n",
    "*StringBuilder* includes a `public StringBuilder(int capacity)` constructor which will allow you to create a StringBuilder by passing an `int` value to the constructor. This creates an empty stringbuilder but with a capacity matching the int value that was passed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7c3987ea",
   "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
}