N'Che는 초보개발자

마켓비를 홍보하는건 아니구 마침 그 페이지가 켜져있었지 뭐야..

package crawling.practice.app;

import java.io.IOException;

import org.jsoup.Jsoup;
import org.jsoup.nodes.Document;
import org.jsoup.nodes.Element;
import org.jsoup.select.Elements;

public class JsoupPractice01 {
	public static void main(String[] args) throws IOException {
		String url = "https://marketb.kr/" ;
		
		Document doc = Jsoup.connect(url).get();
		
		Elements ele = doc.select(".column4");
		
		for(Element e : ele.select("li.item")) {
			System.out.println(e.text()+"\n");
		}	
	}
}

[ONLY] 마켓비 ESTO, DALIA, ELROY 태양광무드등 당일발송 판매가 :6,900원 소비자가 :9,800원 : 리뷰 :

[ONLY] 마켓비 DUGLAS 선반 시리즈 아카시아 당일발송 판매가 :22,900원 소비자가 :45,900원 : 리뷰 :

마켓비 SAZA 러그 D100 당일발송 판매가 :39,900원 : 리뷰 :

마켓비 OFFICY 서랍장 4.1단 당일발송 판매가 :38,900원 : 리뷰 :

마켓비 POLABO 미니수납장 넓은 2문 SHM4262SL 당일발송 판매가 :44,900원 소비자가 :89,900원 : 리뷰 :

마켓비 VAINZ 단스탠드 E14 KS2404T 브라운 당일발송 판매가 :29,900원 소비자가 :49,900원 : 리뷰 :

마켓비 SHOLID 책꽂이 7045 SHM4570 캄포어베니어 당일발송 판매가 :69,900원 : 리뷰 :

마켓비 NISKO 3인 멀티 메모리폼 소파베드 독립형 BC267 당일발송 판매가 :399,000원 소비자가 :789,000원 : 리뷰 :

마켓비 SIMPLIE 시리즈 당일발송 판매가 :129,300원 소비자가 :258,600원 : 리뷰 :

마켓비 FILMON 미니수납장 4문 4242 NFM4242 당일발송 판매가 :41,900원 소비자가 :83,800원 : 리뷰 :

[ONLY] 마켓비 JAWAL 2단 선반행거 대나무 0005.1882 당일발송 판매가 :28,900원 소비자가 :29,900원 : 리뷰 :

마켓비 AMBO 4인 멀티 소파베드 당일발송 판매가 :289,000원 소비자가 :499,000원 : 리뷰 :

마켓비 SHENBON 의자 라탄 D형 5672.2846 당일발송 판매가 :149,000원 : 리뷰 :

마켓비 MONTAC 5문 수납장 13376 CHM76133 캄포어베니어 당일발송 판매가 :199,000원 : 리뷰 :

마켓비 INSIA 목쿠션 ISC0042 레인보우 당일발송 판매가 :19,900원 : 리뷰 :

마켓비 PASAR 3인소파 라탄 CR0053 당일발송 판매가 :699,000원 소비자가 :899,000원 : 리뷰 :

마켓비 DELU 소파 1665 시리즈 당일발송 판매가 :269,000원 : 리뷰 :

[ONLY] 마켓비 FILSTEM 장바구니 시리즈 당일발송 판매가 :900원 소비자가 :7,200원 : 리뷰 :

마켓비 GIBORN USB LED 바조명 시리즈 당일발송 판매가 :11,000원 : 리뷰 :

[캔들/할로겐전구 무료증정] 마켓비 NEW SAMONY 미니 캔들워머 GU10 버튼 KS2306T 당일발송 판매가 :29,900원 : 리뷰 :

마켓비 SHOLID 서랍 2단 DRM4235D2 캄포어베니어 당일발송 판매가 :55,900원 : 리뷰 :

마켓비 TANG 원목의자 45 아카시아 당일발송 판매가 :49,900원 : 리뷰 :

마켓비 DACONA 소파 시리즈 당일발송 판매가 :259,000원 소비자가 :499,000원 : 리뷰 :

마켓비 MONER 장스탠드 E26 KS2333F 화이트 6411.4045 당일발송 판매가 :59,900원 소비자가 :69,900원 : 리뷰 :

마켓비 FILMON 선반수납장 10860 PUM60110OP 캄포어베니어 당일발송 판매가 :159,000원 소비자가 :318,000원 : 리뷰 :

마켓비 FILMON 협탁 3865 STBM6538 캄포어베니어 당일발송 판매가 :83,000원 소비자가 :166,000원 : 리뷰 :

마켓비 NISKO 소파/소파베드 시리즈 당일발송 판매가 :329,000원 소비자가 :719,000원 : 리뷰 :

마켓비 FILMON 4인 원목접이식테이블 세트 DCM74120 7월 중순 입고예정 판매가 :299,000원 소비자가 :598,000원 : 리뷰 :

마켓비 ALOTA 선반 380 3단 라탄 세트 WP3008 당일발송 판매가 :69,900원 소비자가 :139,000원 : 리뷰 :

[ONLY] 마켓비 KUBAN 소파 시리즈 당일발송 판매가 :219,000원 소비자가 :449,000원 : 리뷰 :

마켓비 PECRE 빈티지수납장 PC0102DR 6319.0243 당일발송 판매가 :299,000원 : 리뷰 :

마켓비 DUBLIN 이동식행거 9001650 당일발송 판매가 :33,900원 : 리뷰 :

[ONLY] 마켓비 ROONA 시리즈 당일발송 판매가 :89,900원 소비자가 :449,000원 : 리뷰 :

[ONLY] 마켓비 JAWAL 2단 선반행거 대나무 0005.1882 당일발송 판매가 :28,900원 소비자가 :29,900원 : 리뷰 :

[ONLY] 마켓비 BREDO 의자 당일발송 판매가 :69,900원 소비자가 :89,900원 : 리뷰 :

마켓비 SHENBON 의자 라탄 A형 당일발송 판매가 :139,000원 : 리뷰 :

마켓비 PECRE 빈티지소파 PC0048SF/PC0049SF 당일발송 판매가 :629,900원 : 리뷰 :

마켓비 회전의자 시리즈 당일발송 판매가 :53,900원 : 리뷰 :

[ONLY] 마켓비 PASAR 커피테이블 80 라탄 CR0039 브라운 당일발송 판매가 :199,000원 소비자가 :299,000원 : 리뷰 :

마켓비 MILTON 푸프 당일발송 판매가 :69,900원 : 리뷰 :

[ONLY] 마켓비 NEW HAVEN 2문 수납장 G3915 슬레이트그레이 당일발송 판매가 :499,000원 소비자가 :599,000원 : 리뷰 :

[ONLY] 마켓비 GLABO 커피테이블 6040 대나무 당일발송 판매가 :39,900원 소비자가 :49,900원 : 리뷰 :

[ONLY] 마켓비 MOBOOK 사이드테이블 5030 고무나무 당일발송 판매가 :69,900원 소비자가 :89,900원 : 리뷰 :

마켓비 PECRE 빈티지캐비넷 1문 PC0141CB 판매가 :189,000원 소비자가 :199,000원 : 리뷰 :

[ONLY] 마켓비 BAMBOU 단스탠드 E26 KS2200T 당일발송 판매가 :41,900원 소비자가 :49,900원 : 리뷰 :

[ONLY] 마켓비 TETOS 시리즈 당일발송 판매가 :34,900원 소비자가 :109,900원 : 리뷰 :

[ONLY] 마켓비 BAMBOU 단스탠드 E26 KS2201T 당일발송 판매가 :41,900원 소비자가 :49,900원 : 리뷰 :

[ONLY] 마켓비 GRUET 트롤리 시리즈 당일발송 판매가 :39,900원 소비자가 :55,900원 : 리뷰 :

[ONLY] 마켓비 CORKA 사이드테이블 2종세트 당일발송 판매가 :139,000원 소비자가 :169,000원 : 리뷰 :

마켓비 GLABO 사이드테이블 4040 대나무 당일발송 판매가 :24,900원 : 리뷰 :

마켓비 DUMBUL 스탠드행거 170 당일발송 판매가 :29,900원 : 리뷰 :

[ONLY] 마켓비 HIXA 단스탠드 E26 KS2186T 당일발송 판매가 :29,900원 소비자가 :39,900원 : 리뷰 :

[ONLY] 마켓비 APIN 사이드테이블 D45 티크나무 당일발송 판매가 :129,000원 소비자가 :139,000원 : 리뷰 :

[ONLY] 마켓비 PANTEG 원목벽걸이 소나무 당일발송 판매가 :26,900원 소비자가 :29,900원 : 리뷰 :

[ONLY] 마켓비 CAMFOL 접이식의자 시리즈 당일발송 판매가 :19,900원 소비자가 :29,900원 : 리뷰 :

[ONLY] 마켓비 MKB 커피테이블 서랍장 2칸 802402 당일발송 판매가 :80,000원 소비자가 :88,000원 : 리뷰 :

마켓비 BUGOK 소파 시리즈 당일발송 판매가 :189,000원 : 리뷰 :

마켓비 FRUGA 원목침대 퀸 150200 당일발송 판매가 :129,000원 : 리뷰 :

[ONLY] 마켓비 CHAMBER 벙커침대 싱글 100200 KS1006BD 당일발송 판매가 :159,000원 소비자가 :219,000원 : 리뷰 :

[ONLY] 마켓비 MILKAM 서랍장 3단 CHM7570 캄포어베니어 당일발송 판매가 :149,000원 소비자가 :189,000원 : 리뷰 :

[ONLY] 마켓비 FILMON 시리즈 당일발송 판매가 :39,900원 소비자가 :79,800원 : 리뷰 :

[ONLY] ASHLEY H309-10 LEWIS HOME OFFICE SMALL DESK 책상 당일발송 판매가 :169,000원 소비자가 :180,000원 : 리뷰 :

[ONLY] 마켓비 DUKUN 트롤리 3단 15040 당일발송 판매가 :189,000원 소비자가 :199,000원 : 리뷰 :

마켓비 TARDO 소파 시리즈 당일발송 판매가 :189,000원 소비자가 :219,000원 : 리뷰 :

[ONLY] 마켓비 BERGEN 데이베드 침대 싱글 100200 당일발송 판매가 :89,000원 소비자가 :99,000원 : 리뷰 :

마켓비 회전의자 시리즈 당일발송 판매가 :53,900원 : 리뷰 :

[ONLY] 마켓비 MILKAM 사이드콘솔 5865 CHM6558 당일발송 판매가 :89,000원 소비자가 :119,000원 : 리뷰 :

[ONLY] 마켓비 DEMIL 소파 시리즈 당일발송 판매가 :179,000원 소비자가 :309,000원 : 리뷰 :

[ONLY] 마켓비 WESTOVER 접이식의자 망고나무 당일발송 판매가 :69,000원 소비자가 :89,000원 : 리뷰 :

마켓비 KANIKA 마크라메 펜던트 등갓 시리즈 당일발송 판매가 :39,900원 : 리뷰 :

[ONLY] 마켓비 MIRANS 가로 2문 수납장 NFM9280G 당일발송 판매가 :169,000원 소비자가 :199,000원 : 리뷰 :

마켓비 KANIKA 장스탠드 E26 6종 당일발송 판매가 :139,000원 : 리뷰 :

[ONLY] 마켓비 MIRANS 가로 3문 수납장 NFM92120G 당일발송 판매가 :229,000원 소비자가 :269,000원 : 리뷰 :

마켓비 CHAMBER 벙커침대 더블 140200 KS1006BD/1 당일발송 판매가 :229,000원 소비자가 :279,000원 : 리뷰 :

[ONLY] 마켓비 MIRANS 서랍장 3단 CHM100100 브라운월넛베니어 당일발송 판매가 :199,000원 소비자가 :289,000원 : 리뷰 :

마켓비 MARINO 펜스침대 싱글 100200 KS1015BD 당일발송 판매가 :119,000원 : 리뷰 :

[ONLY] 마켓비 MILKAM 콘솔수납장 17585 CHM85175 당일발송 판매가 :339,000원 소비자가 :449,000원 : 리뷰 :

마켓비 KOBE 침대 퀸 150200 KS1050BD/2 당일발송 판매가 :159,000원 : 리뷰 :

[ONLY] 마켓비 ZERAVITY 리클라이너 1인소파 당일발송 판매가 :249,000원 소비자가 :685,000원 : 리뷰 :

마켓비 NORESUND 침대 퀸 150200 KS1024BD/2 당일발송 판매가 :229,000원 : 리뷰 :

[ONLY] 마켓비 LEILA 침대 퀸 150200 KS1022BD 화이트 당일발송 판매가 :209,000원 소비자가 :289,000원 : 리뷰 :

마켓비 PEMBA 시리즈 당일발송 판매가 :79,900원 : 리뷰 :

[ONLY] 마켓비 GRUET 트롤리 원형 2단 당일발송 판매가 :39,900원 소비자가 :49,900원 : 리뷰 :

[ONLY] 마켓비 DUKUN 트롤리 2단 10060 당일발송 판매가 :149,000원 소비자가 :169,000원 : 리뷰 :

package crawling.practice.app;

import java.io.IOException;

import org.jsoup.Jsoup;
import org.jsoup.nodes.Document;
import org.jsoup.nodes.Element;
import org.jsoup.select.Elements;

public class JsoupPractice02 {
	public static void main(String[] args) throws IOException {
	
		String url = "https://marketb.kr/board/free/list.html?board_no=1" ;
		
		Document doc = Jsoup.connect(url).get();
		
		Elements ele = doc.select(".boardList>table");
		Elements thead = ele.select("thead>tr");
		
		for(Element e : thead) {
			System.out.println(e.select("th").text());
		}
		System.out.println("=========================================================");
        
		for(Element e : ele.select("tbody>tr")) {
        	System.out.println(e.select("td").text());
        	System.out.println("---------------------------------------------------------");
		}			
	}
        
	}
}

번호 카테고리 제목 작성자 날짜 조회수 추천 평점
=========================================================
[공지] 마켓비 5월 공식몰 회원 단독 혜택! 마켓비(JHK) 2021-04-30 426569 0 
---------------------------------------------------------
[이벤트] 2021년 5월 카드사 무이자할부 안내 마켓비(DSP) 2021-04-30 12941 0 
---------------------------------------------------------
[이벤트] 네이버페이 구매평쓰면 포인트 쏜다! 마켓비(SGP) 2021-04-30 9986 0 
---------------------------------------------------------
[이벤트] 5월 베스트리뷰어 참여하고 적립금 받자! 마켓비(HAB) 2021-04-30 98038 0 
---------------------------------------------------------
[모집] 인테리어 풀패키지 서비스! 시공부터 마케팅까지 손쉽게 해결하세요 마켓비(HAB) 2021-04-30 10387 0 
---------------------------------------------------------
[이벤트] 마켓비에서 롯데 롤라카드로 구매하고 최대 10만원 혜택 받아가세요! 마켓비(MKT) 2021-04-30 848 0 
---------------------------------------------------------
[이벤트] 5월에 마켓비 가입하면 인기상품이 0원! 마켓비(MKT) 2021-04-30 27 0 
---------------------------------------------------------
[공지사항] 배송정책 안내 운영자(design) 2021-01-21 26639 0 
---------------------------------------------------------
[대리점모집] 성공비결 마켓비! 오프라인 스토어 창업자 모집 마켓비(JHK) 2020-12-31 1348 0 
---------------------------------------------------------
[공지] 조립 배송 서비스 안내 마켓비(MKT) 2020-11-16 412 0 
---------------------------------------------------------
[모집] Recruitment of MARKETB's overseas partners 마켓비(HAB) 2018-10-23 689 0 
---------------------------------------------------------
[공지사항] AS정책 운영자(DP) 2016-07-13 12954 0 
---------------------------------------------------------
[공지사항] 전국 마켓비 대리점 현황 마켓비(DSP) 2017-09-19 57298 0 
---------------------------------------------------------

간만에 자바스크립트 탐색자도 써보고 재밌었당

내일은 로그인해서 스크랩핑 하는거 연습해보고

어떻게 파싱해서 db에 저장할지 구상해봐야겠다

package kr.or.ksmart;

class Member{
	//인스턴스변수, 멤버필드
	private String memberName;
	//생성자메서드
	public Member(String memberName) {
		this.memberName = memberName;
	};
	//메서드
	public String getMemberName () {
		return memberName;
	};	
}

class User{
	//생성자메서드를 접근지정자 private으로 선언 시 외부에서 객체화 불가능  
	private User() {
		
	};
	
	public static User getInstance() {
		return new User();
	};
}

public class JavaEx01 {

	public static void main(String[] args) {
		/*
		 * 복습1. Member라는 클래스를 생성할 것이다.
		 * 이 Member라는 클래스는 인스턴스화 할 때 매개변수 1개를 받아야만 인스턴스화가 가능하다.
		 * 또한 Member 클래스는 인스턴스변수 memberName 그리고 getMemberName이라는 메서드를 가지게 된다.
		 * 위의 조건대로 클래스를 생성하고 선언과 호출을 하도록 하여라.
		 * (인스턴스화 할 때 들어간 인수값은 인스턴스변수에 저장된다.)
		 */
		
		Member member = new Member("김최첨단");
		System.out.println(member.getMemberName());
		
		/*
		 * 복습2. User클래스를 생성할 것이다.
		 * 이 User클래스는 new 연산자를 통하여 인스턴스화 할 수 없으며, getInstance라는 메서드를 통해서 인스턴스화 가능하다.
		 * 이 클래스를 선언하고 인스턴스화를 시키도록 하여라.
		 */
		
		User user = User.getInstance();
		System.out.println(user+"<<-user");

		/*
		 * 복습3. 래퍼클래스가 무엇인지 서술하시오.
		 * 
		 * 기본형 타입의 데이터를 객체로 취급하기 위해 사용하는 클래스. 
		 * 클래스변수와 클래스메서드 위주로 다 
		 */
		
		/*
		 * 복습4. 인스턴스변수와 클래스변수 차이점을 서술하시오.
		 * 인스턴스변수 : 인스턴스화 되어야 접근 가능한 변수
		 * 클래스변수 : 인스턴스화 하지 않아도 접근 가능한 변수
		 * 
		 * 인스턴스변수는 클래스가 인스턴스화 될 때마다 함께 새로이 인스턴스화 되는 변수이고
		 * 클래스변수는 정적으로 선언되어있어, 한 번 인스턴스화된 주소값을 변동없이 가리키는 변수이다.
		 */
		
		/*
		 * 복습5. class로 변환된(바이트 코드) 파일을 실행시키거나, java 프로그래밍의 메모리를 관리하는 프로그램의 명칭이 무엇인가요?
		 * 
		 * Java Virtual Machine 
		 */
	}

}

package kr.or.ksmart;

class MemberSuper{
	public String getMemberName() {
		return null;
	}
	
	public final int getMemberAge() {
		return 0;
	}
	
	public void setMemberAddr(String addr1) {

	}
	public void setMemberAddr(String addr1, String addr2) {
		
	}
	
}

class MemberSub extends MemberSuper {
	@Override
	public String getMemberName() {
		return null;
	}
	
	/*public int getMemberAge() {
		return 0;
	}*/
}

public class JavaEx02 {
	public static void main(String[] args) {
		/*
		 * 복습6. MemberSuper클래스와 MemberSub클래스가 있다.
		 * MemberSub는 MemberSuper의 멤버를 가지고 있다.
		 * 위의 설명에 맞는 클래스를 선언하고 호출하도록 하여라. 
		 */
		/*
		 * 복습7. 복습6의 클래스의 관계에서 추가적인 메서드를 생성할 것이다.
		 * MemberSuper 클래스에 getMemberName과 getMemberAge라는 메서드가 있다.
		 * MemberSub 클래스에서  getMemberName 오버라이딩은 가능하나, getMemberAge는 오버라이딩이 불가능하다.
		 * 위의 설명에 알맞게 메서드를 작성하여라.
		 */
		/*
		 * 복습8. 복습6의 클래스의 관계에서 추가적인 메서드를 생성할 것이다.
		 * setMemberAddr 메서드가 1개의 매개변수를 받을 수도 있고
		 * setMemberAddr 메서드가 2개의 매개변수를 받을 수도 있다.
		 * 메서드를 알맞게 작성하여라. >>메서드오버로딩
		 */
	}
}

package kr.or.ksmart;

interface In1{
	public int in1();
}
interface In2{
	public int in2();
}

class InIm implements In1, In2 {

	@Override
	public int in2() {
		return 0;
	}

	@Override
	public int in1() {
		return 0;
	}
	
}

public class JavaEx03 {
	public static void main(String[] args) {
		/*
		 * 복습9. 인터페이스 2개를 상속받은 클래스를 생성할 것이다.
		 * 인터페이스의 명은 In1, In2 이며 
		 * int 형을 리턴하는 In1 인터페이스의 in1 메서드, In2 인터페이스의 in2 메서드를 가지고 있다.
		 * InIm으로 클래스를 생성하고 2개의 인터페이스를 상속받아 객체화할 수 있도록 만들어라.
		 * 또한 InIm를 객체화하고 In1, In2를 업캐스팅 하도록 하여라
		 */
		InIm inIm = new InIm();
		
		In1 in1 = inIm;
		In2 in2 = inIm;
		
		/*
		 * 복습10. 객체지향의 4대 원칙을 서술하시오.
		 * 캡슐화, 추상화, 상속, 다형성
		 */
		
		/*
		 * 복습11. 객체지향 설계의 5대 원칙을 서술하시오.
		 * SOLID
		 * 1. SRP(단일 책임 원칙) - 소프트웨어의 설계 부품(클래스, 함수 등)은 단 하나의 책임만을 가져야 한다.
		 * 2. OCP(개방-폐쇄 원칙) - 기존의 코드를 변경하지 않고(Closed) 기능을 수정하거나 추가할 수 있도록(Open) 설계해야 한다. > getter, setter
		 * 3. LSP(리스코프 치환 원칙) - 자식 클래스는 부모클래스에서 가능한 행위를 수행할 수 있어야 한다. > 업캐스팅과 관련
		 * 4. ISP(인터페이스 분리 원칙) - 한 클래스는 자신이 사용하지 않는 인터페이스는 구현하지 말아야 한다. 하나의 일반적인 인터페이스 보다 여러 개의 구체적인 인터페이스가 낫다.
		 * 5. DIP(의존 역전 원칙) - 의존 관계를 맺을 때, 변화하기 쉬운 것 보다 변화하기 어려운 것에 의존해야 한다는 원칙이다.
		 */
		
	}
}

442p 예외처리

14.1 *예외의 원리 이해하기

444P 

runtime exception (uncheckexception)> ex) NullPointExc

check exception>try,catch

445p

447p finally

package kr.or.ksmart;

public class Exception1 {

	public static void main(String[] args) {
		/*
		 * RuntimeException - 언체크 예외
		 * 예외처리를 하지 않아도 작성이 가능한 코드
		 * 
		 * - RuntimeException 예외도 try, catch 구문으로 예외처리가 가능하다.
		 * RuntimeException 클래스를 확장시켜서 작성된 언체크 Exception 클래스를 말한다.
		 * 
		 * Throwable > Exception > RuntimeException
		 * Throwable	:	메세지 및 에러 위치 출력
		 * Exception	:	Throwable에 에러 문구 전달
		 */
		int n = 0;
		int n1 = 2 / n; //에러 강제 발생시키기
		System.out.println(n1);
		System.out.println("예외 발생  이후 출력 테스트");
	}

}

예외 발생 이후는 실행이 안됨.

package kr.or.ksmart;

public class Exception1 {

	public static void main(String[] args) {
		/*
		 * RuntimeException - 언체크 예외
		 * 예외처리를 하지 않아도 작성이 가능한 코드
		 * 
		 * - RuntimeException 예외도 try, catch 구문으로 예외처리가 가능하다.
		 * RuntimeException 클래스를 확장시켜서 작성된 언체크 Exception 클래스를 말한다.
		 * 
		 * Throwable > Exception > RuntimeException
		 * Throwable	:	메세지 및 에러 위치 출력
		 * Exception	:	Throwable에 에러 문구 전달
		 */
		try {
			int n = 0;
			int n1 = 2 / n; //에러 강제 발생시키기
			System.out.println(n1);
			
		} catch(ArithmeticException e) {
			System.out.println(e.getMessage()+"<<e.getMessage()");
			e.printStackTrace();
		}
		System.out.println("예외 발생  이후 출력 테스트");
	}

}

try,catch 구문을 통해 실행 가능

package kr.or.ksmart;

public class Exception1 {

	public static void main(String[] args) {
		/*
		 * RuntimeException - 언체크 예외
		 * 예외처리를 하지 않아도 작성이 가능한 코드
		 * 
		 * - RuntimeException 예외도 try, catch 구문으로 예외처리가 가능하다.
		 * RuntimeException 클래스를 확장시켜서 작성된 언체크 Exception 클래스를 말한다.
		 * 
		 * Throwable > Exception > RuntimeException
		 * Throwable	:	메세지 및 에러 위치 출력
		 * Exception	:	Throwable에 에러 문구 전달
		 */
		try {
			int[] array1 = new int[5];
			array1[6] = 2;
			} catch(ArrayIndexOutOfBoundsException e) {
			System.out.println(e.getMessage()+"<<e.getMessage()");
			e.printStackTrace();
		}
		System.out.println("예외 발생  이후 출력 테스트");
	}

}

package kr.or.ksmart;

public class Exception1 {

	public static void main(String[] args) {
		/*
		 * RuntimeException - 언체크 예외
		 * 예외처리를 하지 않아도 작성이 가능한 코드
		 * 
		 * - RuntimeException 예외도 try, catch 구문으로 예외처리가 가능하다.
		 * RuntimeException 클래스를 확장시켜서 작성된 언체크 Exception 클래스를 말한다.
		 * 
		 * Throwable > Exception > RuntimeException
		 * Throwable	:	메세지 및 에러 위치 출력
		 * Exception	:	Throwable에 에러 문구 전달
		 */
		try {
			String str= null;
			System.out.println(str.toString());
			
		} catch (NullPointerException e) {
			System.out.println(e.getMessage()+" <<NullPointerException e.getMessage()");
			e.printStackTrace();
		}
		System.out.println("예외 발생  이후 출력 테스트");
	}

}

453p throwable (class)

456p 예외던지기  throws 

MyException.java

package kr.or.ksmart;

/**
 * Exception을 상속받았기 때문에 Exception의 멤버를 전부 가지고 있다.
 * @author Administrator
 */
		
public class MyException extends Exception {
	
	public MyException () {
		super();
	}
	
	public MyException (String msg) {
		super(msg + " < My 클래스의 필수값  누락 MyException");
	}
	
}

My.java

package kr.or.ksmart;

public class My {
	private String name;
	
	public My (String name) throws MyException {
		if(name == null || "".equals(name)) {
			throw new MyException(name + " 인수값 null/공백");
		}
	}
}

Exception03.java

>> My() 생성자 메서드에 throws 키워드가 붙어있기 때문에 오류 발생.

throws, try/catch를 사용하여 에러를 제거할 수 있음.

Exception03.java

package kr.or.ksmart;

public class Exception03 {

	public static void main(String[] args) {
		My my = null;
		try {
			//my = new My(""); 생성자 메서드에서 공백 혹은 null일 때 예외 발생
			my = new My("홍길동");

			
		} catch (MyException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
		try {
			my.setMyAge(0); // 값이 0일 경우 강제 예외 발생
		} catch (MyException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	
	}

}

/**
* 실습1. Member 클래스, MemberException 클래스를 선언하고
* Member클래스의 userName의 인수값이 null 혹은 공백일 경우 예외가 발생되도록 구현하여라.  
*/

MemberException.java

package kr.or.ksmart;

public class MemberException extends Exception {
	public MemberException () {
		super();
	}
	public MemberException (String msg) {
		super(msg + " < Member클래스 필수값 누락");
	}
}

Member.java

package kr.or.ksmart;

public class Member {
	private String userName;
	public Member (String userName) throws MemberException {
		if(userName == null || "".equals(userName)) {
			throw new MemberException(userName + "인수값 null/공백");
		}
	}
}

ExceptionEx01.java

package kr.or.ksmart;

public class ExceptionEx01 {

	public static void main(String[] args) {
		/**
		 * 실습1. Member 클래스, MemberException 클래스를 선언하고
		 * Member클래스의 userName의 인수값이 null 혹은 공백일 경우 예외가 발생되도록 구현하여라.  
		 */
		Member m = null;
		try {
			m = new Member("");
		} catch (MemberException e) {
        	e.printStackTrace();
		}
	}
}

실행결과

context.xml

<?xml version="1.0" encoding="UTF-8"?>
<context> 

	<!-- 
	Resource를 등록하여 웹에서 JNDI로 호출할 이름과 정보를 설정. 
	각 db의 Driver jar 필요
	mariadb : org.mariadb.jdbc.Driver // jdbc:mariadb
	mysql : org.gjt.mm.mysql.Driver // jdbc:mysql
	
	-->
	<Resource 
  	name="jdbc/Jo3Con" 
  	auth="Container" 
  	type="javax.sql.DataSource"
	factory="org.apache.tomcat.dbcp.dbcp2.BasicDataSourceFactory"
	driverClassName="com.mysql.jdbc.Driver"
	url="jdbc:mysql://129.128.123.105:3306/3jo?autoReconnect=true&amp;characterEncoding=utf8"
	username="3joid" 
	password="3333" 
	maxActive="100" 
	maxIdle="30" 
	maxWait="10000"
	removeAbandoned="true" 
	removeAbandonedTimeout="60"/> 

  	<!-- 
	1. name : JNDI로 호출될 이름을 설정
	2. auth : DBCP를 관리할 관리자 (Container or Application) -
	3. type : 해당 resource의 return type - 
	4. factory : dbcp를 유용하는 관리 클래스 -
	5. driverClassName : JDBC를 이용하기 위한 드라이버 클래스
	6. url : DB의 접속 URL
	7. username : DB의 계정 명
	8. password : 계정에 대한 비밀번호
	9. maxActive : 최대 접속 허용 개수
	10. maxIdle : DB Pool에 여분으로 남겨질 최대 Connection 개수
	11. maxWait : DB 연결이 반환되는 Timeout의 최대 시간 (-1은 무한 대기)
	12. removeAbandoned : Connection이 잘못 관리되어 버려진 연결을 찾아 재활용할 것인지의 여부 설정
	13. removeAbandonedTimeout : 버려진 연결로 인식할 기본 시간 설정
	(초 단위로 해당 시간이 지나면 버려진 연결로 인식한다.)
	-->	  	

</context>

DBConnection.java

package kr.or.ksmart.dbConnection;

import java.sql.Connection;
import java.sql.SQLException;

import javax.naming.Context;
import javax.naming.InitialContext;
import javax.naming.NamingException;
import javax.sql.DataSource;

public class DBConnection {
	public static Connection getDBConnection () {
		Connection conn = null;
			try {
				Context context = new InitialContext();
				DataSource ds = (DataSource)context.lookup("java:comp/env/jdbc/Jo3Con");
				conn = ds.getConnection();
			
			} catch (SQLException e) {
				e.printStackTrace();	
			} catch (NamingException e) {
				e.printStackTrace();
			}
		return conn;
	} 
}

Connection3JoTest.java

package kr.or.ksmart.test;

import java.io.IOException;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;


import kr.or.ksmart.dbConnection.DBConnection;

@WebServlet("/Connection3JoTest")
public class Connection3JoTest extends HttpServlet {
	private static final long serialVersionUID = 1L;
       
    public Connection3JoTest() {
        super();
    }
	protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
	
		Connection conn = DBConnection.getDBConnection();
		PreparedStatement pstmt = null;
		ResultSet rs = null;
		System.out.println("doget");
		
		try {
			pstmt = conn.prepareStatement("select * from 3jotest where u_id = 'id001'");
			rs = pstmt.executeQuery();
			System.out.println(rs);
			
			if(rs.next()) {
				System.out.println("아이디 : "+rs.getString(1));
				System.out.println("패스워드 : "+rs.getString(2));
				System.out.println("이름 : "+rs.getString(3));
			}
		} catch (SQLException e) {
			e.printStackTrace();
		}finally {
			try{
				if(conn!=null) {conn.close();}
				if(pstmt!=null) {pstmt.close();}
				if(rs!=null) {rs.close();}
			}catch (SQLException e) {
				e.printStackTrace();
			}
		}
		
		response.getWriter().append("Served at: ").append(request.getContextPath());
	}

	protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
		doGet(request, response);
	}

}

Connection3JoTest.java 를 run 했을 경우 db 서버에는 연결이 제대로 되지만, 웹 로딩이 하루종일 걸리고 기다리면 결국에는 아래와 같은 에러가 발생했다..

에러로그

java.sql.SQLException: Cannot create PoolableConnectionFactory (Could not create connection to database server. Attempted reconnect 3 times. Giving up.)
Caused by: com.mysql.jdbc.exceptions.jdbc4.MySQLNonTransientConnectionException: Could not create connection to database server. Attempted reconnect 3 times. Giving up.
Caused by: com.mysql.jdbc.exceptions.jdbc4.CommunicationsException: Communications link failure
Caused by: java.net.ConnectException: Connection timed out: connect
java.lang.NullPointerException at kr.or.ksmart.test.Connection3JoTest.doGet(Connection3JoTest.java:33)

context.xml

<?xml version="1.0" encoding="UTF-8"?>
<context> 

	<!-- 
	Resource를 등록하여 웹에서 JNDI로 호출할 이름과 정보를 설정. 
	각 db의 Driver jar 필요
	mariadb : org.mariadb.jdbc.Driver // jdbc:mariadb
	mysql : org.gjt.mm.mysql.Driver // jdbc:mysql
	
	-->
	<Resource 
  	name="jdbc/Jo3Con" 
  	auth="Container" 
  	type="javax.sql.DataSource"
	factory="org.apache.tomcat.dbcp.dbcp2.BasicDataSourceFactory"
	driverClassName="com.mysql.jdbc.Driver"
	url="jdbc:mysql://localhost:3306/3jo?autoReconnect=true&amp;characterEncoding=utf8"
	username="3joid" 
	password="3333" 
	maxActive="100" 
	maxIdle="30" 
	maxWait="10000"
	removeAbandoned="true" 
	removeAbandonedTimeout="60"/> 

  	<!-- 
	1. name : JNDI로 호출될 이름을 설정
	2. auth : DBCP를 관리할 관리자 (Container or Application) -
	3. type : 해당 resource의 return type - 
	4. factory : dbcp를 유용하는 관리 클래스 -
	5. driverClassName : JDBC를 이용하기 위한 드라이버 클래스
	6. url : DB의 접속 URL
	7. username : DB의 계정 명
	8. password : 계정에 대한 비밀번호
	9. maxActive : 최대 접속 허용 개수
	10. maxIdle : DB Pool에 여분으로 남겨질 최대 Connection 개수
	11. maxWait : DB 연결이 반환되는 Timeout의 최대 시간 (-1은 무한 대기)
	12. removeAbandoned : Connection이 잘못 관리되어 버려진 연결을 찾아 재활용할 것인지의 여부 설정
	13. removeAbandonedTimeout : 버려진 연결로 인식할 기본 시간 설정
	(초 단위로 해당 시간이 지나면 버려진 연결로 인식한다.)
	-->	  	

</context>

url="jdbc:mysql://localhost:3306/3jo?autoReconnect=true&characterEncoding=utf8"

url에 내 ip를 적었던 부분을 localhost로 변경했더니 해결되었다!

Connection3JoTest.java를 실행한 화면

출력된 로그

정보: Server startup in 4024 ms
603724841, URL=jdbc:mysql://localhost:3306/3jo?autoReconnect=true&characterEncoding=utf8, UserName=3joid@localhost, MySQL Connector Java
doget
org.apache.tomcat.dbcp.dbcp2.DelegatingResultSet@4dbe09d9
아이디 : id001
패스워드 : pw001
이름 : 홍

JNDI(Java Naming and Directory Interface)

디렉터리 서비스에서 제공하는 데이터 및 객체를 발견(discover)하고 참고(lookup)하기 위한 자바 API

외부에 있는 객체를 가져오기 위한 기술

DBCP(Database Connection Pool)

데이터베이스와 연결된 커넥션을 미리 만들어서 저장해두고 있다가 필요할 때 저장된 공간(pool)에서 가져다 쓰고 반환(소멸후생성)하는 기법

데이터베이스 연결과 해제 직접 관리

DBCP(컨넥션 풀) 구성

DBCP( 컨넥션 풀 ) 구성

풀 속에 미리 커넥션이 생성되어 있기 때문에 커넥션을 생성하는 데 드는 연결 시간이 소비되지 않는다.

커넥션을 계속해서 재사용하기 때문에 생성되는 커넥션 수가 많지 않다.

커넥션 풀을 사용하면 커넥션을 생성하고 닫는 시간이 소모되지 않기 때문에 그만큼 어플리케이션의 실행 속도가 빨라지며, 또한 한 번에 생성될 수 있는 커넥션 수를 제어하기 때문에 동시 접속자 수가 몰려도 웹 어플리케이션이 쉽게 다운되지 않는다.

DBCP(컨넥션 풀) 환경설정

DBCP 라이브러리 추가

• Tomcat 6.x 이전 버전 commons-dbcp-1.4jar, commons-pool-1.6.jar, commons-collections-3.2.1-bin.zip 3개의 라이브러리 필요
• Tomcat 6.x 이후 버전 tomcat-dbcp.jar (commons-*.jar 통합) (tomcat > lib 의 tomcat-dbcp.jar 존재)

DB Driver 라이브러리 추가

• DB 버전 확인하고 이에 맞는 라이브러리 추가

Context 내에 Resource 추가 방법

• Server.xml 이나 context.xml 의 context 내에 resource 추가
• 프로젝트내의 META-INF에 context.xml 생성 후 context 내에 resource 추가
• Web.xml 에 resource-ref 추가 (tomcat 버전 별 차이 있음)

context.xml
> Context 내에 Resource 추가

<?xml version="1.0" encoding="UTF-8"?>
<context> 

	<!-- 
	Resource를 등록하여 웹에서 JNDI로 호출할 이름과 정보를 설정. 
	각 db의 Driver jar 필요
	mariadb : org.mariadb.jdbc.Driver // jdbc:mariadb
	mysql : org.gjt.mm.mysql.Driver // jdbc:mysql
	
	-->
	<Resource 
  	name="jdbc/myCon" 
  	auth="Container" 
  	type="javax.sql.DataSource"
	factory="org.apache.tomcat.dbcp.dbcp2.BasicDataSourceFactory"
	driverClassName="com.mysql.jdbc.Driver"
	url="jdbc:mysql://localhost:3306/ksmart35db?autoReconnect=true&amp;characterEncoding=utf-8"
	username="root" 
	password="java0000" 
	maxActive="100" 
	maxIdle="30" 
	maxWait="10000"
	removeAbandoned="true" 
	removeAbandonedTimeout="60"/> 

  	<!-- 
	1. name : JNDI로 호출될 이름을 설정
	2. auth : DBCP를 관리할 관리자 (Container or Application) -
	3. type : 해당 resource의 return type - 
	4. factory : dbcp를 유용하는 관리 클래스 -
	5. driverClassName : JDBC를 이용하기 위한 드라이버 클래스
	6. url : DB의 접속 URL
	7. username : DB의 계정 명
	8. password : 계정에 대한 비밀번호
	9. maxActive : 최대 접속 허용 개수
	10. maxIdle : DB Pool에 여분으로 남겨질 최대 Connection 개수
	11. maxWait : DB 연결이 반환되는 Timeout의 최대 시간 (-1은 무한 대기)
	12. removeAbandoned : Connection이 잘못 관리되어 버려진 연결을 찾아 재활용할 것인지의 여부 설정
	13. removeAbandonedTimeout : 버려진 연결로 인식할 기본 시간 설정
	(초 단위로 해당 시간이 지나면 버려진 연결로 인식한다.)
	-->	  	

</context>

MyConnection.java
>db 연결

package kr.or.ksmart.dbConnection;

import java.sql.Connection;
import java.sql.SQLException;

import javax.naming.Context;
import javax.naming.InitialContext;
import javax.naming.NamingException;
import javax.sql.DataSource;

public class MyConnection {
	public static Connection getConnection() {
		Connection con = null;
		try{			
			Context context = new InitialContext();
			DataSource ds = (DataSource)context.lookup("java:comp/env/jdbc/myCon");
			con = ds.getConnection();			
				
    	}catch(SQLException e){
			e.printStackTrace();
		}catch(NamingException e){
			e.printStackTrace();
		}
		return con;
	}
}

ConnectionTest.java
>connection test

package kr.or.ksmart;

import java.io.IOException;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;

import javax.naming.Context;
import javax.naming.InitialContext;
import javax.naming.NamingException;
import javax.servlet.ServletConfig;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.sql.DataSource;

import kr.or.ksmart.dbConnection.MyConnection;

/**
 * Servlet implementation class ConnectionTest
 */
@WebServlet("/ConnectionTest")
public class ConnectionTest extends HttpServlet {
	private static final long serialVersionUID = 1L;
       
    /**
     * @see HttpServlet#HttpServlet()
     */
    public ConnectionTest() {
        super();
        // TODO Auto-generated constructor stub
    }
	
	protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
		
		Connection con = MyConnection.getConnection();
		PreparedStatement ps = null;
		ResultSet rs = null;
		try {
			ps = con.prepareStatement("SELECT u.u_name FROM user AS u WHERE u.u_id = 'id001'");
			rs = ps.executeQuery();
			if(rs.next()) {
				System.out.println(rs.getString("u_name"));
			}
		} catch (SQLException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}finally {
			try{
				if(con!=null) {con.close();}
				if(ps!=null) {ps.close();}
				if(rs!=null) {rs.close();}
			}catch (SQLException e) {
				e.printStackTrace();
			}
		}
		
		response.getWriter().append("Served at: ").append(request.getContextPath());
	}

	protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
		// TODO Auto-generated method stub
		doGet(request, response);
	}

}

ConnectionTest.java 실행

화면

console log

...
정보: Server startup in 3883 ms
홍01

package kr.or.ksmart;

interface SampleInterface{
	public void show();
}
interface SampleInterface2{
	public void print();	
}


class Sample implements SampleInterface, SampleInterface2{

	@Override
	public void print() {
		
	}

	@Override
	public void show() {
		
	}
	
}

public class JavaBasic02 {

	public static void main(String[] args) {
		/*
		 * 인터페이스
		 * - interface 라는 키워드로 선언이 가능하다.
		 * - class 키워드 대신 interface 키워드가 붙는다.
		 * - 추상메서드와 상수를 가질 수 있다.
		 * - 인터페이스를 상속받을 시 implements 키워드를 사용한다.
		 * - 인터페이스를 상속받는 클래스는 다중 상속이 가능하다.
		 */
		
		Sample s = new Sample();
		s.print();
		s.show();
		
		SampleInterface ins1= s;
		ins1.show();
		SampleInterface2 ins2= s;
		ins2.print();
		
	}

}

package kr.or.ksmart;

class MemberDto{
	private String name;
	private String age;
	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + ((age == null) ? 0 : age.hashCode());
		result = prime * result + ((name == null) ? 0 : name.hashCode());
		return result;
	}
	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		MemberDto other = (MemberDto) obj;
		if (age == null) {
			if (other.age != null)
				return false;
		} else if (!age.equals(other.age))
			return false;
		if (name == null) {
			if (other.name != null)
				return false;
		} else if (!name.equals(other.name))
			return false;
		return true;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getAge() {
		return age;
	}
	public void setAge(String age) {
		this.age = age;
	}
}

class MemberDto2 {
	private String name;
	private String age;
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getAge() {
		return age;
	}
	public void setAge(String age) {
		this.age = age;
	}
}

public class JavaBasic01 {

	public static void main(String[] args) {
		/*
		 * equals : 두 객체가 동일한지 비교하는 메서드
		 */
		
		//object의 메서드로 비교
		MemberDto2 m21 = new MemberDto2();
		MemberDto2 m22 = new MemberDto2();
		MemberDto2 m23 = m21;
		
		System.out.println(m21.hashCode() + " <<- m21 object hashcode");
		System.out.println(m22.hashCode() + " <<- m22 object hashcode");
		System.out.println(m21.equals(m22) + " <<- m21/m22 object equals");
		System.out.println(m21.equals(m23) + " <<- m21/m23 object equals");
		
		//오버라이딩 한 메서드로 비교
		MemberDto m1 = new MemberDto();
		MemberDto m2 = new MemberDto();
		System.out.println(m1.hashCode() + " <<- m1 object hashcode");
		System.out.println(m2.hashCode() + " <<- m2 object hashcode");
		System.out.println(m1.equals(m2) + " <<- m1/m2 object equals");

		//해쉬코드
		String str = "홍길동2";
		System.out.println(str.hashCode()+" <<- str hashcode 54150062");

		/**
		 * instanceof 연산자
		 * 두 변수가 같은지 비교할 수 있는 연산자 (클래스 비교)
		 */
		System.out.println((m1 instanceof MemberDto) + " <<- instanceof ");
		
		try {
			//Class  class는 클래스의 메타정보 (jvm에서 활용 등 )
			//Class.forName 사용시 인수에 해당하는 네임스페이스 클래스는 메모리에 등록된다.
			Class getClass = Class.forName("kr.or.ksmart.TestClass");
			System.out.println(getClass.getName() + " <<-getClass.getName()");
			System.out.println(getClass.hashCode() + " <<-getClass.hashCode()" );
			
			
			//동적으로 객체화
			/**
			 *  Class 클래스 내의 newInstance 메서드를 활용하여 동적 인스턴스화
			 *  object 타입으로 결과값이 나온다.
			 */
			Object mObject = getClass.newInstance();
			//동적 인스턴스화는 결과를 다운 캐스팅
			//instanceof 연산자로 비교
			if(mObject instanceof TestClass) {
				TestClass t = (TestClass) mObject;
				t.setName("홍길동");
				System.out.println(t.getName() + " <<- t.getName()");
			}
			
		}catch(ClassNotFoundException e) {
			e.printStackTrace();
		} catch (InstantiationException e) {
			e.printStackTrace();
		} catch (IllegalAccessException e) {
			e.printStackTrace();
		}
		
	}

}

package kr.or.ksmart;

public class TestClass {
	private String name;

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}
	
	
}

object의 메서드로 비교

오버라이딩 한 메서드로 비교

해쉬코드

instanceof

package kr.or.ksmart;

abstract class User{
	protected String name;
	protected String age;
	public final String getName() {
		return name;
	}
	public final String getAge() {
		return age;
	}
	
	public abstract void setUserInfo(String name, String age);
	
}

class CompanyUser extends User {

	@Override
	public void setUserInfo(String name, String age) {
		super.name = name;
		this.age = age;
		
	}
}


public class JavaBasicEx01 {
	public static void main(String[] args) {
		/*
		 * 실습1. 
		 * User 추상 클래스가 있다. User 추상 클래스를 확장하여 CompanyUser를 구현하고 호출하여라.
		 */
		
		User u = new CompanyUser();
		u.setUserInfo("홍길동", "18");
		System.out.println("이름 : "+u.getName()+"\n나이 : "+u.getAge());
	}
}

package kr.or.ksmart;
abstract class Car{
	private int gas;
	private int num;
	private String  carName;
	public Car (int gas, int num, String  carName) {
		this.gas = gas;
		this.num = num;
		this.carName = carName;
	}
	
	public abstract String carInfo();
	
	public final int getGas() {
		return gas;
	}
	public final int getNum() {
		return num;
	}
	public final String getCarName() {
		return carName;
	}
}

class Bus extends Car {

	public Bus(int gas, int num, String carName) {
		super(gas, num, carName);
		// TODO Auto-generated constructor stub
	}

	@Override
	public String carInfo() {
		int gas = super.getGas();
		int num = super.getNum();
		String carName = super.getCarName();
		String carInfo = "연료 : "+ gas +"\n번호 : "+ num +"\n차이름 : "+ carName; 
		return carInfo;
	}
	
}

public class JavaBasicEx02 {

	public static void main(String[] args) {
		/*
		 * 실습2.
		 * Car라는 추상 클래스가 있다. 
		 * Car라는 추상 클래스를 확장하여 Bus클래스를 구현하고 carInfo()메서드를 호출하여라.
		 * carInfo : 부모 필드의 gas, num, carName의 값을 문자 결합 연산자를 사용하여 car의 정보를 출력시키는 메서드 
		 */
		Car car = new Bus(20, 1234, "버스1234");
		System.out.println(car.carInfo());
	}
}

package kr.or.ksmart;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;

class ProductDto{
	private String productName; //상품명
	private int price; //가격
	private String productType; //상품분류 (임대 혹은 판매)
	public String getProductName() {
		return productName;
	}
	public void setProductName(String productName) {
		this.productName = productName;
	}
	public int getPrice() {
		return price;
	}
	public void setPrice(int price) {
		this.price = price;
	}
	public String getProductType() {
		return productType;
	}
	public void setProductType(String productType) {
		this.productType = productType;
	}
}

//상품매출 클래스
abstract class ProductSales{
	/**
	 * 총 분류 총합 판매 내역 등록
	 * */
	public abstract void setProductSale(List<ProductDto> productList);
	/**
	 * 분기 및 분류별 합산
	 * @return int
	 */
	public abstract int quarterSum();
	/**
	 * 분기별 최대 판매 및 임대 상품명
	 * @return String
	 */
	public abstract String maxProductName();
	/**
	 * 분기별 최소 판매 및 임대 상품명
	 * @return String
	 */
	public abstract String minProductName();
}
//임대상품 
class ProductLease extends ProductSales{
	List<ProductDto> productLeaseList = null;
	ProductDto pDto = null;
	@Override
	public void setProductSale(List<ProductDto> productList) {
		productLeaseList = new  ArrayList<ProductDto>();
		if(productList != null) {
			System.out.println("-----임대상품등록시작-----");
			for(int i = 0 ; i <productList.size(); i++) {
				if("임대".equals(productList.get(i).getProductType())) {
					System.out.println(i);
					pDto = new ProductDto();
					pDto.setPrice(productList.get(i).getPrice());
					pDto.setProductName(productList.get(i).getProductName());
					pDto.setProductType(productList.get(i).getProductType());
					productLeaseList.add(pDto);
				}
			}
			System.out.println("-----임대상품등록완료-----");
		}
	}

	@Override
	public int quarterSum() {
		System.out.print("분기 임대 총합 : ");
		int sum = 0;
		for(int i = 0 ; i <productLeaseList.size(); i++) {
				sum += productLeaseList.get(i).getPrice();
			}
		return sum;
	}

	@Override
	public String maxProductName() {
		System.out.print("분기 최대 임대 상품 : ");
		String maxProductName = null;
		int num = 0;
		
		for(int i = 0 ; i <productLeaseList.size(); i++) {
			if(num == 0) {
				num = productLeaseList.get(i).getPrice();
				maxProductName = productLeaseList.get(i).getProductName();
			} else {
				if(productLeaseList.get(i).getPrice() > num) {
					maxProductName = productLeaseList.get(i).getProductName();
					num = productLeaseList.get(i).getPrice();
				}
			}
		}
		return maxProductName;
	}

	@Override
	public String minProductName() {
		System.out.print("분기 최소 임대 상품 : ");
		String minProductName = null;
		int num = 0;
		for(int i = 0 ; i <productLeaseList.size(); i++) {
			if( num == 0) {
				minProductName = productLeaseList.get(i).getProductName();
				num = productLeaseList.get(i).getPrice();
			} else {
				if(productLeaseList.get(i).getPrice() < num) {
					minProductName = productLeaseList.get(i).getProductName();
					num = productLeaseList.get(i).getPrice();
				}
			}
		}
		return minProductName;
	}
}
//판매상품
class ProductSale extends ProductSales {
	List<ProductDto> productLeaseList = null;
	ProductDto pDto = null;
	@Override
	public void setProductSale(List<ProductDto> productList) {
		System.out.println("-----판매상품등록시작-----");
		productLeaseList = new  ArrayList<ProductDto>();
		for(int i = 0 ; i <productList.size(); i++) {
			if("판매".equals(productList.get(i).getProductType())) {
				System.out.println(i);
				pDto = new ProductDto();
				pDto.setPrice(productList.get(i).getPrice());
				pDto.setProductName(productList.get(i).getProductName());
				pDto.setProductType(productList.get(i).getProductType());
				productLeaseList.add(pDto);
			}
		}
		System.out.println("-----판매상품등록완료-----");
	}

	@Override
	public int quarterSum() {
		System.out.print("분기 판매 총합 : ");
		int sum = 0;
		for(int i = 0 ; i <productLeaseList.size(); i++) {
				sum += productLeaseList.get(i).getPrice();
			}
		return sum;
	}

	@Override
	public String maxProductName() {
		System.out.print("분기 최대 판매 상품 : ");
		String maxProductName = null;
		int num = 0;
		for(int i = 0 ; i <productLeaseList.size(); i++) {
			if( num == 0) {
				num = productLeaseList.get(i).getPrice();
				maxProductName = productLeaseList.get(i).getProductName();
			}else {
				if(productLeaseList.get(i).getPrice() > num) {
					num = productLeaseList.get(i).getPrice();
					maxProductName = productLeaseList.get(i).getProductName();
				}
			}
		}
		return maxProductName;
	}

	@Override
	public String minProductName() {
		System.out.print("분기 최소 판매 상품 : ");
		String minProductName = null;
		int num = 0;
		for(int i = 0 ; i <productLeaseList.size(); i++) {
			if(num == 0) {
				num = productLeaseList.get(i).getPrice();
				minProductName = productLeaseList.get(i).getProductName();
			}else {
				if(productLeaseList.get(i).getPrice() < num) {
					num = productLeaseList.get(i).getPrice();
					minProductName = productLeaseList.get(i).getProductName();
				}
			}
		}
		return minProductName;
	}
}

public class JavaBasicEx03 {

	public static void main(String[] args) {		
		//db에서 판매 목록 가지고 왔다는 가정
		List<ProductDto> productSaleList = getPoductList();
		
		/*
		 * 실습3. ProductSales은 상품의 매출을 나타낼 수 있는 추상 클래스이다.
		 *   ProductLease 클래스는 임대상품를 담당하고,
		 *   ProductSale 클래스는 판매상품을 담당한다.
		 *   ProductLease와 ProductSale 클래스는 ProductSales 추상클래스를
		 *   확장하여 추상클래스의 메서드를 구현하고 
		 *   출력을 하여라.
		 *   메서드기능 : 
		 *   quarterSum -> 분기별 합산(분류에 맞는 전체 상품 가격 합산)
		 *   maxProductName -> 최고 매출의 상품명
		 *   minProductName -> 최소의 매출 상품명
		 */
		
		System.out.println("======임대상품매출======");
		ProductSales pl = new ProductLease();
		pl.setProductSale(productSaleList);
		System.out.println(pl.quarterSum());
		System.out.println(pl.maxProductName());
		System.out.println(pl.minProductName());
		System.out.println("====================\n");
		
		System.out.println("======판매상품매출======");
		ProductSales ps = new ProductSale();
		ps.setProductSale(productSaleList);
		System.out.println(ps.quarterSum());
		System.out.println(ps.maxProductName());
		System.out.println(ps.minProductName());
		System.out.println("====================");
	}
	
	/**
	 * 디비에서 상품 판매 및 임대 목록 가지고 온다는 가정
	 * @return List<ProductDto>
	 */
	public static List<ProductDto> getPoductList(){
		
		List<ProductDto> productSaleList = new ArrayList<ProductDto>();
		ProductDto pDto = null;
		pDto = new ProductDto();
		pDto.setPrice(50000);
		pDto.setProductName("임대상품A");
		pDto.setProductType("임대");
		productSaleList.add(pDto);
		pDto = new ProductDto();
		pDto.setPrice(60000);
		pDto.setProductName("임대상품B");
		pDto.setProductType("임대");
		productSaleList.add(pDto);
		pDto = new ProductDto();
		pDto.setPrice(30000);
		pDto.setProductName("임대상품C");
		pDto.setProductType("임대");
		productSaleList.add(pDto);
		pDto = new ProductDto();
		pDto.setPrice(15000);
		pDto.setProductName("판매상품A");
		pDto.setProductType("판매");
		productSaleList.add(pDto);
		pDto = new ProductDto();
		pDto.setPrice(21000);
		pDto.setProductName("판매상품B");
		pDto.setProductType("판매");
		productSaleList.add(pDto);
		pDto = new ProductDto();
		pDto.setPrice(24000);
		pDto.setProductName("판매상품C");
		pDto.setProductType("판매");
		productSaleList.add(pDto);	
		
		return productSaleList;
	}

}

반복작업 최소화

package kr.or.ksmart;

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

class ProductSumDto{
	private int totalPrice;
	private String maxProductName;
	private String minProductName;
	public int getTotalPrice() {
		return totalPrice;
	}
	public void setTotalPrice(int totalPrice) {
		this.totalPrice = totalPrice;
	}
	public String getMaxProductName() {
		return maxProductName;
	}
	public void setMaxProductName(String maxProductName) {
		this.maxProductName = maxProductName;
	}
	public String getMinProductName() {
		return minProductName;
	}
	public void setMinProductName(String minProductName) {
		this.minProductName = minProductName;
	}	
}

class ProductDto{
	private String productName; //상품명
	private int price; //가격
	private String productType; //상품분류 (임대 혹은 판매)
	public String getProductName() {
		return productName;
	}
	public void setProductName(String productName) {
		this.productName = productName;
	}
	public int getPrice() {
		return price;
	}
	public void setPrice(int price) {
		this.price = price;
	}
	public String getProductType() {
		return productType;
	}
	public void setProductType(String productType) {
		this.productType = productType;
	}
}

//상품매출 클래스
abstract class ProductSales{
	/**
	 * 총 분류 총합 판매 내역 등록
	 * */
	public abstract void setProductSale(List<ProductDto> productList);
	/**
	 * 분기 및 분류별 합산
	 * @return int
	 */
	public abstract int quarterSum();
	/**
	 * 분기별 최대 판매 및 임대 상품명
	 * @return String
	 */
	public abstract String maxProductName();
	/**
	 * 분기별 최소 판매 및 임대 상품명
	 * @return String
	 */
	public abstract String minProductName();
	
	protected final ProductSumDto setProductList(List<ProductDto> productList, String getType) {
		ProductSumDto sumDto = new ProductSumDto();
		
		int sum = 0;
		String minProductName = null;
		String maxProductName = null;
		
		if(productList != null) {
			int minPrice = 0;
			int maxPrice = 0;
			for(int i=0; i < productList.size(); i++) {
				ProductDto dto = productList.get(i);
				int price = dto.getPrice();
				String name = dto.getProductName();
				String type = dto.getProductType();
				if(getType.equals(type)) {
					sum += price;
					if(minPrice == 0) {
						minPrice = price;
						minProductName = name;
					}else {
						if(price > minPrice) {
							minPrice = price;
							minProductName = name;
						}
					}
					if(maxPrice == 0) {
						maxPrice = price;
						maxProductName = name;
					}else {
						if(price < maxPrice) {
							maxPrice = price;
							maxProductName = name;
						}
					}
				}
			}
		}
		
		sumDto.setTotalPrice(sum);
		sumDto.setMaxProductName(maxProductName);
		sumDto.setMinProductName(minProductName);
		
		return sumDto;
	} 
	
}
//임대상품 
class ProductLease extends ProductSales{
	
	private int sum;
	private String maxProductName;
	private String minProductName;
	
	@Override
	public void setProductSale(List<ProductDto> productList) {
		ProductSumDto sumDto =  super.setProductList(productList, "임대");
		this.sum = sumDto.getTotalPrice();
		this.maxProductName = sumDto.getMaxProductName();
		this.minProductName = sumDto.getMinProductName();
	}

	@Override
	public int quarterSum() {
		return sum;
	}

	@Override
	public String maxProductName() {
		return maxProductName;
	}

	@Override
	public String minProductName() {
		return minProductName;
	}
	
}
//판매상품
class ProductSale extends ProductSales{
	
	private int sum;
	private String maxProductName;
	private String minProductName;
	
	@Override
	public void setProductSale(List<ProductDto> productList) {
		ProductSumDto sumDto =  super.setProductList(productList, "판매");
		this.sum = sumDto.getTotalPrice();
		this.maxProductName = sumDto.getMaxProductName();
		this.minProductName = sumDto.getMinProductName();
	}

	@Override
	public int quarterSum() {
		return sum;
	}

	@Override
	public String maxProductName() {
		return maxProductName;
	}

	@Override
	public String minProductName() {
		return minProductName;
	}
}

public class JavaBasicEx03 {

	public static void main(String[] args) {		
		//db에서 판매 목록 가지고 왔다는 가정
		List<ProductDto> productSaleList = getPoductList();
		
		/*
		 * 실습3. ProductSales은 상품의 매출을 나타낼 수 있는 추상 클래스이다.
		 *   ProductLease 클래스는 임대상품를 담당하고,
		 *   ProductSale 클래스는 판매상품을 담당한다.
		 *   ProductLease와 ProductSale 클래스는 ProductSales 추상클래스를
		 *   확장하여 추상클래스의 메서드를 구현하고 
		 *   출력을 하여라.
		 *   메서드기능 : 
		 *   quarterSum -> 분기별 합산(분류에 맞는 전체 상품 가격 합산)
		 *   maxProductName -> 최고 매출의 상품명
		 *   minProductName -> 최소의 매출 상품명
		 * */
		
		ProductSales pro = new ProductLease();
		pro.setProductSale(productSaleList);
		System.out.println(pro.quarterSum());
		System.out.println(pro.maxProductName());
		System.out.println(pro.minProductName());

	}
	
	/**
	 * 디비에서 상품 판매 및 임대 목록 가지고 온다는 가정
	 * @return List<ProductDto>
	 */
	public static List<ProductDto> getPoductList(){
		
		List<ProductDto> productSaleList = new ArrayList<ProductDto>();
		ProductDto pDto = null;
		pDto = new ProductDto();
		pDto.setPrice(50000);
		pDto.setProductName("임대상품A");
		pDto.setProductType("임대");
		productSaleList.add(pDto);
		pDto = new ProductDto();
		pDto.setPrice(60000);
		pDto.setProductName("임대상품B");
		pDto.setProductType("임대");
		productSaleList.add(pDto);
		pDto = new ProductDto();
		pDto.setPrice(30000);
		pDto.setProductName("임대상품C");
		pDto.setProductType("임대");
		productSaleList.add(pDto);
		pDto = new ProductDto();
		pDto.setPrice(15000);
		pDto.setProductName("판매상품A");
		pDto.setProductType("판매");
		productSaleList.add(pDto);
		pDto = new ProductDto();
		pDto.setPrice(21000);
		pDto.setProductName("판매상품B");
		pDto.setProductType("판매");
		productSaleList.add(pDto);
		pDto = new ProductDto();
		pDto.setPrice(24000);
		pDto.setProductName("판매상품C");
		pDto.setProductType("판매");
		productSaleList.add(pDto);	
		
		return productSaleList;
	}

}

 @Override 어노테이션

package kr.or.ksmart;

class Car{
	private int num;
	private int gas;
	public int getNum() {
		return num;
	}
	public void setNum(int num) {
		this.num = num;
	}
	public int getGas() {
		return gas;
	}
	public void setGas(int gas) {
		this.gas = gas;
	}	
}

class Bus extends Car{
	@Override
	public void setGas(int gas) {
		super.setGas(gas + 1000);
	}
}

class Sport extends Car{
	@Override
	public void setGas(int gas) {
		super.setGas(gas + 500);
	}
}

public class JavaBasic01 {
	
	public static void main(String[] args) {
		/**
		 * 오버라이딩
		 * - 슈퍼클래스의 메서드와 동일한 메서드 명과 인수로 재 구현하는 방식
		 * - 슈퍼클래스의 메서드를 재 구현 할시 @Override 어노테이션이 붙는다.
		 */
		
		String type = "bus";
		Car car = null;
		if("car".equals(type)) {
			car = new Car();			
		}else if("bus".equals(type)) {
			car = new Bus();
		}else if("sport".equals(type)) {			
			car = new Sport();
		}
		car.setGas(1000);
		System.out.println(car.getGas() + " <<  " + type + " gas");
		
		
	}
}

final

package kr.or.ksmart;

class Sample{
	public void print(String print) {
		System.out.println(print);
	}
	public final void print(String print, String type) {
		System.out.println(print + " : " + type);
	}
}
class SubSample extends Sample{
	@Override
	public void print(String print) {
		super.print(print);
	}
}

public class JavaBasic02 {
	
	//상수 만들기
	public final static String ADD = "전주시";
	
	public static void main(String[] args) {
		/**
		 * final
		 * - 더 이상 변경이 불가능하도록 만드는 키워드
		 * 
		 * 상수 : final 키워드가 붙으며 변수명은 주로 대문자로 쓰인다.
		 * 메서드 : 메서드에 final이 붙을 경우 오버라이딩을 할 수 없다.
		 * 클래스 : 클래스에 final이 붙으면 상속을 할 수 없다.
		 */
		
		//ADD = "전북 전주시";
	}
}

extends 키워드가 (상속)이 없는 클래스는 기본적으로 Object 클래스를 상속 받는다.

package kr.or.ksmart;

import java.lang.reflect.Method;

class Sample2{
	private String name;
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}	
}

public class JavaBasic03 {
	public static void main(String[] args) {
		Sample2 s = new Sample2();
		/**
		 * Sample2클래스는 extends 키워드가 (상속)이 없기때문에 기본적으로
		 * Object 클래스를 상속 받는다.
		 */
		Class sampleClass = s.getClass();
		//네임스페이스 가지고 오기
		System.out.println(sampleClass.getName() + " <<  Class 명 가지고 오기");		
		Method[] mArray = sampleClass.getMethods();
		for(int i=0; i < mArray.length; i++) {
			Method m = mArray[i];
			System.out.println(m.getName());
		}
		
	}
}

추상클래스

package kr.or.ksmart;

abstract class Sample3{
	public abstract void print();
}
class SubSample3 extends Sample3{
	@Override
	public void print() {		
		System.out.println("추상 메서드 구현");
	}
	
}
public class JavaBasic04 {
	public static void main(String[] args) {
		/**
		 * 추상클래스
		 * - 클래스명 앞에 abstract 키워드가 붙는다.
		 * - abstract 키워드가 붙은 추상 메서드를 구현할 수 있다.
		 * - 추상클래스는 일반적은 메서드 및 필드도 구현이 가능하다.
		 * - 추상적인 클래스는 직접 인스턴스화를 할 수 없다.
		 * - 추상 메서드는  몸체가 없다. ('{ }' 구현부가 생략되어야 한다.)
		 * - 추상 메서드는 서브 클래스에서 필히 구현이 되어야한다.(오버라이딩)
		 */
		//추상 클래스는 직접 인스턴스화를 할 수 없다.
		//Sample3 sample3 = new Sample3();
		
		//추상적인 클래스를 상속받아 구현된 서브클래스
		//추상클래스가 직접 인스턴스화를 하는게 아니라 슈퍼클래스 
		//참조타입으로 서브클래스가 인스턴스화된다.
		Sample3 s = new SubSample3();
		
	}
}

package kr.or.ksmart;

abstract class Calculator {
	protected int n1;
	protected int n2;
	public abstract void sum(int n1, int n2); 
	public final int print() {
		return n1 + n2;
	}
}
class Sum extends Calculator {
	@Override
	public void sum(int n1, int n2) {
		super.n1 = n1;
		super.n2 = n2;
	}	
}

public class JavaBasic05 {
	public static void main(String[] args) {
		Calculator cal = new Sum();
		cal.sum(10,20);
		System.out.println(cal.print());
	}
}

package kr.or.ksmart;

class User{
	private String name;
	private String age;
	public User(String name, String age) {
		this.name = name;
		this.age = age;
	}
	public String getName() {
		return name;
	}
	public String getAge() {
		return age;
	}
	@Override
	public String toString() {
		return "User [name=" + name + ", age=" + age + "]";
	}	
}

class ComPanyUser extends User{

	public ComPanyUser(String name, String age) {
		super(name, age);
	}
	
}

public class JavaBasicEx01 {

	public static void main(String[] args) {
		/**
		 * 실습1. User클래스가 있다. User클래스를 확장시켜
		 * ComPanyUser를 구현하고 인스턴스화를 하여 호출하여라.
		 */
		
		ComPanyUser comUser = new ComPanyUser("홍길동","20");
		User user = comUser;

	}

}

package kr.or.ksmart;

class Car2{
	private String number;
	public String getNumber() {
		return number;
	}
	public void setNumber(String number) {
		this.number = number;
	}	
}

class Bus2 extends Car2{
	@Override
	public void setNumber(String number) {
		super.setNumber("B " + number);
	}
}

class Sport2 extends Car2{
	@Override
	public void setNumber(String number) {
		super.setNumber("S " + number);
	}
}


public class JavaBasicEx02 {

	public static void main(String[] args) {
		/**
		 * 실습2. Car2라는 클래스가 있다. Car2의 필드에는 String 타입의 number변수가 있다.
		 *  그리고 setNumber, getNumber 메서드도 가지고 있다. 
		 *  Car2를 상속받아 구현된 클래스는 Bus2와 Sport2클래스가 있으며,
		 *  Bus2와 Sport2의 클래스에서 Car2의 메서드 setNumber를 오버라이딩하여 
		 *  메서드를 재구현하였다.
		 *  Bus2와 Sport2의 클래스에서 getNumber 메서드 호출시
		 *  Bus2클래스의 getNumber 결과값은 'B 번호'로 가공되서 결과물 출력
		 *  Sport2클래스의 getNumber 결과값은 'S 번호'로 가공되서 결과물 출력 되도록 하여라.
		 */
		
		Car2 car = null;
		String type = "bus";
		
		if("car".equals(type)) {
			car = new Car2();
		}else if("bus".equals(type)) {
			car = new Bus2();
		}else if("sport".equals(type)) {		
			car = new Sport2();
		}		
		car.setNumber("1234");
		System.out.println(car.getNumber() + " << " + type + " number");
		
	}

}

package kr.or.ksmart;

abstract class Document{
	protected String documentName;
	public abstract int writeProcess(String documentName) ;
	public final int approval() {
		System.out.println(documentName + " 결재 완료");
		return 1;
	}
}

class Vacation extends Document{
	@Override
	public int writeProcess(String documentName) {
		//휴가 관련된 데이타 db에 등록
		this.documentName = documentName;
		System.out.println(documentName + " 작성 완료");
		return 1;
	}	
}

class BusinessTrip extends Document{
	@Override
	public int writeProcess(String documentName) {
		//출장에 관련된 데이타 db에 등록
		this.documentName = documentName;
		System.out.println(documentName + " 작성 완료");
		return 0;
	}
}

public class JavaBasicEx03 {

	public static void main(String[] args) {
		/*
		 * 실습3. Document라는 추상 클래스가 있다.
		 * writeProcess라는 추상 메서드를 가지고 
		 * approval이라는 final 메서드가 있다.
		 * Document를 상속받아 구현되는 휴가신청서, 출장신청서 클래스를 만들어 구현하고
		 * 호출하여라.
		 * */
		
		Document doc = null;
		String type = "vacation";
		if("vacation".equals(type)) {
			doc = new Vacation();
		}else if("businessTrip".equals(type)) {
			doc = new BusinessTrip();
		}
		
		doc.writeProcess(type);
		doc.approval();
		
	}

}

null 원리 / garbage collection

null을 대입하면 어떠한 객체도 가리킬 수 없다.

garbage collection : 객체를 어떤 변수도 참조하지 않으면 Java의 판단에 따라 객체가 소멸되고 객체를 생성하기 전의 상태로 돌아감.

상속 슈퍼클래스 / 서브클래스

package kr.or.ksmart;

class SuperClass {
	private String name;
	
	public SuperClass () {
		System.out.println("슈퍼클래스 호출");
	}
	public SuperClass(String name) {
		this.name = name;
		System.out.println("슈퍼클래스 생성자 메서드 오버로딩 호출");
	}
	

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}
	

}
class SubClass extends SuperClass {
	public String age;
	public SubClass () {
		System.out.println("서브클래스 호출");
	}
	public SubClass(String name) {
		super(name);
		System.out.println("서브클래스 생성자 메서드 오버로딩 호출");
	}
	public String getAge() {
		return age;
	}
	public void setAge(String age) {
		this.age = age;
	}
	

}

public class JavaBasic06 {

	public static void main(String[] args) {
		/*
		 * 상속
		 * 이미 생성된 클래스를 상속하여 확장한다.
		 * 확장 대상 클래스는 슈퍼클래스, 확장 실행하는 클래스는 서브클래스이다.
		 * extends 라는 키워드를 활용하여 가능하다.
		 * 서브클래스는 슈퍼클래스의 필드 및 메서드를 가진다.
		 * 접근지정자의 영향을 받는다.
		 * 서브클래스에서 부모클래스를 가르키는 키워드는 super 이다.
		 * super. 부모 메서드 혹은 부모의 필드
		 * super() 부모 생성자 메서드
		 */
		
		/*SubClass subClass = new SubClass();
		subClass.setName("홍길동");
		subClass.setAge("20");
		System.out.println(subClass.getName());
		System.out.println(subClass.getAge());*/
		
		/*SuperClass superClass = new SuperClass();
		superClass.setName("이순신");
		System.out.println(superClass.getName());*/
		
		SubClass subClass = new SubClass("홍길동");
		subClass.setAge("20");
		System.out.println(subClass.getName());
		System.out.println(subClass.getAge());
	}

}

package kr.or.ksmart;

class SuperClass2 {
	public SuperClass2(String name) {
		System.out.println("슈퍼클래스 인수 : "+name);
	}
}
class SubClass2 extends SuperClass2 {
	public SubClass2(String name) {
		super(name); //슈퍼클래스의 생성자를 골라서 호출 가능
		System.out.println("서브클래스 인수 : "+name);
	}
}

public class JavaBasic07 {

	public static void main(String[] args) {
		SubClass2 subClass2 = new SubClass2("홍길동");
		
	}

}

객체지향 4대조건 : 상속 추상화 캡슐화 다형성

다형성 / 업캐스팅 / 다운캐스팅

package kr.or.ksmart;

import javax.jws.soap.SOAPBinding;

class Car {
	private int num;
	private int gas;
	public int getNum() {
		return num;
	}
	public void setNum(int num) {
		this.num = num;
	}
	public int getGas() {
		return gas;
	}
	public void setGas(int gas) {
		this.gas = gas;
	}
	@Override
	public String toString() {
		return "Car [num=" + num + ", gas=" + gas + "]" ;
	}
}
class Bus extends Car {
	private String name;

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}
	@Override
	public String toString() {
		return "Bus [name=" + name + "] "+ super.toString();
	}	
}

class Sport extends Car {
	private String name;

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	@Override
	public String toString() {
		return "Sport [name=" + name + "] " + super.toString();
	}
}

public class JavaBsic01 {

	public static void main(String[] args) {
		/*
		 * 다형성
		 * 하나의 클래스를 상속받아 여러개의 클래스로 확장하는 경우
		 * 상속의 주체가 되는 슈퍼클래스의 참조타입으로 업캐스팅이 가능하며,
		 * 업캐스팅된 객체로 비지니스 로직 처리가 가능하다.
		 * 
		 * 업캐스팅
		 * 상속받아 객체화된 대상을 슈퍼클래스 참조타입으로 캐스팅 하는 것
		 * 
		 * 다운캐스팅
		 * 객체화된 부모클래스에서 상속을 받은 서브클래스로 캐스팅 되는 것
		 */
		
		
		String type = "sport";
		Car car = null;
		if("bus".equals(type)) {
			Bus bus = new Bus();
			bus.setNum(1000);
			bus.setGas(1000);
			bus.setName("내버스");
			/*System.out.println(bus.getNum());
			System.out.println(bus.getGas());
			System.out.println(bus.getName());*/
			System.out.println(bus.toString());
			car = bus; //UpCasting
		} else if ("sport".equals(type)){
			Sport sport = new Sport();
			sport.setNum(2000);
			sport.setGas(2000);
			sport.setName("내스포츠카");
			/*System.out.println(sport.getNum());
			System.out.println(sport.getGas());
			System.out.println(sport.getName());*/
			System.out.println(sport.toString());
			car = sport; //UpCasting
		}
		
		/**
		 * 슈퍼클래스를 참조타입으로 서브클래스 인스턴스화 하기
		 * 참조타입의 
		 */
		
		Car car2 = null;
		
		
		if("bus".equals(type)) {
			car2 = new Bus();
			car2.setNum(1000);
			car2.setGas(1000);
		} else if ("sport".equals(type)) {
			car2 = new Sport();
			car2.setNum(2000);
			car2.setGas(2000);
		}
		System.out.println("----------------------------------------------------");
		System.out.println(car2.toString());
		
		//UpCasting
		Car car3 = new Bus();
		//DownCasting
		Bus bus = (Bus) car2;
		System.out.println(bus.toString());
	}
	
	
}

package kr.or.ksmart;

class Car2 {
	private int num;
	private int gas;
	public int getNum() {
		return num;
	}
	public void setNum(int num) {
		this.num = num;
	}
	public int getGas() {
		return gas;
	}
	public void setGas(int gas) {
		this.gas = gas;
	}
	@Override
	public String toString() {
		return "Car2 [num=" + num + ", gas=" + gas + "]";
	}
	
}

class Bus2 extends Car2 {
	private String name;

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	@Override
	public String toString() {
		return "Bus2 [name=" + name + "] " + super.toString();
	}
}

class Sport2 extends Car2 {
	private char course;

	public char getCourse() {
		return course;
	}

	public void setCourse(char course) {
		this.course = course;
	}

	@Override
	public String toString() {
		return "sport2 [course=" + course + "] " + super.toString();
	}
	
}
public class JavaBasicEx01 {

	public static void main(String[] args) {
		/*
		 * 실습3. Car2라는 클래스가 있다.
		 * Car2를 기준으로 다른 아래의 클래스를 확장시켜 다형성을 이용하여 비지니스 로직을 처리할 것이다.
		 * 아래의 클래스를 확장시켜 다형성 코드를 완성하여라.
		 * 서브클래스 명 : Bus2, Sport2
		 */
		Car2 car2 = null;
		String type = "sport";
		if("bus".equals(type)) {
			Bus2 bus2 = new Bus2();
			bus2.setName("시내버스");
			bus2.setNum(1234);
			bus2.setGas(5000);
			System.out.println(bus2.toString());
			car2 = bus2;
		} else if ("sport".equals(type)) {
			Sport2 sport2 = new Sport2();
			sport2.setCourse('D');
			sport2.setNum(4321);
			sport2.setGas(5555);
			System.out.println(sport2.toString());
			car2 = sport2;
		}
		
	}

}

업캐스팅 / 다운캐스팅

package kr.or.ksmart;

class MyClass{
	public String myName;
}

public class JavaBasic02 {

	public static void main(String[] args) {
		/*Object myClass = new MyClass();
		myClass.myName < x*/
		MyClass myClass = new MyClass();
		myClass.myName = "홍길동";
		
		Object myClassObject = myClass; //오브젝트 클래스로 업캐스팅
		
		MyClass myClass2 = (MyClass) myClassObject; //다운캐스팅
		
		//에러발생
		//JavaBasic02 myClass3 = (JavaBasic02) myClassObject;
		
		System.out.println(myClass2.myName);
		
	}

}