• Java용어정리
  💡
  이번 챕터에서 나오는 용어 정리

  1. 데이터🔢 : 컴퓨터가 정보를 담는 자료값

  2. 데이터 타입🔢(자료형) : 데이터의 유형 ex. 정수 / 문자 / 부동소수(소숫점)

  3. 자료구조🗳️ : 데이터 여러개를 분류해서 담을 수 있는 분류통🗳️

  4. 문맥💌  : 문맥이라 함은 개발언어로 표현한 프로그램의 동작 흐름을 의미합니다. 이케아 가구 조립 설명서, 밀키트 요리 레시피에 조건에 따른 문맥이 있듯이 프로그램도 문맥을 가지고 있습니다.

  5. 메서드🎁 : 데이터🔢와 문맥💌을 감싸는 포장지🎁 입니다.

  6. 공통 실행환경🗺️ : 여러 기기의 운영환경에서 실행 할 수 있도록 판을 깔아주는 실행환경

  7. 운영 체제📱: 기기가 프로그램을 실행시키는 운영환경 (ex. Window, Android, iOS, Linux …)

• Mac 에 JDK 설치하기
  1. https://brew.sh/index_ko 에 접속하여 Homebrew 설치하기 명령어 복사하기 버튼을 클릭합니다.
  
  2. 터미널을 열어서 복사한 명령어를 붙여넣기하고 엔터를 쳐서 실행해줍니다. (Password 를 요청하면 잠금 비밀번호를 입력해줍니다.)
  
  3. 이렇게 brew 설치가 완료되면, JDK 를 설치할 저장소를 brew 등록해주는 아래 명령어를 실행합니다.

  brew tap homebrew/cask-versions

  
  4. 저장소 등록이 완료되면 아래 명령어를 통해 JDK 를 설치해줍니다.

  brew install --cask temurin17

  
  5. 설치가 완료되면 java -version 명령어를 실행했을때 버전이 나오면 잘 설치된것 입니다.

  java -version

• Mac 에 IntelliJ 설치하기
  1. 터미널을 켜고 아래 명령어 실행

  brew install --cask intellij-idea-ce

  
  2. 설치가 모두 완료되면 배경화면에서 IntelliJ 앱 실행 후 New Project 클릭합니다.
  
  1. New Project 팝업에서 Name 입력해주고 Location 을 ~₩Desktop 으로 설정 후 Create 클릭 (배경화면이 아닌 다른 경로에 프로젝트를 저장하고 싶으면 폴더 아이콘을 눌러서 지정하면 됩니다.)
  2. -1.생성된 프로젝트의 Main 파일을 열어서 -2.main 의 중괄호({}) 사이에 아래 코드 입력 후 -3.오른쪽 위 초록색 재생버튼 클릭하여 Java 프로그램을 실행한뒤 -4.아래 콘솔에서 Java 프로그램이 출력한 값을 확인합니다.

  System.out.println("Hello world!");

  
  7. Hello World! 가 정상적으로 출력되었으면 IntelliJ 설치가 완료된것 입니다.

• 기본지식

  C언어기능 + 공통 실행환경,클래스,객체

  

  자바 장점 5가지
  1. 고통 실행환경이 있어서 여러 기기에서 실행이 가능
  2. 객체를 사용하여 이해및 유지보수가 쉬움
  3. compiler가 먼저 오류를 체크하여 안정성이 높음
  // 대신 다른 언어보다 무거움
  4. 네트워크및 데이터베이스 연결 및 통신등의 작업을 처리하는 API를 제공
  5. 다양한 개발 도구와 라이브러리

  JVM

  Java Virtual Machine 자바 가상 머신
  가상의 기기를 만들어 주는것
  => Java프로그램을 실행시킬 수 있는 가상의 기기를 만들어 주는것

  바이트 코드

  내가 작성한 코드가 운영체제가 읽을 수 있는 코드(바이트 코드💬)로 Java 컴파일러가 변환한 코드

  💡
  Java 컴파일러란?

  내가 작성한 Java 코드들(.java 파일)을 운영체제가 읽을 수 있는 바이트 코드💬(.class 파일)로 변환하는 변환기

  인터프리터📇

  Java .class 코드 해석기

  • 운영체제가 읽은 바이트 코드💬를 기기(기계)가 실행할 수 있는 기계어로 번역

  JIT 컴파일러📇

  빠른 Java .class 코드 해석기

  • 인터프리터의 효율을 높여주는 서포터 해석기

  메모리 영역🗂️

  Java 데이터를 저장하는 영역

  • 운영체제로 부터 JVM이 할당받은 메모리 영역

  클래스 로더🚚

  Java .class 바이트 코드💬를 메모리 영역에 담는 운반기

  • JVM으로 class(바이트 코드💬)를 불러와서 메모리🗂️에 저장함

  가비지 컬렉터🧹

  Java 쓰레기 청소기

  • 메모리 영역🗂️에서 안쓰는 데이터를 주기적으로 흡수해가는 청소기
  💡
  JVM 놀이터에서 프로그램이 동작하는 흐름

  • 놀이터 그림으로 표현하자면 흐름은 아래와 같다.
    • 여기서, Runtime 은 “프로그램이 실행중인 상태”를 말합니다.
    • 따라서, Runtime 시스템은 “프로그램이 실행중인 상태를 관리하는 시스템” 입니다.

  

  • 좀더 개발자🧑‍💻스럽게 그룹지어서 정리하자면 아래 그림과 같습니다.

  

  JRE
  - Java Runtime Environment 자바 실행 환경
  - Java프로그램을 실행만 시킬 수 있음
  - .class파일만 실행 가능하다
  우리가 작성하는것은 .java파일로 JRE만으로는 기능을 할 수 없다
  JDK
  
  Java Development Kit 자바 개발 키트
  javac명령을 통해 .java파일을 .class파일로 변환
  JRE(JVM)기능을 포함
  코드를 디버깅하는 jdb등의 기능

  💡
  디버깅 = 중단점 일시정지 + 코드 라인단위 수행
  

• 자바 기본 구조

  import java.util.Arrays;
  
  import java.util.Scanner;
  
  // import = im(in) + port(항구) -> 바깥쪽에서 안쪽을 가져오기

// JDK 역할
// 1. .java 파일을 .class 파일로 변환하는 compiler

// 2. JRE

// 3. JDB : 디버깅(버그를 없애기위해 코드를 살피는 과정)
// -> 웹브라우저처럼 해당 위치의 순번을 클릭하고 벌레모양의 디버그 마크 클릭 이어서 재생하고싶으면 하단왼쪽의 재생버튼 누르기

// () : 소괄호
// {} : 중괄호
// [] : 대괄호

// main 메소드 부분
// 무조건 main메소드가 있어야한다
// 자바 프로젝트(앱)은 제일먼저 클래스의 main메소드를 실행
// = JVM의 약속
// static : 이 프로그램이 시작될 때 무조건 실행된다는 표현
// input output 타입을 제한

// output
// static다음에 오는곳이 메소드의 출력 데이터 타입을 정함
// void : return이 없다

// input
// String[] args : 매개변수 자리
// 매개변수 타입과 변수명을 지정
// 변수명의 제한은 없음

public static void main(String[] args) {

    // 객체 : 특징(속성,변수), 행동(메소드)
    // 자바에서 하위 요소를 표현할때 .으로 들어감
    // println -> 줄바꿈
    // print -> 줄바꿈x
    // ln : line
    System.out.println("야야양 왜이리 느려");
    System.out.print("여기는 뭐니");
    System.out.println("여기는 뭐니222");


    System.out.println(7);
    System.out.println(3);
    System.out.println(3.14);
    System.out.println("수비JAVA");

}

}

• 변수 상수

  // 변수 : 변하는 값
  
  // 상수 : 변하지 않는 값
  
  // 변수를 사용하는 이유 : 유지보수를 위해
  
  // 코드를 수정할때 굳이 하나하나씩 수정하지않고 변수 하나만 바꾸면 아래가 변경되는등의 편리성도 있다
  
      // 변수
      int number = 10;
      System.out.println(number);
      number = 222;
      System.out.println(number);
  
      // 상수
      final int num = 2222;
      System.out.println(num);</code></pre></details></li></ul><ul id="e5aabdd5-9967-4bfe-a3a1-d023aa85513b" class="toggle"><li><details open=""><summary>변수 타입(stack heap)</summary><figure id="4ffce2ca-7232-4b6f-8d1f-f7388de74201" class="image"><a href="Java%20bd4a58d5f12642da8418ff1b8949afe5/Untitled_(2).png"><img style="width:1860px" src="Java%20bd4a58d5f12642da8418ff1b8949afe5/Untitled_(2).png"/></a></figure><pre id="734f36be-d0cc-477a-96e3-5803704dbe17" class="code"><code>기본형 변수 : 값을 저장하는 저장공간으로 실제값(리터럴)을저장
  참조형 변수 : 실제값이 아닌 주소값을 저장
  메모리는 공간마다 주소값을 가지고 있다
  
  기본형 변수는 Stack영역에 선언한 변수만큼의 공간이 생성이 되고 그공간 안에 값이 들어가게 된다
  참조형 변수의 경우 해당 변수의 크기만큼 고정된 크기가 Stack에 생성되고 주소값이 저장된다
  그리고 new를 통해 Heap영역에 새로운 저장공간을 생성하게 된다
  공간의 크기는 우리가 넣으려는 값의 크기만큼 생성한다
  이 공간은 메모리 주소값을 할당받게된다 ## Heap영역뿐만 아니라 Stack영역에서 생성된 공간도 주소는 할당받는다
  
  Stack의 경우에는 정적으로 할당된 메모리 영역
  
  -> 크기가 정해져있는 값을 저장
  
  Heap의 경우에는 동적으로 할당된 메모리 영역
  
  -> 크기가 정해져있지 않은 값을 저장

  • 기본형 변수

    				// boolean
    
    boolean flag = true; // 1. 논리형 변수 boolean 으로 선언 및 True 값으로 초기화
    
        flag = false; // 2. False 값으로도 저장할 수 있습니다.
    
        // 문자형
        char alphabet = 'A'; // 문자 하나를 저장합니다. ""로 입력하면 문자열로 인식
    
        // 정수형
        // 카멜케이스 -> 변수명중 중간에 대문자가 있는형태
        byte byteNumber = 127; // byte 는 -128 ~ 127 범위의 숫자만 저장 가능합니다. 1byte만 표현 가능
        // 1byte = 8bit
        // bit = 0과1을 표현하는 최소단위
        // 비트마다 리소스를 확인하는게 비효율적이니까 byte를 만듬
        // 2의8제곱 -> 256 -> 표현할수있는 범위 -128 ~ 127
    
        short shortNumber = 32767; // short 는 -32,768~32,767 범위의 숫자만 저장 가능합니다.
    
        int intNumber = 2147483647; // int 는 -21억~21억 범위의 숫자만 저장 가능합니다.
    
        long longNumber = 2147483647L; // long 은 숫자뒤에 알파벳 L 을 붙여서 표기하며 매우 큰수를 저장 가능합니다.
    
    			// 데이터값(리터럴) 뒤에 붙이는 구분값을 “접미사”라고 부릅니다.
    			// byte -> short(2byte) -> int(4byte) -> long(8bite)
    
        // 실수형
        float floatNumber = 0.123F; // float 는 4byte 로 3.4 * 10^38 범위를 표현하는 실수값
        double doubleNumber = 0.123123123; // double 은 8byte 로 1.7 * 10^308 범위를 표현하는 실수값</code></pre></details></li></ul><ul id="12ff8f4c-5c78-4b42-9b4c-93be51dbc258" class="toggle"><li><details open=""><summary>참조형 변수</summary><pre id="a4402144-3f2e-4acc-b3d7-60e651579652" class="code"><code>// 기본형을 제외한 나머지들 이외에도 많다
    
    			// 문자열
        String hello = &quot;야야야야야야ㅑ야양&quot;;
        System.out.println(hello);
    
        // 배열
        int[] arr = {1,2,3,4,5};
        System.out.println(arr[0]);
        System.out.println(Arrays.toString(arr));</code></pre></details></li></ul><ul id="24fa79bf-57e1-49f9-8b66-ed23ac2cb1d7" class="toggle"><li><details open=""><summary>레퍼클래스 변수</summary><pre id="47eb42b6-3202-472a-99e4-59cdf999c6d3" class="code"><code>기본형 변수를 클래스로 랩핑하는 변수
    
    해당하는 메소드를 사용할 수 있는 장점

    기본 타입	래퍼 클래스
    byte	Byte
    short	Short
    int	Integer
    long	Long
    float	Float
    double	Double
    char	Character
    boolean	Boolean

• 아스키 코드

  // 숫자 -> 문자
  import java.util.Scanner;

public static void main(String[] args) {
	Scanner sc = new Scanner(System.in);

	int asciiNumber = sc.nextInt();
	char ch = (char)asciiNumber; // 문자로 형변환을 해주면 숫자에 맞는 문자로 표현됩니다.

	System.out.println(ch);
}

// 출력
a

// 문자 -> 숫자

import java.util.Scanner;
public class Main {
public static void main(String[] args) {
	Scanner sc = new Scanner(System.in);

	char letter = sc.nextLine().charAt(0); // 첫번째 글자만 받아오기위해 charAt(0) 메서드를 사용합니다.
	int asciiNumber = (int)letter; // 숫자로 형변환을 해주면 저장되어있던 아스키 숫자값으로 표현됩니다.

	System.out.println(asciiNumber);
}
}
// 입력

a
// 출력

97

• 문자와 문자열

  문자는 선언할때 ''를 사용해야한다
  
  문자열의 경우 ""를 사용한다
  
  문자 뒤에는 \0(널문자)가 없다 -> 1byte만 쓰기 때문에 끝을 알 수 있어서
  
  문자열의 경우 널문자와 함께저장되는데 몇개의 byte를 사용하게 될지 모르기때문이다

  

• Scanner 클래스
  • java.util 패키지 내에서 존재하는 클래스
  • 정수,실수등의 기본적인 데이터 타입 입력을 받기위한 클래스
  • 문자열,한줄(엔터키 기준)을 모두 읽기 위해서는 nextLine()함수를 사용
  • 단일 문자(char)를 읽기 위해서 next()와 charAt()함수를 함께 사용 가능

  import java.util.Scanner;
  
  public class myScanner
  
  {
  
  public static void main(String[] args)
  
  {
  
  Scanner scanner = new Scanner(System.in);
      int i = scanner.nextInt();
      char c = scanner.next().charAt(0);
      long l = scanner.nextLong();
      double d = scanner.nextDouble();
      String s = scanner.nextLine();
  
      System.out.println("int : " + i);
      System.out.println("char : " + c);
      System.out.println("long : " + l);
      System.out.println("double : " + d);
      System.out.println("string : " + s);
  }
  }

  • hasNext~()함수를 사용하여, 원하는 만큼 입력을 받을수도 있다.
  • boolean타입으로 다음에 가져올값이 있으면 true,아니면 false

  import java.util.Scanner;
  
  public class myScanner
  
  {
  
  public static void main(String[] args)
  
  {
  
  Scanner scanner = new Scanner(System.in);
      int i = 0;
  
      while(scanner.hasNextInt())
      {
          int num = scanner.nextInt();
          i += num;
      }
  
      System.out.println("total : " + i);
  }
  }

• bit byte
  • Bit
    • Bit(비트)는 0,1 형태의 2진수 데이터로써 컴퓨터가 저장(표현)할 수 있는 최소 단위 입니다.
    • 정수형 값은 10진수 숫자(0~10범위의 숫자)이며 2진수(0~1범위)Bit 로 저장(표현) 합니다.
    • 4개의 Bit로 16진수 숫자(0~F(16)범위의 숫자)를 2진수(0~1범위)Bit 로 저장(표현) 합니다.
    • 2진수(0~1)를 10진수, 16진수로 변환된 값 예시 표
  • Byte = 8 Bit
    • Byte(바이트)는 8개의 Bit(비트)로 구성되어 있습니다.
    • 1 Byte 내에서 숫자 변수는 Bit 2진수를 10진수로 저장(표현)을 합니다.
      • 10진수로는 0~255(2의8승)까지 저장(표현) 합니다.
    • 1 Byte 내에서 문자 변수의 경우만 Bit 2진수를 16진수로 저장(표현)합니다

• 형변환

  // 형변화 : 변수의 타입을 바꾸는 방법
  
  // 문자열 -> 숫자
  
  // 정수 -> 실수
  
  // 실수 -> 정수
  
  double doubleNum = 10.1010101;
  
  float floatNum = 10.10101f;
      int intNum;
  
      intNum = (int)doubleNum;
      System.out.println(intNum);
      intNum = (int)floatNum;
      System.out.println(intNum);
  
      // 정수 -> 실수
      int intNumber2 = 10;
  
      double doubletest = (double) intNumber2;
      System.out.println(doubletest);
  
     float floattest = (float) intNumber2;
      System.out.println(floattest);</code></pre><pre id="2fe552b4-1a46-447d-947b-4ef78631be37" class="code"><code>// 암시적인형변환 : 자동으로 형변환
      // 변수 타입별 크기 순서
      // byte(1) -&gt; short(2) -&gt; int(4) -&gt; long(8) -&gt; float(4) -&gt; double(8)
      // 큰타입에 작은타입을 넣어주면 자동현변환가능
  
      // byte -&gt; int
      byte bytenum = 10;
      int intnum = bytenum;
      System.out.println(&quot;여기요&quot;+intnum);
  
      // char -&gt; int
      char charalp = &#x27;A&#x27;;
      intnum = charalp; //
      System.out.println(&quot;여기요&quot;+intnum); // 65 -&gt; 아스키코드값출력
  
      // int -&gt; long
      intnum = 100;
      long longnum = intnum;
      System.out.println(&quot;여기요&quot;+intnum);
  
      // int -&gt; double
      intnum = 200;
     double doublenum = intnum;
      System.out.println(&quot;여기요&quot;+doublenum);
  
      // 작은 크기의 타입이 큰 크기의 타입과 계산될때
      // 자동으로 큰 크기의 타입으로 형변환이 됨
      intnum = 10;
      doublenum = 5.5;
      // double이 더커서 나오는 값의 데이터 타입은 double로 나옴
      System.out.println(intnum + doublenum);
  
      int iresult = intnum/4;
      System.out.println(iresult);
  
      double dresult = intnum/4.0;
      System.out.println(dresult);</code></pre></details></li></ul><ul id="08992f00-22a8-4467-84fc-9545ef61acd2" class="toggle"><li><details open=""><summary>연산자</summary><ul id="0f581b30-3cf7-4085-8f9b-90ae73ce2b87" class="bulleted-list"><li style="list-style-type:disc">연산자 : 덧셈, 뺄셈 처럼 계산할 기호 ➕</li></ul><ul id="5a30ae62-9118-4999-81f8-56d411eb272e" class="bulleted-list"><li style="list-style-type:disc">피연산자 : 연산자로 인해 계산되는 숫자 🔢</li></ul><ul id="2062389d-9f3d-4153-828f-a034d7cfde6a" class="toggle"><li><details open=""><summary>산술 연산자</summary><ul id="ff0b61ad-f735-4b80-bb98-99bb6e1b0edd" class="bulleted-list"><li style="list-style-type:disc">사칙 연산 및 비트연산을 포함합니다.  (비트연산은 다른 챕터에서 다뤄보아요.)</li></ul><ul id="a188f4ce-824f-4298-b635-5eb3b55ed6ee" class="bulleted-list"><li style="list-style-type:disc">사칙 연산을 계산한 결과값을 응답합니다.</li></ul><ul id="528032d1-c34d-4e29-9f9e-f7047be5edc1" class="bulleted-list"><li style="list-style-type:disc"><code>+</code>(덧셈),  <code>-</code> (뺄셈),  <code>*</code>(곱셈),  <code>/</code>(나눗셈/몫),  <code>%</code> (나눗셈/나머지)</li></ul><pre id="e179f186-8528-4bc2-921e-6bd887dd554b" class="code"><code>// 사칙 연산
  System.out.println(4 + 2); // 6
  
  System.out.println(4 - 2); // 2
  
  System.out.println(4 * 2); // 8
  
  System.out.println(4 / 2); // 2
  
  System.out.println(5 / 2); // 2
  
  System.out.println(2 / 4); // 0
  
  System.out.println(4 % 2); // 0
  
  System.out.println(5 % 2); // 1
  // 우선 순위 연산
  
  System.out.println(2 + 2  2); // 6
  
  System.out.println((2 + 2)  2); // 8
  
  System.out.println(2 + (2 * 2)); // 6
  // 변수를 이용한 연산
  
  int a = 20;
  
  int b = 10;
  
  int c;
  // 덧셈
  
  c = a + b;
  
  System.out.println(c); // 30
  // 뺄셈
  
  c = a - b;
  
  System.out.println(c); // 10
  // 곱셈
  
  c = a * b;
  
  System.out.println(c); // 200
  // 나눗셈 (몫)
  
  c = a / b;
  
  System.out.println(c); // 2
  // 나눗셈 (나머지) = 나머지 연산
  
  c = a % b;
  
  System.out.println(c); // 0

• 비교 연산자
  • 값의 크고/작음을 비교하거나 같고/다름 을 비교하여 참(true)/거짓(false) 값인 boolean 값을 출력합니다.
  • > (크다) , < (작다), >= (크거나 같다), <= (작거나 같다), == (같다), != (다르다)

  // 비교 연산자 (참이면 true, 거짓이면 false)
  
  System.out.println(10 > 9); // 10 는 9 보다 크다 (참이면 true, 거짓이면 false)
  
  System.out.println(10 >= 9); // 10 는 9 보다 크거나 같다 (true)
  
  System.out.println(10 < 9); // 10 는 9 보다 작다 (false)
  
  System.out.println(10 <= 9); // 10 는 9 보다 작거나 같다 (false)
  
  System.out.println(10 == 10); // 10 는 10 와 같다 (true)
  
  System.out.println(10 == 9); // 10 는 9 과 같다 (false)
  
  System.out.println(10 != 10); // 10 는 10 와 같지 않다 (false)
  
  System.out.println(10 != 9); // 10 는 9 과 같지 않다 (true)

• 논리 연산자
  • 비교 연산의 결과값으로 받을 수 있는 boolean 값을 연결하는 연산자 입니다.
  • 조건을 연결 하였을때의 boolean 값들을 조합하여 참(true)/거짓(false) 값인 boolean 값을 출력합니다.
  • && (AND = 피연산자 모두 참), ||(OR = 피연산자 둘중 하나라도 참), !(피연산자의 반대 boolean 값)

  // 논리 연산자
  
  boolean flag1 = true;
  
  boolean flag2 = true;
  
  boolean flag3 = false;
  
  System.out.println(flag1); // true
  
  System.out.println(flag2); // true
  
  System.out.println(flag3); // false
  // 피연산자 중 하나라도 true 이면 true
  
  System.out.println(flag1 || flag2); // true
  
  System.out.println(flag1 || flag2 || flag3); // true
  
  // 피연산자 모두 true 이면 true
  
  System.out.println(flag1 && flag2); // true (flag1, flag2 모두 true 라서)
  
  System.out.println(flag1 && flag2 && flag3); // false (flag3은 false 라서)
  // And 연산
  
  System.out.println((5 > 3) && (3 > 1)); // 5 는 3 보다 크고, 3 은 1 보다 크다 (true)
  
  System.out.println((5 > 3) && (3 < 1)); // 5 는 3 보다 크고, 3 은 1 보다 작다 (false)
  // Or 연산
  
  System.out.println((5 > 3) || (3 > 1)); // 5 는 3 보다 크거나, 3 은 1 보다 크다 (true)
  
  System.out.println((5 > 3) || (3 < 1)); // 5 는 3 보다 크거나, 3 은 1 보다 작다 (true)
  
  System.out.println((5 < 3) || (3 < 1)); // 5 는 3 보다 작거나, 3 은 1 보다 작다 (false)
  // System.out.println(1 < 3 < 5); // 불가능한 코드
  // 논리 부정 연산자
  
  System.out.println(!flag1); // false (flag1 값의 반대)
  
  System.out.println(!flag3); // true (flag3 값의 반대)
  
  System.out.println(!(5 == 5)); // false
  
  System.out.println(!(5 == 3)); // true

• 대입 연산자
  • 변수를 바로 연산해서 그자리에서 저장하는 연산자
  • 기본 대입 연산자인 = 와 다른 연산을 함께쓰는 복합 대입 연산자가 있습니다. (+=, -=, *= …)
  • 복합 대입 연산자는 기본 대입 연산자를 심플하게 작성하게 해주는것이지 기능은 같습니다.
  • 추가로, += 1 는 ++ 과 동일합니다. (피연산자에 1 더해주기)
  • 똑같이 -= 1 은 —-와 동일합니다. (피연산자에 1 빼주기)

  // 대입 연산자
  
  int number = 10;
  
  number = number + 2;
  
  System.out.println(number); // 12
  
  number = number - 2;
  
  System.out.println(number); // 10
  number = number * 2;
  
  System.out.println(number); // 20
  number = number / 2;
  
  System.out.println(number); // 10
  number = number % 2;
  
  System.out.println(number); // 0
  number = number++;
  
  System.out.println(number); // 2
  number = number--;
  
  System.out.println(number); // 0
  // 복합 대입 연산자
  
  number = 10;
  number += 2;
  
  System.out.println(number); // 12
  number -= 2;
  
  System.out.println(number); // 10
  number *= 2;
  
  System.out.println(number); // 20
  number /= 2;
  
  System.out.println(number); // 10
  number %= 2;
  
  System.out.println(number); // 0

  🔥
  대입 연산자 중에 증감 연산자 쓸때 주의할점!

  • ++ 또는 —- 를 붙이면 피연산자가 1 더해지거나 1 빼기가 된다고 말씀드렸는데요.

  • 주의할 점은, 피연산자 뒤에 붙이냐, 앞에 붙이냐에 따라서 연산순서가 달라집니다!!

  연산자	연산자 위치	기능	연산 예
  ++	++{피연산자}	연산 전에 피연산자에 1 더해줍니다.	val = ++num; num값+1 후에 val변수에 저장
  ++	{피연산자}++	연산 후에 피연산자에 1 더해줍니다.	val = num++; num값을 val변수에 저장 후 num+1
  —	—{피연산자}	연산 전에 피연산자에 1 빼줍니다.	val = —num; num값-1 후에 val변수에 저장
  —	{피연산자}—	연산 후에 피연산자에 1 빼줍니다.	val = num—; num값을 val변수에 저장 후 num-1

  • 이처럼 대입연산할때 뿐만아니라 연산을 직접할때도 마찬가지로 선/후적용이 나뉩니다.

  // 대입 증감 연산자
  
  public class Main {
  public static void main(String[] args) {
  	int a = 10;
  	int b = 10;
  	int val = ++a + b--; // a 는 연산전에 +1, b 는 연산후에 -1
  
  	System.out.println(a); // 11
  	System.out.println(b); // 9
  	System.out.println(val); // 21
  
  	// 11 + 9 가 왜 21이 나오는거죠??
  	// 그 이유는 
  	// a 는 val 연산전에 ++ 가 수행되어서 11로 연산되었지만
  	// b 는 val 연산후에 -- 가 수행되어서 기존값이 10으로 연산된 후 -- 가 수행되었습니다.
  	// 따라서 연산된 a값인 11과 연산되기전 b값인 10이 더해져서 21이 된겁니다!
  
  
  	int c = a--; // c 에 a 값 대입 후 a-1  (즉, a=10, c=11)
  	int d = ++b; // b 값 +1 후에 d 에 대입 (즉, b=10, d=10)
  	int val = c-- * ++d; // c 는 연산후에 -1, d 는 연산전에 +1
  
  	System.out.println(a); // 10
  	System.out.println(b); // 10
  	System.out.println(c); // 11
  	System.out.println(d); // 10
  	System.out.println(val); // 11 * 11 = 121
  
  	// 11 * 10 이 왜 121이 나오는거죠??
  	// 그 이유는 
  	// c 는 val 연산후에 -- 가 수행되어서 기존값이 11로 연산된 후 -- 가 수행되었지만
  	// d 는 val 연산전에 ++ 가 수행되어서 11로 연산되었습니다.
  	// 따라서 연산전 a값인 11과 연산된 b값인 11이 곱해져서 121이 된겁니다!
  }
  }

• 기타 연산자
  • 형변환 연산자
    • 1일차 강의에서 배운내용으로 괄호 안에 변환할 타입을 넣으면 피연산자의 타입이 변경 됩니다.

    // 형변환 연산자
    
    int intNumber = 93 + (int) 98.8; // 93 + 98
    
    double doubleNumber = (double) 93 + 98.8; // 93.0 + 98.8

  • 삼항 연산자
    • 비교 연산의 결과값에 따라 응답할 값을 직접 지정할 수 있는 연산자 입니다.
    • 삼항 연산자는 3가지 피연산자가 존재하여 삼항 연산자 라고 합니다. (조건/참결과/거짓결과)
    • (조건) ? (참결과) : (거짓결과)

    // 삼항 연산자
    
    int x = 1;
    
    int y = 9;
    
    boolean b = (x == y) ? true : false;
    
    System.out.println(b); // false
    String s = (x != y) ? "정답" : "땡";
    
    System.out.println(s); // 정답
    int max = (x > y) ? x : y;
    
    System.out.println(max); // 9
    int min = (x < y) ? x : y;
    
    System.out.println(min); // 1

  • instance of 연산자
    • (객체명) instance of (클래스명)
    • 객체 타입을 확인하는 연산자
    • 형변환 가능 여부를 확인하여 true/false 결과 반환
    • 주로 상속 관계에서 부모객체인지 자식 객체인지 확인하는 데 사용

    class Parent{}
    
    class Child extends Parent{}
    
    public class InstanceofTest {
    public static void main(String[] args){
    
        Parent parent = new Parent();
        Child child = new Child();
    
        System.out.println( parent instanceof Parent );  // true
        System.out.println( child instanceof Parent );   // true
        System.out.println( parent instanceof Child );   // false
        System.out.println( child instanceof Child );   // true
    }
    }
    // 1번은 같은거니까 true
    
    // 2번은 child가 Parent를 상속했으니까 true
    
    // 3번은 parent는 부모 이니까 Child가 대처불가능 false
    
    // 4번은 같으니까 true

• 연산자 우선순위
  📌
  연산자 우선순위 : 산술 > 비교 > 논리 > 대입
  • 연산자 여러개가 함께 있는 연산을 계산할때는 우선순위가 있습니다.
  • 위 우선순위에 따라서 최종적인 응답값이 결정됩니다.
  • 단, 괄호로 감싸주면 괄호안의 연산이 최우선순위로 계산됩니다.

  // 연산자 우선순위
  
  int x = 2;
  
  int y = 9;
  
  int z = 10;
  
  boolean result = x < y && y < z; // <,> 비교연산자 계산 후 && 논리 연산자 계산
  
  System.out.println(result); // true
  result = x + 10 < y && y < z; // +10 산술연산자 계산 후 <,> 비교연산자 계산 후 && 논리 연산자 계산
  
  System.out.println(result); // false
  result = x + 2 * 3 > y; // 산술연산자 곱센 > 덧셈 순으로 계산 후 > 비교연산자 계산
  
  System.out.println(result); // false (8>9)
  result = (x + 2) * 3 > y; // 괄호안 덧셈 연산 후 괄호 밖 곱셈 계산 후 > 비교연산자 계산
  
  System.out.println(result); // true (12>9)

• 산술변환
  📌
  연산 전에 피연산자의 타입을 일치시키는 것

  • 두 피연산자의 타입을 같게 일치시킨다. (둘중에 저장공간 크기가 더 큰 타입으로 일치
  • 피연산자의 타입이 int 보다 작은 short 타입이면 int 로 변환
  • 피연산자의 타입이 long 보다 작은 int, short 타입이면 Long 으로 변환
  • 피연산자의 타입이 float보다 작은 long, int, short 타입이면 float 으로 변환
  • 피연산자의 타입이 double 보다 작은 float, long, int, short 타입이면 double 으로 변환
  • 이처럼, 변수여러개를 연산했을때 결과값은 피연산자 중 표현 범위가 가장 큰 변수 타입을 가지게 됩니다.

  // 산술변환
  
  public class Main {
  
  public static void main(String[] args) {
  
  	short x = 10;
  	int y = 20;
  
  	int z = x + y; // 결과값은 더 큰 표현타입인 int 타입의 변수로만 저장할 수 있습니다.
  
  	long lx = 30L;
  	long lz = z + lx; // 결과값은 더 큰 표현타입인 long 타입의 변수로만 저장할 수 있습니다.
  
  	float fx = x; // 결과값은 더 큰 표현타입인 float 타입의 변수로만 저장할 수 있습니다.
  	float fy = y; // 결과값은 더 큰 표현타입인 float 타입의 변수로만 저장할 수 있습니다.
  	float fz = z; // 결과값은 더 큰 표현타입인 float 타입의 변수로만 저장할 수 있습니다.
  	System.out.println(lz);
  	System.out.println(fx);
  	System.out.println(fy);
  	System.out.println(fz);
  }
  }

• 비트 연산
  • <<(왼쪽으로 자리수 옮기기), >>(오른쪽으로 자리수 옮기기)
  • 0,1 은 2진수 값이기 때문에,
    • 자리수를 왼쪽으로 옮기는 횟수만큼 2의 배수로 곱셈이 연산되는것과 동일합니다.
    • 자리수를 오른쪽으로 옮기는 횟수만큼 2의 배수로 나눗셈이 연산되는것과 동일합니다.

  // 비트 연산
  
  System.out.println(3 << 2);
  
  // 3의 이진수는 11  11을 왼쪽으로 2번이동 1100
  
  // 2의 영승은 0 2의 1승은 0 2의2승은 1 2의3승은 1
  
  // 8 + 4  = 12
  
  System.out.println(3 << 1);
  
  // 3을 왼쪽으로 1만큼 비트연산 해달라는 의미
  
  // 110
  
  // 4 + 2 = 6

• 조건문

  // if
  
  if(flag){
  
  System.out.println("정답입니다");
  
  } else if (4 > 3) {
  
  System.out.println("여기도 실행해주세요");
  
  }else {
  
  System.out.println("여기가 마지막입니다!!");
  
  }
  
  // switch / case
  
  int num = 11;
  
  String result;
      switch (num){
          case 1: 
  									result = "1이정답이래";
                  break;
          case 2: 
  									result = "2가정답이래";
                  break;
          default:result = "결국 11이래";
      }
  
      System.out.println(result);
  // 개선된 switch문
  switch (operationInput){
  
  case "+" -> this.calculator.setOperation(new AddOperation());
  
  case "-" -> this.calculator.setOperation(new SubstractOperation());
  
  case "*" -> this.calculator.setOperation(new MultiplyOperation());
  
  case "/" -> this.calculator.setOperation(new DivideOperation());
  
  }
  

• 반복문

  // for
  
      int[] arr = {1,2,3,4,5};
      for(int i = 0; i < arr.length; i++){
          System.out.println(arr[i]);
      }
  // 최신 for
  
  for(int i : arr){
  
  System.out.println(i);
  
  // 초기값이 0으로 설정되고
  
  // 배열끝까지 for문이 돌아간다
  
  // for문이 돌아갈 때마다 설정한 변수에 배열값이 할당된다
  
  }
  // while
  
  boolean answer = true;
  
  int i = 1;
  
  while (answer){
  
  if(i < arr.length){
  
  System.out.println("i값이 아직작아 : "+i);
  
  i++;
  
  }
  
  }
  // do-while
  
  // 연산을 한번 수행 후 조건문 체크
  
  int num1 = 4;
  
  do{
  
  System.out.println(num1 + "출력" );
  
  }while (num1 < 3);
  

  // Objects.equals(좌,우) : 좌우가 같은경우 true ,다른경우 false
  
  //        Scanner sc = new Scanner(System.in);
  
  //
  
  //        System.out.print("A 입력 : ");
  
  //        String aHand = sc.nextLine(); // A 입력
  
  //
  
  //        System.out.print("B 입력 : ");
  
  //        String bHand = sc.nextLine(); // B 입력
  
  //
  
  //        if (Objects.equals(aHand, "가위")) { // 값을 비교하는 Obects.equals() 메서드 사용
  
  //            if (Objects.equals(bHand, "가위")) {
  
  //                System.out.println("A 와 B 는 비겼습니다."); // A 와 B 의 입력값을 비교해서 결과 출력
  
  //            } else if (Objects.equals(bHand, "바위")) {
  
  //                System.out.println("B 가 이겼습니다.");
  
  //            } else if (Objects.equals(bHand, "보")) {
  
  //                System.out.println("A 가 이겼습니다.");
  
  //            } else {
  
  //                System.out.println(" B 유저 값을 잘못 입력하셨습니다.");
  
  //            }
  
  //        } else if (Objects.equals(aHand, "바위")) {
  
  //            if (Objects.equals(bHand, "가위")) {
  
  //                System.out.println("A 가 이겼습니다.");
  
  //            } else if (Objects.equals(bHand, "바위")) {
  
  //                System.out.println("A 와 B 는 비겼습니다.");
  
  //            } else if (Objects.equals(bHand, "보")) {
  
  //                System.out.println("B 가 이겼습니다.");
  
  //            }
  
  //        } else if (Objects.equals(aHand, "보")) {
  
  //            if (Objects.equals(bHand, "가위")) {
  
  //                System.out.println("B 가 이겼습니다.");
  
  //            } else if (Objects.equals(bHand, "바위")) {
  
  //                System.out.println("A 가 이겼습니다.");
  
  //            } else if (Objects.equals(bHand, "보")) {
  
  //                System.out.println("A 와 B 는 비겼습니다.");
  
  //            }
  
  //        }

• break continue

  // break 명령 범위
  
      for (int i = 0; i < 10; i++) {
          System.out.println("i: " + i);
          if (i == 2) {
              break; // i 가 2일때 가장 바깥 반복문이 종료됩니다.
          }
          for (int j = 0; j < 10; j++) {
              System.out.println("j: " + j);
              if (j == 2) {
                  break; // j 가 2일때 가장 안쪽 반복문이 종료됩니다.
              }
          }
      }
  // 출력
  
  //        i: 0 // 바깥 반복문 부터 수행 시작
  
  //        j: 0 // 안쪽 반복문 1회차 수행
  
  //        j: 1
  
  //        j: 2 // j 가 2일때 안쪽 반복문 break;
  
  //        i: 1 // 바깥 반복문은 아직 break; 호출이 안됬으므로 다음 반복수행
  
  //        j: 0 // 안쪽 반복문 2회차 수행
  
  //        j: 1
  
  //        j: 2 // j 가 2일때 안쪽 반복문 두번째 break;
  
  //        i: 2 // i 가 2일때 바깥 반복문도 break; 호출되어 종료

  // continue 명령
  
      int number = 0;
      while(number < 3) {
          number++;
          if (number == 2) {
              continue;  // 2일때 반복 패스
              // 바깥쪽 부분이 패스됨
              // 바로 다음 반복문으로 넘어감
              // 해당 부분은 스킵된다는 의미
          }
          System.out.println(number + "출력");
      }
  // 출력
  
  //        1출력
  
  //        3출력

• 배열
  • 1차원

    // 선언 방식 2가지
    
    int [] num;
    
    int num2 [];
    
        // 배열위치값은 0부터시작
        // Arrays.fill -> 초기화
    
        num = new int[5]; // 배열의 크기 결정 초기값으로 0이들어감
        for(int i =0; i < num.length; i++){
            num[i] = i;
            System.out.println(num[i]);
        }
    
        for (int i : num){
            // map함수 사용법이라고 생각하면 편함
            System.out.println(i);
        }
    
    
        int [] num3 = {1, 2, 3, 4, 5}; // 선언과 동시에 값집어넣음
        Arrays.fill(num3,22); // 22로 전부 변환
        for(int i : num3){
            System.out.println(i);
        }</code></pre></details></li></ul><ul id="dc45e4a6-37b2-4f96-9ce2-d7b489c178aa" class="toggle"><li><details open=""><summary>2차원 / 3차원</summary><pre id="790b751f-2bcc-45ba-a47b-d54de55a30eb" class="code"><code>// 2차원 배열 선언 방식
        // - int[][] array
        // - int array[][]
        // - int[] array[]
    
        // 중괄호를 사용해 초기화
    
        int[][] array = {
                {1, 2, 3},
                {4, 5, 6}
        };
    
        // 반복문을 통한 초기화
    
        int[][] array2 = new int[2][3]; // 최초 선언
    
        for (int i = 0; i &lt; array2.length; i++) {
            for (int j = 0; j &lt; array2[i].length; j++) {
                System.out.println(&quot;확인 : &quot; + i + &quot;//&quot; + j);
    
                array2[i][j] = 0;  // i, j 는 위 노란색 네모박스 안에있는 숫자를 의미하며 인덱스 라고 부릅니다.
            }
        }
    // 3차원 배열의 이해
        // 중괄호 3개를 써서 3차원 배열 초기화를 할 수 있습니다.
        int[][][] MultiArray = {{{1, 2}, {3, 4}}, {{5, 6}, {7, 8}}};</code></pre></details></li></ul><ul id="aabc6078-2ccd-47f1-b302-88a7285972e4" class="toggle"><li><details open=""><summary>가변배열</summary><pre id="b547c95b-f4d1-4a10-8228-60cc7e53c6ad" class="code"><code>// 가변배열
        // 2차원 배열 생성시 행마다 다른 길이를 지정해줄수 있다
    
    
        // 선언 및 초기화
    
        int[][] array = new int[3][]; // 다른 길이를 주고싶을때는 이렇게 그공간의 크기는 작성해주지 않는다
    
        // 배열 원소마다 각기다른 크기로 지정 가능
        array[0] = new int[2];
        array[1] = new int[4];
        array[2] = new int[1];
    
        // 중괄호 초기화할때도 원소배열들의 크기를 각기 다르게 생성 가능
        int[][] array2 = {
                {10, 20},
                {10, 20, 30, 40},
                {10}
    
        };
    
        // 가변 2차원 배열 조회
        int[][] array3 = {
                {10, 20, 30},
                {10, 20, 30, 40},
                {10, 20}
        };
    
        for (int i = 0; i &lt; array3.length; i++) { // 1차원 길이
            for (int j = 0; j &lt; array3[i].length; j++) { // 2차원 길이
                System.out.println(array3[i][j]); // 2중 반복문으로 i, j 인덱스 순회
            }
        }
    
        // 출력
    //        10
    
    //        20
    
    //        30
    
    //        10
    
    //        20
    
    //        30
    
    //        40
    
    //        10
    
    //        20

  • 최대 최소값 예제

    int [] arr = {21,33,555,2,43};
    
        int max = arr[0];
    
        for(int i : arr){
            if(max < i){
                max = i;
            }
        }
        System.out.println(max);
    
        int min = arr[0];
    
        for(int i : arr){
            if(min > i){
                min = i;
            }
        }
        System.out.println(min);</code></pre></details></li></ul></details></li></ul><ul id="29952dc6-6d06-4816-92d5-a9c0a17b1c35" class="toggle"><li><details open=""><summary>깊은 복사 얕은 복사</summary><pre id="2ba0fbf5-141c-470a-b506-38ccb178bd37" class="code"><code>// 바로 할당하면 해당 부분의 주소를 복사하는것이기때문에
        // 할당해준 변수가 변하면 값이 같이 변한다
        // 똑같은 값을 가지고 있는게 아니라 주소값을 가진다
        int a [] = {1,2,3,4};
        int b [] = a; // 얕은 복사
    
        b[0] = 55;
    
        System.out.println(a[0]);
    			System.out.println(b[0]);
    			// 두개 다 같은값을 가진다 
    			// 동일한 주소를 가지기때문에 값역시 같이 변하는것을 확인할 수 있다
    
        // 깊은 복사
        // 할당해준 변수와 별개의 주소를 가지게 된다.
    
        int[] a1 = { 1, 2, 3, 4 };
        int[] b1 = new int[a.length];
    
        for (int i = 0; i &lt; a1.length; i++) {
            b1[i] = a1[i]; // 깊은 복사
        }
    
        b1[0] = 3; // b 배열의 0번째 순번값을 3으로 수정했습니다. (1 -&gt; 3)
    
        System.out.println(a1[0]); // 출력 1 &lt;- 깊은 복사를 했기때문에 a 배열은 그대로 입니다.
    
        // 깊은 복사 메서드
    
        // 1. clone() 메서드
        int[] a2 = { 1, 2, 3, 4 };
        int[] b2 = a2.clone(); // 가장 간단한 방법입니다.
        // 하지만, clone() 메서드는 2차원이상 배열에서는 얕은 복사로 동작합니다!!
    
    
        // 2. Arrays.copyOf() 메서드
        int[] a3 = { 1, 2, 3, 4 };
        int[] b3 = Arrays.copyOf(a3, a3.length); // 배열과 함께 length값도 같이 넣어줍니다.
        for(int i:b3){
            System.out.println(i);
        }</code></pre></details></li></ul><ul id="1a99071d-4564-426f-9364-0ef8a7024730" class="toggle"><li><details open=""><summary>문자 문자열</summary><table id="47d8ff08-51bc-4d56-bd30-3492afdc0bbc" class="simple-table"><tbody><tr id="49a6e1fa-0ca9-49fd-8f47-e657379a6218"><td id="bjre" class="">메서드</td><td id="M_Cj" class="">응답값 타입</td><td id="Rpih" class="" style="width:323px">설명</td></tr><tr id="07253789-1099-4a74-9d1c-d1b58cdcfb23"><td id="bjre" class="">length()</td><td id="M_Cj" class="">int</td><td id="Rpih" class="" style="width:323px">문자열의 길이를 반환한다.</td></tr><tr id="b75212a8-cb77-41d8-a254-85ca4936ea57"><td id="bjre" class="">charAt(int index)</td><td id="M_Cj" class="">char</td><td id="Rpih" class="" style="width:323px">문자열에서 해당 index의 문자를 반환한다.</td></tr><tr id="d5152f12-10d6-423a-bd12-3e53907d3a3e"><td id="bjre" class="">substring(int from, int to)</td><td id="M_Cj" class="">String</td><td id="Rpih" class="" style="width:323px">문자열에서 해당 범위(from~to)에 있는 문자열을 반환한다. (to는 범위에 포함되지 않음)</td></tr><tr id="a0fd74b0-6f66-496c-939c-64a0b50ae0b0"><td id="bjre" class="">equals(String str)</td><td id="M_Cj" class="">boolean</td><td id="Rpih" class="" style="width:323px">문자열의 내용이 같은지 확인한다. 같으면 결과는 true, 다르면 false가 된다.</td></tr><tr id="5269d040-a1f1-4434-ae55-060986417a97"><td id="bjre" class="">toCharArray()</td><td id="M_Cj" class="">char[]</td><td id="Rpih" class="" style="width:323px">문자열을 문자배열(char[])로 변환해서 반환한다.</td></tr><tr id="d5980ae5-60d0-4a8f-bad5-76c27e9194be"><td id="bjre" class="">new String(char[] charArr)</td><td id="M_Cj" class="">String</td><td id="Rpih" class="" style="width:323px">문자배열(char[]) 을 받아서 String으로 복사해서 반환한다.</td></tr></tbody></table><pre id="dd83c706-e169-4482-992c-359e63d7ede4" class="code"><code>// 문자(char / 1byte), 문자열(string)
    
        // 기본형 변수 vs 참조형 변수
        // 1. 기본형 변수는 &#x27;소문자로 시작함&#x27; / 참조형은 &#x27;대문자로 시작함&#x27;
        //  - Wrapper class에서 기본형 변수를 감싸줄 때(boxing), int -&gt; Integer
        // 2. 기본형 변수는 값 자체를 저장, 참조형 변수는 별도의 공간에 값을 저장 후 그 주소를 저장함(=주소형 변수)
    
        // char &lt; String
        // String 가지고 있는 기능이 너무 많아서
        // Wrapper class와도 비슷함 -&gt; 기본형 변수가 가지고 있는 기능이 제한 -&gt; 다양한 기능을 제공하는 Wrpper을 감쌈으로써, 추가기능을 더함
    
        String str =&quot;abcd&quot;;
    
        // length
        int strLength = str.length();
        System.out.println(strLength); // 4
    
        // charAt(int index)
        char strChar = str.charAt(1);
        System.out.println(strChar); // b
    
        // substring (int fromIndex, int toIndex) -&gt; 문자열을 잘라서 새로운 str을 생성
        String strsub = str.substring(0,3);
        System.out.println(strsub); // abc
    
        // equals(String str) 입력받은 문자열과 같니 문자열의 경우의 비교연산자
        String newstr = &quot;abcd&quot;;
        boolean strEqual = newstr.equals(str);
        System.out.println(strEqual); // true
    
        // toCharArray() : String을 char[]로 변환
        char [] strCharArray = str.toCharArray();
    
        // char[] -&gt; String변환 -&gt; char
        char [] charArray = {&#x27;a&#x27;,&#x27;b&#x27;,&#x27;c&#x27;};
        String charArrayString = new String(charArray);
        System.out.println(charArrayString);</code></pre></details></li></ul><ul id="b16e029e-c7b3-4dec-962b-19a6564658ea" class="toggle"><li><details open=""><summary>동기화</summary><pre id="4106af5b-7d17-42f8-917c-2d922fd508c2" class="code"><code>- 쓰레드가 하나의 자원을 놓고 싸우지 말고 락을 가진 쓰레드부터 차례대로 그자원을 쓰고 다음 쓰레드에게 락과 함께 자원을 반남하라는 의미
    
    동기화를 안해도 되는 부분을 괜히 동기화하면 쓰레드가 하나밖에 수행되지 못하는 이슈가 있을수있음

    방법	설명
    임계영역(critical section)	공유 자원에 대해 단 하나의 스레드만 접근하도록 한다. (하나의 프로세스에 속한 스레드만 가능하다)
    뮤텍스 (mutex)	공유 자원에 대해 단 하나의 스레드만 접근하도록 한다. (서로 다른 프로세스에 속한 스레드도 가능)
    이벤트 (event)	특정한 사건의 발생을 다른 스레드에게 알린다.
    세마포어 (Semaphore)	한정된 개수의 자원을 여러 스레드가 사용하려고 할 때 접근을 제한한다.
    대기 가능 타이머 (waitable timer)	특정 시간이 되면 대기중이던 스레드를 깨운다.

  • 컬렉션(Collection)

    JCF(Java Collections Framework)
    
    데이터, 자료구조인 컬렉션과 이를 구현하는 클래스를 정의하는 인터페이스를 제공
    
    사용할때는 기본형 변수가 아닌 참조형 변수를 사용해야한다

  아래 사진은 상속구조를 보여주는 사진
map의 경우에는 collection 인터페이스를 상속받고 있지 않지만 collection으로 분류

  // Collection을 사용하는 이유
  
  1. Collection의 일관된 API를 사용하여 모든 클래스가 Collection에서 상속받아 통일된 메서드를 사용
  
  2. 객체지향프로그래밍의 추상화가 성공적으로 구현

  

  ■ Collection 인터페이스의 특징

  인터페이스	구현클래스	특징
  Set	HashSet TreeSet	순서를 유지하지 않는 데이터의 집합으로 데이터의 중복을 허용하지 않는다.
  List	LinkedList Vector ArrayList	순서가 있는 데이터의 집합으로 데이터의 중복을 허용한다.
  Queue	LinkedList PriorityQueue	FIFO(First in First out) 들어간 순서대로 나온다.
  Map	Hashtable HashMap TreeMap	키(Key), 값(Value)의 쌍으로 이루어진 데이터 집합으로, 순서는 유지되지 않으며 키(Key)의 중복을 허용하지 않으나 값(Value)의 중복은 허용한다.

  • List

    // Vector는 동기화가 이미되어있는 클래스로 한번에 하나의 쓰레드만 접근 가능
    
    // Arraylist는 동기화처리가 안된 클래스로 동시에 여러쓰레드에 접근이 가능

    // ArrayList
    
    // List
    
    // array와 다른점 -> 처음에 길이를 몰라도 만들수있다
    
    // Array -> 정적배열
    
    // List(ArrayList) -> 동적배열(크기가 가변적으로 늘어남)
    
    // - 생성 시점에 작은 연속된 공간을 요청해서 참조형 변수들을 담아놓는다
    
    // - 값이 추가될 때 더 큰 공간이 필요한면 더 큰 공간을 받아서 저장함
    
    // 표준 배열보다 느릴수도있지만 움직이이 많은 배열에서 유용
    
    // ArrayList import를 해주어야함
    
        ArrayList<Integer> intList = new ArrayList<Integer>(); // 선언과 생성
    
        intList.add(1); // 값 추가
        intList.add(12); // 값 추가
        intList.add(123); // 값 추가
    
        System.out.println(intList.get(0)); // 첫번째로 집어넣은 값 가져오기
    
        intList.set(1,22); // 1번째 index위치에있는값을 22로 변환
    
        System.out.println(intList.get(1)); // 22
    
        intList.remove(1); // index번호의 값을 삭제
    
        System.out.println(intList.get(1)); // 123 -> 22번값이 삭제되어 123번이 1번째 index위치로 땅겨져옴
    
        System.out.println(intList.toString()); // list안의값 전부 가져오기
        intList.clear(); // 해당 list 초기화
        System.out.println(intList.toString()); // list안의값 전부 가져오기</code></pre><pre id="483ffd8d-d6d4-42e9-a8cf-ca7105f68f97" class="code"><code>// linked list
        // 메모리에 남는 공간을 요청해서 여기 저기 나누어서 실제 값을 담아둠
        // 실제 값이 있는 주소값으로 목록을 구성하고 저장하는 자료구조
    
        // 기본적 기능 -&gt; ArrayList와 동일
        // LinkedList는 값 -&gt; 여기 저기 나누어서 값을 넣었기때문에 조회하는 속도가 느리다
        // 값을 추가 하거나 삭제할때는 빠르다
        // 이유로는 ArrayList처럼 순서가 있는 경우에는 순서하나하나를 확인하지마
        // Linked List의 경우에는 비어있는 값에가서 그냥 저장 삭제를 하기때문에
    
        LinkedList&lt;Integer&gt; linkedList = new LinkedList&lt;Integer&gt;(); 
    			// LinkedList&lt;Integer&gt; linkedList = new LinkedList&lt;&gt;(); // 생성시 타입생략가능
        linkedList.add(1);
        linkedList.add(122);
        linkedList.add(1333);
    
        System.out.println(linkedList.get(0));
        System.out.println(linkedList.get(1));
        System.out.println(linkedList.get(2));
    
        System.out.println(linkedList.toString()); // arraylist보다 속도가 느림
    
        // arraylist와 다른점
        // add를 할때 index위치를 지정할수있다
    
        linkedList.add(1,4444); // 1번째 index에 4444값을 추가
        System.out.println(linkedList.toString()); // 추가 삭제는 빠르다
    
        linkedList.set(2,5555);
        System.out.println(linkedList.toString());
    
        linkedList.remove(2);
        System.out.println(linkedList.toString());
    
        linkedList.clear();
        System.out.println(linkedList.toString());</code></pre><pre id="ea734050-afad-4567-8ace-3b218d083331" class="code"><code>// Vector
    // ArrayList와 유사
    
    // 차이점으로는 Vector는 동기화가되고, ArrayList는 안됨
    
    // Vector는 동기화가 이미되어있는 클래스로 한번에 하나의 쓰레드만 접근 가능
    
    // Arraylist는 동기화처리가 안된 클래스로 동시에 여러쓰레드에 접근이 가능
    mport java.io.;
    
    import java.util.;
    class GFG {
    
    public static void main(String[] args)
    
    {
        // Vector 선언
        Vector&lt;Integer&gt; v
            = new Vector&lt;Integer&gt;();
    
        // 데이터 입력
        for (int i = 1; i &lt;= 5; i++)
            v.add(i);
    
        // 결과 출력
        System.out.println(v);
    
        // 3번 데이터 삭제
        v.remove(3);
    
        // 결과 출력
        System.out.println(v);
    
        // 하나씩 결과 출력
        for (int i = 0; i &lt; v.size(); i++)
            System.out.print(v.get(i) + &quot; &quot;);
    }
    }

  • Stack

    // Stack
    
    // 수직을 값을 쌓아놓고, 넣었다가 뺀다 filo
    
    // push(넣기),peek(조회),pop(삭제)
    
    // 최근 저장된 데이터를 나열하거나 데이터 중복 처리를 막고 싶을때
    
        Stack<Integer> intStack = new Stack<Integer>();
    
        intStack.push(12);
        intStack.push(1222);
        intStack.push(124444);
    
        // 다 지워질때까지 출력
        while(!intStack.isEmpty()){
            // isEmpty() -> 공백일때 true
            // 위의 조건은 !이 있으니까 값이 있을때 true반환
            System.out.println(intStack.pop());
            // 제일 위에있는 값이 조회되면서 빠져나옴
            // 지금같이 3개가 있는경우 3번돌아감
    
        }
    
        intStack.push(12333);
        intStack.push(12);
        intStack.push(1);
    
        System.out.println(intStack.peek());
        // 가장 마지막에 들어감 값인 1이들어감 / 맨위값을조회
        System.out.println(intStack.size());
        // 길이
    // 스택 인덱스의 값 확인
    // 스택.elementAt(인덱스);
    // 스택 특정 값이 어느 인덱스에 들었나 확인
    // 스택.indexOf("값");

  • Queue

    // Queue : fifo
    
    // add, peek, poll
    
    // Queue : 생성자가 없는 인터페이스
    
        Queue<Integer> intQueue = new LinkedList<Integer>();
    
        intQueue.add(1);
        intQueue.add(12);
        intQueue.add(31);
    
        while (!intQueue.isEmpty()){
            System.out.println(intQueue.poll());
            // stack과 다르게 들어간순서대로 나옴
        }
    
        intQueue.add(1);
        intQueue.add(12);
        intQueue.add(31);
    
        System.out.println(intQueue.peek());
        System.out.println(intQueue.size());
    
        intQueue.add(3133);
        System.out.println(intQueue.size());</code></pre></details></li></ul><ul id="3b2d3347-8d66-4ecd-8dcf-99d9412d17b4" class="toggle"><li><details open=""><summary>Set</summary><ul id="8d7a507d-ca20-49b0-9364-39025e657838" class="bulleted-list"><li style="list-style-type:disc"><strong>HashSet</strong><ul id="77a23984-fe73-409b-932c-a269398141eb" class="bulleted-list"><li style="list-style-type:circle">가장빠른 임의 접근 속도순서를 예측할 수 없음</li></ul><ul id="da3145af-d5a9-4240-b01d-02da27b78659" class="bulleted-list"><li style="list-style-type:circle">순서를 예측할 수 없음</li></ul><ul id="210a3722-690c-4b77-90ff-1eb9df860248" class="toggle"><li><details open=""><summary>HashSet사용법</summary><pre id="464ba4da-e6bd-4740-8d82-1ac843e11353" class="code"><code>// set : 집합 순서 없고, 중복 없음
        // set -&gt; 그냥 사용할수도있고, HashSet,TreeSet등으로 응용해서도 사용 가능
        // set은 생성자가 없는 인터페이스
        // 바로 생성 불가능
        // HashSet은 생성자가 존재
    
        Set&lt;Integer&gt; intSet = new HashSet&lt;Integer&gt;();
    
        intSet.add(11);
        intSet.add(112);
        intSet.add(1133);
        intSet.add(11);
    
        for(Integer value : intSet){
            System.out.println(value);
            // 11이 중복되어서 세번만 반복됨
        }
    
        // contains
        // 해당값을 포함 하고있는지 여부확인 reture값 true/false
        System.out.println(intSet.contains(2));
        System.out.println(intSet.contains(233));</code></pre></details></li></ul></li></ul><ul id="c830386d-b8e7-4e0c-9d0b-aed6937cd022" class="bulleted-list"><li style="list-style-type:disc"><strong>TreeSet</strong><ul id="dc25d88b-7c6f-42a6-8dde-fd86083baac4" class="bulleted-list"><li style="list-style-type:circle">정렬방법을 지정할 수 있음</li></ul><ul id="48647af3-1f02-415b-b869-4d18ddf4d800" class="toggle"><li><details open=""><summary>TreeSet사용법</summary><pre id="15e9d8d0-44d7-4bf2-acb3-c62e438a97d4" class="code"><code>// 처음설정은 오름차순
    TreeSet<자료형> 변수명 = new TreeSet<>();
    // 내림차순
    
    TreeSet<자료형> 변수명 = new TreeSet<>(Collections.reverseOrder);
    
    

    메서드 (Method)

    TreeSet<Integer> tSet = new TreeSet<>();

    연산	코드	반환 값
    삽입	tSet.add(삽입할 value);	트리에 value가 저장되어있던 경우 = False트리에 value가 저장되어있지 않던 경우 = True
    삭제	tSet.remove(삭제할 value);	트리에 value가 저장되어있던 경우 = True트리에 value가 저장되어있지 않던 경우 = False
    모든 값 삭제	tSet.clear();	-
    크기	tSet.size();	트리의 사이즈
    전체 원소 집합 출력	System.out.println(tSet);	[원소1, 원소2, ..., 원소n]
    정렬 순서 기준 맨 앞 원소	tSet.first();	정렬 순서 기준 맨 앞 원소
    정렬 순서 기준 맨 뒤 원소	tSet.last();	정렬 순서 기준 맨 뒤 원소
    value보다 큰 원소들 중 최솟값	tSet.higher(value);	value보다 큰 원소들 중 최솟값
    value보다 작은 원소들 중 최댓값	tSet.lower(value);	value보다 작은 원소들 중 최댓값
    트리가 비어있는지 확인	tSet.isEmpty();	트리의 사이즈가 0이면 = True트리의 사이즈가 0보다 크면 = False
    트리에 value가 저장되어 있는지	tSet.contains(value);	트리에 value가 저장되어있는 경우 = True트리에 value가 저장되어있지 않은 경우 = False

• SortedSet
  • 엘리멘트들을 정렬된 순서로 저장
  • 저장되는 엘리먼트가 Comparable 인터페이스를 구현하고 있다면 compare()메서드의 로직을 이용
  • 구현체를 생성할 때 Comparator 클래스를 넘겨 엘리먼트들의 대소 비교에 사용가능

  SortedSet<String> sortedSet = new TreeSet<>();
  
  //        sortedSet.add("Elem5");
  
  //        sortedSet.add("Elem3");
  
  //        sortedSet.add("Elem1");
  
  //        sortedSet.add("Elem3");
  
  //        sortedSet.add("Elem1");
  
  //
  
  //        for (String elem : sortedSet) {
  
  //            System.out.println(elem);
  
  //            // 중복값은 제거되고 1,3,5순으로 정렬되서 나옴
  
  //        }
      sortedSet.add(&quot;Elem5&quot;);
      sortedSet.add(&quot;Elem2&quot;);
      sortedSet.add(&quot;Elem4&quot;);
      sortedSet.add(&quot;Elem3&quot;);
      sortedSet.add(&quot;Elem1&quot;);
  //        SortedSet<String> headSet = sortedSet.headSet("Elem3");
  
  //        System.out.println("Head Set");
  
  //        for (String elem : headSet) {
  
  //            System.out.println(elem);
  
  //            // Elem3값을 넣어주었기때문에
  
  //            // 끝값인 3전까지 출력
  
  //            // 1,2가 나옴
  
  //        }
  //        SortedSet<String> tailSet = sortedSet.tailSet("Elem4");
  
  //        System.out.println("Tail Set");
  
  //        for (String elem : tailSet) {
  
  //            System.out.println(elem);
  
  //            // Elem4부터 이후로의 값이 나옴
  
  //        }
  
  //
  
  //        SortedSet<String> subSet = sortedSet.subSet("Elem2", "Elem5");
  
  //        System.out.println("Sub Set");
  
  //        for (String elem : subSet) {
  
  //            System.out.println(elem);
  
  //            // 2부터 5사이의 값이 나옴
  
  //            // 마지막 값은 포함안됨
  
  //        }
      System.out.println(sortedSet.first()); // 첫번째 값만
      System.out.println(sortedSet.last()); // 마지막 값만</code></pre></li></ul></details></li></ul><ul id="21281538-e114-4a02-8f17-776745c2b32c" class="toggle"><li><details open=""><summary>Map</summary><ul id="ff125c4f-dff3-4e5b-b228-a700e79ff4c3" class="bulleted-list"><li style="list-style-type:disc"><strong>Hashtable</strong><ul id="19dacc8f-b0ac-4200-935a-d5c40ef45377" class="bulleted-list"><li style="list-style-type:circle">HashMap보다는 느리지만 동기화 지원</li></ul><ul id="684ca327-c1af-466d-bd3d-38544e9e916c" class="bulleted-list"><li style="list-style-type:circle">null불가</li></ul></li></ul><ul id="839b1d57-9096-47cb-900c-aca2f5fab2e4" class="bulleted-list"><li style="list-style-type:disc"><strong>HashMap</strong><ul id="6ff0274e-bad2-4382-925d-90485bcc0821" class="bulleted-list"><li style="list-style-type:circle">중복과 순서가 허용되지 않으며 null값이 올 수 있다.</li></ul></li></ul><ul id="2fb9ca01-e60e-41e9-89fd-f4c530d9327e" class="bulleted-list"><li style="list-style-type:disc"><strong>TreeMap</strong><ul id="9147ab4d-f402-41f3-95ae-80abbe866002" class="bulleted-list"><li style="list-style-type:circle">정렬된 순서대로 키(Key)와 값(Value)을 저장하여 검색이 빠름</li></ul></li></ul><pre id="431660e3-ed58-4fce-aa83-3853119dc69b" class="code"><code>// Map : key - value pair -&gt; 중요
      // key라는 값으로  unique하게 보장이 되어야함
      // Map -&gt; HashMap,TreeMap으로 응용
  
      Map&lt;String,Integer&gt; intmap = new HashMap&lt;&gt;();
  
      // 키 값
      intmap.put(&quot;일&quot;,1);
      intmap.put(&quot;이&quot;,2);
      intmap.put(&quot;삼&quot;,3);
      intmap.put(&quot;사&quot;,4);
      intmap.put(&quot;오&quot;,5);
      intmap.put(&quot;오&quot;,6);
  
      for(String key : intmap.keySet()){
          // .keySet() : key값만 가져옴
          System.out.println(key); // 중복된 key는 생략되어서 하나만 나옴
      }
  
      for(Integer value : intmap.values()){
          // .values() : values값만 가져옴
          System.out.println(value); // 중복된 값중에서 가장 마지막으로 들어간 값이 나옴
      }
  
      System.out.println(intmap.get(&quot;이&quot;)); // key값으로 value값 찾아오기</code></pre><ul id="0a1c64ec-1387-4a37-b95d-7e1d609f701d" class="toggle"><li><details open=""><summary>Map출력방법</summary><p id="03b520dc-d939-437f-b43f-5b765da82f7c" class="">Map에 값을 전체 출력하기 위해서는 entrySet(), keySet() 메소드를 사용하면 되는데 entrySet() 메서드는 key와 value의 값이 모두 필요한 경우 사용하고, keySet() 메서드는 key의 값만 필요한 경우 사용</p><p id="02a8e03d-2178-446b-9de5-40928b9bf3ea" class=""><strong>방법 01. entrySet()</strong></p><pre id="7937cc90-1b9d-4c70-bc2d-915e97962fc3" class="code code-wrap"><code>Map&lt;String, String&gt; map = new HashMap&lt;&gt;();
  map.put("key01", "value01");
  
  map.put("key02", "value02");
  
  map.put("key03", "value03");
  
  map.put("key04", "value04");
  
  map.put("key05", "value05");
  // 방법 01 : entrySet()
  
  for (Map.Entry<String, String> entry : map.entrySet()) {
  
  System.out.println("[key]:" + entry.getKey() + ", [value]:" + entry.getValue());
  
  }

  방법 02. keySet()

  Map<String, String> map = new HashMap<>();
  
  map.put("key01", "value01");
  
  map.put("key02", "value02");
  
  map.put("key03", "value03");
  
  map.put("key04", "value04");
  
  map.put("key05", "value05");
  
  // 방법 02 : keySet()
  
  for (String key : map.keySet()) {
  
  String value = map.get(key);
  
  System.out.println("[key]:" + key + ", [value]:" + value);
  
  }

  방법 03. entrySet().iterator()

  Iterator 인터페이스를 사용할 수 없는 컬렉션인 Map에서 Iterator 인터페이스를 사용하기 위해서는 Map에 entrySet(), keySet() 메소드를 사용하여 Set 객체를 반환받은 후 Iterator 인터페이스를 사용

  Map<String, String> map = new HashMap<>();
  
  map.put("key01", "value01");
  
  map.put("key02", "value02");
  
  map.put("key03", "value03");
  
  map.put("key04", "value04");
  
  map.put("key05", "value05");
  
  // 방법 03 : entrySet().iterator()
  
  Iterator<Map.Entry<String, String>> iteratorE = map.entrySet().iterator();
  
  while (iteratorE.hasNext()) {
  
  Map.Entry<String, String> entry = (Map.Entry<String, String>) iteratorE.next();
  
  String key = entry.getKey();
  
  String value = entry.getValue();
  
  System.out.println("[key]:" + key + ", [value]:" + value);
  
  }

  방법 04. keySet().iterator()

  Map<String, String> map = new HashMap<>();
  
  map.put("key01", "value01");
  
  map.put("key02", "value02");
  
  map.put("key03", "value03");
  
  map.put("key04", "value04");
  
  map.put("key05", "value05");
  
  // 방법 04 : keySet().iterator()
  
  Iterator<String> iteratorK = map.keySet().iterator();
  
  while (iteratorK.hasNext()) {
  
  String key = iteratorK.next();
  
  String value = map.get(key);
  
  System.out.println("[key]:" + key + ", [value]:" + value);
  
  }

  방법 05. Lambda 사용

  Map<String, String> map = new HashMap<>();
  
  map.put("key01", "value01");
  
  map.put("key02", "value02");
  
  map.put("key03", "value03");
  
  map.put("key04", "value04");
  
  map.put("key05", "value05");
  
  // 방법 05 : Lambda 사용
  
  map.forEach((key, value) -> {
  
  System.out.println("[key]:" + key + ", [value]:" + value);
  
  });

  방법 06. Stream 사용

  Map<String, String> map = new HashMap<>();
  
  map.put("key01", "value01");
  
  map.put("key02", "value02");
  
  map.put("key03", "value03");
  
  map.put("key04", "value04");
  
  map.put("key05", "value05");
  
  // 방법 06 : Stream 사용
  
  map.entrySet().stream().forEach(entry-> {
  
  System.out.println("[key]:" + entry.getKey() + ", [value]:"+entry.getValue());
  
  });
  // Stream 사용 - 내림차순
  
  map.entrySet().stream().sorted(Map.Entry.comparingByKey()).forEach(entry-> {
  
  System.out.println("[key]:" + entry.getKey() + ", [value]:"+entry.getValue());
  
  });
  // Stream 사용 - 오름차순
  
  map.entrySet().stream().sorted(Map.Entry.comparingByKey(Comparator.reverseOrder())).forEach(entry-> {
  
  System.out.println("[key]:" + entry.getKey() + ", [value]:"+entry.getValue());
  
  });

• Vector

  // ArrayList와 동일한 내부구조
  
  // ArrayList와 다르게 동기화된 메소드로 구성
  
  // 멀티 스레드가 동시에 이 메서드를 실행할 수 없고,하나의 스레드가 실행을 완료해야만 다른 스레드들이 실행할 수 있다
  
  // 멀티 스레드 환경에서 안전하게 객체를 추가 삭제가 가능
  
  // 항상 동기화 되기때문에 스레드가 하나여도 동기화를 한다
  
  // 그렇기 때문에 ArrayList보다 성능이 떨어진다
  
  // ArrayList는 자동 동기화기능은 없고 옵션으로 존재한다
  
  // 그리고 벡터보다 속도가 빠르기 때문에 ArrayList를 더많이 사용한다

  

  // 선언
  
  // 타입을 지정하지 않고 임의의 타입의 값을 넣고 사용할 수도 있지만
  
  // 벡터 내부의 값을 사용하려면 캐스팅(Casting)연산이 필요하며 잘못된 타입으로 캐스팅을 한 경우에는 에러가 발생할 수 도 있다
  
  // 그렇기 때문에 사용시 타입명시를 하는게 좋다
  
  Vector v = new Vector();//타입 미설정 Object로 선언된다.
  
  Vector<Student> student = new Vector<Student>(); //타입설정 Student객체만 사용가능
  
  Vector<Integer> num2 = new Vector<Integer>(); //타입설정 int타입만 사용가능
  
  Vector<Integer> num3 = new Vector<>(); //new에서 타입 파라미터 생략가능
  
  Vector<String> v2 = new Vector<String>(10);//초기 용량(capacity)지정
  
  Vector<Integer> v3 = new Vector<Integer>(Arrays.asList(1,2,3)); //초기값 지정

  // 값 추가
  
  // 구조는 ArrayList와 LinkedList와 같다
  
  // add(index,value)
  
  // index를 사용하지않으면 맨뒤에 값이 추가된다
  
  Vector<Integer> v = new Vector<Integer>();
  
  v.add(3); //값 추가
  
  v.add(null); //null값도 add가능
  
  v.add(1,10); //index 1뒤에 10 삽입
  
  Vector v = new Vector();
  
  Student student = new Student(name,age);
  
  v.add(student);
  
  v.add(new Member("홍길동",15));

  // 값 삭제
  
  Vector<Integer> v = new Vector<Integer>(Arrays.asList(1,2,3));
  
  v.remove(1);  //index 1 제거
  
  v.removeAllElements(); //모든 값 제거
  
  v.clear();  //모든 값 제거

  // 크기 구하기
  
  Vector<Integer> v = new Vector<Integer>(10);//초기용량 10
  
  v.add(1); //값 추가
  
  System.out.println(v.size()); //Vector 자료 개수 : 1
  
  System.out.println(v.capacity()); //Vector 물리적크기 : 10

  // 값 출력
  
  Vector<Integer> list = new Vector<Integer>(Arrays.asList(1,2,3));
  System.out.println(list.get(0));//0번째 index 출력
  for(Integer i : list) { //for문을 통한 전체출력
  
  System.out.println(i);
  
  }
  Iterator iter = list.iterator(); //Iterator 선언
  
  while(iter.hasNext()){//다음값이 있는지 체크
  
  System.out.println(iter.next()); //값 출력
  
  }

• Iterator

  // 컬렉션 프레임워크에서 값을 가져오거나 삭제할 때 사용
  
  // 컬렌션 프레임워크를 생성한 뒤
  
  // Iterator<데이터타입> 변수명 = 컬렉션.iterator();
  
  // 장점
  
  // 1. Iterator는 모든 컬렉션 프레임워크에 공통으로 사용가능
  
  // 2. 컬렉션 프레임워크에서 쉽게 값을 가져오고 제거할 수 있음
  
  // 3. 3개의 메소드만 알면 되어서 사용하기 쉬움
  // 단점
  
  // 1. 처음부터 끝까지의 단방향 반복만 가능
  
  // 2. 값을 변경하거나 추가하는게 안됨
  
  // 3. 대량의 데이터를 제어할 때 속도가 느림

  Iterator.hasNext()

  • Iterator 안에 다음 값이 들어있는지 확인
  • 들었으면 true, 안들었음 false

  Iterator.next()

  • iterator의 다음 값 가져오기

  Iterator.remove()

  • iterator에서 next() 시에 가져왔던 값을
  • 컬렉션(List, Set, Map) 등에서 삭제
  • 반드시 next() 후에 사용해야 함

• Collections(Collection과다름!!!)

  // 이 클래스는 컬렉션에서 작동하거나 반환하는 정적 메서드로만 구성됨
  
  // 컬렉션에서 작동하는 다형성 알고리즘이 포함됨
  
  // Collection과 Colletions는 다른것이다
  
  // 정적(static)메서드이므로 인스턴스화 불필요
  
  // Collections는 클래스이다!!
  
  // Collection인터페이스를 구현한 클래스에 대한 객체생성,정렬,병합등의 기능을 안정적으로 수행하도록 도와주는 역할

  주요 method()

  메소드	설명	쓰는법
  max	지정된 컬렉션에서 최대 요소를 반환한다. (인덱스 X)
  min	지정된 컬렉션에서 초소 요소를 반환한다. (인덱스 X)
  sort	지정된 컬렉션을 정렬시킨다.오버로드 메소드들이 존재하며 가장 기본적인 메소드는 자연순서에 따라 내림차순으로 정렬된다.	Collections.sort(list)
  shuffle	지정된 컬렉션의 요소들의 순서를 무작위로 섞는다.	Collections.shuffle(list)
  synchronizedCollection	지정된 컬렉션에 의해 지원되는 동기화 된 컬렉션을 재생성해 반환한다.
  binarySearch	지정된 컬렉션에서 이진 탐색 알고리즘을 사용해 지정된 객체를 검색해 인덱스를 반환한다.	Collections.binarySearch(list,element(탐색할원소))
  disjoint	2개의 지정된 컬렉션들에서 공통된 요소가 하나도 없는 경우 true 를 반환한다.
  copy	지정된 켈렉션의 모든 요소를 새로운 컬렉션으로 복사해 반환한다.
  reverse	지정된 컬렉션에 있는 순서를 역으로 변경한다.
  reverseOrder	Comparable인터페이스를 구현하는 객체 컬렉션에 자연순서(natural ordering)의 역순을 적용하는 comparator를 반환

  Sort()

  • List인터페이스를 구현하는 컬렉션에 대하여 정렬을 수행
  • Collections.sort()는 list / Arrays.sort()는 array에 사용된다
  • 들어가는 값이 Date타입이면 시간적인 순서로 정렬
    • String클래스와 Date클래스 모두 Comparable 인터페이스를 구현하기 때문에
    • 정렬은 Comparable 인터페이스를 이용하여 이루어진다
    • List인터페이스는 Comparable인터페이스를 상속하므로 정렬이 가능하다
    • comparaTo()메서드는 매개변수 객체를 현재의 객체와 비교하여 음수,같으면0,크면 양수를 반환

  shuffle()

  • list에 존재하는 정렬을 파괴하여서 원소들의 순서를 랜덤하게 만든다
  • 정렬과 반대 동작을 한다

  binarySearch()

  • Collections클래스는 정렬된 리스트에서 지정된 원소를 이진 탐색
  • “정렬된 리스트” 에 한해서 탐색을 진행한다는 점을 명심!!!
    • 선형 탐색 : 처음부터 모든 원소를 방문하는 탐색 방법으로, 리스트가 정렬되어 있지않은 경우 사용됨
    • 이진 탐색 :
      • 리스트가 정렬되어 있는 경우 중간에 있는 원소(n)와 먼저 비교하여, 크면 그 다음부터(n+1)끝까지 비교하고,
      • 작으면 처음부터 그 전(n-1)까지의 원소들과 비교하여 방식을 반복하여 하나의 리스트를 계속해서 두 개의 리스트로 분할
      • 리스트에 하나의 원소가 남을 때까지 반복된다
      • 이진탐색은 문제의 크기를 반으로 줄일 수 있기 때문에 선형 탐색보다 효율적
    • 반환값이 양수이면 찾고자 하는 원소의 인덱스값을 출력
    • 음수이면 탐색이 실패하여 원소를 찾지 못했음을 의미
    • 단, 실패하더라도 도움이 되는 정보를 반환한다
    • 반환값에는 현재의 데이터가 삽입될 수 있는 위치정보가 들어있다
    • 반환값이 pos라고 한다면, (-pos-1)이 해당 데이터를 삽입할 수 있는 위치이다.

    // -pos-1이 데이터 삽입 가능 index이다.
    
    int pos = Collections.binarySearch(list, key);
    
    if(pos < 0) list.add(-pos-1);

• length vs length() vs size()
  💡
  length vs length() vs size() - 길이값 가져오기

  1. length

  • arrays(int[], double[], String[])

  • length는 배열의 길이를 조회해줍니다.

  2. length()

  • String related Object(String, StringBuilder etc)

  • length()는 문자열의 길이를 조회해줍니다. (ex. “ABCD”.length() == 4)

  3. size()

  • Collection Object(ArrayList, Set etc)

  • size()는 컬렉션 타입목록의 길이를 조회해줍니다.

• 랜덤값 만들기

  System.out.println("0.0 ~ 1.0 사이의 난수 1개 발생 : " + Math.random());
  
  System.out.println("0 ~ 10 사이의 난수 1개 발생 : " + (int)((Math.random()10000)%10));
  
  System.out.println("0 ~ 100 사이의 난수 1개 발생 : " + (int)(Math.random()100));

  Random random = new Random(); //랜덤 객체 생성(디폴트 시드값 : 현재시간)
  
  random.setSeed(System.currentTimeMillis()); //시드값 설정을 따로 할수도 있음
  
  System.out.println("n 미만의 랜덤 정수 리턴 : " + random.nextInt(10));
  
  System.out.println("무작위 boolean 값 : " + random.nextBoolean());
  
  System.out.println("무작위 long 값 : " + random.nextLong());
  
  System.out.println("무작위 float 값 : " + random.nextFloat());
  
  System.out.println("무작위 double 값 : " + random.nextDouble());
  
  System.out.println("무작위 정규 분포의 난수 값 :" + random.nextGaussian());

• 숫자야구만들기

  // 이슈
  
  int 타입의 숫자값을 scanner로 입력한 값을 받아오고 그다음 잘라서 배열에 넣어주어야하는 작업이 있었다
  
  String으로 변환하는 과정에서 첫번째 숫자값이 0이면 인식을 못하고 나중에 배열에 값을 넣어줄때
  
  가장 마지막 index로 값이 들어가는 이슈가 발생
  
  타입변환으로 사용한 메소드는
  
  1. String.valueof()
  
  2. Integer.toString()
  
  3. int [] answer = Stream.of(String.valueOf(result).split("")).mapToInt(Integer::parseInt).toArray(); 
  해결법으로는 받아오는 값을 String으로 하여 나중에 배열로 집어넣을때 Integer로 형변환 해주었다.
  
  하지만 왜 첫번째자리가 0이면 인식을 못하는지의 이슈는 찾아보면서 해결해야한다.
  // 해결
  int typing = sc.nextInt();
  
  System.out.print("받아온 숫자값 : ");
  
  System.out.println(typing);
  
  String str = String.valueOf(typing);
  
  System.out.print("문자열로 형변환 : ");
  
  System.out.println(str);
  
  String [] strarr = str.split("");
  
  System.out.print("split진행 : ");
  
  System.out.println(Arrays.toString(strarr));
  위의식으로 테스트해본결과 입력할때 숫자를 023으로 하였지만
  
  출력했을때는 전부다23으로나왔다 여기서 유추해볼수있는것은 숫자는 첫숫자가 0이면 생략하고
  
  023과 23이 같다고 인식하여 23으로 나오게한다.
  
  그래서 데이터를 변환하는 과정에서 0이계속해서 사라지는것을 확인할수있었다.
  그리고 마지막에 0이들어간 이유로는 이미 배열은 3개의공간을 생성했는데
  
  받아와지는 값이 두개 밖에없으니까 마지막값은 생성할때의 0인상태로 남아있었던 것이다.
  
  

  import java.util.Random;
  
  import java.util.Scanner;
  
  public class Main {
  
  public static void main(String[] args) {
  
  Random rd = new Random();
  
  Scanner sc = new Scanner(System.in);
  
  int [] arr = new int[3];
  
  for(int i = 0; i < arr.length; i++){
  
  arr[i] = rd.nextInt(10);
  
  for(int j = 0; j < i; j++){
  
  if(arr[i] == arr[j]){
  
  arr[i] = rd.nextInt(10);
  
  i--;
  
  }
  
  }
  
  }
  
  // System.out.println(Arrays.toString(arr));
    int cnt = 0;
    while (true){
        cnt++;
        System.out.print(cnt+&quot;번째 시도 : &quot;);
        String result = sc.nextLine();
  
        String [] result2 = result.split(&quot;&quot;);
        int [] arr2 = new int[3];
        for(int i =0; i &lt; result2.length; i++){
            arr2[i] = Integer.parseInt(result2[i]); // (int)로는 기본형변수타입이기때문에 참조형변수인 string이 변환이 안되어 한번 wrapper class를 사용하여 변환
        }
  
        int strikes = 0;
        int balls = 0;
        for(int i = 0; i &lt; arr.length; i++){
            if(arr[i] == arr2[i]){
                strikes++;
            }
            for(int j = 0; j &lt; arr.length; j++){
                if(arr[i] == arr2[j] &amp;&amp; j != i){
                    balls++;
                }
            }
        }
  
        String strikeresult = strikes+&quot;S&quot;;
        String ballsresult = balls+&quot;B&quot;;
        if(strikes == 0){
            strikeresult =&quot;&quot;;
        }
        if(balls == 0){
            ballsresult = &quot;&quot;;
        }
  
        if(strikes == 3){
            System.out.println(strikeresult);
            System.out.println(cnt+&quot;번만에 맞히셨습니다.&quot;);
            break;
        }
  
        System.out.println(ballsresult + strikeresult);
  
  
  
  
    }
  }
  }

  

• 객체

  // 속성 = 필드
  
  // 메소드 = 행위
  
  // 객체 = 인스턴스(클래스를 기반으로) 인스턴스화
  
  // 클래스 : 객체를 만들기 위한 설계도

  // 캡슐화
  
  // 필드와 메서드를 하나로 묶어 객체로 만든후 외부에서 알 수 없게 감춘것
  
  // 외부에서는 내부를 알 수 없기때문에 접근할 수 있는 필드나 메서드를 통해 접근
  
  // 외부에서 잘못사용하여 객체가 변화하지않는 것을 막기위해
  
  // 접근제어자를 통해서 허용범위를 정함
  
  // 상속
  
  // 부모객체의 필드와 메서드를 자식객체에게 물려줘서 사용할 수 있게함
  
  // 객체간의 구조파악이 쉬워짐
  
  // 필드 메서드 변경시 부모객체에 있는 것만은 부모객체에서 수정하면 자식객체에서 전부에 반영되므로 일관성이 좋음
  
  // 코드 중복이줄고 재사용성이 좋다
  // 다형성
  
  // 객체가 연산을 수행할 때 하나의 행위에 대해 각 객체가 가지고있는 고유한 특성에 따라 다른 여러가지 형태로 재구성되는것
  // 추상화
  
  // 객체에서 공통되는 부분들을 모아 상위 개념으로 새롭게 선언하는것
  
  // 공통적이고 중요한 것들을 모아 객체를 모델링

  • 전반적인 틀만들기 및 사용법 예시

    Car car1 = new Car(); // new 키워드를 사용해서 생성자 호출
    
    Car car2 = new Car(); // 인스턴스 생성
    
        System.out.println(car1); // 주소값 : week03.chap07.Car@7a81197d
    
        car1.horn();
    
        Car [] carArray = new Car[3];
        char p = car1.changeGear('P');
        System.out.println(p);
    
        carArray[0] = car1;
    
        car2.changeGear('N');
    
        carArray[1] = car2;
    
        Car car3 = new Car();
        car3.changeGear('D');
        carArray[2] = car3;
    
        for(Car car : carArray){
            System.out.println("car.gear = " + car.gear); // .(도트)연산자로 접근
             위에서 changeGear()메소드를 통해서 값을 변경하고
             해당값이 들어간 필드를 불러와서 보여줌
        }</code></pre><pre id="f1a3ec79-6f5a-49b6-bebb-b11701a73fd8" class="code"><code>Car car = new Car();
    
         초기값 기본 값 확인 : 초기값을 준 것은 그 값이 들어가고, 아닌값은 default value가 들어있음
        System.out.println(&quot;car.model = &quot;+car.model);
        System.out.println(&quot;car.color = &quot;+car.color);
    
        System.out.println(&quot;car.speed = &quot;+car.speed);
        System.out.println(&quot;car.gear = &quot; + car.gear);
        System.out.println(&quot;car.lights = &quot;+car.lights);
    
        System.out.println(&quot;car.tire = &quot;+car.tire);
        System.out.println(&quot;car.door = &quot;+car.door);
    
        // 필드 사용
        car.color = &quot;blue&quot;;
        car.speed = 100;
        car.lights = false;
    
        System.out.println(&quot;car.color = &quot;+car.color);
        System.out.println(&quot;car.speed = &quot;+car.speed);
        System.out.println(&quot;car.lights = &quot;+car.lights);</code></pre><pre id="d0ef6683-9c63-4f90-ad00-0eed62896e1b" class="code"><code>System.out.println(&quot;car.gear = &quot;+ car.gear);
    
        double speed = car.gasPedal(100,&#x27;D&#x27;);
        System.out.println(&quot;speed : &quot; + speed);
    
        boolean lights = car.onOffLight();
        System.out.println(&quot;lights : &quot; + lights);
    
        System.out.println();
        System.out.println(&quot;car.gear = &quot;+ car.gear);
    
        System.out.println(&quot;&quot;);
        car.carSpeed(100,80,22);
    
        System.out.println(&quot;&quot;);
        car.carSpeed(100,80,22,2222,44);</code></pre><hr id="25e8146e-4baf-4ca5-960a-b4eeac3fc2c9"/><pre id="7bbd36cb-cca0-479f-bfeb-19e9509c2fa6" class="code"><code>package week03.chap07;
    // 클래스 만들때의 4가지 스텝
    
    // 1. 클래스 선언
    
    // 2. 속성 정의
    
    // 3. 생성자 -> constructor(정의하는방식)
    
    // 4. 메서드 정의
    
    public class Car {// 1. 클래스 선언
    // 2. 속성 정의
    // 필드 영역
    // 선언만한 상태
    
    // 고유 데이터 영역
    String company;
    String model = &quot;Gv80&quot;;
    String color;
    double price;
    
    // 상태 데이터 영역
    double speed;
    char gear = &#x27;P&#x27;;
    boolean lights = true;
    
    // 객체 데이터 영역
    Tire tire = new Tire();
    Door door;
    Handle handle;
    
    
    // 3. 생성자(클래스 이름과 동일해야함) : 처음 객체가 생성될때(instance화) 어떤 로직을 수행해야하며, 어떤값이 필수로 들어와야 하는지 정의
    public Car (){
        // 기본생성자 : 생략이 가능출
        System.out.println(&quot;Car 생성자 호출&quot;);
    }
    
    // 4. 메소드
    
    // gasPedal
    // input : kmh
    // output : spped
    double gasPedal(double kmh, char type){ // 리턴타입을 작성
        changeGear(type);
        speed = kmh;
        return speed;
    }
    
    // brakePedal
    // input : none
    // output : speed
    double brakePedal(){
        speed = 0;
        return speed;
    }
    
    // changeGear
    // input : gear(char type)
    // output : gear
    char changeGear(char type){
        gear = type;
        return gear;
    }
    
    // onOffLight
    // input : none
    // output : boolean
    boolean onOffLight(){
        lights = !lights;
        return lights;
    }
    
    // horn
    // input : x
    // output : x
    void horn(){
        // return값이 필수가 아니다
        System.out.println(&quot;나와!!!!!&quot;);
    }
    
    
    
    // 자동차의 속도 .. 가변길이 메소드
    void carSpeed(double ... speeds){   // ... : 스프레드 매개 변수 / 배열로 들어옴
        for(double v : speeds){
            System.out.println(&quot;v = &quot;+v);
        }
    }
    }

    package week03.chap07;
    
    public class Door {
    
    public Door(){
    
    System.out.println("문 객체 생성");
    
    }
    
    }
    package week03.chap07;
    public class Handle {
    
    public Handle (){
    
    System.out.println("핸드객체 만들어짐");
    
    }
    
    }
    package week03.chap07;
    public class Tire {
    
    public Tire(){
    
    System.out.println("타이어 생성");
    
    }
    
    }

  • 필드 타입별 기본값

    데이터 타입	기본값
    byte	0
    char	\u0000 (공백)
    short	0
    int	0
    long	0L
    float	0.0F
    double	0.0
    boolean	false
    배열	null
    클래스	null
    인터페이스	null

• 오버로딩

  // 오버로딩
  
  // 메서드의 이름은 같지만 매개변수의 타입이나 순서나 개수가 다른것
  
  // 응답값만 다른것은 안된다
  
  // 접근 제어자만 다른것도 오버로딩이라고 할 수 없다
  
  // 매개변수의 차이로만 구현가능
  
      // 장점
      // 1. 메서드명을 절약할수있다 -> 같은 이름에서 타입만 변경해서 쓸수있기때문에
      // 2. 같은이름으로 다른 동작을 개별 정의가 가능하다
  
      // 기본형 매개변수는 값자체가 복사되어 넘어가기때문에 매개값으로 지정된 변수의 원본값이 변경안됨
      // 참조형 매개변수는 지정한 값의 주소를 매개변수에 복사해서 전달하기 때문에 값을 읽거나 변경하는 것이 가능</code></pre><ul id="800b055a-a94e-4baf-8b57-b83a2dad9bd3" class="bulleted-list"><li style="list-style-type:disc">예시 </li></ul><pre id="4d7ec027-db4e-4cbf-aee4-d02e4f1afdc1" class="code"><code>public class PrintStream extends FilterOutputStream
  implements Appendable, Closeable
  {
  
  ...
  	public void println() {
      newLine();
  }
  
  public void println(boolean x) {
      if (getClass() == PrintStream.class) {
          writeln(String.valueOf(x));
      } else {
          synchronized (this) {
              print(x);
              newLine();
          }
      }
  }
  
  public void println(char x) {
      if (getClass() == PrintStream.class) {
          writeln(String.valueOf(x));
      } else {
          synchronized (this) {
              print(x);
              newLine();
          }
      }
  }
  
  public void println(int x) {
      if (getClass() == PrintStream.class) {
          writeln(String.valueOf(x));
      } else {
          synchronized (this) {
              print(x);
              newLine();
          }
      }
  }
  
  public void println(long x) {
      if (getClass() == PrintStream.class) {
          writeln(String.valueOf(x));
      } else {
          synchronized (this) {
              print(x);
              newLine();
          }
      }
  }
  
  public void println(float x) {
      if (getClass() == PrintStream.class) {
          writeln(String.valueOf(x));
      } else {
          synchronized (this) {
              print(x);
              newLine();
          }
      }
  }
  
  public void println(double x) {
      if (getClass() == PrintStream.class) {
          writeln(String.valueOf(x));
      } else {
          synchronized (this) {
              print(x);
              newLine();
          }
      }
  }
  
  public void println(char[] x) {
      if (getClass() == PrintStream.class) {
          writeln(x);
      } else {
          synchronized (this) {
              print(x);
              newLine();
          }
      }
  }
  
  public void println(String x) {
      if (getClass() == PrintStream.class) {
          writeln(String.valueOf(x));
      } else {
          synchronized (this) {
              print(x);
              newLine();
          }
      }
  }
  
  public void println(Object x) {
      String s = String.valueOf(x);
      if (getClass() == PrintStream.class) {
          // need to apply String.valueOf again since first invocation
          // might return null
          writeln(String.valueOf(s));
      } else {
          synchronized (this) {
              print(s);
              newLine();
          }
      }
  }
  
  
  	  ...
  }

• 기본형과 참조형 매개변수의 차이

  // 기본형 매개변수는 매개값 자체가 복사되어 넘어가기때문에 원본에는 영향을 안미친다
  
  // 참조형 매개변수의 경우에는 주소값이 넘어가기 때문에 원본이 바뀌는등 영향을 미친다

  package week03.parameter;
  
  public class Main {
  
  public static void main(String[] args) {
  
  Car car = new Car(); // 객체 생성
      // 기본형 매개변수
      char type = 'D';
      car.brakePedal(type);
  
      // 메서드 실행 완료 후 전달할 매개값으로 지정된 type 값 확인
      System.out.println("type = " + type); // 기존에 선언한 값 'D' 출력, 원본 값 변경되지 않음
      // 메서드 실행 완료 후 반환된 car 인스턴스의 gear 타입 확인
      System.out.println("gear = " + car.gear); // 객체 내부에서 type을 변경하여 수정했기 때문에 'P' 출력
  
  
  
      System.out.println();
      // 참조형 매개변수
      Tire tire = new Tire();
      tire.company = "금호"; // 금호 타이어 객체 생성
  
      // 차 객체의 타이어를 등록하는 메서드 호출한 후 반환값으로 차 객체의 타이어 객체 반환
      Tire carInstanceTire = car.setTire(tire);
  
      // 메서드 실행 완료 후 전달할 매개값으로 지정된 참조형 변수 tire의 company 값 확인
      System.out.println("tire.company = " + tire.company); // "KIA" 출력
      // 전달할 매개값으로 지정된 tire 인스턴스의 주소값이 전달되었기 때문에 호출된 메서드에 의해 값이 변경됨.
  
      // 메서드 실행 완료 후 반환된 car 인스턴스의 tire 객체 값이 반환되어 저장된 참조형 변수 carInstanceTire의 company 값 확인
      System.out.println("carInstanceTire.company = " + carInstanceTire.company); // "KIA" 출력
  }
  }

  package week03.parameter;
  
  public class Tire {
  
  String company; // 타이어 회사
  
  public Tire() {}
  
  }

  package week03.parameter;
  
  public class Car {
  String company; // 자동차 회사
  String model; // 자동차 모델
  String color; // 자동차 색상
  double price; // 자동차 가격
  
  double speed;  // 자동차 속도 , km/h
  char gear; // 기어의 상태, P,R,N,D
  boolean lights; // 자동차 조명의 상태
  
  Tire tire;
  Door door = new Door();
  Handle handle = new Handle();
  
  public Car() {} // 기본 생성자
  
  double gasPedal(double kmh, char type) {
      changeGear(type);
      speed = kmh;
      return speed;
  }
  
  double brakePedal(char type) {
      speed = 0;
      type = 'P'; // 정지 후 매개변수 type을 어떤 타입으로 전달 받았는지 상관없이 'P'로 고정시키기
      changeGear(type);
      return speed;
  }
  
  char changeGear(char type) {
      gear = type;
      return gear;
  }
  
  boolean onOffLights() {
      lights = !lights;
      return lights;
  }
  
  void horn() {
      System.out.println("빵빵");
  }
  
  Tire setTire(Tire tireCompany) {
      tireCompany.company = "KIA"; // 금호 타이어를 전달 받았지만 강제로 KIA 타이어로 교체
      tire = tireCompany;
      return tire;
  }
  }

• 인스턴스 멤버와 클래스 멤버
  💡
  멤버 = 필드 + 메서드

  • 인스턴스 멤버 = 인스턴스 필드 + 인스턴스 메서드

  • 클래스 멤버(정적 멤버) = 클래스 필드 + 클래스 메서드

  선언하는 방법에 따라서 인스턴스 멤버와 클래스 멤버로 구분할 수 있다

  인스턴스 멤버는 객체 생성 후에만 사용할 수 있고, 클래스 멤버의 경우에는 그럴 필요가 없다

  인스턴스 멤버의 경우 지금까지 new를 사용해서 객체생성해준것들
  
  클래스는 Java의 클래스 로더에 의해 메서드 영역에 저장되고 사용됨
  클래스 멤버란 메서드 영역의 클래스와 같은 위치에 고정적으로 위치하는 멤버
  객체생성이 불필요

  // 클래스 멤버 선언
  
  필드와 메서드에서 static키워드를 사용하면 가능
  
  static은 정적인 메소드를 의미한다
  
  Static영역에 할당되며, Static영역에 할당된 메모리는 모든 객체가 공유하여 하나의 멤버를 어디서든지 참조할 수 있는 장점을 가지지만
  
  Garbage Collector의 관리 영역 밖에 존재하므로 Static영역에 있는 멤버들은 프로그램의 종료시까지 메모리가 할당된 채로 존재
  
  그러므로 너무 남발하면 시스템 성능에 악영향을 줄 수 있다.
  
  // 사용하는 경우
  
  1. 인스턴스마다 모두 가지고 있을 필요가 없는 공용적인 데이터를 저장하는 필드의 경우
  
  2. 인스턴스 필드를 사용하지 않고 실행되는 메서드의 경우
  클래스 멤버로 선언된 메서드는 인스턴스 멤버를 사용할 수 없다
  
  인스턴스 멤버로 선언된 메서드는 클래스 멤버를 사용할 수 있다
  
  클래스 멤버는 객체 생성없이 바로 사용 가능하기 때문에 객체가 생성되어야 존재할 수 있는 인스턴스 멤버를 사용할 수 없다
  
  클래스 필드로 공유하게 만든다면 메모리를 효율적으로 사용할 수 있다

  // 인스턴스 변수는 인스턴스가 생성될때마다 생성되므로 인스턴스마다 각기 다른 값을 가지지만
  
  // 정적변수(클래스 필드)는 모든 인스턴스가 하나의 저장공간을 공유하기에 항상 같은 값을 가진다
  
  // 아래식에서 첫번째 println은 num이 정적 변수이기에 new로 객체생성을 해도 number1과number2와 동일한 저장공간을 공유하기때문에 값이1로 올라간것을 확인할수있다.
  
  // 하지만 두번째 println의 경우 인스턴스 필드로 객체가 생성될때 마다 별도의 값을 생성해서 사용하기때문에 number2.num2는 0인상태이고 number1.num2만 1로올라간것을 확인할수있다.
  
  class Number{
  
  static int num = 0; //클래스 필드
  
  int num2 = 0; //인스턴스 필드
  
  }
  public class Static_ex {
  public static void main(String[] args) {
  	Number number1 = new Number(); //첫번째 number
  	Number number2 = new Number(); //두번쨰 number
  	
  	number1.num++; //클래스 필드 num을 1증가시킴
  	number1.num2++; //인스턴스 필드 num을 1증가시킴
  	System.out.println(number2.num); //두번째 number의 클래스 필드 출력
  	System.out.println(number2.num2); //두번째 number의 인스턴스 필드 출력
  }
  }
  

  • 예제코드

  public class Car {
  
  static String company = "GENESIS"; // 자동차 회사 : GENESIS
  String model; // 자동차 모델
  String color; // 자동차 색상
  double price; // 자동차 가격
  
  double speed;  // 자동차 속도 , km/h
  char gear; // 기어의 상태, P,R,N,D
  boolean lights; // 자동차 조명의 상태
  
  
  public Car() {} // 기본 생성자
  
  double gasPedal(double kmh, char type) {
      changeGear(type);
      speed = kmh;
      return speed;
  }
  
  double brakePedal() {
      speed = 0;
      return speed;
  }
  
  char changeGear(char type) {
      gear = type;
      return gear;
  }
  
  boolean onOffLights() {
      lights = !lights;
      return lights;
  }
  
  void horn() {
      System.out.println("빵빵");
  }
  
  String getCompany() {
      return "(주)" + company;
  }
  
  static String setCompany(String companyName) {
      // System.out.println("자동차 모델 확인: " + model); // 인스턴스 필드 사용 불가
      company = companyName;
      return company;
  }
  }

  public class Main {
  
  public static void main(String[] args) {
  
  // 클래스 필드 company 확인
  
  System.out.println(Car.company + "\n");
  
  // 클래스 필드 변경 및 확인
  
  Car.company = "Audi";
  
  System.out.println(Car.company + "\n");
  
      // 클래스 메서드 호출
      String companyName = Car.setCompany("Benz");
      System.out.println("companyName = " + companyName);
  
      System.out.println();
      // 참조형 변수 사용
      Car car = new Car(); // 객체 생성
  
      car.company = "Ferrari";
      System.out.println(car.company + "\n");
  
      String companyName2 = car.setCompany("Lamborghini");
      System.out.println("companyName2 = " + companyName2);
  }
  }

• 지역 변수 final필드 상수

  // 지역 변수 <-> 전역 변수
  
  // 해당 메서드가 실행될 때 마다 독립적인 값을 저장하고 관리
  
  // 이 지역변수가 메서드 내부에서 정의될 때 생성
  
  // 이 메서드가 종료될 때 소멸
  
  // final
  
  // final 필드는 초기값이 저장되면 해당값을 프로그램이 실행하는 도중에는 절대로 수정할 수 없습니다.
  
  // 또한 final 필드는 반드시 초기값을 지정해야 합니다.
  // 상수
  
  // 전체가 대문자인 변수는 상수
  
  // 상수의 특징은 값이 반드시 한개이며 불변의 값
  
  // 스턴스마다 상수를 저장할 필요가 없다
  
  // final 앞에 static 키워드를 추가하여 모든 인스턴스가 공유할 수 있는 값이 한개이며 불변인 상수를 선언

  static final String COMPANY = "GENESIS";
  
  ...
  System.out.println(Car.COMPANY);

• 생성자

  // 기본 생성자는 매개변수가 없는것을 의미한다
  // 모든 클래스에는 매개변수가 하나이상 존재해야지만 매개변수는 생략이 가능하기때문에
  // 따로 만들지 않아도 오류가 발생하지 않는것이다
  // 하지만 생성자가 있는경우에는 자동으로 기본 생성자는 생성되지않는다
  // 생성자는 객체를 초기화 하는 역할을 수행
  
  // 생성자의 매개변수에 맞추어서 인스턴스화해야한다.
  // 생성자 오버로딩도 가능하다
  
  // 개수,타입,순서가 동일한데 매개변수명만 다른경우에는 불가능

  package week03.constructor;
  
  import java.util.stream.StreamSupport;
  public class Car {
  static final String COMPANY = "GENESIS"; // 자동차 회사 : GENESIS
  String model; // 자동차 모델
  String color; // 자동차 색상
  double price; // 자동차 가격
  
  double speed;  // 자동차 속도 , km/h
  char gear = 'P'; // 기어의 상태, P,R,N,D
  boolean lights; // 자동차 조명의 상태
  
  
  // constructor
  // 오버로딩 생성자
  public Car(String modelName) {
      model = modelName;
      System.out.println("첫번째 생성자");
  }
  
  public Car(String modelName, String colorName) {
      model = modelName;
      color = colorName;
      System.out.println("두번째 생성자");
  }
  
  public Car(String modelName, String colorName, double priceValue) {
      model = modelName;
      color = colorName;
      price = priceValue;
      System.out.println("세번째 생성자");
  }
  
  double gasPedal(double kmh, char type) {
      changeGear(type);
      speed = kmh;
      return speed;
  }
  
  double brakePedal() {
      speed = 0;
      return speed;
  }
  
  char changeGear(char type) {
      gear = type;
      return gear;
  }
  
  boolean onOffLights() {
      lights = !lights;
      return lights;
  }
  
  void horn() {
      System.out.println("빵빵");
  }
  }

  package week03.constructor;
  
  public class Main {
  
  public static void main(String[] args) {
      // 기본 생성자 호출 오류 확인
      // Car car1 = new Car(); // 오류 발생
  
      // 생성자 오버로딩을 통해 여러 상황에서 자동차 생산
      // 제네시스 자동차를 생산 : static final String COMPANY = "GENESIS"; 상수 고정
      // 모든 자동차는 생산시 기어의 최초 상태 'P' 로 고정 : char gear = 'P'; 직접 대입하여 초기화
  
      // GV60 모델만 기본으로 선택
      Car car2 = new Car("GV60");
      System.out.println("car2.model = " + car2.model);
      System.out.println("car2.gear = " + car2.gear + "\n");
  
      // GV70 모델, 색상 Blue 만 기본으로 선택
      Car car3 = new Car("GV70", "Blue");
      System.out.println("car3.model = " + car3.model);
      System.out.println("car3.color = " + car3.color);
      System.out.println("car3.gear = " + car3.gear + "\n");
  
      // GV80 모델, 색상 Black, 가격 50000000 으로 완전하게 고정된 경우
      Car car4 = new Car("GV80", "Black", 50000000);
      System.out.println("car4.model = " + car4.model);
      System.out.println("car4.color = " + car4.color);
      System.out.println("car4.price = " + car4.price);
      System.out.println("car4.gear = " + car4.gear + "\n");
  
  }
  }

• this this()

  // this는 객체(인스턴스) 자신을 표현
  
  // 매개변수명과 사용하는 필드이름이 같은 경우
  
  // 오류는 발생하지않지만 필드가 아닌 가장 가까운 매개변수명을 가리키게 됨으로 자기 자신에게 값을 대입하는 상황이 된다.
  
  // 그래서 this 키워드를 사용해서 해결해줄수있다
  
  // this는 인스턴스 자신을 뜻하기도하니까 객체의 메서드에서 리턴타입이 인스턴스 자신의 클래스 타입이라면
  
  // this르 사용하여 인스턴스 자신의 주소 반환 가능
  
  Car returnInstance() {
  
  return this;
  
  }

  // this()
  
  // 인스턴스 자신의 생성자를 호출
  
  // this()키워드를 사용해서 다른 생성자를 호출할때는 반드시 첫번째줄에 작성해야한다

  public class Car {
  
  static final String COMPANY = "GENESIS"; // 자동차 회사 : GENESIS
  String model; // 자동차 모델
  String color; // 자동차 색상
  double price; // 자동차 가격
  
  double speed;  // 자동차 속도 , km/h
  char gear = 'P'; // 기어의 상태, P,R,N,D
  boolean lights; // 자동차 조명의 상태
  
  
  	// 결론은 세번째의 생성자로 만들어지게 된다.
  public Car(String model) {
      this(model, "Blue", 50000000);
  }
  
  public Car(String model, String color) {
      this(model, color, 100000000);
  }
  
  public Car(String model, String color, double price) {
      this.model = model;
      this.color = color;
      this.price = price;
  }
  
  double gasPedal(double kmh, char type) {
      changeGear(type);
      speed = kmh;
      return speed;
  }
  
  double brakePedal() {
      speed = 0;
      return speed;
  }
  
  char changeGear(char type) {
      gear = type;
      return gear;
  }
  
  boolean onOffLights() {
      lights = !lights;
      return lights;
  }
  
  void horn() {
      System.out.println("빵빵");
  }
  
  Car returnInstance() {
      return this;
  }
  }

  public class Main {
  
  public static void main(String[] args) {
  
      // 생성자 오버로딩을 통해 여러 상황에서 자동차 생산
      // 제네시스 자동차를 생산 : static final String COMPANY = "GENESIS"; 상수 고정
      // 모든 자동차는 생산시 기어의 최초 상태 'P' 로 고정 : char gear = 'P'; 직접 대입하여 초기화
  
      // 모델을 변경하면서 만들 수 있고 색상 : Blue, 가격 50000000 고정
      Car car1 = new Car("GV60");
      System.out.println("car1.model = " + car1.model);
      System.out.println("car1.color = " + car1.color);
      System.out.println("car1.price = " + car1.price);
      System.out.println("car1.gear = " + car1.gear + "\n");
  
      // 모델, 색상을 변경하면서 만들 수 있고 가격 100000000 고정
      Car car2 = new Car("GV70", "Red");
      System.out.println("car2.model = " + car2.model);
      System.out.println("car2.color = " + car2.color);
      System.out.println("car2.price = " + car2.price);
      System.out.println("car2.gear = " + car2.gear + "\n");
  
      // GV80 모델, 색상 Black, 가격 120000000 으로 완전하게 고정된 경우
      Car car3 = new Car("GV80", "Black", 120000000);
      System.out.println("car3.model = " + car3.model);
      System.out.println("car3.color = " + car3.color);
      System.out.println("car3.price = " + car3.price);
      System.out.println("car3.gear = " + car3.gear + "\n");
  
      // this 키워드를 통해 car3 인스턴스 자신을 반환 : car3.returnInstance() = 인스턴스의 주소
      System.out.println(car3.returnInstance().model); // car3의 model
      System.out.println(car3.returnInstance().color); // car3의 color
      System.out.println(car3.returnInstance().price); // car3의 price
  
  }
  }

• super super()

  // super -> 부모 클래스의 멤버를 참조 / 자식클래스의 위치에서 사용
  
  // 자식클래스의 내부와 부모클래스에서 상속받은 멤버와 이름이 같은경우에 구분하기위해서
  
  // super.필드 -> 부모클래스의 필드값에 들어감

  public class Car {
  
  String company; // 자동차 회사
  String model; // 자동차 모델
  String color; // 자동차 색상
  double price; // 자동차 가격
  
  double speed;  // 자동차 속도 , km/h
  char gear = 'P'; // 기어의 상태, P,R,N,D
  boolean lights; // 자동차 조명의 상태
  
  public String getModel() {
      return model;
  }
  
  public String getColor() {
      return color;
  }
  
  public double gasPedal(double kmh, char type) {
      changeGear(type);
      speed = kmh;
      return speed;
  }
  
  public double brakePedal() {
      speed = 0;
      return speed;
  }
  
  public char changeGear(char type) {
      gear = type;
      return gear;
  }
  
  public boolean onOffLights() {
      lights = !lights;
      return lights;
  }
  
  public void horn() {
      System.out.println("빵빵");
  }
  }

  public class SportsCar extends Car{
  
  String engine;
  
  String model = "Ferrari"; // 자동차 모델
  String color = "Red"; // 자동차 색상
  double price = 300000000; // 자동차 가격
  
  public SportsCar(String engine) {
      this.engine = engine;
  }
  
  public void booster() {
      System.out.println("엔진 " + engine + " 부앙~\n");
  }
  
  public void setCarInfo(String model, String color, double price) {
      super.model = model; // model은 부모 필드에 set
      super.color = color; // color는 부모 필드에 set
      this.price = price; // price는 자식 필드에 set
  }
  
  @Override
  public double brakePedal() {
      speed = 100;
      System.out.println("스포츠카에 브레이크란 없다");
      return speed;
  }
  
  @Override
  public void horn() {
      booster();
  }
  }

  public class Main {
  
  public static void main(String[] args) {
  
  // 자식 클래스 스포츠카 객체 생성
  
  SportsCar sportsCar = new SportsCar("Orion");
  
      // 자식 객체의 model, color, price 초기값 확인
      System.out.println("sportsCar.model = " + sportsCar.model); // Ferrari
      System.out.println("sportsCar.color = " + sportsCar.color); // Red
      System.out.println("sportsCar.price = " + sportsCar.price); // 3.0E8
      System.out.println();
  
      // setCarInfo 메서드 호출해서 부모 및 자식 필드 값 저장
      sportsCar.setCarInfo("GV80", "Black", 50000000);
  
      // this.price = price; 결과 확인
      System.out.println("sportsCar.price = " + sportsCar.price); // 5.0E7
      System.out.println();
  
      // super.model = model; super.color = color;
      // 결과 확인을 위해 자식 클래스 필드 model, color 확인 & 부모 클래스 메서드인 getModel(), getColor() 호출
      // 자식 클래스 필드 값은 변화 없음.
      System.out.println("sportsCar.model = " + sportsCar.model); // Ferrari
      System.out.println("sportsCar.color = " + sportsCar.color); // Red
      System.out.println();
  
      // 부모 클래스 필드 값 저장됨.
      System.out.println("sportsCar.getModel() = " + sportsCar.getModel()); // GV80
      System.out.println("sportsCar.getColor() = " + sportsCar.getColor()); // Black
  
  }
  }

  ---

  // super() -> 부모클래스의 생성자를 호출
  
  // 기본 생성자의 부모클래스는 자동적으로 자식생성자에서도 생성

  // 부모 클래스 Car 생성자
  
  public Car(String model, String color, double price) {
  
  this.model = model;
  
  this.color = color;
  
  this.price = price;
  
  }
  
  // 자식 클래스 SportsCar 생성자
  
  public SportsCar(String model, String color, double price, String engine) {
  
  // this.engine = engine; // 오류 발생
  
  super(model, color, price);
  
  this.engine = engine;
  
  }

• 접근제어자
  💡
  제어자는 클래스, 변수, 메서드의 선언부에 사용되어 부가적인 의미를 부여해 줍니다.

  • 접근 제어자 : public, protected, default, private

  • 그 외 제어자 : static, final, abstract

  ❗️ 하나의 대상에 여러 개의 제어자를 조합해서 사용할 수 있으나, 접근 제어자는 단 하나만 사용할 수 있습니다.

  private < default < protected < public 순으로 많은 접근을 허용
  
  
  private
  
  
  해당 클래스 안에서만 접근이 가능
  다른 클래스에서는 접근이 불가능
  
  
  default
  
  
  따로 설정하지않으면 default로 자동설정됨
  동일한 패키지 안에서만 접근이 가능
  
  
  protected
  
  
  동일 패키지의 클래스 또는 해당 클래스를 상속받은 클래스에서만 접근 가능
  
  
  public
  
  
  어떤 클래스에서도 접근 가능

  • 사용가능한 접근 제어자
    • 클래스 : public, default
    • 메서드 & 멤버변수 : public, protected, default, private
    • 지역변수 : 없음
  • 접근 제어자를 이용한 캡슐화 (은닉성)
    • 접근제어자는 클래스 내부에 선언된 데이터를 보호하기 위해서 사용합니다.
    • 유효한 값을 유지하도록, 함부로 변경하지 못하도록 접근을 제한하는 것이 필요합니다.
  • 생성자의 접근 제어자
    • 생성자에 접근 제어자를 사용함으로 인스턴스의 생성을 제한할 수 있습니다.
    • 일반적으로 생성자의 접근 제어자는 클래스의 접근 제어자와 일치합니다.

• Getter Setter

  객체의 무결성(변경이 없는 상태를 유지하기 위해 접근제어자를 사용)

• 외부에서 필드에 직접 접근을 막기위해 private default등 사용
  • Getter
    📌
    외부에서 객체의 private 한 필드를 읽을 필요가 있을 때 Getter 메서드를 사용합니다.

    private double speed;  // 자동차 속도 , km/h
    
    private char gear = 'P'; // 기어의 상태, P,R,N,D
    
    private boolean lights; // 자동차 조명의 상태

    • 자동차 클래스의 필드에 이처럼 private 접근 제어자로 지정한 필드가 있을 때 Getter 메서드를 통해 값을 가져올 수 있습니다.

    public String getModel() {
    
    return model;
    
    }

  public String getColor() {
  return color;
  }

  public double getPrice() {
return price;
}

  • 메서드 이름의 규칙은 : get + 필드이름(첫 글자 대문자) 입니다.
  • 사용하는 방법은 인스턴스 메서드 호출과 동일합니다.