7/21 : 표준 문자 전산 처리 방식, 객체, Array copy, 2차원 배열, 가변배열, 클래스 구조, 생성자, final, 생성자 overLoading, 클래스변수, 인스턴스변수, 지역변수, this 참조변수, 객체지향 OOP

[표준 문자 전산 처리 방식] (중요 외우기. 면접 질문)

1. ASCII 코드정의

  ASCII 코드란  American Standard Code for Information Interchange (외우기)
 아스키 코드는 미국 ANSI에서 표준화한 정보교환용 7비트 부호체계
 영문 키보드로 입력할 수 있는 모든 기호들이 할당되어 있는 부호 체계이며, 
 매우 단순하고 간단하기 때문에 어느 시스템에서도 적용가능하다는 장점이 있으나,
 2바이트 이상의 코드를 표현할 수 없기 때문에 국제표준의 위상은 유니코드 

2. ANSI 코드정의
 ANSI는 8bit로 구성되어 있으며 256개의 문자를 표현할 수 있다.
 ANSI는 ASCII의 확장판으로 이해하면 된다.
 ANSI = ASCII(7bit) + CodePage(1bit)
 그 이유는 ASCII에서 1bit를 더 사용한 것이기 때문이다.
 ANSI의 앞 7bit는 ASCII와 동일하고, 뒤에 1bit를 이용하여 다른 언어의 문자를 표현
 각 언어별로 Code 값을 주고, Code마다 다른 문자열 표를 의미

3. UNICODE 코드정의
 전 세계의 모든 문자를 다루도록 설계된 표준 문자 전산 처리 방식. 
 이것을 규율하는 단체는 유니코드 콘소시엄(Unicode Consortium)이다. 
 주요 구성 요소는 ISO/IEC 10646 Universal Character Set과 UCS, UTF 등의 인코딩 방식, 
 문자 처리 알고리즘

(우리나라 전자정부에서 UTF-8을 써서 대부분 개발에서 UTF-8을 사용) 가변길이 문자 인코딩(UTF-8)을 도입해서 기존 ASCII와 호환되는 규격도 도입. 
 흔히 우리가 웹 브라우저의 인코딩을 설정하면서 자주 보는 UTF-8이라는 말이 이것이고,
 바로 유니코드에 기반한 인코딩 방식 중 하나

ASCII코드를 포함하고 있고, ASCII코드를 확장시킨 것임.

4. 각 코드의 장단점
 1) 아스키코드 :
 장점 - 매우 단순하고 간단하기 때문에 어느 시스템에서도 적용가능하다는 장점
 단점 - 128개의 문자만 표현 가능.(나머지 1비트는 패리티 비트)
 2) ANSI코드 :
 장점 - 아스키코드보다 2배 더 많은 문자를 표현할 수 있다.
 단점 – 영어 외 다른 언어를 사용할 때 코드페이지를 사용
 3) 유니코드 :
 장점 – 멀티바이트(2바이트)라는 가변적 공간을 이용하여 모든 언어를 표현할 수 있다, 
          아스키코드보다 8688배 많은 문자를 표현.
 단점 – 인코딩 종류에 따라 멀티바이트 공간이 달라지는데, 
          언어에 적합하지 않는인코딩을 사용하면 공간이 낭비될 수 있다
          (ex : 영어에 UTF 32를 사용하는 경우 공간이 낭비됨. 영어는 8비트로 표현가능하기 때문.)

 

[5. 자바 객체 개념(중요 단원)]

4p. 프로그래밍에서의 객체란 속성(필드, 데이터)와 메소드(함수, 행위)의 집합체이다.

속성(필드) : 객체의 정적 특성으로 객체가 가지고 있는 정보를 보관하는 기억장소로 사용되는 데이터 영역

메소드 : 객체의 동적특성으로서 객체의 데이터를 엑세스하거나 또는 객체가 가지고 있는 속성을 변경하는 일을 한다.

 

6p. 클래스 : 일반화된 속성과 메소드로 객체를 기술한 것. 자료구조와 연산(메소드)로 구성된다
클래스로부터 생성된 객체를 instance라고 한다. 객체는 항상 클래스로부터 생성된다.  
정보처리의 주체는 클래스가 아니라 객체이다.

클래스가 붕어빵의 틀(설계도)이라면 객체는 붕어빵이다.

 

9p. 객체의 구성요소 : 

객체는 속성과 기능로 이루어져있다.

클래스를 정의할 때 속성은 변수로, 기능은 메소드(함수)로 정의한다.

 

ArrCopy.java

package ch04;

//배열 복사
public class ArrCopy {

	public static void main(String[] args) {
		int[] a = {1,2,3,4,5,6,7};
		int[] b = new int [10]; //숫자형의 배열에 초기값을 안주면 빈 자리는 숫자 0이 들어감.
		System.out.println("-------------------");
		
		//a의 0번째부터 a의 길이만큼 b의 0번째 자리에 복사를 함.
		//그럼 b 는 1 2 3 4 5 6 7 0 0 0 이 됨.
		System.arraycopy(a, 0, b, 0, a.length);
		pr(a); // -> pr를 호출했으므로 pr 함수의 b에 a가 들어가는 것.(b와 a는 타입이 꼭 같아야 함.)
		pr(b); // -> pr 함수의 b에 b가 들어가는 것.
		cls(b); // -> cls를 호출했으므로 arr에 b가 들어감.
		pr(b);
		//static 안에선 static 메소드만 호출할 수 있다.
		
		//a의 0번째부터 a의 길이만큼 b의 2번째 자리에 복사를 함.
		System.out.println("------2------");
		System.arraycopy(a, 0, b, 2, a.length);
		pr(b);
		cls(b);
		
		System.out.println("------3------");
		System.arraycopy(a, 1, b, 0, a.length-1);
		pr(b);
		cls(b);
		
		System.out.println("------4------");
		System.arraycopy(a, 1, b, 3, a.length-1);
		pr(b);
		cls(b);

	}
	//모든 원소를 0으로 초기화
	public static void cls(int[] arr) {
		for (int i = 0; i < arr.length; i++) {
			arr[i] = 0;
		}
	}
	public static void pr(int[] b) {
		for (int i = 0; i < b.length; i++) {
			System.out.print(b[i] + "\t");
		}
		System.out.println();
	}
}

출력 결과

MultiArr01.java

package ch04;

//2차원 배열
public class MultiArr01 {

	public static void main(String[] args) {
		int[][] a = new int[2][3];
		a[0][0] = 1;
		a[0][1] = 2;
		a[0][2] = 3;
		a[1][0] = 11;
		a[1][1] = 12;
		a[1][2] = 13;
		for (int i = 0; i < a.length; i++) {	//a.length 는 행 값을 가져와서 2임.
			for (int j = 0; j < a[i].length; j++) { 	// a[i].length는 열 값이라서 3임.
				System.out.print("일반 For " + a[i][j] + "\t");
			}
			System.out.println();
		}
		System.out.println("==========향상==========");
		for(int[] arr1 : a ) {	//행만 뜻함 (a[0], a[1])
			for(int arr2 : arr1) {	//열을 뜻함 (행이 0일 경우 a[0][0], a[0][1], a[0][2])
			//이 순간에 구체적으로 각 배열에 해당하는 값이 arr2에 할당이 되는 것임.
				System.out.println("확장 For->" + arr2 + "\t");
			}
			System.out.println();
		}
	}
}

 

VarArr01.java

package ch04;

//가변배열
public class VarArr01 {

	public static void main(String[] args) {
		int[][] a = new int[3][];
		a[0] = new int[3];
		a[1] = new int[2];
		a[2] = new int[4];
        //행은 가변 불가, 열은 가변 가능
		//int[][] b = new[][5]; 로 하면 오류남.
		
		a[0][0] = 7;	a[0][1] = 23;	a[0][2] = 13;
		a[1][0] = 23;	a[1][1] = 3;
		a[2][0] = 2;	a[2][1] = 21;	a[2][2] = 56;	a[2][3] = 71;
		
		for (int i = 0; i < a.length; i++) {		//행
			for (int j = 0; j<a[i].length; j++) {	//열. 가변배열이기 때문에 i값에 따라 j의 범위가 달라짐.
				System.out.print(a[i][j]+"\t");
			}
			System.out.println();
		}
	}
}

출력 결과

 

VarArr02.java

package ch04;

//가변배열 향상형
public class VarArr02 {

	public static void main(String[] args) {
		int sum = 0;
		
		int[][] a = {{12,34,32}, {21,54,76,23}, {12,65}};
		for ( int[] arr : a) { //a는 {12,34,32}, .. 으로 받음 때문에 int[]로 선언해야 함
			for (int ar : arr) { //arr는 12, 34, 32로 받음. 때문에 int로 선언해야 함.
				System.out.print(ar + "\t");
				sum += ar;
			}
			System.out.println("합계 :" + sum + "\t 평균 :" + sum/arr.length);
			sum = 0;
		}
	}
}

출력 결과

 

p.12 클래스의 일반구조

// 클래스 헤더부분
class SampleClass { 
	// 멤버 변수 부분
	int a; 
	int b; 
	int c;
    
    // 생성자부분 이름이 클래스 명과 같다
    public SampleClass() { 
        a = x; 
        b = y; 
        c = z; 
    } 
    
    // 메소드 부분
    public int sum() {
        int d; 
        d = a + b + c; 
    } 
}

 

Car.java

package ch05;

//Class임. 실행하지 않는 코드. 필요한 요소를 모듈화해둔 것
//설계도(실행하지 않는 것)
//main 작성하지 않음. 설계도를 만들기 때문
public class Car {
	String	color;	//Member 변수, 필드
	int		speed;
	
	void speedUp() {
		speed++;
		System.out.println(speed + "속도를 올렸다.");
	}
	void speedDown() {
		speed--;
		System.out.println(speed + "속도를 내렸다.");
	}
	void print() {
		System.out.println("색깔 : " + color);
		System.out.println("속도 : " + speed);
	}

}

 

CarEx.java () 

package ch05;

//인스턴스(실행하는 코드)
public class CarEx {
	//실행할 class는 무조건 main을 가지고 있어야 함.
	public static void main(String[] args) {
		
		//class car(Car.java)를 사용하려면 이렇게 해야 함.
		//선언 + 생성 : 만들어둔 class인 Car를 토대로 myCar을 선언 후 new로 myCar 인스턴스를 생성
		//Car myCar 까지가 선언, = new Car까지 해야 생성이 되고 메모리에 올라감. 이렇게 하면 값들을 조정할 수 있게 되는 것임. 
		Car myCar = new Car();	
		
		myCar.color = "빨강"; //Car.java에서 color는 String이기 때문
		myCar.speed = 200;	//Car.java에서 speed는 int이기 때문 
		myCar.speedUp();
		myCar.print();
		
		//이렇게 따로 작성해도 된다.
		Car yourCar;		//선언
		yourCar= new Car();	//생성
		yourCar.speedUp();
		yourCar.color = "초록";
		yourCar.speed = 150;
		yourCar.print();
		yourCar.speedUp();
		
	}

}

 

실행 결과 : CarEx.java가 Car.java의 속성을 그대로 가지고 사용하기 때문에 출력결과가 이렇게 나옴. 이것이 객체지향의 가장 기본적인 모습. 필요한 요소들을 전부 모듈화 시켜놓고 한 곳에 모아둔 것이 객체지향이다.

 

* 하단에 뜨는 object들은 객체들의 아버지. 객체가 가지고 있는 고유 속성임. 객체를 상속받아 쓰는 것.

 

 

Car1Ex.java (중요한 개념 많음. 자주 반복해서 보기)

Car과 CarEx를 한 파일로 만듦.

package ch05;

//설계도
//Car1Ex의 이름이 아니기 때문에 public을 만들 수 없다. 
//그래서 이렇게 한 파일에 작성하지 않고 클래스를 분리해서 만드는 것이 권장된다.
class Car1 {
	String	color;	//인스턴스 변수 : Member 변수, 필드
	int		speed;
	//클래스변수 : 동일 클래스 내의 모든 인스턴스들이 공유하는 변수 (면접 질문 외우기 별 3개)
	static int wheel;
	
	
	void speedUp() {
		speed++;
		System.out.println(speed + "속도를 올렸다.");
	}
	void print() {
		System.out.println("색깔 : " + color);
		System.out.println("속도 : " + speed);
		System.out.println("바퀴 : " + wheel);
	}

}

public class Car1Ex {

	public static void main(String[] args) {
		//클래스변수는 클래스명.변수명 으로 하단처럼 써도 된다.
		Car1.wheel = 8; //UFO
		System.out.println("UFO wheel: " + Car1.wheel);
		//static 변수는 인스턴스가 생성되기 전에 공유해서 쓸 수 있다.
		//34줄부터의 과정이 없어도 사용할 수 있다는 뜻.
		

		Car1 c1 = new Car1();	//c1 메모리가 생성된다. (HDD에서 Memory로 c1이 올라간다.)
		Car1 c2 = new Car1();
		//이 코드를 작성하면 Car1() 생성자가 없어도 기본생성자를 기본으로 만들어줌. 기본생성자가 자동으로 생김.
		//기본 생성자란 매개변수가 없는 생성자이다.
		//클래스에 생성자가 하나도 없으면 컴파일러가 기본 생성자를 추가한다.
		//(생성자가 하나라도 있으면 컴파일러는 기본 생성자를 추가하지 않는다.)
		
		c1.color = "빨강";
		c1.speed = 200;
		c1.wheel = 4;
		c2.color = "노랑";	//c2는 int값이기 때문에 출력결과의 속도가 0이 된다.
		// c2.wheel = 3;	
		//이 문장을 주석해제하면 wheel값은 전부 3이 나온다. 
		//static은 동일 클래스 내의 모든 인스턴스들이 공유하는 변수이기 때문.
		
		c1.print();
		c2.print();
	}
}

클래스변수 : 동일 클래스 내의 모든 인스턴스들이 공유하는 변수 (면접 질문 외우기)

 

출력 결과

 

Car3.java :  class 내에 main method가 있어야 실행이 된다. 그래서 Car3.java 자체로는 실행되지 않음.

package ch05;

public class Car3 {
	String name;	//차 이름
	int inTime;		//입고시간
	int outTime;	//출고시간
	int fee;		//주차요금
	final int AMTPERTIME = 3000;	//시간 당 요금. 마지막 값(final)이므로 상수
	
	//생성자(Constructor) : void인데도 void라고 하지 못하는 것. class명과 똑같은 이름.
	//생성자 역할 : 메모리를 만든다. 멤버변수 초기화(멤버변수에게 필요한 값을 생성해준다.)
	Car3(String n, int in, int out) {
		name = n;
		inTime = in;
		outTime = out;
	}
	
	void print() {		//return값이 없는 것이 void임.
		int fee = (outTime - inTime) * AMTPERTIME;
		System.out.println("차 이름 : " + name);
		System.out.println("입고시간 : " + inTime);
		System.out.println("출고시간 :" + outTime);
		System.out.println("주차요금 : " + fee);
		System.out.println("---------------------");
		
		
	}

}

생성자는 리턴값이 없지만 void를 쓰지 않음. 클래스의 이름과 같아야 함(외우기)

 

Car3Ex.java

package ch05;

public class Car3Ex {

	public static void main(String[] args) {
		Car3 c1 = new Car3("소나타", 10, 14); 	//Car3의 변수가 3개
		Car3 c2 = new Car3("그랜저", 9, 20);
		Car3 c3 = new Car3("아반떼", 12, 13);
		
		//c1.AMTPERTIME = 2500;
		//final 값은 변경할 수 없는 상수이다.
		//AMTPERTIME은 final 변수로 지정해줬기 때문에 변경할 수 없어서 주석해제하면 오류남.
		c1.print();
		c2.print();
		c3.print();

	}

}

 

*final 변수명은 무조건 전부 대문자로 작성.

 

출력 결과

 

PersonEx.java

package ch05;

class Person {
	String name;
	int age;
	String gender;
	
	void print() {
		System.out.println("이름:" + name + " 나이  :"+age + " 성별 : " + gender);
	}
}

public class PersonEx {

	public static void main(String[] args) {
		//Person Instance -> per1, per2, per3
		
		Person pr1 = new Person();
		Person pr2 = new Person();
		Person pr3 = new Person();
		
		pr1.name = "홍 길동";
		pr1.age = 22;
		pr1.gender = "M";
		
		pr2.name = "연개소문";
		pr2.age = 32;
		pr2.gender = "M";
		
		pr3.name = "선덕여왕";
		pr3.age = 42;
		pr3.gender = "F";
		
		pr1.print();
		pr2.print();
		pr3.print();		
		
	}

}

출력 결과

 

SubscribeEx.java

package ch05;

class Subscribe {
	String name;
	String telnum;
	int age;
	
	//생성자 overLoading(생성자를 2개 이상을 같이 넣은 것을 뜻함. 동시에 2개의 생성자를 업로드한다라는 의미)ㄴ
	Subscribe() {	//기본생성자임. 하단 생성자가 있기 때문에 자동으로 생성되지 않아서 기본생성자가 필요하면 직접 써야 함.
	}
	
	Subscribe (String n, String t) {	//파라미터를 넣은 생성자임.
		name = n;
		telnum = t;
	}
	void ChgTelNum(String t) {
		telnum = t;
	}
	
	//
	void ChgAge(int age1) {
		if (age1 < 0) {
			System.out.println("당신은 - 나이를 넣고 있네요");
			return;
		}
		age = age1;
	}
	
	void print() {
		System.out.printf("이름 : %s 전화번호 : %s \n", name, telnum);
	}
}


public class SubscribeEx {

	public static void main(String[] args) {
		Subscribe s1 = new Subscribe("이성계", "010-2223-5567");
		s1.print();
		
		//위와 똑같은 class를 사용하였는데 파라미터 생성자 대신 기본생성자를 사용함.
		Subscribe s2 = new Subscribe();
		
		//1,2번째 줄 처럼 직접 값을 지정하지 말고 3번째 줄 처럼 메소드를 통해 구현해야 함.
		//이유1. 다른 곳에서 접근하지 못하도록 하는 것.
		//이유2. 직접 값을 지정하게 되면 코드를 수정할 때 엄청난 양의 코드를 (예를 들면 나이를 -10으로 지정한 것) 일일이 다 수정해야 해서 유지보수가 힘듦.
		//메소드를 통해 구현하게 되면 void구문 (예를 들면 void ChgAge(int age1) 부분) 만 수정하여 해결할 수 있음.
		s2.name = "김유신";
		s2.age = -10;
		s2.ChgTelNum("010-1111-2222");
		s2.print();
	}
}

출력 결과

 

 

OverLoadingEx.java

package ch05;

class OverLoading {
	String name;
	int	age;
	String gender;
	
	//생성자 OverLoading 3개
	OverLoading() {	//기본생성자
	}
	OverLoading(int a) {
		age = a;		
	}
	OverLoading(String str) {
		name = str;		
	}
	void print() {
		System.out.println("---------------");
		System.out.println("name->" + name);
		System.out.println("age ->" + age);
	}
}

//OverLoading은 똑같은 메소드를 가지고 파라미터 타입이나 수에 따라 자동으로 호출되는 기법이다.
//생성자 오버로딩, 메소드 오버로딩으로 크게 두 가지로 나뉜다.
public class OverLoadingEx {

	public static void main(String[] args) {
		OverLoading ov1 = new OverLoading();	//기본생성자
		OverLoading ov2 = new OverLoading(25);	//기본생성자
		OverLoading ov3 = new OverLoading("홍길동");
		ov1.print();
		ov2.print();
		ov3.print();

	}

}

출력 결과

 

p.17 선언 위치에 따른 변수의 종류 (면접 질문 외우기 중요)

ㆍ클래스변수(class variable)

- 같은 클래스의 모든 인스턴스들이 공유하는 변수

- 인스턴스 생성없이 ‘클래스이름.클래스변수명’으로 접근 ex) Variables.staticVar = 10; 

- 클래스가 로딩될 때 생성되고 프로그램이 종료될 때 소멸

 

ㆍ인스턴스변수(instance variable)

- 각 인스턴스 개별적인 저장공간. 인스턴스마다 다른 값 저장가능

- 인스턴스 생성 후, ‘참조변수.인스턴스변수명’으로 접근

- 인스턴스를 생성할 때 생성되고, 참조변수가 없을 때 가비지 컬렉터에 의해 자동 제거됨

- 인스턴스 변수는 틀에서 생성하기 때문에 인스턴스마다 다른 값을 저장할 수 있음.

 

ㆍ지역변수(local variable)

-  메서드 내에 선언되며, 메서드의 종료와 함께 소멸

- 조건문, 반복문의 블럭{} 내에 선언된 지역변수는 블럭을 벗어 나면 소멸

- 말 그대로 지역 안에서 선언하는 변수가 지역변수

Class Variables {
	static int staticVar;		//클래스변수
    
  	int instanceVar;		//인스턴스변수
    
  	Void method() {
    		int localVar;		//지역변수
   	}
}

인스턴스변수 : 인스턴스가 생성될 때마다 생성, 인스턴스 마다 각기 다른 저장공간 생성 - 동적변수

클래스변수 : 클래스가 로딩 될 때 한 번만 생성, 하나의 저장공간을 공유, 공통된 값을 갖는 경우 - 정적변수

 

 

[ch06]

Account2Ex.java

package ch06;

//class는 설계도임.
class Account2 {
	String 	accountNo;	//계좌번호
	String 	ownerName;	//계좌주
	int 	balance;	//잔고
	
	//생성자의 역할 : 메모리를 만든다. 파라미터를 받는 경우 기본값을 세팅해준다. (중요 외우기)
	//Account2() {} //생성자를 이렇게 만들면 - 메모리만 만들어서 메모리만 올려놓겠다는 뜻	
	Account2(String amtno, String own, int bal) {	//생성자 - 멤버변수의 기본값을 세팅해서 메모리에 올려놓겠다.
		accountNo = amtno;
		ownerName = own;
		balance = bal;
	}
	//예금
	void deposit(int amt) {
		balance += amt;
	}
	//출금
	void withdraw(int amt) {
		if (balance < amt) {
			System.out.println(ownerName + "인출 안됨-->현재 잔액 부족 : 잔액->" 
								+ balance + " 요청금액->" + amt);
		}
		else balance -= amt;
	}
	//잔고
	int getBal() {
		return balance;
	}
	
}


public class Account2Ex {

	public static void main(String[] args) {	//보통 public에 main메소드를 둔다.
		//메모리와 초기값을 동시 세팅하는 것.
		Account2 ac1 = new Account2("국민 1111", "김춘추", 10000);
		Account2 ac2 = new Account2("신한 2222", "강감찬", 20000);
		Account2 ac3 = new Account2("농협 3333", "조정은", 30000);
		ac1.deposit(5000);
		//ac1.getBal()
		System.out.println("은행계좌:" + ac1.accountNo + " 성함:" + ac1.ownerName + " 잔액 : "+ ac1.balance);
		
		ac1.withdraw(12000);
		System.out.println("은행계좌:" + ac1.accountNo + " 성함:" + ac1.ownerName + " 잔액:" + ac1.balance);
		
		ac1.withdraw(5000);
		System.out.println("은행계좌:" + ac1.accountNo + " 성함:" + ac1.ownerName + " 잔액:" + ac1.balance);
		
		//강감찬 --> 예금 7000 조회, 출금은 3500원 조회
		ac2.deposit(7000);
		System.out.println("은행계좌:" + ac2.accountNo + " 성함:" + ac2.ownerName + " 잔액:" + ac2.balance);
		ac2.withdraw(3500);
		System.out.println("은행계좌:" + ac2.accountNo + " 성함:" + ac2.ownerName + " 잔액:" + ac2.balance);
	}
}

출력 결과

 

Car2Ex.java

package ch06;

class Car2 {
	String 	name;
	String 	color;
	int 	speed;
	
	//외우기
	//생성자는 클래스명과 메소드명이 같다. 하지만 void라 하지 않는다.
	//생성자의 역할은 메모리를 생성시켜준다. 기본생성자가 아닌 것은 멤버변수의 값을 세팅시켜서 초기화시켜준다.
	Car2(String name, String color, int speed) {
		//이름이 같으면 지역변수로 세팅되기 때문에 this연산자를 세팅해줘야 인스턴스변수(코드상 4~6줄)를 뜻한다는 것을 알 수 있다.
		//this 인스턴스는 자신을 가리키는 참조변수
	    //모든 인스턴스 메서드에 지역변수로 숨겨진 채로 존재
	    //인스턴스변수와 지역변수를 구별하기 위해 참조변수 this사용
		//헷갈리지 않도록 생성자에 this라는 참조변수를 쓰는 것을 권장.
		this.name = name;
		this.color = color;
		this.speed = speed;
	}
	void print() {
		System.out.println(name +"\t" + color + "\t" + speed);
	}
}

public class Car2Ex {

	public static void main(String[] args) {
		Car2 c1 = new Car2("소나타","빨강",150);
		c1.print();

	}

}

출력 결과

 

 

[객체지향 OOP]

(면접 중요. 면접 단골 질문. 외우기) *다음시간부터 하나씩 배울 예정

 

OOP의 개념

1. 상속(Inheritance)

1) extends

2) Implements

 

2. 다형성(Polymorphysm) (특히  아주 중요)

1) OverLoading : 하단 코드와 같이 똑같은 이름의 생성자가 여러개 있는 것.

public class Constructor { 
	int i; int j; 
		public Constructor(){ // 디폴트생성자
			System.out.println("Constructor()"); this.i=100; this.j=100; 
		} 
		public Constructor(int i){ // 매개변수가 있는 생성자
			System.out.println("Constructor(int i)"); this.i=i; this.j=100; 
		} 
		public Constructor(int i,int j){ 
			System.out.println("Constructor(int i,int j)"); 
			this.i=i; this.j=j; 
		} 
}

2) OverRiding : 상속받을 때

 

3. 캡슐화(Encapsulation)

- 정보보호(Private)