midOOP-1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 2019 객체지향프로그래밍 중간고사\n",
    "\n",
    "    * 이름: 20180637\n",
    "    * 학번: 송기원\n",
    "\n",
    "----"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 배열 (1점)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "true"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import java.util.*;\n",
    "\n",
    "int[] arr = {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};\n",
    "\n",
    "int acc = 0;\n",
    "\n",
    "for(int i =0; i < arr.length; i++){\n",
    "    acc += arr[i];\n",
    "}\n",
    "\n",
    "// 여기에 반복문을 활용하여 arr에 들어있는 수의 총합이\n",
    "// 반목문을 수행한 후에 acc에 저장되도록 하여\n",
    "// 아래 리턴 결과가 true가 되게 하라\n",
    "// (단, arr의 내용을 바꾸어도 항상 리턴 결과가 true가 되어야 한다)\n",
    "\n",
    "return acc == Arrays.stream(arr).sum();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 이차원 배열 (2점)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "true"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import java.util.*;\n",
    "\n",
    "int[][] arr = { {1,2,3}, {4,5,6,7}, {8,9,10,11,12}, {13,14,15,16,17} };\n",
    "\n",
    "int acc = 0;\n",
    "\n",
    "for(int i = 0; i < arr.length; i++){\n",
    "    for(int j = 0; j < arr[i].length; j++){\n",
    "        acc += arr[i][j];\n",
    "    }\n",
    "}\n",
    "\n",
    "// 여기에 반복문을 활용하여 arr에 들어있는 수의 총합이\n",
    "// acc에 저장되도록 하여 아래 리턴 결과가 true가 되게 하라.\n",
    "// (단, arr의 내용을 바꾸어도 항상 리턴 결과가 true가 되어야 한다)\n",
    "\n",
    "return acc == Arrays.stream(arr).map(a -> Arrays.stream(a).sum()).reduce(0,Integer::sum);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 이차원 배열로부터 일차원 배열 계산 (3점)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "true"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import java.util.*;\n",
    "\n",
    "int[][] arr = { {1,2,3}, {4,5,6,7}, {8,9,10,11,12}, {13,14,15,16,17} };\n",
    "int[] ar = new int[4];\n",
    "\n",
    "// arr안에 있는 각각의 일차원 배열의 합들을 계산해 ar에 저장하라\n",
    "// 이 때 ar의 타입은 일차원 배열인 int[]로 정의해야 한다.\n",
    "// 그렇게 해서 에러없이 아래 리턴 결과가 true가 되도록 하라.\n",
    "// (단, arr의 내용을 바꾸어도 항상 리턴 결과가 true가 되어야 한다)\n",
    "\n",
    "for(int i = 0; i < arr.length; i ++){\n",
    "    for(int j = 0; j < arr[i].length; j++){\n",
    "        ar[i] += arr[i][j];\n",
    "    }\n",
    "}\n",
    "\n",
    "return Arrays.equals(\n",
    "    Arrays.stream(ar).mapToObj(a -> new Integer(a)).toArray(),\n",
    "    Arrays.stream(arr).map(a -> Arrays.stream(a).sum()).toArray() );"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 인스턴스 변수 (2점)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "com.twosigma.beaker.javash.bkrdc5c6b52.C"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class C {\n",
    "    // 인스턴스 변수 두 개를 적절히 정의하여 에러없이 아래 리턴 결과가 true가 되게 하라\n",
    "    String s;\n",
    "    int n;\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "true"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "C c1 = new C();\n",
    "C c2 = new C();\n",
    "c1.s = \"abc\";\n",
    "c1.n = 5;\n",
    "c2.s = c1.s + \"def\";\n",
    "c2.n = c1.n + 1;\n",
    "return c1.s.equals(\"abc\") && c1.n==5 && c2.s.equals(\"abcdef\") && c2.n==6;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 클래스 변수 (정적 변수) (2점)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "com.twosigma.beaker.javash.bkrdc5c6b52.B"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class B {\n",
    "    // String 타입의 클래스 변수 s를 적절히 정의하여 에러없이 아래의 리턴 결과가 true가 되게 하라\n",
    "    static String s = \"hello\";\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "true"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "return B.s.length()==5;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 클래스 변수 및 메소드 (정적 변수 및 메소드) (2점)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "com.twosigma.beaker.javash.bkrdc5c6b52.BB"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class BB {\n",
    "    // int 타입의 c라는 이름의 클래스 변수와 put라는 이름의 클래스 메소드를\n",
    "    // 적절히 정의하여 에러없이 아래의 리턴 결과들이 모두 true가 되게 하라\n",
    "    // 필요하면 클래스 변수를 정의해도 좋다\n",
    "    \n",
    "    static int c;\n",
    "    static void put(int x){\n",
    "      c = x;\n",
    "    }\n",
    "    \n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "true"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "BB.put(365);\n",
    "return BB.c==365;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "true"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "BB.put(153);\n",
    "return BB.c==153;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 인스턴스 메소드 (2점)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "com.twosigma.beaker.javash.bkrdc5c6b52.A"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class A {\n",
    "    int v;\n",
    "    // put이라는 이름의 인스턴스 메소드를 적절히 정의하여 에러없이 아래의 리턴 결과가 true가 되게 하라\n",
    "    public void put (int x){\n",
    "        this.v = x;\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "true"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A a1 = new A();\n",
    "A a2 = new A();\n",
    "a1.put(365);\n",
    "a2.put(153);\n",
    "return a1.v==365 && a2.v==153;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 인스턴스 메소드 및 생성자 (2점)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "com.twosigma.beaker.javash.bkrdc5c6b52.MyInt"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class MyInt {\n",
    "    // get이라는 이름의 인스턴스 메소드와 생성자를 하나 작성하여 에러없이 아래의 리턴 결과가 true가 되게 하라\n",
    "    // 필요하다면 인스턴스 변수들도 정의하라\n",
    "    int a;\n",
    "    public MyInt (int x){\n",
    "        this.a = x;\n",
    "    }\n",
    "    \n",
    "    public int get(){\n",
    "        return this.a;\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "true"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "return new MyInt(3).get() == 3 && new MyInt(2).get() == 2;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 상속과 생성자 (3점)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "com.twosigma.beaker.javash.bkrdc5c6b52.Person"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class Person {\n",
    "    String name; // 이름\n",
    "    int age;     // 나이\n",
    "    public Person(String name, int age){\n",
    "        this.name = name;\n",
    "        this.age = age;\n",
    "    }\n",
    "    // 적절한 생성자를 정의하여 에러없이 아래 리턴 결과가 true가 되게 하라\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "com.twosigma.beaker.javash.bkrdc5c6b52.Student"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class Student extends Person {\n",
    "    String school; // 학교\n",
    "    int number;    // 학번\n",
    "    public Student(String school, int number, String name, int age){\n",
    "        super(name, age);\n",
    "        this.school = school;\n",
    "        this.number = number;\n",
    "    }\n",
    "    // 적절한 생성자를 정의하여 에러없이 아래 리턴 결과가 true가 되게 하라\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "true"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Student p1 = new Student(\"HNU\", 20191111, \"강성연\", 42);\n",
    "Student p2 = new Student(\"한남대학교\", 20192222, \"권상우\", 41);\n",
    "return p1.school.equals(\"HNU\")        && p1.number==20191111 && p1.name.equals(\"강성연\") && p1.age==42\n",
    "    && p2.school.equals(\"한남대학교\") && p2.number==20192222 && p2.name.equals(\"권상우\") && p2.age==41;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## toString 관련 문제 (2점)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "com.twosigma.beaker.javash.bkrdc5c6b52.Hello"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class Hello {\n",
    "    String hello;\n",
    "    \n",
    "    public Hello(){\n",
    "     this.hello = \"Hello\";   \n",
    "    }\n",
    "    \n",
    "    public String toString(){\n",
    "        return hello;\n",
    "    }\n",
    "    // toString 함수를 적절히 오버라이딩하여 아래의 리턴 결과가 true가 되도록 하라\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "true"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Hello h = new Hello();\n",
    "String str = h+\" world\";\n",
    "return str.equals(\"Hello world\"); // 그래서 리턴값이 true가 되도록"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 인스턴스 변수 및 메소드 (3점)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "com.twosigma.beaker.javash.bkrdc5c6b52.D1"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class D1 {\n",
    "    double d;\n",
    "    \n",
    "    public D1(double d){\n",
    "        this.d = d;\n",
    "    }\n",
    "    \n",
    "    public D1 copy(){\n",
    "        D1 d1 = new D1(this.d);\n",
    "        \n",
    "        return d1;\n",
    "    }\n",
    "    // 생성자 및 리턴 타입이 D1인 copy라는 이름의 메소드를 정의하여\n",
    "    // 아래의 리턴 결과가 true가 되도록 하라\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "true"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "D1 o1 = new D1(1.5);\n",
    "D1 o2 = new D1(-2.3);\n",
    "return o1.d ==  1.5 && o1.copy().d == o1.d && o1.copy() != o1\n",
    "    && o2.d == -2.3 && o2.copy().d == o2.d && o2.copy() != o2;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 인스턴스 변수 및 메소드 (3점)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "com.twosigma.beaker.javash.bkrdc5c6b52.D2"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class D2 {\n",
    "    double d;\n",
    "    // 생성자 및 리턴 타입이 D2인 copy라는 이름의 메소드를 정의하여\n",
    "    // 아래의 리턴 결과가 true가 되도록 하라\n",
    "    public D2(double d){\n",
    "        this.d = d;\n",
    "    }\n",
    "    public D2 copy(){\n",
    "        return this;\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "true"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "D2 o1 = new D2(1.5);\n",
    "D2 o2 = new D2(-2.3);\n",
    "return o1.d ==  1.5 && o1.copy().d == o1.d && o1.copy() == o1\n",
    "    && o2.d == -2.3 && o2.copy().d == o2.d && o2.copy() == o2;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 생성자 및 final 관련 문제 (3점)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "com.twosigma.beaker.javash.bkrdc5c6b52.Point3D"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class Point3D {\n",
    "    final int x, y, z;\n",
    "    \n",
    "    public Point3D(int _x, int _y, int _z){\n",
    "        this.x = _x;\n",
    "        this.y = _y;\n",
    "        this.z = _z;\n",
    "    }\n",
    "    \n",
    "    public Point3D(){\n",
    "        this.x = 0;\n",
    "        this.y = 0;\n",
    "        this.z = 0;\n",
    "    }\n",
    "    // 하나 또는 여러개의 생성자들을 작성하여 에러없이 아래의 리턴 결과가 true가 되게 하라\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "true"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Point3D p0 = new Point3D();\n",
    "Point3D p1 = new Point3D(1,2,3);\n",
    "return p0.x==0 && p0.y==0 && p0.z==0\n",
    "    && p1.x==1 && p1.y==2 && p1.z==3;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "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": 2
}