chapter1-java-basics.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Java Basics"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Section 1. Introduction to Java"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The majority of you may have taken CSCI 141 prior to taking this course. As a result, we will start introducing Java by comparing some key differences between Python (the language you learned in CSCI 141) and Java. If you have little coding experience in Python, you can still get a sense of programming paradigm in Java.\n",
    "\n",
    "The first major difference between Python and Java is that Java is a statically typed and Python is dynamically typed. In other words, when you write code in Python, you don't need to define data types when initializing or declaring variables or functions. However, you must do so in Java. For instance, if you want to declare an integer variable with value as 5 and print it out, we need to do this in Java:\n",
    "\n",
    "```\n",
    "int var = 5;\n",
    "System.out.println(var);\n",
    "```\n",
    "\"int\" is the data type of variable named var, and it has to be specified before the appearance of the variable.\n",
    "\n",
    "\n",
    "The second major difference lies in the supported programming paradigm. Python supports functional, imperative, and procedural programming paradigms. Java was designed as an object-oriented, concurrent, and class-based programming language. Although Java has been evolving and started supporting lambda expression since Java 8, it is still considered an object-oriented language by most developers. For a better understanding of Object-Oriented Programming, please refer to Section 2.\n",
    "\n",
    "Some small syntactical differences include semicolon and denoting code blocks. Every statement in Java needs to end with a semicolon. For instance, if you want to declare an integer variable with value as 5, increment it by 3, and print it out, we need to do this in Java:\n",
    "```\n",
    "int var = 5;\n",
    "var = var + 3;\n",
    "System.out.println(var);\n",
    "```\n",
    "\n",
    "Python uses whitespaces to denote code blocks, while Java uses brackets to denote code blocks. For instance, if we want to declare an integer variable with value as 5, keep incrementing it by 3 for 10 times using a while loop, and print it out, we need to do this in Java:\n",
    "```\n",
    "int var = 5;\n",
    "int i = 0;\n",
    "while (i < 10) {\n",
    "  var = var + 3;\n",
    "  i = i + 1;\n",
    "}\n",
    "System.out.println(var);\n",
    "```\n",
    "\n",
    "The following are some code samples (including the above ones) you may want to play with. Note that multiple code sections are organized in one code cell, so you may need to keep one section uncommented each time when you run it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n",
      "8\n",
      "35\n",
      "1024\n"
     ]
    }
   ],
   "source": [
    "// print var with value of 5\n",
    "int var = 5;\n",
    "System.out.println(var);\n",
    "\n",
    "// add 3 to 5 and print\n",
    "int var = 5;\n",
    "var = var + 3;\n",
    "System.out.println(var);\n",
    "\n",
    "// add 3 to 5 for 10 times\n",
    "int var = 5;\n",
    "int i = 0;\n",
    "while (i < 10) {\n",
    "  var = var + 3;\n",
    "  i = i + 1;\n",
    "}\n",
    "// print\n",
    "System.out.println(var);\n",
    "\n",
    "//multiply 2 to 1 for 10 times\n",
    "int base = 1;\n",
    "int i = 0;\n",
    "while (i < 10) {\n",
    "  base = base * 2;\n",
    "  i = i + 1;\n",
    "}\n",
    "// print\n",
    "System.out.println(base);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The data types that you can directly initialize and declare are called primitive data types. Some most frequently used primitive data types include:\n",
    "\n",
    "* int\n",
    "* char\n",
    "* double\n",
    "* boolean\n",
    "\n",
    "To initialize a variable with a primitive data type, you simply need to say \"dataType variableName\":\n",
    "```\n",
    "// example 1\n",
    "int var;\n",
    "var = 5;\n",
    "\n",
    "// example 2\n",
    "char var2 = 'd';\n",
    "\n",
    "// example 3\n",
    "double var3 = 3.1;\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Section 2. Object-Oriented Programming"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The paradigm of object-oriented programming is for the convenience of designing and developing large-scale projects. Imagine that you have over 100 functions listed one after another, it will make the maintenance and upgrade difficult and time-consuming. Object-Oriented Programming is a systematic approach to making the design and development manageable.\n",
    "\n",
    "Two major concepts of object-oriented programming include:\n",
    "\n",
    "* Class: A class is a template that describes the behavior/state of its objects\n",
    "* Object: An instance that is cast from its Class; an object has states and behaviors\n",
    "\n",
    "For instance, suppose that we are developing a scalable smart car system. The implementation of the system can be a class named \"SmartCar\". There would be many methods defined underneath this class:\n",
    "\n",
    "```\n",
    "public class SmartCar {\n",
    "    // method 1\n",
    "    public void autoPilot() { // ... }\n",
    "    \n",
    "    // method 2\n",
    "    public void smartBreak() { // ... }\n",
    "    \n",
    "    // many methods\n",
    "}\n",
    "```\n",
    "\n",
    "When the system is actually being used in a real car, we need to initialize an object from the class we developed and call its method through the object:\n",
    "\n",
    "```\n",
    "SmartCar car1 = new SmartCar();\n",
    "if (theOwnerSaySo) {\n",
    "    car1.autoPilot();\n",
    "}\n",
    "```\n",
    "Now let's make the above code work as real code first. The methods would do nothing except for printing their purposes out."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Autopilot starts now.\n",
      "Stop if the car is about to hit something.\n"
     ]
    }
   ],
   "source": [
    "// define the class\n",
    "public class SmartCar {\n",
    "    // method 1\n",
    "    public void autoPilot() {\n",
    "        System.out.println(\"Autopilot starts now.\");\n",
    "    }\n",
    "    \n",
    "    // method 2\n",
    "    public void smartBreak() {\n",
    "        System.out.println(\"Stop if the car is about to hit something.\");\n",
    "    }\n",
    "    \n",
    "    // many methods\n",
    "}\n",
    "\n",
    "// some basic testing\n",
    "SmartCar car1 = new SmartCar();\n",
    "boolean theOwnerSaySo = true;\n",
    "if (theOwnerSaySo) {\n",
    "    car1.autoPilot();\n",
    "    car1.smartBreak();\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are three things we need to cover from the above-given code, including\n",
    "\n",
    "* Reference Data Type\n",
    "* Methods\n",
    "* how you do basic testing right\n",
    "\n",
    "Technically speaking, any data that are not with primitive data types are considered reference data in Java. For now, you only need to understand that the initialization and declaration process for reference data is different from that of primitive data. To initialize a reference data typed variable, you need to use the keyword \"**New**\". For instance, Random is a Reference data type that is provided to you in Java. You can use it to generate random numbers:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "24"
     ]
    }
   ],
   "source": [
    "import java.util.Random;\n",
    "// initialize a Random object\n",
    "Random rand = new Random();\n",
    "// get a number between [0 - 49].\n",
    "int num = rand.nextInt(50);\n",
    "System.out.print(num);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Just in case you are not familiar with the concept of functions/methods, a method serves as a black box that performs a certain task. A method can be defined to accept parameters (i.e., variables). Depending on the values of the given parameters, the method may return different results. Please note that data types of both returned results and parameters of a method need to be clearly specified. For instance, we can try to make a method that returns the square of a given integer:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "25\n",
      "100\n"
     ]
    }
   ],
   "source": [
    "// purpose: calculate the square of a given number\n",
    "// input: an integer\n",
    "// return: an integer\n",
    "public int square(int input) {\n",
    "    int result = input * input;\n",
    "    return result;\n",
    "}\n",
    "\n",
    "// insanity check\n",
    "System.out.println(square(5));\n",
    "System.out.println(square(10));"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When it comes to testing, things will be a bit different from the environment of Jupyter Notebook. You can see the result immediately without manually compiling your Java code here. However, outside of the environment of Jupyter Notebook, you have to compile your code first and then run the generated Java bytecode. Additionally, the main method is required for any executable Java program. In other words, when it comes to testing, you may need a class that comes with the main method. Let's revamp the testing of our SmartCar class defined above."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "// define the class -- SmartCar.java\n",
    "public class SmartCar {\n",
    "    // method 1\n",
    "    public void autoPilot() {\n",
    "        System.out.println(\"Autopilot starts now.\");\n",
    "    }\n",
    "    \n",
    "    // method 2\n",
    "    public void smartBreak() {\n",
    "        System.out.println(\"Stop if the car is about to hit something.\");\n",
    "    }\n",
    "    \n",
    "    // many methods\n",
    "}\n",
    "\n",
    "// testing in real world -- SmartCarTest.java\n",
    "public class SmartCarTest {\n",
    "    \n",
    "    public static void main(String[] args) {\n",
    "        // some basic testing\n",
    "        SmartCar car1 = new SmartCar();\n",
    "        boolean theOwnerSaySo = true;\n",
    "        if (theOwnerSaySo) {\n",
    "            car1.autoPilot();\n",
    "            car1.smartBreak();\n",
    "        }\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the environment of Jupyter Notebook, the above code will not output anything. However, you are strongly recommended to try out the above code in two separate java files, compile them together, and execute the Java bytecode. The following examples can further demonstrate the differences between the environment of coding inside and outside Jupyter Notebook. You may need to comment out one to see their effects separately."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, world!\n"
     ]
    }
   ],
   "source": [
    "// this does not output anything here\n",
    "// but works fine inside a java file named Hello.java\n",
    "public class Hello{\n",
    "    public static void main(String[] args) {\n",
    "        System.out.println(\"Hello, world!\");\n",
    "    }\n",
    "}\n",
    "\n",
    "// this only works here\n",
    "System.out.println(\"Hello, world!\");"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Section 3. Conditional Execution and Loops"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The conditional execution in Java is similar as in Python, but Java uses brackets and indentation instead of whitespeaces to denote code blocks. The demonstration of if/else conditional execution is:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The number 15 is an odd number.\n",
      "The number 22 is an even number.\n"
     ]
    }
   ],
   "source": [
    "// this method prints out if a number is even or odd\n",
    "// input - integer\n",
    "// output - none\n",
    "public void numberDecider(int num) {\n",
    "    if (num % 2 == 0) { // modular\n",
    "        System.out.println(\"The number \" + num + \" is an even number.\");\n",
    "    } else {\n",
    "        System.out.println(\"The number \" + num + \" is an odd number.\");\n",
    "    }\n",
    "}\n",
    "\n",
    "// testing\n",
    "numberDecider(15);\n",
    "numberDecider(22);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If there are more than two conditions, if/else if/else will be needed. Consider the following problem:\n",
    "```\n",
    "Write a short program that prints each number from 1 to 100 on a new line. \n",
    "For each multiple of 3, print \"Fizz\" instead of the number. \n",
    "For each multiple of 5, print \"Buzz\" instead of the number. \n",
    "For numbers which are multiples of both 3 and 5, print \"FizzBuzz\" instead of the number.\n",
    "\n",
    "```\n",
    "More than 2 conditions are specified. The solution to this problem will need the help of \"else if\":"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "FizzBuzz\n",
      "Fizz\n",
      "Buzz\n"
     ]
    }
   ],
   "source": [
    "// FizzBuzz solver\n",
    "// input - integer\n",
    "// output - none\n",
    "public void fizzBuzz(int num) {\n",
    "    if (num % 3 == 0 && num % 5 == 0) {\n",
    "        System.out.println(\"FizzBuzz\");\n",
    "    } else if (num % 3 == 0) {\n",
    "        System.out.println(\"Fizz\");\n",
    "    } else if (num % 5 == 0) {\n",
    "        System.out.println(\"Buzz\");\n",
    "    }\n",
    "}\n",
    "\n",
    "// testing\n",
    "fizzBuzz(30);\n",
    "fizzBuzz(33);\n",
    "fizzBuzz(35);\n",
    "fizzBuzz(2);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You may notice the usage of \"&&\" from the above code snippet. \"&&\" is a logical operator that stands for \"and\". The two most commonly used logical operators include:\n",
    "\n",
    "* && --- and\n",
    "* || --- or\n",
    "* == --- check equivalence\n",
    "\n",
    "The concept of loops is the same regardless of programming languages. The syntax of while loop is very similar in Java as in Python. Here is a demonstration:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "25"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "// power function\n",
    "// input - int base, int power\n",
    "// output - int base power to \"power\"\n",
    "public int power(int base, int power) {\n",
    "    int i = 0, result = 1;\n",
    "    while (i < power) {\n",
    "        result *= base;\n",
    "        i += 1;\n",
    "    }\n",
    "    return result;\n",
    "}\n",
    "\n",
    "// testing\n",
    "power(5, 2);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You may notice from the above code snippet:\n",
    "```\n",
    "result *= base;\n",
    "```\n",
    "This is essentially the same as written in:\n",
    "```\n",
    "result = result * base;\n",
    "```\n",
    "The same can be said for \"i += 1\".\n",
    "\n",
    "The syntax of for loop in java might be slightly different from in Python. Here are two demonstrations. You may need to comment out one section to see the other being executed:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n",
      "1 2 3 4 5 \n"
     ]
    }
   ],
   "source": [
    "// section 1\n",
    "int result = 0;\n",
    "for (int i = 0; i < 5; i++) {\n",
    "    result += 1;\n",
    "}\n",
    "System.out.println(result);\n",
    "\n",
    "// section 2\n",
    "int[] arr = {1, 2, 3, 4, 5}; // this is an array and we will cover it in future chapters\n",
    "for (int num : arr) {\n",
    "    System.out.print(num + \" \");\n",
    "}\n",
    "System.out.println();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Practices\n",
    "\n",
    "Based on the above content and knowledge covered in lectures, you should be able to solve the following listed problems. Please note that **you are strongly recommended to solve the problems by yourself first before you look at the provided solutions**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Multiply two integers together\n",
    "\n",
    "Assume a user inputs two integers x and y.  Without using a * operator, compute their product and print it.  Do not use any methods in the Math class. You can also safely assume the two given integers are positive.\n",
    "\n",
    "The code skeleton has been provided and you have to use it.\n",
    "\n",
    "```\n",
    "public int multiply(int x, int y) {\n",
    "  //……\n",
    "}\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "12"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "// a sample solution\n",
    "public int multiply(int x, int y) {\n",
    "    int i = 1, result = 0;\n",
    "    while (i <= x) {\n",
    "        result += y;\n",
    "        i += 1;\n",
    "    }\n",
    "\n",
    "    return result;\n",
    "}\n",
    "\n",
    "// test\n",
    "multiply(3, 4);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Print A Matrix\n",
    "\n",
    "Print a matrix given r rows, c columns. In the matrix, each cell has value ith/jth. The example is the case when r = 5, c = 5.\n",
    "```\n",
    "1/1 1/2 1/3 1/4 1/5 \n",
    "2/1 2/2 2/3 2/4 2/5 \n",
    "3/1 3/2 3/3 3/4 3/5 \n",
    "4/1 4/2 4/3 4/4 4/5 \n",
    "5/1 5/2 5/3 5/4 5/5 \n",
    "```\n",
    "You can also safely assume the two given integers as row and column numbers are positive. The code skeleton has been provided and you have to use it.\n",
    "\n",
    "```\n",
    "public void printCells(int r, int c) {\n",
    "    //……\n",
    "}\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1/1 1/2 1/3 \n",
      "2/1 2/2 2/3 \n",
      "3/1 3/2 3/3 \n"
     ]
    }
   ],
   "source": [
    "// a sample solution\n",
    "public  void printCells(int r, int c){\n",
    "    for (int i = 1; i <= r; i++){\n",
    "        for (int j = 1; j <= c; j++){\n",
    "            System.out.print(i + \"/\" + j + \" \");\n",
    "        }\n",
    "        System.out.println();\n",
    "    }\n",
    "}\n",
    "\n",
    "// test\n",
    "printCells(3, 3);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "Fizz\n",
      "4\n",
      "Buzz\n"
     ]
    }
   ],
   "source": [
    "int n = 5;\n",
    "for (int i = 1; i <= n; i++){\n",
    "    if(i % 3 == 0 && i % 5 == 0){\n",
    "        System.out.println(\"FizzBuzz\");\n",
    "    } else if(i % 5 == 0){\n",
    "        System.out.println(\"Buzz\");\n",
    "    } else if (i % 3 == 0){\n",
    "        System.out.println(\"Fizz\");\n",
    "    } else {\n",
    "        System.out.println(i);\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Prints a Diamond\n",
    "\n",
    "Print the top half of a diamond shape with the height as n. For instance, when n = 5, the diamond would be\n",
    "```\n",
    "    *\n",
    "   ***\n",
    "  *****\n",
    " *******\n",
    "*********\n",
    "```\n",
    "The code skeleton has been provided and you have to use it.\n",
    "```\n",
    "public void diamondPrinter(int n) {\n",
    "    // ...\n",
    "}\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "    *\n",
      "   ***\n",
      "  *****\n",
      " *******\n",
      "*********\n"
     ]
    }
   ],
   "source": [
    "// a sample solution\n",
    "public void diamondPrinter(int n) {\n",
    "    int space = n-1;\n",
    "    for (int i = 1; i <= n; i++){\n",
    "        //spaces\n",
    "        for (int j = 1; j <= space; j++){\n",
    "            System.out.print(\" \");\n",
    "        }\n",
    "\n",
    "        //asterisks\n",
    "        for (int j = 1; j <= 2*i-1; j++){\n",
    "            System.out.print(\"*\");\n",
    "        }\n",
    "\n",
    "        //end of line\n",
    "        System.out.print(\"\\n\");\n",
    "        space--;\n",
    "    }\n",
    "}\n",
    "\n",
    "// test\n",
    "diamondPrinter(5);"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Java",
   "language": "java",
   "name": "java"
  },
  "language_info": {
   "codemirror_mode": "java",
   "file_extension": ".jshell",
   "mimetype": "text/x-java-source",
   "name": "Java",
   "pygments_lexer": "java",
   "version": "12.0.2+10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}