매료매료의 개발 이야기

############### 오버라이딩(Overriding) ##################

override : ~을 타고 넘다. ~에 우선하다. 라는 뜻.

자바에서의 오버라이딩은 슈퍼 클래스의 메소드를 하위 클래스에서 다시 정의 하는것.

하위 클래스에서 다시 정의된 메소드가 슈퍼클래스의 메소드보다 우선한다고 생각하면 됨.

하위 클래스 입장에서 부모 클래스란 말하자면 기본적인 동작 방법을 정의한 것이라고 생각할 수 있다.

하위 클래스에서 상의 클래스와 동일한 메소드를 정의하면 부모 클래스로부터 물려 받은 기본 동작 방법을 변경하는 효과를 갖게 된다. 기본동작은 폭넓게 적용되고, 예외적인 동작은 더 높은 우선순위를 갖게하고 있다. 이것은 공학에서 일반적으로 발견되는 규칙이다. 이것을 메소드 오버라이딩(overriding)이라고 한다.

overriding을 하기 위해서는 메소드의 리턴 형식이 같아야 한다. 오버라이딩을 하기 위해서는 아래의 조건을 충족시켜야 한다.

• 메소드의 이름
• 메소드 매개변수의 숫자와 데이터 타입 그리고 순서
• 메소드의 리턴 타입
•  

위와 같이 메소드의 형태를 정의하는 사항들을 통털어서 메소드의 서명(signature)라고 한다. 즉, 시그니처가 같아야함.

############### 오버로딩(Overloading) ##################

한 클래스 내에서 같은 이름의 메소드를 파라미터와 처리동작, 리턴값을 다르게 하여 여러번 정의하는 것.

이름은 같지만 시그니처는 다른 메소드를 중복으로 선언 할 수 있는 방법을 메소드 오버로딩(overloading)이라고 한다.

메소드 오버로딩은 매개변수를 사용한다. 즉 매개변수가 다르면 이름이 같아도 서로 다른 메소드가 되는 것이다.

반면에 매개변수는 같지만 리턴타입이 다르면 오류가 발생한다. 

'같은 이름, 다른 매개변수를 가진 메소드를 여러 클래스에 로딩한다.'

<예시>

class Calc{

  int plus(int a, int b){   -> 매개변수가 다름

     int k = a + b;

     return k;

  }

  double plus(double a, double b, double c){         -> 매개변수가 다름

     return a+b+c;

  }

}

기존의 객체를 그대로 유지하면서 어떤 기능을 추가하는 맥락에서 등장한 것이 상속.

기존의 객체는 기능을 물려준다는 의미에서 부모객체.

새로운 객체는 기존 객체의 기능을 물려받는다는 의미에서 자식 객체.

부모 클래스와 자식 클래스의 관계를 상위(super) 클래스와 하위(sub) 클래스라고 표현하기도 한다.

또한 기초 클래스(base class), 유도 클래스(derived class)라고도 부른다. 

슈퍼클래스로 하위 클래스를 여러 개 만들 수 있지만, 하위클래스가 상속받을 수있는 슈퍼 클래스는 하나뿐.(단일상속)

클래스를 상속하려면 'extends' 라는 단어를 사용한다.

상속을 통해서 코드의 중복을 제거할 수 있었고,

또 부모 클래스을 개선하면 이를 상속받고 있는 모든 자식 클래스들에게 그 혜택이 자동으로 돌아간다.

다시 말해서 유지보수가 편리해진다는 것이다.

재활용성과 중복의 제거, 그리고 유지보수의 편의는 서로 다른 목적으로 가지고 있지만, 하나가 좋아지면 자연스럽게 다른 쪽도 좋아지는 관계에 있다는 것이다.

############### 상속과 생성자 ##################

생성자가 존재하지 않으면 자동으로 기본생성자로 설정.

매개변수가 있는 생성자가 있을 때는 자동으로 기본 생성자를 만들어주지 않는다.

############### super ##################

자신의 상위클래스를 지칭할 때 사용하는 예약어

상위클래스의 생성자를 호출할수 있다.

This와 마찬가지로 Super.메소드/변수 명으로 상위클래스의 메소드, 변수에 접근 할수있다.(단, 상속된것에만 가능)

ex. super.name

하위 클래스 내에서 super는 슈퍼 클래스를 의미함.

슈퍼클래스의 메소드를 하위클래스에서 오버라이딩할때는 해당 메소드의 이름과 인자, 리턴값은 그대로 선언하고 {}안의 처리명령만 변경하여 작성하면 됨.

super를 활용하면 부모 클래스의 기본 생성자가 없어져도 오류가 발생하지 않음.

하위 클래스의 생성자에서 super를 사용할 때 주의할 점은 super가 가장 먼저 나타나야 한다는 점이다.

즉 부모가 초기화되기 전에 자식이 초기화되는 일을 방지하기 위한 정책.

<예시>

super.printInfo();       슈퍼클래스 안의 printInfo 메소드를 호출한다.

생성자란 객체가 생성과 동시에 객체 안의 데이터 값을 설정(초기화)하는 코드.

생성자의 이름은 반드시 클래스의 이름과 같아야 하고, 리턴 타입이 없다.

객체 지향 프로그래밍도 초기화에 해당하는 기능이 제공되는데 이것을 생성자(constructor)라고 한다.

생성자(constructor) : 그 어떠한 메소드보다 먼저 실행됨. 초기화작업을 함. 인스턴스를 생성하는 자.

클래스 이름과 똑같은아이 - 생성자 
기본생성자를 정의해주지 않으면 null or 기본값으로 초기화하게 됨. 

생성자 : parameter가 있는 생성자, 아무것도 들어가지 않는 생성자라고도 함.

<예시>

class Person{

  String name;

  int age;

  Person(String name, int age){     Person클래스의 객체 필드를 초기 설정하는 생성자를 만들고, 문자열 값을 담는 name 파라미터 변수와 age 파라미터 변수를 인자로 받는다.

    this.name = name;                  이 클래스로 생성된 객체 안의 name 변수에 name 파라미터 변수를 저장한다.

    this.age = age;                       이 클래스로 생성된 객체 안의 age 변수에 age 파라미터 변수를 저장한다.



* this 는 객체 자신을 가리키는 키워드

############### 생성자의 특징 ##################

• new를 사용하면 반드시 호출된다.
• 클래스 객체가 생성될때 반드시 하나의 생성자가 호출된다.
• 생성자가 없으면 default생성자가 있는것으로 인식한다.
• 생성자의 첫번째 라인으로 this생성자를 사용하여 또 다른 생성자 하나를 호출할 수있다. 
• 리턴값을 반환하지 않는다. 
  생성자는 인스턴스를 생성해주는 역할을 하는 특수한 메소드라고 할 수 있다. 그런데 반환 값이 있다면 엉뚱한 객체가 생성될 것이다. 따라서 반환 값을 필요로하는 작업에서는 생성자를 사용하지 않는다. 반환 값이 없기 때문에 return도 사용하지 않고, 반환 값을 메소드 정의에 포함시키지도 않는다.
• 생성자의 이름은 클래스의 이름과 동일하다.
  자바에서 클래스의 이름과 동일한 메소드는 생성자로 사용하기로 약속되어 있다.
• 생성자는 메소드처럼 오버로딩이 가능하다. 즉, 같은 이름의 생성자를 파라미터와 처리동작을 다르게 하여 여러번 정의할수 있음.

* 이클립스에서 생성자 자동으로 만들기 : 생성자 코드 만들기 원하는 위치 마우스 오버롤 -> 이클립스 상단의 source -> Generate Constructor using Field... 클릭

스코프(Scope).

메소드 안에서 변수를 선언하면 그 메소드 안에서만 영향을 미침.

유효범위란 변수를 전역변수, 지역변수 나눠서 좀 더 관리하기 편리하도록 한 것.

전역변수(globe variables) : 클래스 바로 밑에서 선언된 변수 -> 전역에 영향을 미침

지역변수(local variables) : 해당 범위 내에서만 영향을 미침. 다른 곳에서는 접근 불가능.

동적인 유효범위(dynamic scope)

정적인 유효범위(static scope, lexical scope)

자바는 동적 스코프를 채택하지 않고 있다. 대부분의 현대적인 언어들이 정적 스코프 방식을 선택하고 있다.

################## 인스턴스의 유효범위 ##################

인스턴스에서의 유효범위도 클래스와 거의 동일하지만 결정적인 차이점은 this에 있다고 할 수 있다.

객체지향 프로그래밍에서도 가급적이면 전역변수의 사용을 자제하는 것이 좋고, 동시에 단일 객체가 너무 비대해지지 않도록 적절하게 규모를 쪼개는 것도 중요하다.

OOP(Object Oriented Programming)

하나의 객체(프로그램)는 여러 목적성을 가짐.

기능별로 객체로 구분(카테고라이징)

객체는 변수와 메소드를 그룹핑한 것이다.

################## 문법과 설계 ##################

문법 : 객체지향을 편하게 할 수 있도록 언어가 제공하는 기능을 익히는 것

설계 : 프로그램을 만든다는 것은 소프트웨어의 추상화. 현실을 좀 더 잘 반영하기 위한 노력의 산물. 고도의 추상화 능력이 필요.

################## 부품화 ##################

객체지향은 부품화의 정점. 메소드는 부품화의 예라고 할 수 있음.

연관된 메소드와 그 메소드가 사용하는 변수들을 분류하고 그룹핑 하는 것.

################## 은닉화, 캡슐화 ##################

내부의 동작방법을 단단한 케이스(객체) 안으로 숨기고 사용자에게는 그 부품의 사용방법(메소드)만을 노출하고 있는 것.

은닉화(Information Hiding), 캡슐화(Encapsulation)

부품을 사용하는 방법이 중요한 것.

################## 인터페이스 ##################

프로그램을 부품에 비유하자면,

부품과 부품의 연결점을 인터페이스(Interface)라고 한다.

동작하지 않을 뿐 아니라 연결 자체가 되지 않는다.

인터페이스란 이질적인 것들이 결합하는 것을 막아주는 역할도 하는 것이다.

즉 인터페이스는 부품들 간의 약속이다.

import java.util.Scanner;

public class park {
	private String carNum;
	private int inTime;
	private int outTime;

// 빈칸에 차량번호를 Empty 로 정해줌으로써 
// 빈칸찾기를 할때 carNum String이 
// Empty인지 비교해준다. 

	private Park() {
		this.carNum = "Empty";
		this.inTime = 0;
		this.outTime = 0;
	}

	private Park(String carNum, int inTime) {
		this.carNum = carNum;
		this.inTime = inTime;
	}

	private Park(Park park) {
		this.carNum = park.carNum;
		this.inTime = park.inTime;
	}

// 파크 배열을 준비하고 메뉴를 보여주는 showMenu 
// 메소드를 실행한다. 
	public static void init() {
		int size = 3;
		Park[] parkList = new Park[size];
		for (int i = 0; i < parkList.length; i++) {
			parkList[i] = new Park();
		}
		showMenu(parkList);
	}

// 무한루프로 메뉴를 보여주고 
// 사용자의 선택에 따라서 
// 입차를 담당하는 method, 
// 출차를 담당하는 method, 
// 종료를 선택할 수 있게 한다. 
	private static void showMenu(Park[] parkList) {
		Scanner scan = new Scanner(System.in);
		while (true) {
			System.out.println("=========================");
			System.out.println("주차장관리프로그램");
			System.out.println("=========================");
			System.out.println("1. 입차 2. 출차 3. 종료");
			System.out.print("선택: ");
			int choice = scan.nextInt();
			if (choice == 3) {
				System.out.println("사용해주셔서 감사합니다.");
				break;
			} else if (choice == 1) {
				startPark(parkList, scan);
			} else if (choice == 2) {
				endPark(parkList, scan);
			} else {
				System.out.println("잘못 누르셨습니다.");
			}
		}
		scan.close();
	}

// 입차를 시작하는 메소드 
	private static void startPark(Park[] parkList, Scanner scan) {
// 먼저 빈 공간이 존재하는지 체크하고 
// 빈 공간이 존재하면 입고를 시작한다. 
		if (checkEmptySpot(parkList)) {
//Park의 객체 newCar를 insertCarNum 메소드와 insertInTime 메소드에서  
//각각 받아온 유효한 String carNum과 int inTime을 이용하여 초기화한다. 
//초기화 시에는 parameter가 있는 생성자로 초기화 해준다. 
			Park newCar = new Park(insertCarNum(parkList, scan), insertInTime(scan));
//park 배열인 parkList의 빈 공간에 윗줄에서 생성된 newCar를 넣어준다. 
			insertPark(newCar, parkList);

		} else {
// 빈 공간이 존재하지 않으므로 사용자에게 알려주고 
// 메뉴로 돌아간다. 
			System.out.println("자리가 꽉찼습니다.");
		}
	}

// 배열을 돌면서 carNum이 empty인 곳이 있는지 찾는다 
	private static boolean checkEmptySpot(Park[] parkList) {
		boolean isEmpty = false;
		for (int i = 0; i < parkList.length; i++) {
//해당 칸의 carNum 이 Empty, 즉 빈 공간이므로 
//isEmpty 를 true로 바꿔주고 break를 통해 
//for 반복문을 종료한다. 
			if (parkList[i].carNum.equals("Empty")) {
				isEmpty = true;
				break;
			}
		}
		return isEmpty;
	}

// 차량 번호가 입고된 기록이 있는지 체크해서 
// 없으면 해당 번호를 리턴해주고 
// 있으면 계속 루프를 돌면서 입력을 받는다. 
	private static String insertCarNum(Park[] parkList, Scanner scan) {
		scan.nextLine();
		System.out.print("차량 번호를 입력해 주세요: ");
		String carNum = scan.nextLine();
//입력받은 carNum을 validateCarNum 메소드를 통해서 
//이미 입고된 번호인지를 체크를 하여 
//입고가 된 기록이 없는 번호가 들어올 때까지 
//사용자에게 입력을 요구한다. 
		while (validateCarNum(carNum, parkList)) {
			System.out.println("이미 입고된 차량입니다.");
			System.out.print("차량 번호를 다시 입력해 주세요: ");
			carNum = scan.nextLine();
		}
//while문을 통과하면 carNum이 중복된 번호가 아니므로 
//리턴하여 Park(String, int) 의 String으로 쓸 수 있게 한다. 
		return carNum;
	}

// 입력한 carNum이 입고된 기록이 있는지 확인한다. 
	private static boolean validateCarNum(String carNum, Park[] parkList) {
		boolean isAlreadyIn = false;
		for (int i = 0; i < parkList.length; i++) {
//배열을 돌면서 parameter로 넘어온 carNum이 
//해당 칸의 carNum과 같을 시에는 
//중복된 번호 이므로 isAlreadyIn을 true로 바꾸고 
//리턴해준다. 
			if (parkList[i].carNum.equals(carNum)) {
				isAlreadyIn = true;
				break;
			}
		}
		return isAlreadyIn;
	}

// 시간을 입력받아 유효한 시간을 리턴해준다. 
	private static int insertInTime(Scanner scan) {
		System.out.print("입고 시간을 입력해주세요: ");
		int inTime = scan.nextInt();
//입력받은 inTime을 validateTime 메소드로  
//올바른 시간인지 확인한다. 
//단 validateTime 메소드가 올바른 시간인 경우 
//true를 리턴하므로 반전연산자인 ! 연산자를 붙여서 
//true는 false로, false는 true로 반전시켜서 
//잘못 입력된 시간일 경우에만 while 반복문에 들어가게 한다. 
		while (!validateTime(inTime)) {
			System.out.println("잘못된 시간 형식입니다.");
			System.out.print("입고 시간을 입력해주세요: ");
			inTime = scan.nextInt();
		}
		return inTime;
	}

// 시간이 올바른 형태인지 확인하는 메소드 
	private static boolean validateTime(int inTime) {
		boolean isTimeCorrect = false;

//4자리 숫자가 넘어 올시 
//앞의 두자리와 뒤의 두자리를 분리하려면 
//앞의 두자리는 100으로 나눈 값을, 
//뒤의 두자리는 100으로 나눈 나머지 값을 
//넣어준다. 
//앞의 두자리는 시간이, 뒤의 두자리는 분이 된다. 
		int hour = inTime / 100;
		int min = inTime % 100;

//시간과 분이 유효한지 체크한다. 
//시간은 0~23, 분은 0~59 만 유효하기 때문에 
//&& 연산을 통해 hour는 -1보다 크고 24 보다 작은(0~23) 경우에만 
//분은 -1보다 크고 60보다 작은(0~59) 경우를 모두 만족할 때에만 
//isTimeCorrect를 true로 바꾼다. 
		if (hour > -1 && hour < 24 && min > -1 && min < 60) {
			isTimeCorrect = true;
		}
		return isTimeCorrect;
	}

//차량을 입고하는 메소드 
	private static void insertPark(Park newCar, Park[] parkList) {
		for (int i = 0; i < parkList.length; i++) {
//parameter로 넘어온 newCar를 parkList의 요소 중에서 carNum이 
//Empty 인 곳에 넣는다. 
			if (parkList[i].carNum.equals("Empty")) {
				parkList[i] = newCar;
//단 여기서 넣자마자 break를 해야하는데 
//break가 없으면 넣은 이후에도 반복 되면서 
//모든 빈칸에 newCar를 넣기 때문에 
//1번만 실행해도 모든 칸이 다 꽉차서 
//더이상 주차를 할 수 없게 된다. 
				break;
			}
		}
	}

// 차량 출고 메소드의 시작지점. 
	private static void endPark(Park[] parkList, Scanner scan) {
// 주차장이 비어있는지 확인한다. 
		if (checkParkExist(parkList)) {
// 주차된 차량이 1대라도 존재하므로 차량 번호를 통해 
// 해당 차량의 정보를 받아온다. 
			Park outCar = new Park(retrievePark(parkList, scan));
// 차량의 출차시간을 기록한다. 
			outCar.outTime = insertOutTime(outCar, scan);
// 요금 계산 
			calcRate(outCar);
// 나간 차량의 자리를 비어준다. 
			removeOutCar(parkList, outCar);
		} else {
// 주차된 차량이 없으므로 사용자에게 메시지를 띄우고 
// 메뉴로 돌아간다. 
			System.out.println();
			System.out.println("주차된 차량이 없습니다.");
			System.out.println();
		}
	}

// 주차장이 비어있는지 확인하는 메소드 
	private static boolean checkParkExist(Park[] parkList) {
		boolean isExist = false;
// parkList 배열을 쭉 돌면서 carNum이 "Empty"가 아닌 
// 요소가 존재하는지를 찾는다. 
		for (int i = 0; i < parkList.length; i++) {
			if (!parkList[i].carNum.equals("Empty")) {
				isExist = true;
			}
		}
		return isExist;
	}

// 입고된 차량의 정보를 받아오는 메소드 
	private static Park retrievePark(Park[] parkList, Scanner scan) {
		scan.nextLine();
		Park outCar = new Park();
		System.out.print("출고할 차량번호를 입력해주세요: ");
		String carNum = scan.nextLine();
// validateCarNum 메소드를 통해서 입력한 차량 번호가 
// 리스트에 없으면 없다고 말해주고 다시 입력하라고 
// 사용자에게 지시한다. 
		while (!validateCarNum(carNum, parkList)) {
			System.out.println("입고된 기록이 없는 번호입니다.");
			System.out.print("출고할 차량번호를 다시 입력해주세요: ");
			carNum = scan.nextLine();
		}
// while문을 통과할 시에는 해당 번호가 리스트에 존재하므로 
// 그 번호와 같은 parkList의 요소를 outCar에 담아서 
// 리턴해준다. 
		for (int i = 0; i < parkList.length; i++) {
			if (parkList[i].carNum.equals(carNum)) {
				outCar = parkList[i];
			}
		}
		return outCar;
	}

// 출고 시간을 저장하는 메소드 
	private static int insertOutTime(Park outCar, Scanner scan) {
		System.out.print("출고 시간을 입력해주세요: ");
		int outTime = scan.nextInt();
// 출고 시간이 올바른 형태인지 확인하고 
// 올바른 형태가 아니면 다시 입력하라고 
// 사용자에게 시킨다. 
		while (!validateTime(outCar, outTime)) {
			System.out.println("잘못된 시간 형식입니다.");
			System.out.print("출고 시간을 입력해주세요: ");
			outTime = scan.nextInt();
		}
		return outTime;
	}

// 출고 시간이 유효한지 체크하는 메소드 
	private static boolean validateTime(Park outCar, int outTime) {
		boolean isOutTimeCorrect = false;
// 아까 전 inTime의 유효성을 체크했던 메소드로 outTime도 
// 체크를 하고 거기에 && 연산자를 통해서 outTime이 outCar에 
// 저장된 inTime보다 큰지도 같이 확인한다. 
		if (validateTime(outTime) && outTime > outCar.inTime) {
			isOutTimeCorrect = true;
		}
		return isOutTimeCorrect;
	}

// 요금을 계산하는 메소드 
	private static void calcRate(Park outCar) {
// 시간의 차이를 계산한다 
		int hourDiff = outCar.outTime / 100 - outCar.inTime / 100;
// 분의 차이를 계산한다. 
		int minDiff = outCar.outTime % 100 - outCar.inTime % 100;

// 총 분의 시간을 계산하고 10분당 1000원으로 계산한 후 
// 출력한다. 
		int totDiff = hourDiff * 60 + minDiff;
		int rateStd = 1000;
		int rate = totDiff / 10 * rateStd;
		System.out.println("총 주차요금은 " + rate + "원입니다.");
	}

// 나간 차의 자리를 비어주는 메소드 
	private static void removeOutCar(Park[] parkList, Park outCar) {
// parkList 배열을 돌면서 해당 칸의 carNum이 
// outCar(나가는 차)의 번호와 같으면 
// 해당칸에 기본 생성자를 호출해서 
// carNum은 "Empty", inTime과 outTime은 0으로 초기화해준다. 
		for (int i = 0; i < parkList.length; i++) {
			if (parkList[i].carNum.equals(outCar.carNum)) {
				parkList[i] = new Park();
			}
		}

	}
}

​

abstract

추상 클래스 또는 추상 메소드에 사용함

boolean

논리형 참(true) 과 거짓(false)

default 값은 false

break

반복문 또는 Switch 문을 벗어나거나 멈출때 사용함

byte

데이터 정수형 타입 1byte = 8 bit

정수형: byte < short < int <long

case

switch ~ case ~ default 를 많이 봤을것이다.

switch 조건문에서 사용함.

case 문에서는 리터럴과 상수만 허용

변수는 안됩니다~

break 를 만나면 switch 문을 빠져나옴

catch

try~catch~finally문에서 사용됨

예외처리 할때 사용됩니다.

catch(){}

() 안에는 예외에 해당하는 인스턴스를 집어넣음

ex) catch(예외클래스  변수)  // catch(Exception e)

{} 안에는

예외 처리 내용을 적어넣음

예외처리 순서

try 문 -> 예외발생 -> catch -> 예외확인/에러처리 -> finally 예외발생 유무상관없이 실행

char

​데이터 문자형 (변수) 타입 2byte

ex) ​'A'  로 입력, 하나의 문자만 저장할수있음

​

class

모든 코드는 클래스 안에 존재해야함​

클래스 작성방법은 매우 간단함

class 클래스명{}

클래스 이름 첫글자는 '대문자'로 시작하는것이 좋음

ex) Pyh class

​

​continue

반복문, 루프돌때 현재 루프를 끝낸뒤,

뒤에 내용 무시하고

앞으로가서 다음 루프를 실행​함

default

접근제어자 및 switch 문 에서 쓰임

접근제어자는 클래스,메소드,멤버변수 앞에 아무것도 선언을 안하면 default 가 됨.

switch 문에서 default 는 case 문을 돌다가

해당하는 case 가 없으면 default 로 와서 실행함.​

do

do~while 문에서 쓰임

하지만 잘 쓰이지 않는 do~while 문​

do {  반복 실행 내용 } while (조건문)

​

double

​데이터 실수형 (변수) 타입 8byte​

실수값을 넣을때 쓰임​

​

else

'사전적내용 - 또 다른 , 다른'

if~else 문에 쓰임

총 3가지 형식이 있음

​

1. if(조건) {실행내용}​

2. if(조건) {실행내용} else {실행내용}

3. if(조건){실행내용}  else if(조건){실행내용}  else if(조건){실행내용}  else{실행내용}

​

extends

​클래스 상속에 쓰임

상속은 2가지 형태가 있음

1. extends - 부모의 모든권한을 가져오는것 (상속+내용까지모두)

클래스 한개만 상속가능.

2. implements​ - 인터페이스 (상속은 하지만, 내용은 비어있음, 추상)

다중 상속가능.

​

false​

사전적의미 - 틀린,사실이아닌​

boolean 에서도 쓰임

그외 어디 쓰이는거 같은데 잘모르겠음.

​

finally​

try~catch~finally 예외처리에 쓰임

switch 문의 default 처럼 쓰임

try { 예외가 발생할만한 코드 }

catch(Exception e){ 예외처리 방법 }

예외가 발생할만한 코드를 try {} 안에 넣고

예외가 발생하면 실행을 멈추고 catch{}안의 내용을 실행함

finally{ try~catch 끝난후 처리할내용 }

예외처리 순서

try 문 -> 예외발생 -> catch -> 예외확인/에러처리 -> finally 예외발생 유무상관없이 실행​

​

​

​float

데이터 실수형 (변수) 타입 4byte

실수값 넣을때 사용됨

​

for

반복문 중 하나

for(초기값;조건식;증가값){내용}

ex ) for(int i = 0 ; i <= 9; i++)

{

                              System.out.println(i);

}

0부터9까지 화면에 뿌려줌​

if

일반적으로 사용되는 조건문

1. if(조건) {실행내용}​

2. if(조건) {실행내용} else {실행내용}

3. if(조건){실행내용}  else if(조건){실행내용}  else if(조건){실행내용}  else{실행내용}

​

implements

​인터페이스 구현 할때 쓰임, 다중상속 가능

interface 는 메소드 선언만 되어있고

빈 껍데기 (내용이없음)

​

import​

import 패키지명.클래스명;

import 패키지명.*; 을 사용하면

그 패키지 내에 모든 클래스를 가져올수있음.

java api, 외부클래스를 사용하고싶을때 쓰입니다.

단축키 : ctrl + shift + o

​

​instanceof

​객체타입 검사시 사용됨

형변환이 가능한지 알고싶을때

true / false로 답을 얻을수있음

​

int

데이터 정수형 4byte

제일 많이 쓰이는 기본 정수형이 아닐까 싶습니다.

 정수형: byte < short < int <long

interface​

일종의 추상클래스, 상속을 목적으로 만들어지며 다중상속가능

상수와 추상메소드만​ 가짐 (내용선언안함)

interface 인터페이스이름 { public static final 타입 이름 = 값 ;

public abstract 메소드이름(매개변수); }

상속은 implements 로 한다.

​

long

데이터 정수형 8byte

정수값을 저장하는 변수타입

​정수형: byte < short < int <long

​

native​

자바 외 다른 프로그래밍 언어로 구현되었음을 알려줌

​

new​

인스턴스,객체를 만들때 사용

객체를 생성하여 메모리공간을 만듬 ​

​

​null

ex) Box box1 = null

변수선언 하고 box1 의 값은 null로 초기화 시킨것

메모리에 할당 안된상태

숫자타입의 변수는 null을 넣을수없음

​

package​

​클래스들을 편리하게 관리하기 위해 묶어놓은것 (하나의 폴더라고 생각)

​package 작성법: package 패키지명;

import 방법: import 패키지명.클래스명;​

​

​private

접근제한자 중 가장 높은보안수준(?)

같은 클래스 내에서만 접근 가능한것

순서: public > protected > default (아무것도 안적음) > private

​

​protected

접근제한자 이며,  같은패키지와 상속받은 클래스에서 접근이 가능한것

순서: public > protected > default (아무것도 안적음) > private​

​

 public

접근제한자 중 가장 제한이 없는것

접근제한이 없기때문에 같은클래스,패키지,상속에 상관없이

누구나 이용할수있다.

​

return

메소드를 종료하거나 값을 반환할때 쓰임

​

​

short

데이터 정수형 타입 2byte

정수값을 저장하는데 사용됨

​정수형: byte < short < int <long

​​

​static

정적변수 혹은 클래스변수 라고 부르며

클래스 변수란 클래스 단위로 존재하며

클래스로부터 만들어진 모든 객체가 공유할수있는 변수를 의미

한번만 생성되고, 컴파일할때 만들기때문에 객체생성(인스턴스)이 불필요하다.

 static 은 main함수 보다 먼저 실행된다 (단 한번 실행함)

static 에서는 this 와 super 를 사용할 수 없다.

​

super

상위 클래스의 생성자를 호출할때 또는

상위 클래스의 멤버변수 또는 메소드에 접근할때 사용됨.​

super 로 호출하기 위해선 해당 멤버변수,메소드 가 protected,public 이여야함.

호출방법​

1. 상위 클래스의 생성자 호출 super(매개변수)

2. 상위 클래스의 멤버 변수 호출 super.변수명

3. 상위 클래스의 메소드 호출 super.메소드명(매개변수)

​

switch

조건문 중 하나

조건의 수가 많을때는 if문 보다 switch문을 사용하는것이 더 좋다.

switch(조건식) {

case 값1 :   내용     break;

case 값2 :   내용     break;

case 값3 :   내용     break;

case 값4 :   내용     break;​​

default :     내용

}

​

syn​chronized

쓰레드 동기화 를 위해 존재함

쓰레드2가 방(syn​chronized) 메소드에 들어가기위해선

열쇠(lock)이 필요한데 이 열쇠(lock) 가 딱 하나밖에없다.

쓰레드1이 방(syn​chronized)에 열쇠(lock)를 들고 들어갔으면

일을 마치고 ​나와서 열쇠(lock) 를 반환할때까지

쓰레드2는 기다렸다가 쓰레드1이 방에서 일을 마치고 나오면

그 열쇠(lock) 를 받아서 방(syn​chronized)에 들어갈수가 있는것이다.

​

this​

인스턴스가 '본인(자기자신)' 을 가르킬때 사용할 수 있다.

​

​

throw / throws

​둘다 예외를 던질때 사용

throw 사전적의미 '던지다'

throw 와 throws 의 차이점

throw는 메소드내에서 상위 블럭 으로 예외를 던짐

throw 는 현재 메소드에서 상위 메소드로 예외를 던짐

throw 는 일부러 예외를 발생시킬때 사용되기도 하지만

현재 메소드 에러를 처리한후 상위 메소드에 에러정보를 줌으로써

상위 메소드에서도 에러를 감지할수있음

​

​true

사전적의미 - 사실,참,진실

boolean 에서도 쓰임

그외 어디 쓰이는지 잘모르겠어요.

​

try

try~catch~finally문에서 사용됨

예외처리 할때 사용됩니다.

try { 예외가 발생할만한 코드 }

catch(Exception e){ 예외처리 방법 }

예외가 발생할만한 코드를 try {} 안에 넣고

예외가 발생하면 실행을 멈추고 catch{}안의 내용을 실행함

finally{ try~catch 끝난후 처리할내용 }

예외처리 순서

try 문 -> 예외발생 -> catch -> 예외확인/에러처리 -> finally 예외발생 유무상관없이 실행

​

​void

아무것도 리턴할것이 없다.

void 에 속한 메소드는 리턴할게 없어서

처리를 끝낸 후 메소드를 호출한곳으로 넘어가 제어를 함.

while

반복문 for문과 while문은 항상 서로 변환이 가능함.

while(조건식) { 조건식이 맞으면 수행할 내용 }

*주의점 초기값 위치는 while문 밖에해야한다.

while 문 내에 하면 무한루프에 빠진다.

특정 조건을 만족할 때까지 똑같은 구문을 반복

while문, for문

################## while ################## 

특정조건을 만족할 때까지 무한정 돌아간다.

무한 루프를 만들기 쉽다.(while 문 조건에 항상 참이 되는 식을 넣으면 됨.)

while(조건){

반복 실행 영역

}

조건이 true면 중괄호 구간을 반복적으로 실행한다. 조건이 false면 반복문이 실행되지 않는다.

콘솔에서 실행할 경우 Ctrl+C(dnls 나 Cmd+.) 단축키를 이용해서 무한 반복을 중지할 수 있다.

<예시>

while(i == 0){

    처리할 명령들

}

-> 변수 i 의 값이 0과 같을 동안 { } 안을 반복해라

<do~while문 예시>

do{

   처리할 명령들

} while(i == 0) ;

-> 일단 { } 안의 명령을 수행하라. 변수 i 의 값이 0과 같을 동안 { } 안을 반복해라

################## for ##################

정확한 횟수가 정해져 있을때 for문 사용

for문 안에는 for문이 또 들어갈 수 있다.

하지만 for문 안에 변수는 달라야 한다.

     초기화       종료조건      반복실행
for(int i = 0;   i < 종료지점;     i++     ){ 

     반복적으로 실행될 구문
} 

i = 반복횟수 

먼저 int i = 0 을 통해서 제어변수인 i를 선언한다.
그리고 i < 종료지점 이 true 가 나오면 반복할 코드들을 다 실행하고
}을 만나게 되면 i++이 실행된다.
i++을 실행한 후에 i < 종료지점을 다시 실행하여 true 가 나오면 반복
false가 나오면 반복문은 종료가 된다.

초기화 : 반복문이 실행될 때 1회 실행된다.

종료조건 : 초기화가 실행된 후에 종료조건이 실행된다. 종료조건의 값이 false일 때까지 반복문의 중괄호 구간의 코드가 반복 실행된다.

중괄호 구간의 실행이 끝나면 반복 실행이 실행된다. 일반적으로 이 곳에 i++와 같이 변수를 증가시키는 로직이 위치하고, 이것이 실행된 후에 종료조건이 실행된다. 종료조건이 false가 될 때까지 이 과정이 반복된다.

<예시>

for(int i=0; i<4; i++){

    처리할 명령들

}

-> 정수값을 담는 i라는 변수에 0을 대입하고 1씩 증가시키면서 i가 4보다 작을 동안 { } 안을 반복해라

<확장for문> = for in문, for-each문

double[] a = {... } ;

for(double i : a) // 배열 a의 처음부터 끝까지 모든 요소를 한개씩 스캔. i는 스캔할때 주목하고 있는 요소. 

( )안의 콜론(:)은 "~의 안에 있는"

################## 반복문의 제어 ##################

반복문의 흐름을 바꾸는 break와 continue.

break : 반복문을 중단시킴.(탈출) - 조건문, 반복문 둘다 쓰임.

continue : 반복문 내에서 continue 아래 남겨진 명령어들은 생략하고 다음 반복으로 넘어감. 실행을 즉시 중단하면서 반복은 지속하게 함. - 반복문에서만 쓰임.

################## 반복문의 중첩 ##################

반복문의 기준점은 서로 다른값으로 세팅해야함.

이중for문 : for문 안에 for문이 있는구조. 안쪽에 있는 for문이 바깥쪽 for문의 실행 횟수만큼 실행됨. 삼중~ 이상도 가능하지만 프로그램 실행 속도가 느려져 잘 사용하지는 않는다.

배열은 연관된 정보를 그룹핑하는데 사용.

하나의 변수에 여러가지 값을 할당하는데 쓰임. 

거대한 데이터의 덩어리에서 필요에 따라 같은 이름으로 그룹핑.(파일, 디렉토리)

배열은 연관된 데이터를 모아서 관리하기 위해서 사용하는 데이터 타입이다.

변수가 하나의 데이터를 저장하기 위한 것이라면 배열은 여러 개의 데이터를 저장하기 위한 것.

String[] classGroup 의 의미 -> 'classGroup이라는 변수의 배열에는 문자열로 구성된 데이터가 담긴다'

String[] args 의 의미 -> '프로그램 생성시 파라미터로 받는 모두를 문자열로 인식하여 args라는 이름의 배열에 저장하겠다는 의미.'(String args[] 로 적어도 상관없음)

int arr[] = new int[3]; 의 의미 -> '정수 값을 담는 arr이라는 이름의 배열을 3개 크기 만큼 새로 선언한다.'

int arr[] = new int[]{1,2,3); 의 의미 -> '정수 값을 담는 arr이라는 이름의 배열을 새로 선언하고 각 요소에 1,2,3을 저장한다.'

int arr2[][] = new int[2][3]; 의 의미 -> '정수 값을 담는 arr2라는 이름의 2차원 배열을 2행 3열 크기만큼 새로 선언한다.'

다차원 배열에서는 []개수만큼 {}개수도 늘어나야 한다.

여기서 [0] 과 같은 넘버링을 'index' 
{"생", "활"} 과 같은 원소를 'element' 
원소를 담을수 있는 최대개수를 'length'

################ 기본형 데이터타입 ################

int size = 5; (int변수 5개가 모여서 만들어진 int형 배열 변수 arr)
배열의 크기는 정수형 변수가 들어갈 수 있다.

int[] arr = new int[size];
배열의 인덱스는 0~size~1 까지 이다.
배열의 값을 접근할 때에는 배열이름[인덱스번호(요소번호)] 로 접근이 가능하다.

배열을 정의(선언)할때 new를 사용!!

arr[0] = 4;
arr[1] = 6;
arr[2] = 8;
arr[3] = 10;
arr[4] = 12;

배열의 값을 1개씩 출력할 땐 for문을 이용하면 편하다.

for (int i = 0; i < arr.length; i++)

arr.length : arr이 담을수 있는 최대의 값.

배열에 인덱스에는 변수가 들어갈 수 있다.
단! 배열의 크기보다 작아야 한다.

################ 클래스 데이터타입 배열 ################

		Student[] arr = new Student[3]; 
		Scanner scan = new Scanner(System.in); 
		for (int i = 0; i < arr.length; i++) {
//			!!!!!!!!!!!!!!!!!!중요!!!!!!!!!!!!!!!!! 
//			참조형 배열의 경우 각 요소를 다시 new 를 통해서 초기화 해야"만"한다. 
			arr[i] = new Student(); 
//			!!!!!!!!!!!!!!!!!!중요!!!!!!!!!!!!!!!!! 
		System.out.print("이름: "); 
			String name = scan.nextLine(); 
			arr[i].setName(name); 
			}for(
				int i = 0;i<arr.length;i++)
				{
				System.out.println((i + 1) + "번 학생");
				System.out.println(arr[i].getName());
		}scan.close();

배열이란? 똑같은 데이터를 나열
배열의 크기에 관련된 for문은 그것의 크기보다 작은 것으로('='은 빼야)
null : 메모리 공간확보가 안되어있는것.

초기화항상해줄것! 이런식으로-> arr[i] = new Student();

################ 반복문과 배열의 조화 ################

반복문이 처리해야할 데이터를 배열이라는 그릇에 담아 하나하나 꺼내면서 처리.

배열이란 연관된 정보를 하나의 그룹으로 관리하기 위해서 사용하는데 그 정보를 처리 할 때는 반복문을 주로 이용한다. 반복문과 배열은 매우 밀접한 관계에 있다고 할 수 있다.

################ for-each ################

for문과 배열을 결합해서 사용하다가 목적에 주목하여 사용하게 된 것.

반복문과 배열은 뗄려야 뗄수없는 관계.

이클립스에서 오류가 발생한다면 아래와 같이 자바의 버전을 변경해주자. 가장 높은 버전으로 지정한다.

################ 오류와 한계 ################

배열은 초기화할 때 그 크기가 정해진다. 그래서 정해진 크기 이상의 값을 넣을 수 없다.

비유하면, 학생의 수요를 예측하고 그에 따라서 교실을 지으면 그 이상의 학생을 수용 할 수 없는 것과 같다. 부시고 다시 짓든지 새로운 교실을 만들든지 해야 한다. 이러한 한계는 c와 같은 언어에 익숙한 사람에게는 당연한 것이지만, JavaScript나 Python, PHP와 같은 언어에 익숙한 사람에게는 의아할 것이다. 후자의 언어들은 배열의 크기를 미리 정의하고 사용하지 않는다. 물론 방법이 있다.

자바에는 컬렉션 Collection이라는 기능이 있다. Container라고도 부르는 이 기능을 이용하면 JavaScript의 배열과 같이 유연하게 배열을 사용할 수 있다. 컬렉션은 매우 중요한 주제이지만 지금 단계에서는 이것을 이해하기 위한 부품이 부족하다. 객체지향에 대해서 일정한 이해가 있을 때 컬렉션에 대해서도 온전하게 이해할 수 있기 때문이다.

Collection 변수의 각 요소는 이렇게 접근이 가능하다.
단 < >안에 들어가 있는 class 변수로만 사용 가능하다.
for(String title : titleList) {
System.out.println(title);
}

객체를 만들기 위해서 우선 클래스를 정의하고, 클래스에 대한 인스턴스를 만들었다.

클래스 : 설계도, 정의, 연관되어 있는 변수와 메소드의 집합.

클래스 = 필드(데이터) + 메소드(처리동작)

인스턴스 : 구체적인 제품, 호출.

객체 : 상태(변수)와 행위(메소드)의 집합

클래스를 인스턴스화 할 때는 변수에 담아야 한다는 것과 이 때 사용하는 변수의 데이터 타입은 그 클래스가 된다는 점.

즉 하나의 클래스를 바탕으로 서로 다른 상태를 가진 인스턴스를 만들면 서로 다른 행동을 하게 된다는 것을 알 수 있다. 하나의 클래스가 여러개의 인스턴스가 될 수 있다는 점이 객체 지향이 제공하는 가장 기본적인 재활용성이라고 할 수 있다.

필드와 메소드가 합쳐진 객체를 뜻함.

(ex. String클래스(char[]필드와 string[]메소드가 합쳐짐)

아이디로그인시 검색방법 : 대문자로 만들어놓고 비교, 소문자로 만들어놓고 비교, 
각 데이터는 주소값이 존재(생성자)

################## 멤버 ##################

멤버 : 구성원

################## 클래스선언 ##################

<예시>

class Person{               객체를 정의/생성하는 툴인 Person 이라는 클래스를 만든다(관례상 클래스의 이름 첫글자는 대문자)

   String name;            문자열 값을 담는 name 이라는 변수를 선언한다

   int age;                   정수 값을 담는 age 라는 변수를 선언한다                              데이터 = 필드

   int weight;               정수 값을 담는 weight 라는 변수를 선언한다

   String eat(){             문자열 값을 리턴값으로 받는 eat라는 메소드를 선언한다

     return "eat";          이 메소드를 호출한 곳에 "eat"를 리턴한다

   }                                                                                                                처리동작 = 메소드

   String sleep(){          문자열 값을 리턴값으로 받는 sleep 라는 메소드를 선언한다

     return "sleep";        이 메소드를 호출한 곳에 "sleep"를 리턴한다

   }

}

################## 클래스변수 ##################

클래스 변수의 용도를 정리해보면 아래와 같다.

- 인스턴스에 따라서 변하지 않는 값이 필요한 경우
(이런 경우 final을 이용해서 상수로 선언하는 것이 바람직)

- 인스턴스를 생성할 필요가 없는 값을 클래스에 저장하고 싶은 경우

- 값의 변경 사항을 모든 인스턴스가 공유해야 하는 경우

################## 클래스메소드 ##################

클래스변수에 직접 접근가능.

일회용처럼 굳이 인스턴스를 만들 필요없을때 사용.(메소드가 인스턴스 변수를 참조하지 않는다면 클래스 메소드를 사용해서 불필요한 인스턴스의 생성을 막을 수 있다.)

1. 인스턴스 메소드는 클래스 맴버에 접근 할 수 있다.
2. 클래스 메소드는 인스턴스 맴버에 접근 할 수 없다. 

변수와 필드는 서로 대체가능한 용어임.

인스턴스 변수 -> Non-Static Field

클래스 변수 -> Static Field

필드(field)라는 것은 클래스 전역에서 접근 할 수 있는 변수

################## 객체의 생성과 사용 ##################

<예시>

class PersonExample{                           객체를 정의/생성하는 툴인 PersonExample 이라는 클래스를 만든다

  public static void main(String[] args){   

     Person personObj1;                        personObj1 변수에 클래스의 객체를 담는 personObj1이라는 변수를 선언한다

     personObj1 = new Person();            personObj1 변수에 Person 클래스의 객체를 새로 생성하여 저장한다.

     personObj1.name = "김삿갓";          personObj1 변수 안의 name 변수에 "김삿갓"을 저장한다.

* Person personObj1;

  personObj1 = new Person(); 

-> Person personObj1 = new Person(); 과 동일!

Person 이라는 클래스의 객체를 담는 personObj1 이라는 변수를 선언하고 Person 클래스의 객체를 새로 생성하여 저장한다.

* new 연산자 : "새롭게 ~ 을 생성한다"

* 객체가 생성되었으면 그 객체에 이는 데이터와 메소드에 접근하여 이를 참조하거나 값을 저장하여 사용해야함. 이때 '.'을 사용하여 데이터와 메소드의 소속을 밝혀줌.