DanStory

Map에 HashMap넣는건 동시성 문제생기니 코테때만 사용하기
Value Map은 그냥 Map 2개 만들어서 사용하는게 더 편할듯하다

import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;


 		/**
         * 1. MAP<String, LIST>
         */

        HashMap<String, List> mapList = new HashMap<>();
        //PUT
        mapList.put("A", Arrays.asList("list1","list2"));
        //GET
        mapList.get("A").get(0);

        /**
        //2. MAP<String, MAP<Key,Value>>
         *
         */
        Map<String, Map<String,Integer>> mapMapOf = new HashMap<>();
        Map<String, Map<String,Integer>> mapMapOfEntry = new HashMap<>();
        HashMap<String, HashMap<String,Integer>> mapMapPut = new HashMap<>();
        Map<String, int[]> mapArr = new HashMap<>();


        /**
         * ※ 수정이 불가능
         * 자바 9버전 이상에서는 Map.of 사용가능
         * 10개 제한

         */
        mapMapOf.put("key1",Map.of(
                                    "mapKey1",1,
                                    "mapKey2",2
                                   )
        );

        System.out.println("mapMapOf = "+mapMapOf);
        System.out.println("mapMapOf = "+mapMapOf.get("key1").get("mapKey1"));
      //mapMapOf.get("key1").put("mapKey1",3);
        System.out.println("mapMapOf = "+mapMapOf);
      //mapMapOf.put("key1",mapMapOf.get("key1").put("mapKey1",3));
        /**
         * ※ 수정이 불가능
         * 10개 이상 초기화 가능
         */
        new HashMap<String,Integer>().entrySet();
        mapMapOfEntry.put("key1",Map.ofEntries(
                                      entry("sndKey1",1),
                                      entry("sndKey2",2)
                                 )
        );

        System.out.println("mapMapOfEntry = "+mapMapOfEntry);
        System.out.println("mapMapOfEntry = "+mapMapOfEntry.get("key1").get("sndKey2"));
      //  mapMapOfEntry.get("key1").put("sndKey2",3);
      //  System.out.println("mapMapOfEntry = "+mapMapOfEntry);

        /**
         * 자바 8버전 이하에서도 사용 가능
         * ※ 수정가능
         */
        mapMapPut.put("key1",new HashMap<String,Integer>(){{ put("sndKey1",1);
                                                          put("sndKey2",2); }});

        //값 얻기
        System.out.println("mapMapPut = "+mapMapPut.get("key1").get("sndKey1"));
        mapMapPut.get("key1").put("sndKey2",3);
        System.out.println("mapMapPut = "+mapMapPut);

        //혹은 map 상시 생성
        HashMap<String,Integer> hs = new HashMap<>();
        System.out.println("=> "+hs.put("sndKey3",3));
        mapMapPut.put("key2",hs);

        System.out.println("mapMapPut = "+mapMapPut);



        /**
         * 맵 배멸
         *  3. MAP<Stirng, int[]>
         *
        */
        mapArr.put("key1",new int[]{1,2});
        System.out.println(mapArr.get("key1")[0]);

        mapArr.get("key1")[0]= mapArr.get("key1")[0]+10;

        System.out.println("mapArr change value => "+mapArr.get("key1")[0]);

Date Type 변경
- format 변경 = .format
- Type 변경 = .parse

1. 소스 코드

String time = "2020/10/15 17:37:15"  // 시간
int minute = 30;  // 분

SimpleDateFormat fm1 = new SimpleDateFormat("yyyy/mm/dd HH:mm:ss");


//1. String to Date
Date StringToDate;
StringToDate = fm1.parse(time);
System.out.println("1. String to Date");
System.out.println("String -> Date : "+StringToDate);
System.out.println("String -> Date : "+StringToDate.getClass()+"\n");

//2. Date to String
String DateToString;
DateToString = StringToDate.toString();
System.out.println("2. Date to String");
System.out.println("Date -> String : "+DateToString);
System.out.println("Date -> String : "+DateToString.getClass()+"\n");

//3. String change Format
String chg_dateFormat;
chg_dateFormat = fm2.format(StringToDate);
System.out.println("3. String change DateFormat");
System.out.println("String Change DateFormat : "+chg_dateFormat);
System.out.println("StringToDate Type : "+chg_dateFormat.getClass());

//4. Time Add           
String beforeTime ="2020/09/30 17:30:15";
String afterTime ="";

int minute = 30;
int hour = 1;
int day = 2;

Date D;
Calendar cal = Calendar.getInstance();
D = fm1.parse(beforeTime);
cal.setTime(D);
cal.add(Calendar.DAY_OF_WEEK, day);
cal.add(Calendar.MINUTE, minute);
cal.add(Calendar.HOUR, hour);
afterTime = fm1.format(cal.getTime());

System.out.println("4. Time Add");
System.out.println("before : "+beforeTime);
System.out.println("after  : "+afterTime);

t

2. 실행 결과

알고리즘 문제풀이를 사이트별로 따로 관리했는데, 점점 많아지면서 관리하기 귀찮아서 하나로 통합했다.

그런데 통합 후 clone 후 import 하니까 아래 사진처럼 폴더가 정렬이 안되었다.

이런 불 - 편한게 보기 싫어서 여기저기 찾아보니 java Working Set이라는 것을 발견!

설정은 아래 사진과 같다

우선 Package Explorer에서 폴더를 선택하지 않은 상태에서 빈곳을 마우스 우클릭하면 아래 사진2 처럼 나온다.
그 다음 아래 사진대로 진행

이렇게 하면 아래 사진처럼 편-안하게 폴더를 관리할 수 있다.

이거를 이제 알게되다니... 어쨋건 알았으니 유용하게 사용해야지~

인터페이스의 경우 공통된 동작을 기대하기 위해 사용하고

추상메서드의 경우 기능의 확장을 기대하기 위해 사용한다.

!?

java에서는 반복문에 이름을 정해서 해당 원하는 반복문을 빠져나갈 수 있게 코드를 작성할 수 있습니다.

int n = 1;
		for(int i=0; i<3; i++) {
			for(int j=0; j<3; j++) {
				if(n==j) {
					break;
				}
			}
		}

위 경우에는 안쪽에 있는 반복문만 탈출

전체 반복문을 빠져나가고 싶다면 아래와 같이

	loopName:
		for(int i=0; i<3; i++) {
			for(int j=0; j<3; j++) {
				if(n==j) {
					break loopName;
				}
			}
		}

loopName으로 반복문 이름을 설정하고, break에 빠져나갈 반복문 이름을 작성하면 됩니다!

상속!!!!

면접 단골 질문!

Q. 객체지향 프로그래밍(OOP)의 특징이 무엇인가요?

A. 객체지향 프로그래밍의 특징은 추상화, 캡슐화, 상속과 다형성 입니다. 

이 중에서 오늘 다루어볼 내용은 상속! 입니다.

또, 자바 시험볼 때 상속 관련 문제가 상당히 많이 출제되는 것 같습니다.

헷깔리거든요 ㅋㅋ (알면 아니지만)

어쨋건! 그래서 오늘 정리할 내용은 "상속 + 다형성" 입니다.

- 목차
1. 상속 개념
2. 생성자
3. OverLoading (다형성)
4. OverRiding
5. super

1. 상속 개념

Q. 상속이란 ?  

A. 상속을 통해 부모 클래스에 선언된 메서드나 변수를 자식 클래스에서 사용, 확장시킬 수 있는 것을 말합니다.
extends 라는 키워드를 통해 상속 받을 수 있습니다.

- 간단한 예로 살펴봅시다.

부모 클래스인 Parent class와 자식 클래스인 Child class를 생성 후 사진 1과 같이 Child class에 Parent를 상속 받습니다.

그러면 부모 클래스에 있는 print_parent()라는 메서드 및 변수들을 사용할 수 있게 됩니다. 

그러면, 궁금한 것이 생기죠. 부모 클래스의 어디까지 쓸 수 있는가!?

-> private으로 선언되지 않은 나머지는 받아 쓸 수 있습니다.

큼..심플하군.. 다음!

2. 생성자

상속을 배울때 나오는 개념 중 하나는 생성자!

Q. 생성자란 무엇이냐?

A. 클래스와 동일한 이름을 가진 메서드로, return 값이 없고, 초기화 목적으로 사용되는 메서드를 말합니다.

(전 이해 안하고 그냥 기계마냥 이렇게 외웠었음..)

맞는말이지만 제가 궁금한건 왜? 생성자를 쓰냐는 것이지요.
이유를 찾아보니, 단순했습니다. 

1. 초기값을 강제하기 위해서
2. 값을 초기화 하기 위해서

물론 생성자를 통하지 않고 값을 초기화 할 수 있습니다.

Child 객체를 3개 만들고 값을 초기화 하는 코드 입니다.

public class Child extends Parent{
		
	public static void main(String args[]) {
		
		Child c1 = new Child();
		Child c2 = new Child();
		Child c3 = new Child();
		
		c1.name = "c1 name";
		c1.age = 1;
		c1.assets = 1;
		c2.name = "c2 name";
		c2.age = 2;
		c2.assets = 2;
		c3.name = "c3 name";
		c3.age = 3;
		c3.assets = 3;
	}
}

객체가 늘어날수록 개판이 될것같네여

생성자를 통해 초기화 한다면? (물론, 생성자를 통한 초기화를 위해, Parent와 Child에 생성자를 선언해줍니다.)

깔끔하군여!

이렇게 초기화와 값의 입력을 강제하면 보다 통일된 형태와 깔끔한 코드로 작성할 수 있습니다. 그렇기 때문에 생성자를 사용하는 것이지요.

- 생성자 만들기

그러면, 생성자는 어떻게 만드는가? 가 궁금해집니다.
(아래 예제는 맨 위 '사진 1. 상속예제' 기준으로 작성했습니다.)

먼저 기본 생성자를 알아봅시다. 기본 생성자의 형태는 다음과 같습니다.

클래스이름(){

}

겁나 간단하군요. 

일반적으로 클래스를 생성하고, 객체를 생성할 때 우리는 Child c = new Child(); 이렇게 씁니다.

당연한거아닌가!?

여기서 주목할 점은 new Child() 입니다. 하나씩 명령어를 살펴봅니다.

new Child() -> new '객체'를 생성하겠다 -> 객체 'Child()'를 생성하겠다 -> Child()는 method 로군. 
-> ? -> 나는 Child() 라는 메서드를 생성한 기억이 없다!!!

일반적으로 클래스를 생성하면 자동으로 생성자가 생성됩니다. (직접 생성 안해도 자바 컴파일러가 알아서 만들어줌)
그래서 따로 생성자를 선언하지 않고, 클래스를 생성 해도 객체가 생성 될 수 있었던 이유입니다.

Class가 선언되고 실행하려면 동작 메서드가 필요한데 아무것도 없으면 곤란합니다.
그래서 만약 아무것도 작성되있지 않다면 기본 생성자를 생성하게 되는 것 입니다.

- 생성자의 생성 조건은 다음과 같습니다.

1. 클래스의 이름과 동일해야 한다.
2. return 값이 없어야 한다.
3. 생성자는 매개 변수값이 다르면 여러개 생성이 가능하다.

'사진 2. 생성자 초기화를 위한 코드수정' 생성자를 기준으로 봅시다.
기본적으로 생성자가 생성이 되었는데, Child(String name), Child(String name, int age, int assets) 과 같이 또 작성이 되어있습니다.

이게 무엇인가!? 생성 조건 3을 보듯 생성자는 매개 변수가 다르면 생성자는 여러가지로 생성될 수 있습니다.

이것을 설명하는 이유는 자바 필ㄹㄹㄹㄹㄹ수 개념 OverLoadig 과 관련이 있기 때문입니다.

3. OverLoading

Q. OverLoading이 뭔데?
A. 생성자의 파라미터의 타입이나, 개수로 구분이 되기 때문에 생성자의 초기화 목적에 따라 같은 이름으로 여러개를 구현할 수 있죠. 이것을 오버로딩(OverLoading) 이라고 합니다.

바로 예시 들어갑니다.

public class Child extends Parent{
	
	String name;
	int age;
	Child(String name){
		System.out.println("set Child name");
	}
	Child(int age){
		System.out.println("set Child age");
	}
	Child(String name, int assets) {
		//super(name, assets);
		System.out.println("set Child name,assets");
	}

	public static void main(String args[]) {
		
		Child c1 = new Child("c1_name",1);
		Child C2 = new Child("c2_name");
		Child C3 = new Child(3);
	}
}

Q. 출력 값은 무엇일까요?
A.
set Child name,assets
set Child name
set Child age

이렇듯, 파라미터의 타입, 개수에 따라 구분이 가능하게 하고, 이름이 같은 생성자를 여러개 만드는 것
이것을 "짐을 더 실어준다"라고 해서 = OverLoading 이라고 말합니다.

[★○@!!] 여러가지 형태로 사용 할 수 있는 '오버로딩(OverLoading), 오버라이딩(OverRiding)'은 OOP 특징이 중 하나인 '다형성'을 지원하기 위한 장치이기도 합니다.

4. OverRiding

Q. 그럼 OverRide는 뭔가요?
A. '재정의'요

맞습니다!! 재정의하는것을 OverRide라고 합니다.
근데, 무엇은 재정의 한다는거지?

부모 클래스로 부터 상속받은 메서드를 다른 방식으로 사용하도록 다시 사용하는 것을 재정의 라고 합니다.

Q. 아래 사진과 같이 작성을 했을때 출력값은 무엇일까요? Parent_print vs Child_print

A. Child_print 입니다.

위 예제와 같이 부모 클래스에서 상속받은 print_parent()라는 메서드를 자식 클래스에서 다시 정의해서 사용하는 것
이것을 OverRide라고 합니다. 

추상 클래스를 상속받아 사용할때 오버라이드를 주로 사용합니다.

이렇게 오버로딩과 오버라이딩의 차이를 알아 보았습니다.
상속 문제가 장난치기 참 좋은것 같습니다. 장난에 말리지 않게 꼼꼼히 정리해 두면 좋을 것 같네요 

5. super

위 예시(사진 2)를 보다보면, super() 라는 메서드를 볼 수 있습니다.

이건 또 뭐야!?

super()를 보기 전에 예제를 하나 봅시다.

public class GrandParent {
	GrandParent(){System.out.println("GrandParent_Constructor"); }
}

public class Parent extends GrandParent{
	Parent(){ System.out.println("Parent_Constructor");}
}

public class Child extends Parent{
	Child(){System.out.println("Child_Constructor");}
	
	public static void main(String args[]) {
		Child c = new Child();
	}
}

Q. 이거 실행하면 결과값이 뭘까요?

A.
GrandParent_Constructor
Parent_Constructor
Child_Constructor

상속을 받는 경우 생성자는 부모 클래스를 찾아가도록 설정이 되어있습니다.
생성자를 생성하지 않으면 Default 생성자를 생성하듯,

부모생성자를 부르지 않아도 알아서 부르도록 설정이 되어있지요.
저기서 보이지 않지는 않지만 부모 클래스를 참조하도록 super() 메서드가 작성되어 있습니다!

참 재미있지요?

그럼 대체 super가 무엇이냐 하면

정의는 다음과 같습니다.
super 키워드는 부모 클래스로부터 상속받은 필드나 메소드를 자식 클래스에서 참조하는 데 사용하는 참조 변수이다.

super는 기본적으로 부모 클래스를 메서드를 참조합니다. 그래서 위에서 예시를 볼때
GrandParent 까지 참조하는 이유는 아래와 같습니다.

1. Child에서 부모 참조(super())를 통해 Parent를 참조하면서 생성자 Parent()가 실행됨
2. Parent() 실행되면서 안에 보이진 않지만 작성 된 super()로 인해 GrandParent를 참조함
3. GrandParent를 참조 하면서 GrandParent()가 실행 됨. GrandParent는 상속받지 않았으므로, super()가 생성되지 않음. 

그리고, 결과적으로 메모리는 스택으로 실행되기 때문에 GrandParent -> Parent -> Child 순서로 출력이 되는 것 입니다!

참고,
상속을 받게되면 super()가 생성되기 때문에 부모를 참조하려 합니다.  그래서 부모 클래스에 적절한 생성자가 없다면 자식클래스의 생성자를 만들었을때 오류가 생긴다는 점 참고하면 좋을 것 같습니다!

기본형이 아닌, 파라미터로 구분가능 부모 생성자를 호출하고 싶다면 표기 아래와 같이 사용 가능 합니다!

이상 상속 정리 끝

자바의 기본 개념들이 생각이 안나거나 이해가 잘 안되었던 부분들을 

여기에 하나씩 정리해 볼 예정 입니다. 그렇기 때문에 보통 책에 나오는 목차들과는 달리 마구잡이로

정리될 것 같네요 ㅠㅠ

어쨋건 시작해 보겠습니다!

#접근 제어

이클립스(Eclipse)를 설치하고  코딩 예제를 시작하고

Hello World!를 출력하고자 한다면 다음과 같은 예제를 많이 사용합니다.

------------------------------------------------------------

Public class hello

public static void main(String[] args){

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

}

}

------------------------------------------------------------

그러면 오늘은 위에서 밑줄이 그어진 public과 같은 접근 제어자에 관해서 정리해 볼 예정입니다.

* 자바의 접근 제어 지정자

멤버 접근 제어는 public, private, protected 이렇게 3가지 지정자로 이루어집니다. 

그럼 이 접근 지정자를 표로 정리해 보면 다음과 같습니다.

사실 이것만 보면 뚜렷하게 와닿지가 않습니다.

- 간단하게 그림으로 정리하기

이렇게 정리하면 어디서 사용 되고, 또 안되는지를 확인 할 수 있을 것 같습니다.

(자식 클래스의 경우 상속 개념을 알면 따로 설명하지 않아도 될 것 같아서 표기하진 않았습니다.)

- 클래스 끼리는 객체를 생성하면 사용 가능 합니다.

- 패키지로 떨어진 것은 import를 사용하면 사용 가능 합니다.

- 전체 세계 즉, 다른 프로젝트에 있는 클래스를 사용하고자 한다면 프로젝트 속성 -> Build Path 설정 -> "사용할 클래스가 있는 프로젝트" 추가

   한 후 import 하면 사용할 수 있습니다.

쉽지만 중요한 개념이기 때문에 정리 해봤습니다.

또 1차 자바를 주력으로 하는 회사에서 필기 시험에서 가끔 나오기 때문에 위에 표를 외워두면 두면 좋을 것 같네요 

끝!