N'Che는 초보개발자

init () 메소드를 호출하여 초기화.

service () 메소드를 호출 하여 클라이언트의 요청을 처리.

(init 메소드는 처음 한번만 실행되고 이후 service()가 처리.)

destroy () 메소드를 호출하여 종료.

JVM의 가비지 컬렉터에 의해 가비지 수집.

ActionForward 클래스 통해 생성된 객체 내부 //redirect/forward 결정 경로세팅역할 
주소값: ~~ 
private boolean isRedirect=false; // true: Redirect 또는 false: forward(주소창의경로그대로,실제내용은forward경로의내용) 결정 
private String path=null; 

redirect > ?키=값으로 이루어진 데이터만 이동 가능하고, 주소가 변할 경우에 데이터가 사라진다.

forward > redirect보다 대용량의 데이터를 제어할 수 있음

BoardAddAction

ActionForward 클래스 통해 생성된 객체 내부 //redirect/forward 결정 경로세팅역할

주소값: ~~

private boolean isRedirect=true;

// true: Redirect 또는 false: forward(주소창의경로그대로,실제내용은forward경로의내용) 결정

private String path="./BoardList.bo";

expression language jhtml

oracle model2 분석

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);
		
	}

}

package kr.or.ksmart;

class UserDto{
	private String userName;
	private String userEmail;
	private String userPw;
	private String userTel;
	private String userAdd;
	private String compName;
	private String compTel;
	private String userLevel;
	
	public String getUserLevel() {
		return userLevel;
	}
	public void setUserLevel(String userLevel) {
		this.userLevel = userLevel;
	}
	public String getUserName() {
		return userName;
	}
	public void setUserName(String userName) {
		this.userName = userName;
	}
	public String getUserEmail() {
		return userEmail;
	}
	public void setUserEmail(String userEmail) {
		this.userEmail = userEmail;
	}
	public String getUserPw() {
		return userPw;
	}
	public void setUserPw(String userPw) {
		this.userPw = userPw;
	}
	public String getUserTel() {
		return userTel;
	}
	public void setUserTel(String userTel) {
		this.userTel = userTel;
	}
	public String getUserAdd() {
		return userAdd;
	}
	public void setUserAdd(String userAdd) {
		this.userAdd = userAdd;
	}
	public String getCompName() {
		return compName;
	}
	public void setCompName(String compName) {
		this.compName = compName;
	}
	public String getCompTel() {
		return compTel;
	}
	public void setCompTel(String compTel) {
		this.compTel = compTel;
	}
	
}

class UserService{ //dao와 연결
	/**
	 * 회원등록 메서드
	 * @param userDto
	 * @return 
	 */
	public int userAddProcess(UserDto userDto) {
		//기업 관련 데이터가 있을 경우 레벨을 기업회원으로 설정
		String userLevel = null;
		if ( userDto != null) {
			if(	!"".equals(userDto.getCompName()) && "".equals(userDto.getCompTel()) ) {
				userLevel = "기업회원";
			} else {
				userLevel = "일반회원";
			}
		}
		userDto.setUserLevel(userLevel);
		
		UserDao userDao = new UserDao();
		return userDao.userAddProcess(userDto); 
	}
}

class UserDao{ //db연결
	/**
	 * 회원등록 메서드
	 * @param userDto
	 * @return
	 */
	public int userAddProcess(UserDto userDto) {
		//dao에서 userDto값 콘솔에 출력하시오.
		int result = 0;
		if(userDto != null) {
			if(userDto.getUserName() != "" && userDto.getUserEmail() != "" 
					&& userDto.getUserPw() != "" && userDto.getUserTel() != "" 
					&& userDto.getUserAdd() != "" && userDto.getUserLevel() != ""){
			System.out.println(userDto.getUserName());
			System.out.println(userDto.getUserEmail());
			System.out.println(userDto.getUserPw());
			System.out.println(userDto.getUserTel());
			System.out.println(userDto.getUserAdd());
			System.out.println(userDto.getUserLevel());
			System.out.println(userDto.getCompName());
			System.out.println(userDto.getCompTel());
			result = 1;
			}
		}
		return result; //db에 정상 등록 완료 이후에는 1 이상이 리턴되어야 함
	}
}

public class JavaBasicEx01 {

	public static void main(String[] args) {
		/*
		 * 실습1. 회원가입 한다는 가정을 두고 아래의 조건에 맞는 클래스를 선언하고 호출하여라
		 * 1) 콘트롤러, 서비스, dao, dto 존재
		 * 2) 콘트롤러에서 파라미터를 받아 dao를 통해 db에 데이터 등록
		 * 3) db에 데이터 등록 전에 서비스 단에서 회원 레벨 설정
		 * 4) 회원 레벨은 기업회원 관련 데이터가 있으면 기업회원으로 없으면 일반회원으로
		 * 5) 콘트롤러 > 서비스 > dao 호출하여 실행 결과값을 리턴 받아야 함
		 * 6) 콘트롤러에서 결과값을 받아 등록 완료 되었을 경우 '완료' 메세지 출력 실패시 '실패' 메세지 출력 
		 * 7) 파라미터 정의
		 * 		- 회원명, 이메일, 패스워드, 회원휴대전화번호, 주소, 기업명, 기업전화번호
		 * 		- 파라미터명 : userName, userEmail, userPw, userTel, userAdd, compName, compTel
		 */
		
		String userName = "홍길동";
		String userEmail="aaa@aaa";
		String userPw = "pw001";
		String userTel = "010-001-0011";
		String userAdd = "전라북도";
		String compName = "한국스마트정보교육원";
		String compTel = "063-717-1008";
		
		UserDto userDto = new UserDto();
		userDto.setUserName(userName);
		userDto.setUserEmail(userEmail);
		userDto.setUserPw(userPw);
		userDto.setUserTel(userTel);
		userDto.setUserAdd(userAdd);
		userDto.setCompName(compName);
		userDto.setCompTel(compTel);
		
		
		UserService userService = new UserService();
		int result = userService.userAddProcess(userDto);
		if (result > 0) {
			System.out.println("=====등록완료=====");
		} else {
			System.out.println("=====등록실패=====");
		}		
	}

}

생성자 / 오버로딩

package kr.or.ksmart;

import java.io.File;

class User{
	
	private String name;
	private String age;
	
	public void setUserInfo(String name) {
		this.name = name;
	}
	public void setUserInfo(String name, String age) {
		this.name = name;
		this.age = age;
	}
	public String getName() {
		return name;
	}
	public String getAge() {
		return age;
	}
}

class UserInfoService{
	public int userAddProcess(User user) {
		System.out.println("userAddProcess 호출");
		return 1;
	}
	public int userAddProcess(User user, File file) {
		int result = userAddProcess(user);
		if(result > 0 ) {
			//파일처리
			System.out.println("userAddProcess 오버로딩 호출");
		}
		return result;
	}
}

public class JavaBasic01 {

	public static void main(String[] args) {
		/**
		 * 메서드 오버로딩
		 * 동일한 매서드명으로 메서드 선언이 가능하다.
		 * 단 인수 타입, 인수 개수가 달라야 한다.
		 * 
		 * 주의점
		 * 메서드의 리턴타입으로 메서드 오버로딩을 할 수 없다.
		 * 메서드의 인수명으로 메서드 오버로딩을 할 수 없다.
		 */
		
		User user = new User();
		user.setUserInfo("홍길동", "20");
		File file = null ; 
		
		UserInfoService service = new UserInfoService();
		//service.userAddProcess(user);
		service.userAddProcess(user, file);
	}
}

package kr.or.ksmart;
class Sum {

	private int sum;
		
	public Sum(int num1, int num2) {
		this.sum = num1 + num2;
	}
		
	int getSum() {
		return sum;
	}
}
public class JavaBasicEx02 {

	public static void main(String[] args) {
		/*
		 * 실습2.
		 * Sum 클래스를 인스턴스화 할 때 int형 데이터 인수 2개를 넘겨 인스턴스화 하고 getSum() 메서드로 합산 결과를 받아 출력하시오.
		 */
		Sum sum = new Sum(10,90);
		int result = sum.getSum();
		System.out.println(result);
	}

}

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 CreateCar{
	private Car car;
	public CreateCar(Car car) {
		this.car = car;
	}
	public void setNum ( int num) {
		car.setNum(num);
	}
	public void setGas (int gas) {
		car.setGas(gas);
	}
	public Car getCar() {
		return car;
	}
}


public class JavaBasic03 {

	public static void main(String[] args) {	
		CreateCar createCar = new CreateCar(new Car());
		createCar.setNum(1000);
		createCar.setGas(100);
		Car car = createCar.getCar();
		System.out.println(car.getNum());
		System.out.println(car.getGas());
	}

}

package kr.or.ksmart;

class Ex01 {
	public static int count = 0;
	public int num;
	
	Ex01(){
		count++;
		num++;
	}
	public static void exCall() {
		//System.out.println(num);
		System.out.println(count + " (exCall 합산 결과 값)");
	}
}

public class JavaBasic04 {

	public static void main(String[] args) {
		/*
		 * 클래스 변수, 클래스 메서드
		 * 
		 * 데이터 혹은 메서드를 공유하는 변수 혹은 메서드
		 * static이라는 키워드가 붙는다.
		 */
		
		Ex01 ex01 = new Ex01();
		System.out.println("count : " + ex01.count);
		System.out.println("num : " + ex01.num);
		Ex01 ex02 = new Ex01();
		System.out.println("count : " + ex02.count);
		System.out.println("num : " + ex02.num);
		Ex01 ex03 = new Ex01();
		System.out.println("count : " + ex03.count);
		System.out.println("num : " + ex03.num);
		Ex01 ex04 = new Ex01();
		System.out.println("count : " + ex04.count);
		System.out.println("num : " + ex04.num);
		
		Ex01.exCall();
	}

}

package kr.or.ksmart;

class MemberDto{
	private String userName;
	private String userAge;
	private String userEmail;
	private String userTel;
	
	public String getUserName() {
		return userName;
	}
	public void setUserName(String userName) {
		this.userName = userName;
	}
	public String getUserAge() {
		return userAge;
	}
	public void setUserAge(String userAge) {
		this.userAge = userAge;
	}
	public String getUserEmail() {
		return userEmail;
	}
	public void setUserEmail(String userEmail) {
		this.userEmail = userEmail;
	}
	public String getUserTel() {
		return userTel;
	}
	public void setUserTel(String userTel) {
		this.userTel = userTel;
	}	
}
class MemberService{
	public int memberJoinPorcess(MemberDto memberDto) {
		MemberDao mDao = new MemberDao();
		return mDao.memberJoinPorcess(memberDto);
	}
}
class MemberDao{
	public int memberJoinPorcess(MemberDto memberDto) {
		System.out.println(memberDto.getUserName());
		System.out.println(memberDto.getUserAge());
		System.out.println(memberDto.getUserEmail());
		System.out.println(memberDto.getUserTel());
		return 1;
	}
}

public class JavaBasicEx07 {

	public static void main(String[] args) {
		/*
		 * 실습8. 회원가입을 한다는 가정하에. 다음의 클래스를 생성하고
		 * 각각 controller > service > dao 순으로 객체 전달하도록 하여라.
		 * 가정 
		 * controller > main 메서드
		 * service > MemberService 클래스 생성 > db에 등록이 완료되었을 경우 리턴값 1
		 * dao > MemberDao 클래스 생성 > db에 등록이 완료되었을 경우 리턴값 1
		 * dto > MemberDto 클래스 생성 
		 * 
		 * 콘트롤러에 넘어온 파라미터 
		 * userName : '홍길동', userAge : 20 , userEmail : 'user@nave.com',
		 * userTel : '010-0000-0000'
		 * */
		String userName = "홍길동";
		String userAge = "20";
		String userEmail = "user@nave.com";
		String userTel = "010-0000-0000";
		
		//서비스단 호출하여 결과값을 출력하여라.
		//1. dto 객체 생성 > 서비스 호출 > dao 호출 > 결과값 리턴
		
		MemberDto mdto = new MemberDto();
		mdto.setUserName(userName);
		mdto.setUserAge(userAge);
		mdto.setUserEmail(userEmail);
		mdto.setUserTel(userTel);
		
		MemberService mService = new MemberService();
		int result = mService.memberJoinPorcess(mdto);
		System.out.println("db 등록 결과값 : " + result);

	}

}

Casting

package kr.or.ksmart;

public class JavaBasic01 {

	public static void main(String[] args) {
		/*
		 * 형변환 (케스팅)
		 * 다른 자료형(데이타형)으로 변환할때 
		 */
		
		int inum = 160; 
		double dnum = inum; //명시적으로 형변환
		
		System.out.println(inum + " -- " + dnum);
		
		//큰 데이타 형에서 작은형 데이타로 변환시 케스팅 연산자를 활용해야하며
		//변환될 데이타형의 크기를 넘어서는 안된다.
		int inum2 = (int) dnum; //케스팅연산자를 활용하여 형변환
		
		System.out.println(dnum + " -- " + inum2);
		
		/*
		 * 다른 데이타형끼리 연산하기
		 * - 다른 데이타 형끼리 연산시 큰형으로 변환 후 연산이 된다.
		 * */
		int inum3 = 10;
		double dnum2 = 5.2;
		System.out.println("다른형끼리 연산 ->" + inum3 + dnum2);
		//연산을 할 경우 연산자 우선 순위를 기억하여 코드 작성
		System.out.println("다른형끼리 연산 ->" + (inum3 * dnum2));
		
	}

}

package kr.or.ksmart;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class JavaBasicEx01 {

	public static void main(String[] args) throws IOException {
		/*
		 * 실습1. 키보드(표준입력장치)로 다섯과목의 점수를 받아
		 * 합계와 평균을 구하시오.
		 * 50,68,75,83,36
		 * */
		
		//System.in -> 표준입력장치(키보드)
		InputStreamReader reder = new InputStreamReader(System.in);
		//키보드 입력을 임시적으로 저장할 공간 선언
		BufferedReader br = new BufferedReader(reder);
		
		System.out.println("과목 1~5의 점수를 정수로 입력하십시오.");
		
		double sum = 0;
		for(int i=0; i < 5; i++) {
			String line = br.readLine();
			if(line != null && !"".equals(line.trim())) {				
				sum += Double.parseDouble(line);
			}
		}
		int sum2 = (int) sum;
		//double을  int로 케스팅한 결과
		System.out.println("점수 합산 : " + sum2);
		//double과 int 연산임으로 결과값은 double
		System.out.println("점수 평균 : " + (sum / 5));

	}

}

Array

package kr.or.ksmart;

public class JavaBasic02 {
	
	public static void main(String[] args) {
		/*
		 * 배열
		 * 메모리 공간에 여러개의 값을 저장하는 객체
		 * 배열선언방법
		 * 
		 * 기본형
		 * 데이타형[] 변수명 = new 데이타형[배열크기]; 
		 * 데이타형[] 변수명 = new 데이타형[]{"데이타"};
		 * */
		
		//데이타형은 객체(클래스)로 선언가능하다.
		int[] numArray = new int[5];
		String[] strArray = new String[5];
		
		//배열에 값 대입하기
		//배열의 요소를 인덱스로 접근하여 값을 대입한다.
		//배열의 크기를 넘어서는 인덱스로 접근하여 값을 대입할 수 없다.
		numArray[0] = 1;
		numArray[1] = 2;
		numArray[2] = 3;
		numArray[3] = 4;
		numArray[4] = 5;
		//에러 강제 발생
		//numArray[5] = 6;
		
		for(int i=0; i < numArray.length; i++) {
			System.out.println(numArray[i] + " --> 인덱스" + i);
		}
		
	}
	
}

package kr.or.ksmart;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class JavaBasicEx02 {

	public static void main(String[] args) throws IOException {
		/*
		 * 실습1. 키보드(표준입력장치)로 다섯과목의 점수를 받아
		 * 합계와 평균을 구하시오.(아래의 구문 다 출력 / 배열활용)
		 * 
		 * 학생의 점수를 받아 평균값과 합산값을 출력시키시오.
		 * 50
		 * 68
		 * 75
		 * 83
		 * 36
		 * 학생점수의 합산값 : 
		 * 학생점수의 평균값 :
		 * */
		
		//System.in -> 표준입력장치(키보드)
		InputStreamReader reder = new InputStreamReader(System.in);
		BufferedReader br = new BufferedReader(reder);
		
		System.out.println("학생의 점수를 받아 평균값과 합산값을 출력시키시오.");
		
		double[] numArray = new double[5];
		
		for(int i=0; i < numArray.length; i++) {
			String line = br.readLine();
			if(line != null && !"".equals(line.trim())) {
				numArray[i] = Double.parseDouble(line);
			}
		}
		
		double sum = 0;
		for(int i=0; i < numArray.length; i++) {
			sum += numArray[i];
		}
		int num = (int) sum;
		System.out.println("학생점수의 합산값 : "+ num);
		System.out.println("학생점수의 평균값 : "+ (sum / numArray.length));
		
		
	}

}

package kr.or.ksmart;

public class JavaBasicEx03 {

	public static void main(String[] args) {
		/*
		 * 실습3. 아래의 배열이 있다. 배열의 값 중 최댓값과 최소값을 구하여 출력하여라.
		 * */
		
		int[] numArray = new int[] {25,5,10,37,35};
		int min = numArray[0];
		int max = numArray[0];
		
		for(int i=0; i < numArray.length; i++) {
			if(min > numArray[i]) {
				min = numArray[i];
			}
			if(max < numArray[i]) {
				max = numArray[i];
			}
		}
		
		System.out.println("최소값 : " + min);
		System.out.println("최댓값 : " + max);
		

	}

}

Class Basic

package kr.or.ksmart;

/*
 * 클래스 선언하기
 * - 클래스키워드와 함께 클래스명을 지정
 * - 접근지정자 지정
 * - 필드와 메서드를 같는다.
 * 
 * 1.접근지정자
 * - public : 전 패키지내에 접근가능
 * - protected : 해당 패키지 내에서 접근가능
 * - private : 해당 클래스에서 접근가능
 * - default : 접근 지정자가 명시 안되어 있는 클래스나 메서드를 말하며, protected와 동일
 * */
public class JavaBasic03 {
	
	//필드는 접근지정자와 데이타형 변수명으로 변수를 선언가능
	//접근지정자 데이타형 변수명;
	//필드는 주로 private으로 선언하여 캡슐화를 한다.
	//캡슐화 : 데이타 은닉
	private String name;
	
	public void test() {
		//메서드는 접근지정자, 리턴타입, 메서드명으로 이루어진다.
		//매개변수를 받거나 생략할수 있다.
		//명시된 리턴타입에 맞춰 해당 데이타형을 리턴해줘야한다.
		
		//메서드 내에서 this키워드로 활용하여 자신의 클래스에 해당되는 
		//필드 혹은 메서드 접근이 가능하다.
		
		this.name = "홍길동";
	}
	
	public static void main(String[] args) {
		JavaBasic03 javabasic = new JavaBasic03();
		javabasic.test();
	}

}

package kr.or.ksmart;

class Member{
	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 JavaBasicEx04 {

	public static void main(String[] args) {
		String[][] memberInfo = new String[][] {
			{"홍길동","20"},
			{"이순신","21"},
			{"고길동","25"}
		};
		//다차원배열 값 접근하기
		//System.out.println(memberInfo[0][0]);
		
		Member[] memberInfoArray = new Member[memberInfo.length];
		
		/*
		 * 실습4. 위의 회원의 정보가 담긴 다차원 배열이 있다.
		 * memberInfoArray의 객체(Member) 배열에 회원정보를 담아라.
		 * 순서 : memberInfo 반복문 > Member 인스턴스화 > memberInfoArray에 담기
		 */
		
		for(int i=0; i < memberInfo.length; i++) {
			String[] member = memberInfo[i];
			String name = member[0];
			String age = member[1];
			System.out.println(name + " -- " + age);
			
			Member memberClass = new Member();
			memberClass.setName(name);
			memberClass.setAge(age);
			
			memberInfoArray[i] = memberClass;			
		}
		for(int i=0; i < memberInfoArray.length; i++) {
			Member memberClass = memberInfoArray[i];
			System.out.println("memberInfoArray > " + memberClass.getName());
			System.out.println("memberInfoArray > " + memberClass.getAge());
		}
		
	}

}

package kr.or.ksmart;

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

class Score{
	private int avg;
	private int totalScore;
	
	public int getAvg() {
		return avg;
	}
	public void setAvg(int avg) {
		this.avg = avg;
	}
	public int getTotalScore() {
		return totalScore;
	}
	public void setTotalScore(int totalScore) {
		this.totalScore = totalScore;
	}	
}

class MemberScore{
	private Score score;
	public void setScoreList(List<Integer> scoreList) {
		if(scoreList != null) {
			this.score = new Score();
			int totalScore = 0;
			int avg = 0;
			for(int i=0; i < scoreList.size(); i++) {
				totalScore += scoreList.get(i);
			}
			if(totalScore != 0) {				
				avg = totalScore / scoreList.size();
			}
			score.setAvg(avg);
			score.setTotalScore(totalScore);
		}
	}
	public Score getScore() {
		return score;
	}
}


public class JavaBasic05 {

	public static void main(String[] args) {
		
		List<Integer> scoreList = new ArrayList<Integer>();
		scoreList.add(10);
		scoreList.add(20);
		scoreList.add(30);
		
		MemberScore ms = new MemberScore();
		ms.setScoreList(scoreList);
		
		Score score = ms.getScore();
		System.out.println(score.getAvg() + " << Avg");
		System.out.println(score.getTotalScore() + " << TotalScore");

	}

}

package kr.or.ksmart;

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

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

public class JavaBasicEx05 {
	public static void main(String[] args) {
		/*
		 * 실습5. 아래의 회원 정보가 있다.
		 * 회원정보를 MemberInfo 객체에 담고 memberInfoList에 
		 * 저장한 후 결과값을 출력하여라.
		 * 회원정보 : 홍길동, 고길동, 이순신
		 * */
		List<MemberInfo> memberInfoList = new ArrayList<MemberInfo>();
		
		MemberInfo memberInfo = null;
		
		memberInfo = new MemberInfo();
		memberInfo.setName("홍길동");
		memberInfoList.add(memberInfo);
		
		memberInfo = new MemberInfo();
		memberInfo.setName("고길동");
		memberInfoList.add(memberInfo);
		
		memberInfo = new MemberInfo();
		memberInfo.setName("이순신");
		memberInfoList.add(memberInfo);
		
		for(int i=0; i < memberInfoList.size(); i++) {
			MemberInfo m = memberInfoList.get(i);
			System.out.println(m.getName());
		}
		
		
	}
}

package kr.or.ksmart;

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

class ACalculator{
	private int sum;
	public int sum(int n1, int n2) {
		this.sum = n1 + n2;
		return sum;
	}
	public int getSum() {
		return sum;
	}
}

public class JavaBasicEx06 {
	
	public static void main(String[] args) {
		/*
		 * 실습6. ACalculator 클래스를 생성하고 계산을 할 수있는 메서드를
		 * 만들어 계산을 하고 그 결과값을 반환하시오.
		 * 연산 10 + 20
		 * */		
		ACalculator cal = new ACalculator();
		System.out.println(cal.sum(10, 20));
		
		/*
		 * 실습7. ACalculator 클래스를 생성하고 계산을 할 수있는 메서드를
		 * 만들고 아래의 연산을 처리 후에 처리한 내용을 list 객체에 담아라
		 * 연산 10 + 20, 20 + 50, 30 + 40
		 * */
		List<ACalculator> list = new ArrayList<ACalculator>();
		
		ACalculator cal2 = null;
		cal2 = new ACalculator();
		cal2.sum(10, 20);
		list.add(cal2);
		
		cal2 = new ACalculator();
		cal2.sum(20, 50);
		list.add(cal2);
		
		cal2 = new ACalculator();
		cal2.sum(30, 40);
		list.add(cal2);
		
		for(int i=0; i < list.size(); i++) {
			ACalculator acal = list.get(i);
			System.out.println(acal.getSum());
		}
		
	}
}

https://programmers.co.kr/learn/courses/17/lessons/805

https://wayhome25.github.io/cs/2017/04/17/cs-18-1/ 

https://milhouse93.tistory.com/64

https://allg.tistory.com/26