{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "toc: true\n",
    "comments: true\n",
    "layout: notebook\n",
    "title: Classes\n",
    "description: The difference in the application and use of Value and Reference types in Java.\n",
    "authors: Kevin Du\n",
    "courses: { compsci: {week: 1} }\n",
    "type: hacks\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. **Class Instantiation**:\n",
    "    - **Purpose**: Creating an object (instance) of a class.\n",
    "    - **Syntax**: `ClassName objectName = new ClassName();`\n",
    "    - **Explanation**:\n",
    "        - `ClassName` refers to the name of the class you want to instantiate.\n",
    "        - `objectName` is the reference variable that points to the newly created object.\n",
    "        - `new ClassName()` allocates memory and initializes the object.\n",
    "\n",
    "2. **Constructors**:\n",
    "    - **Purpose**: Special methods used for object initialization.\n",
    "    - **Default Constructor**:\n",
    "        - Takes no arguments.\n",
    "        - Initializes instance variables to default values (e.g., `0`, `null`, etc.).\n",
    "    - **Parameterized Constructors**:\n",
    "        - Accept one or more arguments.\n",
    "        - Used to set initial values for instance variables."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "public class MyClass {\n",
    "    private int value;\n",
    "\n",
    "    // Parameterized constructor\n",
    "    public MyClass(int initialValue) {\n",
    "        value = initialValue;\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Instantiation of Classes\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "public class WordPair { \n",
    "    /** Constructs a WordPair object. */ \n",
    "    public WordPair(String first, String second) \n",
    "    { \n",
    "        /* implementation not shown */ \n",
    "    } \n",
    "    /** Returns the first string of this WordPair object. */ \n",
    "    public String getFirst() \n",
    "    { \n",
    "        /* implementation not shown */ \n",
    "    } /** Returns the second string of this WordPair object. */ \n",
    "    public String getSecond() \n",
    "    {\n",
    "        /* implementation not shown */ \n",
    "    } \n",
    "}\n",
    "public class WordPairList { \n",
    "    /** The list of word pairs, initialized by the constructor. */ \n",
    "    private ArrayList<WordPair> allPairs; \n",
    "    /** Constructs a WordPairList object as described in part (a). * Precondition: words.length >= 2 */ \n",
    "    public WordPairList(String[] words) \n",
    "    { \n",
    "        /* to be implemented in part (a) */ \n",
    "    } \n",
    "    /** Returns the number of matches as described in part (b). */ \n",
    "    public int numMatches() { \n",
    "        /* to be implemented in part (b) */\n",
    "    } \n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Here are the results for example 2 and 3\n",
      "0\n",
      "1\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "public class WordPair {\n",
    "    private String First;\n",
    "    private String Second;\n",
    "    /** Constructs a WordPair object. */ \n",
    "    public WordPair(String first, String second) \n",
    "    { \n",
    "        this.First = first;\n",
    "        this.Second = second;\n",
    "    } \n",
    "    /** Returns the first string of this WordPair object. */ \n",
    "    public String getFirst() \n",
    "    { \n",
    "        return this.First;\n",
    "    } /** Returns the second string of this WordPair object. */ \n",
    "    public String getSecond() \n",
    "    {\n",
    "        return this.Second;\n",
    "    } \n",
    "}\n",
    "public class WordPairList { \n",
    "    /** The list of word pairs, initialized by the constructor. */ \n",
    "    private ArrayList<WordPair> allPairs; \n",
    "    /** Constructs a WordPairList object as described in part (a). * Precondition: words.length >= 2 */ \n",
    "    public WordPairList(String[] words) \n",
    "    { \n",
    "        this.allPairs = new ArrayList<WordPair>(); //Some people miss this for some reason. You need an array list so that way you can add more pairs needed in the future.\n",
    "        for (int i = 0; i<words.length;i++){ //Goes through each word\n",
    "            for(int j = i+1;j<words.length;j++){ //This is the nested for loop; The i+1 makes it so that j doesn't overlap itself, otherwise, it would think that it was pairing with itself; Many people miss this surprisingly\n",
    "                this.allPairs.add(new WordPair(words[i],words[j]));\n",
    "            }\n",
    "        }\n",
    "    } \n",
    "    /** Returns the number of matches as described in part (b). */ \n",
    "    public int numMatches() { \n",
    "        int result = 0;\n",
    "        for (WordPair wp:allPairs){ //this for iterates through each word pair in the allPairs arraylist\n",
    "            if(wp.getFirst() == wp.getSecond()){ //This makes sure that the words are equal to each other to create a valid pair.\n",
    "                result += 1; //This increments for every pair\n",
    "            }\n",
    "        }\n",
    "        return result;\n",
    "    } \n",
    "}\n",
    "\n",
    "//Main Function\n",
    "//Example 1:\n",
    "String[] wordNums = {\"one\", \"two\", \"three\"}; \n",
    "WordPairList exampleOne = new WordPairList(wordNums);\n",
    "//Example 2\n",
    "String[] phrase = {\"the\", \"more\", \"the\", \"merrier\"}; \n",
    "WordPairList exampleTwo = new WordPairList(phrase);\n",
    "//Example 3:\n",
    "String[] moreWords = {\"the\", \"red\", \"fox\", \"the\", \"red\"}; \n",
    "WordPairList exampleThree = new WordPairList(moreWords);\n",
    "System.out.println(\"Here are the results for example 2 and 3\");\n",
    "System.out.println(exampleOne.numMatches());\n",
    "System.out.println(exampleTwo.numMatches());\n",
    "System.out.println(exampleThree.numMatches());"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Overloaded Constructor\n",
    "\n",
    "Below is an example of an overloaded constructor. It's identical to the code above, except now when creating a WordPairList object if we don't pass through any words, tester words will be given and used. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Here are the results for the examples\n",
      "1\n",
      "1\n"
     ]
    }
   ],
   "source": [
    "public class WordPairList { \n",
    "    /** The list of word pairs, initialized by the constructor. */ \n",
    "    private ArrayList<WordPair> allPairs; \n",
    "    /** Constructs a WordPairList object as described in part (a). * Precondition: words.length >= 2 */ \n",
    "    public WordPairList(String[] words) \n",
    "    { \n",
    "        this.allPairs = new ArrayList<WordPair>(); \n",
    "        for (int i = 0; i<words.length;i++){ \n",
    "            for(int j = i+1;j<words.length;j++){ \n",
    "                this.allPairs.add(new WordPair(words[i],words[j]));\n",
    "            }\n",
    "        }\n",
    "    } \n",
    "\n",
    "    public WordPairList() \n",
    "    { \n",
    "        String[] testerWords = {\"test\", \"testing\", \"best\", \"test\", \"hello\"}; \n",
    "        this.allPairs = new ArrayList<WordPair>(); \n",
    "        for (int i = 0; i<testerWords.length;i++){ \n",
    "            for(int j = i+1;j<testerWords.length;j++){ \n",
    "                this.allPairs.add(new WordPair(testerWords[i],testerWords[j]));\n",
    "            }\n",
    "        }\n",
    "    } \n",
    "\n",
    "    /** Returns the number of matches as described in part (b). */ \n",
    "    public int numMatches() { \n",
    "        int result = 0;\n",
    "        for (WordPair wp:allPairs){ //this for iterates through each word pair in the allPairs arraylist\n",
    "            if(wp.getFirst() == wp.getSecond()){ //This makes sure that the words are equal to each other to create a valid pair.\n",
    "                result += 1; //This increments for every pair\n",
    "            }\n",
    "        }\n",
    "        return result;\n",
    "    } \n",
    "}\n",
    "\n",
    "String[] words = {\"the\", \"more\", \"the\", \"merrier\"}; \n",
    "WordPairList exampleOne = new WordPairList(words);\n",
    "WordPairList exampleTwo = new WordPairList();\n",
    "System.out.println(\"Here are the results for the examples\");\n",
    "System.out.println(exampleOne.numMatches());\n",
    "System.out.println(exampleTwo.numMatches());"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Resources\n",
    "\n",
    "GridWorld Case Study is a program that was previously used to supplement the AP CSA curriculum and was on the AP Exam from 2008 to 2014. While it is no longer tested, it is still a useful program to help prepare for the AP Exam as it provides a graphical environment that shows objects inhabiting and interacting with each other in a grid. For those interested, you can start [here](http://www.minich.com/education/wyo/java/apexam/gridworld_notes.php).\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Tips and Tricks\n",
    "\n",
    "1. Common Points:\n",
    "    - declared class header \n",
    "    - constructor\n",
    "    - private instances \n",
    "    - declare headers for class methods\n",
    "    - properly uses methods from given class\n",
    "    - methods returns the right thing based on logic\n",
    "2. Use meaningful variable names\n",
    "3. For inheritence questions, pay attention to whether the attribute is of the parent or child class\n",
    "4. Check your code with the examples provided\n",
    "5. Super() must be in the first line of your constructor\n",
    "6. Initialize your variables outside of the constructor and any method (to have the correct scope)\n",
    "7. Point distribution, very few given for functioning code, just ensure you have the basic requirements"
   ]
  }
 ],
 "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": "17.0.10+7-Ubuntu-122.04.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}