JAVA

1. Java 시작

• Java Technology

  • Programming Language
  • Development Environment
  • Application Environment
  • Deployment Environment

• JVM / JRE / JDK

  • 사용자/개발자 입장에 따라 설치 범위가 달라짐
  • JRE (Java Runtime Environment) : for Java User
  • JDK (Java Development Kit) : for Java Developer (JRE 포함)
    

• Java Platform 종류

  • J2SE : Java 2 Standard Edition
  • J2EE : Java 2 Enterprise Edition
  • J2ME : Java 2 Micro Edition

• Java 특징

  • 사용하기 쉬운 언어 제공
    • 다른 언어의 단점 보완 (포인터/메모리)
    • 객체 지향 언어
    • 능률적이고 명확한 코드 작성
  • Interpreted Environment
    • 개발 속도 향상
    • 코드 이식성(bytecode)
  • Thread 제공
  • 클래스의 동적 메모리 Load
  • 변경된 class를 원격지로부터 다운로드하여, Runtime시 반영
  • 코드 안전성

• Java 요소

  • Java Virtual Machine
  • Garbage Collection
  • Code Security

• JVM 특징

  • H/W platform 규약을 제공함
  • Platform 독립적인 bytecode를 해석하고, 실행
  • S/W 또는 H/W로 구현
  • 실행환경은 일반 PC 혹은 Web Brower
  • 설치된 platform에 종속적
    

• Garbage Collection

  • 더 이상 사용되지 않는 메모리는 재사용 가능하게 해제시킴
  • 자바는 자동 (다른언어에서는 메모리 해제는 프로그래머가 직접 코드로서 구현함)
  • 일어나는 시점은 구현된 JVM마다 다를 수 있음 (Vendor Dependent)
  • 개발자가 System.gc(); 호출 가능

• Consol에서의 컴파일과 실행
  

• Java 프로그램 수행 과정
  

1. Garbage Collector의 설명으로 맞는 것은?

1) 더 이상 쓰이지 않는 메모리를 회수하여 사용 가능하게 한다.
2) Garbage Collection 시점을 예측하여, 효율을 높일 수 있다.
3) 모든 JVM은 동일한 Garbage Collection 기법을 사용한다.
4) 메모리에 대한 관리 책임을 프로그래머에게 위임한다.

➡️ 2️⃣ : Grabage Collector 스레드가 알아서 하고, 예측할 수 없음
3️⃣ : Garbage Collection 기법은 모두 다름

2. 다음 중 bytecode에 대한 설명으로 맞는 것은?

1) 개발자가 작성한 소스 코드를 말한다.
2) 바로 실행 가능한 실행 모듈이다.
3) Platform 독립적이다.

➡️ 1️⃣ : java code
2️⃣ : jre가 있어야지 실행 가능

3. 자바 실행 순서를 맞게 기술한 것은?

1) Compile–Bytecode Verifier–Class Loader–Interpreter–Run
2) Compile–Class Loader–Bytecode Verifier–Interpreter–Run
3) Compile–Class Loader–Interpreter–Bytecode Verifier–Run

4. 다음 중 자바 가상 머신(Java Virtual Machine)이 하는 일은?

1) 자바 소스 코드를 바이트 코드로 변환시킨다.
2) byte code를 해석해서 자바 프로그램을 실행시킨다.
3) 자바 소스 코드를 compile 한다.
4) 자바 소스 코드를 작성하는 에디터 이다.
➡️ 1️⃣ : 컴파일러
3️⃣ : 컴파일러
4️⃣ : 이클립스

5. 자바 프로그래밍 언어에 대해 설명으로 틀린 것은?

1) 플랫폼 독립적이다.
2) 객체 지향적이다.
3) Thread를 사용한다.
4) 메모리 해제를 프로그래머가 직접 해야 한다

➡️ 4️⃣ : 메모리 해제는 Garbage Collector Thread가 수행

2. 객체 지향 프로그래밍

• Abstraction

  • 실 세계의 객체를 프로그래밍 관점에서 관심의 대상이 되는 속성과 행동을 추출해 내는 것
  • Class (Abstraction 결과) : Member Variable(속성) + Member Method(행동)

• Class

  • 클래스는 추상화된 대상이 속성과 행동을 가진다는 것을 정의한 설계 (실제로 값을 가진 객체X)
  • 실제로 값을 갖는 객체(instance)는 new라는 키워드를 이용해서, 클래스 정의에 해당하는 내용으로 메모리에 할당되어져 이용

• Class Diagram

  • Class Name
  • Variable
  • Method
    
  • Class 작성
    
  • Class 사용
    

• package

  • 한 자바 파일에서 단 한번만 사용 가능
  • 관련 있는 클래스를 묶어 주는 역할

• import

  • 한 자바 파일에 여러번 사용 가능
  • 서로 다른 package에 있는 클래스를 참조하기 위해, 어느 package에 있는 클래스인지 선언해 주는 역할
  • 같은 package 클래스 사용할 때는 필요X

• Member Variable

  • public + int + rating
  • Access Modifier + Data Type + Variable Name

• Method

  • public + void + setTitle + (String newTitle) {
    title = new Title;
    }
  • Access Modifier + Return Type + Method Name + Parameter + Method Body

  package chap02.entity;
  
  		public class Movie {
      // Movie의 속성을 변수로 선언
      public String title;
      public String director;
      public String starring;
      public int raing;
      // Source -> Generate Getters and Setters로 생성
      // Method Signature 
      public String getTitle() {
          return title;
      }
      public void setTitle(String title) {
          this.title = title;
      }
  
      public void playMovie() {
          System.out.println(title + "을 상영합니당");
      }
  }

• 접근 제한자 (Access Modifier)

  • (+) public : universe

  • (#) protected : same package + subclassing

  • (~) default : same package

  • (-) private : same class

  • class : public, default

  • method/Virable : public, protected, default, private

  • Account 클래스(부모 클래스), SavingAccount 클래스 (자식 클래스)

    • (1) Account와 SanvingAccount 패키지 명이 다르다
    • (2) Account에서 protected withdraw()메서드가 선언 되어있다
    • (3) SavingAccount에서 부모 Account의 withdraw() 메서드에 접근할 수 있다 (패키지가 달라도 서로 상속 관계이기 때문에)

• OOP (Object-Oriented Programming) 특징

  • Encapsulation
  • Inheritance
  • Polymorphism

• Encapsulation

  • Information hiding
    • Class 외부에서 주요 정보에 접근하지 못 하도록 숨기는 것
    • 멤버변수는 private로 선언하여, 외부에서 직접 참조하지 못하도록 막음
    • 멤버 변수는 getter/setter를 이용하여 참조
  • Encapsulation 특징
    • Class 구현에 대한 상세내용을 숨기는 것
    • Class 사용자는 Class 내부 구현에 신경 쓸 필요 없이, 제공되는 Interface(method) 이용
    • 내부 로직은 private 선언, 외부에서는 Interface만 이용 (Data 보호, 유지보수 편함)
  • 수정
    • 수정 전 (public으로 제한하지 않으면, 컴파일 오류는 없지만 잘못된 값으로 오염될 수 있음)
      
    • 수정 중 (숨겨진 data(private 멤버 변수)에 대한 access는 getter/setter 이용)
      
    • 수정 후
      
  • MyDate.java

    package chap02.entity;
  
  public class MyDate {
      private int year;
      private int month;
      private int day;
  
      public int getYear() {
          return year;
      }
      public void setYear(int year) {
          if(year >= 2000)
              this.year = year;
          else
              System.out.println("년도는 2000년 이후 값만 가능 ");
      }
  
      public int getMonth() {
          return month;
      }
      public void setMonth(int month) {
          if (month >= 1 & month <= 12)
              this.month = month;
          else
              System.out.println("월은 1 ~ 12 값만 가능 ");
      }
  
      public int getDay() {
          return day;
      }
      public void setDay(int day) {
          if (day >= 1 & day <= 31)
              this.day = day;
          else
              System.out.println("일은 1 ~ 31 값만 가능 ");
      }
  
      public String getDate() {
          return this.year + "-" + this.month + "-" + this.day;
      }
  
  }

  • TestMyDate.java

    package chap02.entity;
  
  import chap02.entity.MyDate;
  
  public class TestMyDate {
  
      public static void main(String[] args) {
          MyDate myDate1 = new MyDate();
  
  //		myDate.year = 2023;
  //		myDate.month = 13;
  //		myDate.day = 33;
  
          myDate1.setYear(2023);
          myDate1.setMonth(9);
          myDate1.setDay(11);
  
          System.out.println(myDate1.getDate());
  
          MyDate myDate2 = new MyDate();
  
          myDate2.setYear(1999);
          myDate2.setMonth(13);
          myDate2.setDay(33);
          
          System.out.println(myDate2.getDate());
      }
  }

  

• Constructor

  • 멤버 변수 초기화하는데 사용
  • 특징
    • 클래스 이름과 같음
    • return 타입이 없음
    • 상속되지 않음
    • 객체 생성시 new라는 키워드를 만났을 때 호출됨
  • Default Constructor
    • 모든 클래스는 최소한 하나의 constructor가 있음
    • constructor를 정의하지 않을 경우에, 자동적으로 default constructor가 생성됨 (1개라도 있으면 default 생성자 생성 안됨)
    • default constructor는 아무런 argument가 없고, body에 내용이 없음
      

• MyDate.java

package chap02.entity;

public class MyDate {
	private int year;
	private int month;
	private int day;
	
	// 디폴트 생성
	public MyDate() {
		this.year = 2000;
		this.month = 1;
		this.day = 1;
	}
	//3개의 값을 argument로 받아 초기화 
	public MyDate(int year, int month, int day) {
		super();
//		this.year = year;
//		this.month = month;
//		this.day = day;
		setYear(year);
		setMonth(month);
		setDay(day);
	}
	
	public int getYear() {
		return year;
	}
	public void setYear(int year) {
		if(year >= 2000)
			this.year = year;
		else
			System.out.println("년도는 2000년 이후 값만 가능 ");
	}
	
	public int getMonth() {
		return month;
	}
	public void setMonth(int month) {
		if (month >= 1 & month <= 12)
			this.month = month;
		else
			System.out.println("월은 1 ~ 12 값만 가능 ");
	}
	
	public int getDay() {
		return day;
	}
	public void setDay(int day) {
		if (day >= 1 & day <= 31)
			this.day = day;
		else
			System.out.println("일은 1 ~ 31 값만 가능 ");
	}
	
	public String getDate() {
		return this.year + "-" + this.month + "-" + this.day;
	}
}

• TestMyDate.java

package chap02.entity;

import chap02.entity.MyDate;

public class TestMyDate {

	public static void main(String[] args) {
		MyDate myDate1 = new MyDate();
		
//		myDate.year = 2023;
//		myDate.month = 13;
//		myDate.day = 33;
		
		myDate1.setYear(2023);
		myDate1.setMonth(9);
		myDate1.setDay(11);

		System.out.println(myDate1.getDate());
		
		MyDate myDate2 = new MyDate();
		
		myDate2.setYear(1999);
		myDate2.setMonth(13);
		myDate2.setDay(33);
		
		System.out.println(myDate2.getDate());
	
		MyDate myDate3 = new MyDate(2001, 1, 3);
		System.out.println(myDate3.getDate());
	}
}

• SourceFile Layout
  

1. 객체지향 프로그래밍 언어의 3대 주요 특징은?

➡️ 캡슐화 (Encapsulation), 상속 (Inheritance), 다형성 (Polymorphism)

2. 다음은 무엇에 대한 설명인지 보기에서 고르세요.

1) 패키지
2) API
3) 클래스 Loader
4) 클래스 Directory

3. 다음 자바 코드는 컴파일시 에러가 난다. 그 이유는?

➡️ dog 메서드의 반환값이 없음
public void dog()
➡️ 생성자와 클래스 이름이 다름
Dog d = new dog();

4. 다음 자바 코드는 실행시 에러가 난다. 그 이유는?

➡️ 메인 메서드의 매개변수형이 잘못 됨
public static void main(String[] args)

5. 다음은 무엇에 대한 설명인가?

➡️ import

6. 생성자(Constructor)에 대한 설명 중 틀린 것은?

1) 호출 시점에 new 키워드가 사용한다.
2) Class명과 같은 이름을 쓴다.
3) Return 값을 명시해 주어야 한다.
4) 객체 값을 초기화 시키는데 사용된다.

과제 1 (Encapsulation 개념)

문제

1. 클래스 이름은 Account로 합니다.
2. package명은 workshop.account.entity입니다.
3. 고객번호(custId), 계좌번호(acctId), 잔액(balance)에 해당하는 변수를 선언합니다.
모든 변수들을 다른 클래스에서 직접 사용하지 못하도록 private으로 선언하며, 고객번호, 계좌번호는
String type으로 , 잔액은 int type으로 합니다.
4. 멤버변수 balance는 private으로 선언하였기 때문에 다른 클래스에서 이 멤버변수에 대해 직접 값을 읽거
나 쓸 수 없습니다. 다른 클래스에서 잔액의 값을 할당하고, 읽을 수 있도록 메서드를 작성합니다.
1) 값 할당 메서드
메서드 이름 : setBalance, 아규먼트: int newBalance , 리턴타입: void
2) 값 얻기 메서드
메서드 이름 : getBalance, 아규먼트: 없음 , 리턴타입: int type
5. 멤버변수 custId와 acctId에 대해서도 값을 할당하고, 읽을 수 있는 메서드를 작성합니다.
-setCustId, getCustId, setAcctId, getAcctId
6. 계좌잔액을 입력한 금액만큼 증가(입금) 시키는 메서드를 작성합니다.
메서드이름 : deposit, 아규먼트: int amount , 리턴타입: void
7. 계좌잔액을 입력한 금액만큼 감소(출금) 시키는 메서드를 작성합니다.
메서드이름 : withdraw, 아규먼트: int amount , 리턴타입: void
8. Account클래스를 객체 생성하여 이용하는 클래스인 TestAccount 클래스를 작성합니다.
1) package는 workshop.account.test입니다.
2) Account 클래스가 다른 package에 있기 때문에 import 해야 합니다.
3) 실행 가능한 메서드인 main 메서드를 작성해야 합니다.
a. Account 클래스의 객체를 생성합니다 (new 연산자를 사용함)
b. 생성한 Account 객체의 멤버변수의 값을 아래와 같이 할당합니다.
고객번호 : “A1100”, 계좌번호 : “221-22-3477”, 잔액 : 100000
c. 고객번호와 계좌번호를 화면에 출력합니다.
d. 잔액을 화면에 출력합니다.
e. 잔액을 10000원 증가시킵니다.
f. 잔액을 화면에 출력합니다.
g. 잔액을 20000원 감소시킵니다.
h. 잔액을 화면에 출력합니다.

Account.java

package workshop.account.entity;

public class Account {
	private String custId;
	private String acctId;
	private int balance;
	
	public int getBalance() {
		return balance;
	}
	public void setBalance(int newBalance) {
		this.balance = newBalance;
	}
	
	public String getCustId() {
		return custId;
	}
	public void setCustId(String custId) {
		this.custId = custId;
	}
	
	public String getAcctId() {
		return acctId;
	}
	public void setAcctId(String acctId) {
		this.acctId = acctId;
	}
	
	public void deposit(int amount) {
		balance += amount;
	}
	
	public void withdraw(int amount) {
		if ((balance - amount) >= 0) {
			balance -= amount;
		}
		else {
			System.out.println("잔액이 부족합니다.");
		}
	}
	
}

TestAccount.java

package workshop.account.test;

import workshop.account.entity.Account;

public class TestAccount {

	public static void main(String[] args) {
		Account act = new Account();
		
		act.setCustId("A1100");
		act.setAcctId("221-22-3477");
		act.setBalance(100000);
		
		System.out.println("고객 : " + act.getCustId());
		System.out.println("계좌번호 : " + act.getAcctId());
		System.out.println("잔액 : " + act.getBalance());
		act.deposit(10000);
		System.out.println("잔액 : " + act.getBalance());
		act.withdraw(20000);
		System.out.println("잔액 : " + act.getBalance());
	}

}

3. 식별자, 키워드와 타입

• 주석

package chap02.entity;

/**
 * 영화정보를 담는 클래스
 *  
 * @author 홍길동
 * @version 1.0, 2023/09/12 
*/

public class Movie {
	// Movie의 속성을 변수로 선언
	public String title;
	public String director;
	public String starring;
	public int raing;
	
	public Movie()
	{
		this.title = title;
		this.director = director;
		this.starring = starring;
		this.raing = raing;
	}
	
	/**
	* 모든 정보를 갖는 Movie 클래스의 생성자 * @param title 제목
	* @param director 감독
	* @param starring 주연
	* @param rating 등급
	*/
	public Movie(String title, String director, String starring, int raing)
	{
		this.title = title;
		this.director = director;
		this.starring = starring;
		this.raing = raing;
	}
	
	
	// Source -> Generate Getters and Setters로 생성
	// Method Signature 
	/**
	* 제목 정보에 대한 getter * @return 영화제목
	*/
	public String getTitle() {
		return title;
	}
	public void setTitle(String title) {
		this.title = title;
	}
	
	public void playMovie() {
		System.out.println(title + "을 상영합니당");
	}
}

• javadoc

  • 자바 어플리케이션에 대해서 html파일 생성
    • Java 소스 코드의 코드 문서를 생성하는데 도움을 주는 도구
    • 소스 코드에 작성된 코멘트를 따라 문서를 만듦
  • 소수 수정시 javadoc 일치 필요
  • Project -> Generate javadoc
    

• Identifier

  • 클래스, 변수, 메소드에 주는 이름
  • 이름 규칙
    • Unicode 문자, '_', '$'로 구성
    • 숫자로 시작X
    • 대소문자로 구분
  • Keyword는 Identifier 사용 불가
  • 예약어(true, false null 등)와 키워드(goto, const 등), 연산자(sizeof) 변수명 사용 불가

• Keyworkd

  • 접근 제한자 : public, private, default, protected
  • 메서드 : void, return
  • 제어문, if, else, for, do~while, while, switch, case, break, continue, goto
  • 데이터 타입 : boolean, byte, short, int, long, float, double, char
  • 예외 처리 : try, catch, finally, throw, throws
  • 클래스 : class, interface, extends, implements, abstract, super, this
  • 패키지 : package, import
  • 스레드 : synchronized
    

• Data Type

  • Primitive : 기본 데이터 단일 값 (정수형/실수형/문자형/논리형)
    • 논리형 (boolean) : 기본값 false
    • 문자형 (char) : 기본값 '₩u0000'
    • 정수형 (byte/short/int/long) : 기본값 0/0/0/0L (1/2/4/8bytes)
      ➡️ 정수형 literal의 data type은 int형
    • 실수형 (float/double) : 0.0F/0.0D (4/8bytes)
      ➡️ 실수형 literal의 data type은 double형
  • Reference : 객체에 대한 주소 값
    • new를 이용해 생성한 객체의 주소 값을 가지고, 객체를 제어하는데 사용
    • 기본값 null

• 객체 생성시, 메모리가 할당되는 순서

  • (1) 메모리 할당 (reference 변수, 객체)
  • (2) 객체의 멤버변수 초기화
    • default value로 초기화
    • 명시적 초기화
    • Constructor에 의한 초기화
  • (3) 객체의 주소 값이 reference 변수에 할당

• this 키워드

  • 자기자신의 객체를 가리킴
  • 용도
    • 자기자신이 멤버변수 참조 : this.멤버변수_이름
    • 자기자신이 멤버메소드 참조 : this.멤버메소드_이름()
    • 자기자신의 생성자 호출 : this.(파라미터_리스트)

1. 다음 중 잘 못 선언된 identifier는?

1) $money
2) is-valid
3) _leftTime
4) 4chonman
5) man4ma

➡️ 2️⃣ : - 대신 _ 사용
4️⃣ : 숫자로 시작X

2. 다음과 같이 기본 데이터 타입의 변수들이 선언되어 있을 때, 값 할당 이 모두 맞게 된 것은?

      float z;
      int x,y;
      boolean d;
      

1) z=3.1415; x=14;
2) x = 14; d = "false";
3) z = 3.1415; d = "false";
4) x = 14; y = x;

➡️ 1️⃣ : z=3.1415f;
2️⃣ : d = false;
3️⃣ : z=3.1415f;, d = false;

3. 다음 클래스 중에서 유효한 할당 문은?

public class Time {
    int hour, minute, seconds;
	public static void main( String[] args ) { 
    	Time start, end;
		start = new Time(); }
	}

1)start.hour = 8;
start.seconds = 0;
2)start.hour = 8;
minute = 0;
3)start.seconds = 0;
end.hour = 16;
4)end.hour = 16;
minute = 0;

➡️ 3️⃣ : 초기화가 되어있지 않아 runtime 에러
4️⃣ : 초기화가 되어있지 않아 runtime 에러

4. 다음 중 Java의 Coding Convention에 의해 대문자로 시작해야 하는 것이 아닌 것은?

1)Package Name
2)Class Name
3)Contant Variable Name
4)Interface Name

5. Method내의 local variable이나, argument로 전달 받은 variable의 이름이 member variable과 같을 때 이를 구분하기 위해 member variable에 사용하는 키워드는?

➡️ this

4. 표현과 흐름 차트

• 변수의 분류

  • primitive type
  • reference type

• 선언위치에 따라

  • 메소드 내부 선언, 메소드 파라미터 : local variable
  • 클래스 안 & 메소드 밖 선언 : member variable, class variable

• 변수의 생명, 초기화 문제, 참조 범위

  • local 변수
    • 메소드 시작시 생성, 메소드 종료시 해제 (stack)
    • 자동 초기화X (반드시 사용전 명시적 초기화 필요)
    • 해당 메소드 내 참조
  • 멤버 변수
    • 객체 생성시 생성, 객체 메모리 해제시 같이 해 (heap)
    • 자동 초기화
    • 한 객체 내 참조
  • 클래스 변수 (static)
    • 클래스 로드시 생성, Appliaction 종료시 해제(static 영역)
    • 자동 초기화
    • 전 클래스 객체 공통 참조

• 지역변수

  • 명시적 초기화 필요

package chap04;

public class Initializing {
	public void doComputation() 
	{
		int x = 10;
		int y; // local 변수 초기화 필요 
		int z = 0;
		if ( x > 50 ) { y = 9;
		}
		z = y + x; 
		}
}

• 연산자
  

  • logical operator
    

• promotion & casting

  • 정보를 잃지 않는 방향을 데이커 타입간 변환 허용
    • 큰 데이터 타입을 작은 데이터 타입에 넣을 수 없음
    • primitive data type 뿐만 아니라 reference data type도 type casting 가능
  • promotion : 상위 데이터 타입으로의 conversion 자동 허용
  • casting : 하위 데이터 타입으로 강제 변환되도록 명시

5. 배열

• array
  • 동일한 타입의여러 데이터를 하나의 이름으로 관리
  • 배열의 이름은 배열객체의 주소 값을 갖는 참조 변수
  • 선언 : int[] numbers
  • 생성 : numbers = new int[];
• array size
  • 배열은 크기 바꿀 수 없음

  int[] myArray = new int[6];
  myArray = new int[10]; // size 늘어나는 것이 아니라, 새로운 배열이 생성
  

1. 다음 중 잘못된 배열 선언은 무엇인가?

1)float [][] mat = new float[4][4];
2)float [] mat [] = new float[4][6];
3)float [][] mat = new float[4][];
4)float [][] mat = new float[][4];

2. 다음 코드를 컴파일하고 실행한다면 그 결과는 어떻게 되는가?

public class Test { 
	public static void main ( String[] args ) {
    int [] x ;
    System.out.println( "Value is " + x[5]); 
    }
}

1) 컴파일 오류가 발생됩니다.
2) 런타임 오류가 발생됩니다.
3) 아무 것도 출력되지 않습니다.
4) Value is 0 이 출력됩니다.

3. 다음 코드를 컴파일하고 실행한다면 그 결과는 어떻게 되는가?

public class Test { 
	public static void main ( String[] args ) {
    int[] x = new int[10];
    System.out.println( "Value is " + x[5] ); 
    }
}

1) 컴파일 오류가 발생됩니다.
2) 런타임 오류가 발생됩니다.
3) 아무 것도 출력되지 않습니다.
4) Value is 0 이 출력됩니다.

4. 다음 코드에서 _ 부분에 들어갈 수 있는 문장은?

public class Movie {
	private int rating;
    private String title;
    public Movie(int rtng, String name) 	{
		rating = rtng;
		title = name; 
     }
public static void main( String[] args ) { 
	Movie myMovies[] = new Movie[2]; 
    ____________________________
	}
}

1) myMovies[0].title = “Maxtrix 3”;
2) myMovies[0] = new Movie( 13, “Maxtrix 3” );
3) myMovies[0] = new Movie[3];
4) myMovies = new Movie( 13, “Matrix 3” );

6. 클래스 디자인

• 코드 재사용하는 방법

  • Copy & Paste
  • 함수나 메서드
  • 상속 (변수와 메서드)
  • AOP(Aspect Oriented Programming) 관점 지향 프로그래밍

• 상속

  • 문법 : class 자식클래스 extends 부모클래스
  • 자바에서는 단일 상속만 지원
    • 단일 상속의 제한점 극복 : interface 이용
    • 다중 상속 허용하지 않는 이유 : 코드의 모호성 배제
  • 장점
    • 비슷한 유형의 코드 재사용
    • 검증된 코드를 사용 (오류의 최소화)
    • 관련된 여러 클래스들의 공통점 통이로하
      
  • 변경 전 (많은 속성이 중복된 경우)
    
  • 변경 후
    

• Refactoring과 Desing Pattern (GoF Pattern)

  • 유지보수성이 좋은 코드 작성
  • Code Quality를 개선하기 위한 방법

• 접근 제한자

  • 클래스 : public, default
    

• Overriding과 Overloading
  

• Method Overriding (재정의)

  • 자식 클래스에서 부모 메소드의 기능을 자신의 기능에 맞게 메소드 Body를 새롭게 정의하는 것
  • 하위 메소드의 접근 범위가 상위 메소드의 접근 범위보다 넓거나 같아야 함

• Custructor Overloading

  • 메소드 뿐만 아니라 생성자도 오버로딩 가능
  • 생성자에서 자신의 다른 생성자 호출 : this() 이용

• Super 키워드

  • 부모 객체를 가리팀
  • 부모의 멤버변수 참조 : super. 멤버변수 이름
  • 부모의 멤버메소드 참조 : super.멤버메소드 이름
  • 부모의 생성자 호출 : super(파라미터 리스트)

• Constructor

  • 생성자는 상속이 안됨
  • this나 super 키워드가 생성자를 호출하는데 쓰일 경우, 반드시 생성자 첫 줄에 기술
    • this()와 super() 같이 호출 불가
    • 생성자 호출하지 않는 경우 super() 묵시적으로 자동 호출
    • 클래스 작성시 항상 default 생성자 기술
  • 자식 클래스에서 부모 클래스의 멤버변수를 초기화 : super() 이용

1. 다음과 같이 클래스들이 상속관계에 있을 때, ( ) 속에 들어갈 코드를 차례 로 나열한 것 중 맞는 것을 고르세요.

class Animal { } 
class Dog extends Animal { } 
class Cat extends Animal { }

Dog d1,d2;
Animal a1,a2;
a1 = new Animal( ); 
d1 = new Dog( ); 
a2 = (a)d1;
d2 = (b)a2;

1)a 없음 b 없음
2)a Animal b 없음
3)a 없음 b Dog

2. 다음 코드를 실행시킬 때 컴파일 및 실행 결과로 올바른 것을 고르세요.

public class Example{
	public static void main( String[] args ){
   SubClass s = new SubClass( "Hi“ );
	BaseClass b = new BaseClass( "Hello“); 
   }
}

class SubClass extends BaseClass{ 
	String s;
	public SubClass( String st )
   {
		s = st; // 이거 대신 super(st) 사용
		System.out.print( s ); 
    }
}

class BaseClass{
	String s;
	public BaseClass( String st )
   {
		s = st;
		System.out.print( s );
	}
}

1)HiHello
2)HelloHi
3)컴파일 오류 발생
4)런타임 오류 발생
➡️ 3️⃣ : 부모의 기본 생성자가 없음 (BaseClass에 기본 생성자 만들거나, 만들지 않을 경우 자식에서 부모의 생성자를 호출해야함(super(st))

3. 다음과 같이 주어진 메소드가 있을 때 오버로딩 된 메소드로 적당하지 않은 것을 고르세요.

public Picture drawPicture(int x, int y, double val){...}

1)public Picture drawPicture( int x, double val, int y ){...}

2)public SmallPicture drawPicture( int x, char z, int y, double val ){...}

3)public Picture drawPicture( int x, int y, double val, String label ){...}

4)public SmallPicture drawPicture( int x, int y, double val ){...}

➡️ 4️⃣ : 매개변수가 동일해서 (오버로딩은 매개변수/타입 달라야함, 리턴값만 다른 경우 오버로딩 불가)

4. 다음 클래스의 실행 결과로 올바른 것을 고르세요.

public class A    
{
	String s = "Hello";
    public String toString()
    {
    	return s;
	}
    public static void main( String[] args )
    {
    	A a = new A();
		System.out.println( a ); 
    }
}

1)a 객체의 클래스이름과 주소가 출력됩니다.
2)아무것도 출력되지 않습니다.
3)“Hello”가 출력됩니다.
4)컴파일 오류가 발생합니다.

5. 다음 중에서 method Overriding에 대한 설명으로 맞는 것을 고르시오.

1) 생성자는 Overriding 할 수 없다.
2) 자식 method의 접근 제한자는 부모의 method의 접근 제한자보다 제한적이어야 한다.
3) Overriding 하는 method는 부모 method와 같아야 하는것은 이름, argument 리스트이다.
4) Overriding 하는 method는 return type는 같지 않아도 된다.

➡️ 2️⃣ : 부모의 접근제한자보다 자식이 더 넓어야함 (부모 - protected, 자식 - public)
3️⃣ : method이름, argument, return type 동일
4️⃣ : method이름, argument, return type 동일

7. 다형성

• 다형성

  • 한 참조 변수가 다른 형태의 객체를 참조할 수 있음
    

• 실행 시에는 실제 new를 통해서 생성 되는 객체의 메소드 실행

  • e.methodA() : 실행 안됨 (다운캐스팅 Manamger m = (Manager)e 필요)
  • e.getDetails() : Manager 메소드 실행
  • 종류
    

• Casting
  

• A instance of B

  • TRUE : A가 B의 자식이거나 같은 class 타입
  • FALSE : A가 B의 부모
  • 부모/자식 관계에 속하지 않는 것끼리 instance of 하면 컴파일 에러

• Object 클래스

  • 모든 클래스의 부모 클래스
  • extends 키워드 사용하지 않으면 자동 extends Object 됨
  • Object 클래스의 메소드
    • equals() : 주소 값 비교
    • toString() : 객체를 String으로 변환 (클래스 이름 @ 해시코드값)
      

• Wrapper 클래스

  • primitive data type을 객체화 해주는 클래스
    • boxing : Int ➡️ Integer
    • unboxing : Integer ➡️ Int
  • String을 숫자로 바꾸기
    • Integer.parseInt(문자);
      

8. 추상 클래스와 인터페이스

• static keywordd
  • member 변수, member 메소드 앞에 사용
    • 멤버 변수나 멤버 메소드는 한 객체에서 의미가 있음
    • static 키워드 사용시 한 객체가아닌 클래스 자체와 연관
  • class 변수, class 변수라고 불림
    • class 로드시에 메모리에 생성되어짐
  • 전체 객체에서 공용으로 사용하는 변수 (클래스이름.변수명으로 참조)
  • 객체 생성없이 호출 가능
  • static 메소드 안에서 this, super, not-static 멤버 사용 불가능 (local 변수는 가능)
• final keyword
  • final class : 상속 못하게 함
  • final method : override
  • final variable : 상수
    • 선언시 초기화 안 할 수 있음
    • 초기화 안한 경우 모든 생성자에서 초기화 해주어야함
    • 사용하기 전에 초기화 되어야함 (local 변수와 동일)
• abstract method
  • body가 없고, 선언만 한 메서드
• concrete method
  • body가 있고, 구현한 메서드
• abstract class
  • abstract method와 concrete method도 가질 수 있음
• interface
  • abstract method만 가질 수 있음 (java se 7)
  • default method 혹은 static method로 선언하면 body를 가질 수 있음 (java se 8 이후)
  • private method로 선언하면 body를 가질 수 있음 (java se 9)
  • protected 안됨
• 추상 클래스
  • 미완성 클래스
  • abstract 메소드가 포함된 클래스 (abstract 메소드 없어도 추상 클래스 가능)
  • 자체적으로 객체 생성 불가 (반드시 상속 통해 객체 생성)
  • 객체 생성은 안되지만, Ref 변수로 가능 (Application app = new Radio();)
  • 꼭 필요한 기능 가제함
• 인터페이스
  • 관계 되는 메소드 형식만 모아 놓은 클래스 제공
  • 모든 메소드가 abstract 메소드인 클래스
  • 메소드는 묵시적으로 public abstract
  • 멤버 변수는 묵시적으로 public static final
  • 다중 구현 가능, 단일 상속 극복
  • 객체 생성은 안되지만 Ref 변수로 가능 (Recording app = new MP3();)

1. 다음 중 잘못된 코드를 선택하세요.

1)abstract class A{
abstract void aMethod( );
}
2)abstract class A{
void aMethod( ){ }
}
3)interface A{
void aMethod( );
}
4)interface A{
void aMethod( ){ }
}

2. 다음 Eagle 클래스의 { }안에 반드시 구현해야 할 메소드를 맞게 선택한 것을 고르세요.

public interface Flyer{ 
	public void takeOff( );
    public void land( ); 
}

abstract class Animal{ 
	abstract void eat( ); 
    public void walk( ){} 
}

public Eagle extends Animal implements Flyer { 
//여기에 반드시 구현해야 할 메소드를 모아놓은 것을 고르세요. 
}

1)takeOff, land()
2)takeOff(), land(), eat()
3)eat()
4)eat(), walk()

3. 다음 소스 코드의 출력 결과로 맞는 것을 고르세요.

class Count{
 	int a = 0;
    static int b =0;
	void increase()
    { 
    	a++; 
        b++; 
    }
public class CountTest{
	public static void main( String[] args ){ 
       	Count c1 = new Count(); 
        Count c2 = new Count(); 
            
        c1.increase( ); 
        c2.increase( ); 
        System.out.println( c1.a + ",“ + Count.b ); }
	}
}

1)1,1
2)2,2
3)1,2
4)2,1

4. 다음 중에서 static에 대한 설명으로 틀린 것을 모두 고르시오.(2개)

1) static은 멤버 변수, 멤버 메소드 등의 지정자로 사용된다.
2) static으로 선언된 변수는 객체 생성을 통하여서만 참조할 수 있다.
3) static 변수는 선언할 때 초기화 할 수 있다.
4) 로컬 변수에 static을 붙이면 global 변수와 같은 기능을 한다.

➡️ 2️⃣ : class 이름.변수명으로 참조 가능

5. 다음 중에서 final에 대한 설명으로 맞는 것을 고르시오.

1) class선언 시 사용할 수 없다.
2) static 키워드와 같이 쓸 수 없다.
3) member 변수 선언 시 사용하면, 해당 멤버는 상수가 된다.
4) local 변수 선언 시 사용하면, 상수가 되기 때문에 초기화할 필요 없다.

9. 컬렉션

• 컬렉션

  • 객체를 저장할 때마다, 크기를 자동으로 늘림
  • Set 계열 : 중복 허용하지 않고, 추가되는 순서를 유지하지 않음
  • List 계열 : 중복 허용하고, 추가되는 순서 유지
  • Map 계열 : 키와 값의 쌍으로 저장 (키와 값 모두 객체여야 함)
  • java.util 패키지에 있음
    

• List 메소드

  • 리스트 생성
    • List list = new ArrayList();
      ➡️ List<String> list = new ArrayList<>();
  • 리스트에 데이터 삽입
    • list.add(new String("java"));
    • list.add(new Integer(100));
  • 리스트에서 데이터 추출
    • for (int i=0; i < list.size(); i++)
      String value = (String)list.get(i);
      ➡️ 실행타임에 오류 발견
  • 

• 함수형 인터페이스

  • 추상메서드를 1개만 가지고 있는 인터페이스
  • 함수형 인터페이스가 가진 추상 메서드를 재정의할 때의 구문을 람다식으로 표현 가능

    package chap09.collections;
  
   import java.util.ArrayList;
   import java.util.List;
  
   import java.util.function.Consumer;
  
   public class TestArrayList {
       public static void main(String[] args) {
           List<String> strList = new ArrayList<>();
  
           strList.add("java");
           strList.add("javaScript");
           strList.add("java");
  
           System.out.println(strList);
  
           for (String value : strList) {
               System.out.println(value);
           }
  
           // 1단계 (consumer을 상속받은 myconsumer 작성)
           strList.forEach(new MyConsumer()); // 낭비 
           // 2단계 (consumer을 익명 내부 클래스로 작성)
           System.out.println("----익명 내부 클래스-----");
           strList.forEach(new Consumer<String>() {
  
               @Override
               public void accept(String t) {
                   System.out.println(t);
               }
  
           });
           // 3단계 (람다식으로 작성)
           System.out.println("----람다식----");
           // Iterable의 forEach(Consumer consumer)
           // Consumer의 추상메서드가 void accept(T t)
           strList.forEach(val ->  System.out.println(val));
  
           // 4단계 (method reference)
           System.out.println("-----method reference-----");
           strList.forEach(System.out::println); //String::new
       }
   }
  
   class MyConsumer implements Consumer<String> {
       @Override
       public void accept(String t) {
           System.out.println("MyConsumer에서 출력 " + t);
       }
   }
  

• 람다식 실습

package workshop.person.control;

import  workshop.person.entity.PersonEntity;
import	java.util.*;

public class PersonManager {

	
	public void fillPersons(List<PersonEntity> persons) // persons 배열에 정보 set 
	{
		persons.add(new PersonEntity("이성호","7212121028102", "인천 계양구", "032-392-2932"));
		persons.add(new PersonEntity("김하늘","7302132363217", "서울 강동구", "02-362-1932"));
		persons.add(new PersonEntity("박영수","7503111233201", "서울 성북구", "02-887-1542"));
		persons.add(new PersonEntity("나인수","7312041038988", "대전 유성구", "032-384-2223"));
		persons.add(new PersonEntity("홍정수","7606221021341", "서울 양천구", "02-158-7333"));
		persons.add(new PersonEntity("이미숙","7502142021321", "서울 강서구", "02-323-1934"));
		persons.add(new PersonEntity("박성구","7402061023101", "서울 종로구", "02-308-0932"));
		persons.add(new PersonEntity("유성미","7103282025101", "서울 은평구", "02-452-0939"));
		persons.add(new PersonEntity("황재현","7806231031101", "인천 중구", "032-327-2202"));
		persons.add(new PersonEntity("최철수","7601211025101", "인천 계양구", "032-122-7832"));
	}
	
	public void showPerson(List<PersonEntity> persons) // 전체 persons 정보를 display
	{
		for (PersonEntity person : persons)
		{
			System.out.print("[이름] " + person.getName() + '\t');
			System.out.print("[성별] " + person.getGender() + '\t');
			System.out.println("[전화번호] " + person.getPhone() + '\t');
			printItemLine();
		}
		// 람다식 표현
		persons.forEach(person -> {
			System.out.print("[이름] " + person.getName() + '\t');
			System.out.print("[성별] " + person.getGender() + '\t');
			System.out.println("[전화번호] " + person.getPhone() + '\t');
			printItemLine();
		});
	}
	
	public void showPerson(List<PersonEntity> persons, String name) // 특정 person의 상세 정보를 display
	{
		for (PersonEntity person : persons)
		{
			if (person.getName() == name)
			{
				System.out.println("-- 이름 : '" + name + "' (으)로 찾기 결과입니다. --");
				printItemLine();
				System.out.println("[이름] " + person.getName());
				System.out.println("[성별] " + person.getGender());
				System.out.println("[전화번호] " + person.getPhone());
				System.out.println("[주소] " + person.getAddress() );
			}
		}
	}
	
	public int findByGender(List<PersonEntity> persons, char gender) // 해당 Gender의 인원수 return
	{
		int count = 0;
		
		for (PersonEntity person : persons)
		{
			if (person.getGender() == gender)
				count++;
		}
		return count;
	}
	
	public void printTitle(String title) // Title 출력하는 메서드 
	{
		System.out.println('\n' + title + '\n');
	}
	
	public void printTitleLine() // TilteLine 출력하는 메서드 
	{
		for (int i = 0; i < 60; i++)
			System.out.print('=');
		System.out.println();
	}
	
	public void printItemLine() // ItemLine 출력하는 메서드 
	{
		for (int i = 0; i < 60; i++)
			System.out.print('-');
		System.out.println();
	}

	public static void main(String[] args) {
		
		PersonManager pManager = new PersonManager();
//		PersonEntity[] persons = new PersonEntity[10];
		
		int gender_count;
		
		//PersonEntity 엘리먼트를 담아주는 역할을 하는 ArrayList 생성 
		List<PersonEntity> persons = new ArrayList<>();
		
		pManager.printTitle("@@@ 인물 정보 조회 시스템 @@@");
		pManager.printTitleLine();
		
		pManager.fillPersons(persons);
		pManager.showPerson(persons);
		gender_count = pManager.findByGender(persons, '여');
		System.out.println("성별 : '여'(은)는 " + gender_count + "명 입니다.");
		pManager.printTitleLine();
		pManager.showPerson(persons,"김하늘");
	}

}

• HashSet 실습

package chap09.collections;

import java.util.HashSet;
import java.util.Set;

import chap02.entity.MyDate;

public class TestHahSet {
	public static void main(String[] args) {
		Set<String> myset = new HashSet<>();
		
		myset.add("java");
		myset.add("javascript");
		myset.add("java");
		myset.add("python");
		myset.forEach(val -> System.out.println(val));
		
		Set<MyDate> dateset = new HashSet<>();
		
		dateset.add(new MyDate(2023,9,13));
		dateset.add(new MyDate(2023,8,16));
		dateset.add(new MyDate(2023,9,13));
		dateset.forEach(date -> System.out.println(date.getDate()));
		
	}

}

• HashMap 실습

package chap09.collections;

import java.util.HashMap;
import java.util.Map;

public class TestHashMap {
	public static void main(String[] args) {
		Map<Integer, String> myMaps = new HashMap<>();
		
		myMaps.put(100, "java"); // 동일키가 나와서 무시 
		myMaps.put(200, "javascript");
		myMaps.put(300, "java");
		myMaps.put(100, "python");
		
		System.out.println(myMaps);
		
		// 1개만 데이터 꺼내기 
		String value = myMaps.get(100);
		System.out.println(value);
		
		for(Integer key : myMaps.keySet()) {
			System.out.printf("key = value : %d = %s\n", key, myMaps.get(key));
		}
		
		//public Set<Map.Entry<E,V> entrySet()
		// Map.Entry<K,V> getkey(), getvalue()
		for (Map.Entry<Integer, String> entry : myMaps.entrySet())
		{
			System.out.printf("%d = %s \n",entry.getKey(), entry.getValue());
		}
	}
}

1. 다음 소스 코드에서 두 개의 _ 칸에 들어갈 적당한 코드를 차례대로 쓴 것을 보기 중에서 고르시오.

public void second()
{ 
	try {
    	first();
    }
    catch( UserDefinedException e )
    {
     }
}

public void first() _____ UserDefinedException {
	______ new UserDefinedException();
}

1)throws, throws
2)throw, throws
3)throw, throw
4)throws, throw

2. 다음 소스 코드의 예외가 처리 되어 프로그램이 정상 종료되도록 _칸에 들어갈 적당한 예외 클래스를 보기에서 고르시오.

import java.io.*;

public class Test {
	public static void main( String[] args ){
    	int a[] = new int[5]; 
        try {
        	a[5] = 5;
         } 
         catch ( _____________ e ){
         	System.out.println( "Exception이 발생 했습니다 : " + e);
			}
	}
}

1)IOException
2)FileNotFoundException
3)Exception
4)ClassNotFoundException

3. 다음 코드를 실행한 결과로 맞는 것을 보기에서 고르세요.

try{
	int x = 10/0;
	System.out.print( “a” ); 
}
catch( NullPointerException e1 ) {
	System.out.print( “b” );
}
catch( Exception e2 ){
 	System.out.print( “c” ); 
}
finally{
	System.out.print( “d” );
}


System.out.println( “e” );

1)abcde
2)bde
3)cde
4)cd

4. 다음과 같이 사용자 정의 예외 클래스를 만들려고 할 때, 빈 칸에 적당한 코드를 고르세요.

public class UserDefinedException ______________{ public UserDefinedException(){
super( “사용자 정의 예외 발생” ); }
}

1)implements Throwable
2)extends Exception
3)implements Exception
4)아무 코드도 필요하지 않습니다.

1. ArrayList 클래스가 implements하는 Collection API의 Interface는 무엇인지 고르시오.

1)java.util.Map
2)java.util.List
3)java.util.Set
4)java.util.Collection

2. 다음 소스 코드에서 만들어지는 set 컬렉션에 element를 입력하려고 합니다. 다음 중 적당하지 않는 코드를 고르세요.

      Set set = new HashSet();

1)set.add( “3” );
2)set.add( new Integer(3).intValue() );
3)set.add( new Integer(3) );
4)set.add( new Object() );

➡️ 2️⃣ : 오토 박싱이 되지 않았을 때는 int라서 오류였지만, 지금은 개선되어 가능

3. 다음 소스 코드를 실행한 결과는 ?

// 012345678901234567 
String s = "ABCDEFGH IJKLMN ";

System.out.println( "1 : " + s.substring( 3, 6 ) ); System.out.println( "2 : " +s.substring( 9 ) ); 
System.out.println( "4 : " +s.charAt( 5 ) ); 
System.out.println( "5: " + s.trim() + "XY" );

s.concat( " TEST" ); System.out.println( "6: " + s );
s = s.concat( " TEST" ); System.out.println( "7: " + s );

➡️

4. 다음 소스 코드를 실행한 결과는 ?

String str1 = "abc";
String str2 = "ABC";
String str3 = new String("abc"); 
String str4 = "abc";

if( str1.equals( str2 )){
	System.out.println( "equals test : str1과 st2는 같은 string입니다." );
}else{
	System.out.println( "equals test : str1과 st2는 다른 string입니다." );
}

if( str1.equals( str3 )){
	System.out.println( "equals test : str1과 st3는 같은 string입니다." );
}else{
	System.out.println( "equals test : str1과 st3는 다른 string입니다." );
}

if( str1.equals( str4 )){
	System.out.println( "equals test : str1과 st4는 같은 string입니다." );
}else{
	System.out.println( "equals test : str1과 st4는 다른 string입니다." );
}

➡️

5. 다음 소스 코드를 실행한 결과는 ?

String str1 = "abc";
String str2 = "ABC";
String str3 = new String("abc");
String str4 = "abc";

if( str1 == str4 ){
	System.out.println( "equals test : str1과 st4는 같은 string입니다." );
}else{
	System.out.println( "equals test : str1과 st4는 다른 string입니다." );
}
if( str1.equalsIgnoreCase( str2 )){
	System.out.println( "equalsIgnoreCase test : str1과 st2는 같은 string입니다." );
}else{
	System.out.println( "equalsIgnoreCase test : str1과 st2는 다른 string입니다." );
}

if( str1.compareTo( str2 ) < 0 ){
	System.out.println( "compareTo test : str1는 st2보다 문자 순서가 빠릅니다." );
}else{
	System.out.println( "compareTo test : str1는 st2보다 문자 순서가 빠르지 않습니다.");
}

➡️