매료매료의 개발 이야기

<클래스 - 형식, 포함멤버>
- 접근제한자 지정예약어 <class 클래스명> extends 상위클래스, 추상클래스
										implements 상위인터페이스들{
                                        }

package Week01;

import java.util.Scanner;

//일반화 객체
class Person{
	void Person(String name, String gen){
		System.out.println("Person 이름 = " + name);
		System.out.println("Person 성별 = " + gen);
	}
}

class Animal{
	void Animal(String name, String gen) {
		System.out.println("Animal 이름 = " + name);
		System.out.println("Animal 성별 = " + gen);
	}
}

//추상화 객체
abstract class Person1{
	abstract void Person1();
}
class Animal1 extends Person1{
	String pername, pergen, aniname, anigen;

	@Override
	void Person1() {
		System.out.println("Person 이름 = " + pername);
		System.out.println("Person 성별 = " + pergen);
		System.out.println("Animal 이름 = " + aniname);
		System.out.println("Animal 성별 = " + anigen);
	}
}

public class 실습1일차 {

	
	public static void main(String[] args) {
		
		/*실습1 : 일반화, 추상화
		 *1. 일반화 객체 : Person, Animal
		 *2. 추상화 객체 : Person, Animal의 추상화 객체
		 *추상화는 인터페이스 기반으로 쓰임. 많이 연습해야함. 추상화 -> 디자인패턴
		 *
		 *1. Person
		 *-속성 : 이름, 성별, 거주지, 직업, 키
		 *-메소드 : 말하다(추), 자다, 먹다, 출근하다, 퇴근하다.
		 *추상메소드면 반드시 자식메소드가 재정의 해야함.
		 *2. Animal
		 *- 속성 : 이름, 성별, 몸무게, 길이, 너비
		 *- 메소드 : 짖다, 뛰다, 울다, 먹다, 자다
		 *3. Person 추상화 : 인종, 국가, 종교, 취미   
		 *4. Animal 추상화 : 품종, 먹이, 서식지    
		 */
		//일반화객체
		String name, gen;
		Person per = new Person();
		Animal ani = new Animal();
		per.Person("홍길동", "남자");
		ani.Animal("개똥이", "암컷");
		
		//추상화객체
		Animal1 ani1 = new Animal1();
		ani1.Person1();
		
		/*실습2. 급여계산하기
		 * 입력 : 기본급, 직책(사원/대리/과장/부장)
		 * 출력 : 실수령액 = xxx원
		 * -계산식은 다음과 같다
		 * 실수령액 = 기본급 + 직책수당 -세금
		 * 세금 = 기본급의 10%
		 * -직책수당표(사원, 대리는 0)
		 * 과장 : 200,000
		 * 부장 : 500,000
		 */
		int mon;
		double sal = 0;
		String lev;
		Scanner sc = new Scanner(System.in);
		System.out.println("기본급을 입력하세요.");
		mon = sc.nextInt();
		System.out.println("직책을 입력하세요.");
		lev = sc.next();
		switch(lev) {
			case("사원"):
				sal = mon - mon*0.1;
				break;
			case("대리"):
				sal = mon - mon*0.1;
				break;
			case("과장"):
				sal = mon + 200000 - mon*0.1;
				break;
			case("부장"):
				sal = mon + 500000 - mon*0.1;
				break;
		}
		System.out.println("실수령액 = " + sal + "원입니다.");
		
		/*실습3. 사칙연산
		 * -입력
		 * A값 :
		 * B값 :
		 * 연산자(+, -, *, /)
		 * -출력
		 * 결과 = xxx
		 * -오류처리
		 * 연산자에 +,-,*,/ 이외의 값이 입력시 아래 메세지를 출력한다.
		 * "잘못된 연산자를 입력하였습니다."
		 */
		double a, b, d;
		String c;
		Scanner sc = new Scanner(System.in);
		System.out.println("A의 값을 입력하세요.");
		a = sc.nextDouble();
		System.out.println("B의 값을 입력하세요.");
		b = sc.nextDouble();
			while(true) {
				System.out.println("연산자를 입력하세요.");
				c = sc.next();
				if(c.equals("+")) {
					d = a + b;
					System.out.println("결과 = " + d);
					break;
				}
				else if(c.equals("-")) {
					d = a - b;
					System.out.println("결과 = " + d);
					break;
				}
				else if(c.equals("*")) {
					d = a * b;
					System.out.println("결과 = " + d);
					break;
				}
				else if(c.equals("/")) {
					d = a / b;
					System.out.println("결과 = " + d);
					break;
				}
				else 
					System.out.println("잘못된 연산자를 입력하셨습니다.");
			}

	}

}
---------------------------------------------------------------------
<클래스 - 생성자>
1. 형식
	접근제한자 클래스명(매개변수들) throws 예외처리클래스들{
    	멤버필드 초기화 작업
    }
2. 생성자는 오브젝트 생성시 한번만 수행
3. new 키워드를 사용해서 자동적으로 호출되어 실행되는 특수한 메소드
4. 작성규칙
- 클래스명과 동일. 리턴값을 가지지 않는다.
- 객체가 생성될 때 반드시 하나의 생성자가 호출
- default생성자 : 매개변수도 없고 내용부도 없는 생성자
- 생성자들이 여러개 있을 수 있다(생성자 오버로딩)
- 생성자의 첫번째 라인(필수)으로 this 생성자를 사용하여 또 다른 생성자 하나를 호출할 수 있다.

package Week01;

class ConstructorTest {
	int a, b, c, d, e, f, g;
	ConstructorTest(){
		a=1; b=2; c=3; d=4; e=5; f=6; g=7;
	}
	
	ConstructorTest(int x){
		this(); // 생성자에서 다른 생성자 호출(생성자안에서만 가능)
		d = x;
		//this(); => ERROR, 생성자 안에서 다른 생성자를 호출하려면 첫번째 라인에서 호출해야한다.
		System.out.println(a);
		System.out.println(b);
		System.out.println(c);
		System.out.println(d);
		System.out.println(e);
		System.out.println(f);
		System.out.println(g);
	}
	
	ConstructorTest(int x, int y){
		this(x);
		e = y;
	}

	public static void main(String[] args) {
		ConstructorTest rEx = new ConstructorTest(); // 값을 무엇을 넣느냐에 따라 달라짐.

	}

}
---------------------------------------------------------------------------
<클래스 - this>
1. 자기자신을 참조하는 객체
2. static 메소드가 아니라면 0번째 매개변수로 자신을 참조하는 this가 있다고 보면 됨.

package Week01;

public class ThisSample {
	private int x;
	private static int y;
	
	//public void aaa(ThisSample this){
	public void aaa() {
		this.x = 10;
		ThisSample.y = 20;
	}
	
	// public void bbb(ThisSample this, int x, int y){
	public void bbb(int x, int y) {
		this.x = x; //멤버변수에 파라미터 변수정보를 대입
		ThisSample.y = y;
	}
	
	//public static void ccc(){ //static 에는 this 가 없다.(인스턴스가 존재하지 않는상황에서 this를 쓰는 의미가 없다.)
	public static void ccc() {
		//this.x ERROR
		ThisSample.y = 10;
	}

}
---------------------------------------------------------------------------
<클래스 - super>
1. 자신의 상위클래스를 지칭할 때 사용하는 예약어
2. 상위클래스의 생성자를 호출
3. 상위클래스의 메소드, 변수에 접근(상속된 것에만 가능)

package Week01;

class Employee{
	/*
	 Employee(){ // 생략시 자동으로 기본형이 생성된다. Employee(){}, java.lang.Object 생성
	 System.out.println("나는 부모 Constructor");
	 }
	 */
	
	Employee(int a){// 생략시 자동으로 기본형이 생성된다. Employee(){}, java.lang.Object 생성
		System.out.println("나는 부모 Constructor");
	}
}

class Manager extends Employee{
	Manager(){
		super(1); //생략시 자동으로 생성된다. (클래스들에서의 생성자 초기화는 각자함. -> employee 따로 manager 따로)
		//super();
		System.out.println("나는 자식 Constructor");
	}
}

public class TestSuper {

	public static void main(String[] args) {
		Manager m = new Manager(); //constructor 라인 호출
	}

}
---------------------------------------------------------------------------
<클래스 - 접근제한자>
1. private : 자신의 클래스 내부에서만 사용, 업무에서 많이 쓰임.
2. package : 동일한 파일, 패키지간에서만 사용
3. protected : 하위 클래스 그리고 동일한 파일 내부 그리고 동일한 폴더에서만 사용
4. public : 어디에서든 사용 가능

package Week01.president;

import Week01.prince.Hyunchul;

public class Daujung {
	private int a = 70;
	int b = 70;
	protected int c = 70;
	public int d = 70;

	public static void main(String[] args) {
		Daujung dj = new Daujung();
		System.out.println(dj.a);
		System.out.println(dj.b);
		System.out.println(dj.c);
		System.out.println(dj.d);
		dj.test();
		dj.test2();
		
		Youngsam ys = new Youngsam(); // 같은 패키지에 있는 클래스
		System.out.println(ys.b);
		System.out.println(ys.c);
		System.out.println(ys.d);
		
		Hyunchul h = new Hyunchul(); // 다른 패키지 -> dd만 호출됨.
		System.out.println(h.c);
		System.out.println(h.d);
		System.out.println(h.dd);
	}
	
	public static void test() {}
	public void test2() {}

}

package Week01.prince;

import Week01.president.Daujung;
import Week01.president.Youngsam;

public class Hyunchul extends Youngsam {
	
	private int aa = 70;
	int bb = 70;
	protected int cc = 70;
	public int dd = 70;

	public static void main(String[] args) {
		Hyunchul hc = new Hyunchul(); // 상속받은 클래스
		System.out.println(hc.c);
		System.out.println(hc.d);
		
		Daujung dj = new Daujung(); // 관계없는 클래스
		System.out.println(dj.d);

	}

}

package Week01.president;

public class Youngsam {
	private int a = 70; // priavte -> 상속불가
	int b = 70; // 상속불가
	protected int c = 70; // protected -> 상속가능
	public int d = 70; // public -> 상속가능

}
---------------------------------------------------------------------------
<클래스 - 멤버필드와 멤버 메서드>
1. 필드_형식
접근제한자 [ 지정예약어 ]
ex) public static final double pi = 3.14;

2. 필드에 대한 지정예약어
- static : 모든 객체가 공유하는 필드
- final : 변경하지 못하는 필드
- trasient : 임시 메모리 필드

3. 메소드_형식
- 접근제한자 [지정예약어]
ex) private static void main(String[] arg) throws IOExecption{}

4. 메소드에 대한 지정예약어
- static : static 메소드 내부에는 static 필드나 static 메소드만 올 수 있다.
- final : Overriding을 할 수 없다
- static final : 혼합형태
- abstract : 내용부 정의가 없는 추상 메소드 선언할 때. 메소드는 반드시 overriding되어야 한다.
---------------------------------------------------------------------------
<static>
1. static 필드 : 모든 객체가 공유
2. 생성자에서 초기화 할수 없다.
3. 응용프로그램 실행순서 : static -> main() -> 생성자() -> finalize()
4. static 메소드 : static 필드를 처리하기 위한 메소드

package Week01;

public class StaticTest {
	private static int x; //static은 생성자에서 초기화할수없다.
	
	static {
		System.out.println("Static.."); //static 필드의 초기화
		x=0;
	}
	
	public void Test() {
		System.out.println("Test...");
	}
	public StaticTest(String arg) {
		System.out.println("생성자" + arg);
	}

	public static void main(String[] args) {
		System.out.println("Main..");
		StaticTest st = new StaticTest("1");
		StaticTest st2 = new StaticTest("2");
		StaticTest st3 = new StaticTest("3");

	}

}
<final>
1. final필드 : 상수변수를 지정, 지역변수로 사용할 수 없다.
2. final메소드 : final 메소드를 재정의 할 수 없게 해줌
3. final클래스 : 상속자체를 못하게 막음.
4. abstract 와 함께 사용불가(abstract : 반드시 상속을 해야 사용)
---------------------------------------------------------------------------
<is a / has a 관계>
1. is a : 오브젝트간에 존재하는 논리적인 포함관계(ex.특별회원도 회원이다)
2. has a : 오브젝트간에 존재하는 물리적인 포함관계(ex. 회원은 비디오테이프를 빌려가서 보관한다.)

---------------------------------------------------------------------------
<상속>
1. is a 관계
2. overriding : 매소드를 하위클래스에서 재정의
3. overriding규칙
- 메소드 이름, 파라미터개수, 데이터형, 리턴형 같아야함
- 상위메소드와 동일하거나 더 구체적인 Exception을 발생시켜야
- 상위메소드와 동일하거나 접근 범위가 넓은 접근 제한자를 사용해야함.

package Week01.inherit;

class A{
	private int x = 100;
	private int y = 200;
}

class B extends A{
	private int r = 300;
}

public class InheritTest1 {

	public static void main(String[] args) {
		B bp = new B(); //아무런 멤버에 접근 할 수 없다.

	}

}

package Week01.inherit;

class A1{
	protected int x = 100;
	protected void disp() {
	}
}

class B1 extends A1{
//	private int x = 200;
	public int x = 200;
	public int y = 100;
	public void disp() { // Overriding
		
		System.out.println("A1 클래스의 x = " + super.x);
		System.out.println("B1 클래스의 x = " + this.x);
	}
	public void disp2(){}
}

public class InheritTest2 {

	public static void main(String[] args) {
		B1 bp = new B1(); //200
		System.out.println(bp.x); //100
		bp.disp(); //200
		
		A1 ap = new B1(); //100   부모는 자식인스턴스를 가리킬수 있으나, 자식은 부모인스턴스를 가리킬수 없음.
		System.out.println(ap.x); //100
		ap.disp(); //200

	}

}
---------------------------------------------------------------------------

package Week01;

public class OperatorEx2 {
	
	public static void main(String[] args) {
		
        //문자열 비교
		String str1 = "abc"; //우선 찾고, 없으면 생성.
		String str2 = new String("abc");
		
		System.out.println("abc"=="abc"); // true. 주소값이 같음.
		System.out.println(str1=="abc"); //true
		System.out.println(str2=="abc"); //false, 서로 다른 주소값
		System.out.println(str1.equals("abc")); //true
		System.out.println(str2.equals("abc")); //true
		System.out.println(str2.equals("ABC")); //false, 대소문자 구분
		System.out.println(str2.equalsIgnoreCase("ABC")); //true
	}
	

}
---------------------------------------------------------------------------
package Week01;

public class OperatorEx3 {

	public static void main(String[] args) {
		
		//논리연산자 : &&, || -> 앞쪽 항만으로 결과가 결정되면 뒤쪽항을 실행하지 않는다.
		// && : and
		// || : or
		int x = 15;
		System.out.println(10>x && x++<20); //false
		System.out.println("x="+x);// 15
		System.out.println(10<x || x++<20); //true
		System.out.println("x="+x); //15
		
		System.out.println(10>x & x++<20); //false
		System.out.println("x=" +x); //16
		System.out.println(10<x | x++<20); //true
		System.out.println("x=" +x); //17
		
		// 조건연산자 : 조건식 ? 식1 : 식2  ->많이 쓰임.
		// 참이면 식1, 거짓이면 식2 출력
		int y, z;
		int absX, absY, absZ;
		char signX, signY, signZ;
		
		x= 10;
		y=-5;
		z=0;
		
		absX = x>=0 ? x : -x; //x의 값이 음수이면 ,양수로 만든다.
		absY = y>=0 ? y : -y;
		absZ = z>=0 ? z : -z;

	}

}

---------------------------------------------------------------------------

package Week01.state;

//swtich 문 : 기능이 변경되더라도 소스는 변경되면 안됨.
public class Employee {
	public static final int ENGINEER = 1;
	public static final int MANAGER = 2;
	public static final int SALESMAN = 3;
	
	private int type;
	public void setType(int type) {
		this.type = type;
	}
	
	public Employee(int type) {
		setType(type);
	}
	
	public int getAmount() {
		switch(type){
			case ENGINEER:
				return 100;
			case MANAGER:
				return 100;
			case SALESMAN:
				return 100;
		}
		return 0;
	}

}


package Week01.state;

//state 패턴 : 기능이 추가되도 객체만 추가하면 됨.

//객체를 던지는 부분
interface EmployeeType{ // 인터페이스 1개 박아놓는 개념. 프로토콜개념.(규칙)
	public int getAmount(); //abstract가 생략된 거다.(인터페이스포함 멤버 메서드는 무조건 public abstract)
}

class Engineer implements EmployeeType{
	public int getAmount() {
		return 100;
	}
}

class Manager implements EmployeeType{
	public int getAmount() {
		return 200;
	}
}

class Salesman implements EmployeeType{
	public int getAmount() {
		return 300;
	}
}

//객체를 받는 부분
public class Employee2 {
	private EmployeeType type; //멤버변수
	
	public Employee2(EmployeeType type) { //인터페이스도 상속처럼 받을 수있다. 상속은 가진게 많은 부모. 인터페이스는 가진게 없는 부모.
		setType(type);
	}
	
	public void setType(EmployeeType type) {
		this.type = type;
	}
	
	public void getAmount() {
		type.getAmount();
	}
	
	//메소드 수정해보기.
//	public static void main(String[] args) {
//		Employee2 et = new Employee2(); 
//		et.getAmount();
//	}

}
---------------------------------------------------------------------------

package Week01;

public class InnerEx1 {
	int m = 0;
	class InstanceInner{
		int iv = 100;
		int t = m; //Outer의 멤버변수 접근가능
//			static int cv = 100; //에러! static 변수를 선언할 수 없다.
		final static int CONST = 100; //final static은 상수이므로 허용한다.
	}
	
	static class StaticInner{
		int iv = 200;
		//int t = m; //ERROR 발생
		static int cv = 200; //static 클래스만 static 멤버를 정의할 수 있다.
	}
	
	void myMethod() {
		class LocalInner{
			int iv = 300;
			int t = m; //Outer의 멤버변수 접근가능
//				static int cv = 300; //에러! static 변수를 선언할 수 없다.
			final static int CONST = 300; //final static은 상수이므로 허용
		}
	}

	public static void main(String[] args) {
		System.out.println(InstanceInner.CONST);
		System.out.println(StaticInner.cv);

	}

}
---------------------------------------------------------------------------

package Week01;

class Card{
	final int NUMBER; //상수지만 선언과 함께 초기화 하지 않고
	final String KIND; // 생성자에서 단 한번만 초기화할 수 있다.
	static int width = 100;
	static int height = 250;
	
	Card(String kind, int num){
		KIND = kind;
		NUMBER = num;
	}
	
	Card(){
		this("HEART", 1);
	}
	
	public String toString() {
		return KIND + " " + NUMBER;
	}
}

public class FinalCardTest {

	public static void main(String[] args) {
		Card c = new Card("HEART", 10);
		//c.NUMBER = 5;
		System.out.println(c.KIND);
		System.out.println(c.NUMBER);
		System.out.println(c);
//		System.out.println(c.toString());

	}

}
---------------------------------------------------------------------------

package Week01;

final class Human{ //final은 생성자를 통해 호출됨.
	public void pro() {
		System.out.println("pro");
	}
}

/*
 class Student extends Human{
 	public void info(){
 		System.out.println("info");
 }
 */

class Student{
	public void info() {
		System.out.println("info");
	}
}

public class FinalTest {

	public static void main(String[] args) {
		Student s = new Student();
		s.info();
		//s.pro();

	}

}
---------------------------------------------------------------------------

package Week01.perani;

//클래스 다이어그램 실습
interface Race{
	static void getRace(String race) { //static은 개체에 전체적인 사용목적이 있을때 사용함.
		System.out.println(race);
	}
}

class Animal{ //부모클래스에 abstract 넣는것이 좋다.
	public String name;
	public String type;
}

class Person extends Animal implements Race{
	public String name;
	public int age;
	Animal[] animal;
	
	public void speak(String name, int age, String animal) {
		System.out.println("이름 = " + name);
		System.out.println("나이 = " + age);
		System.out.println("구분 = " + animal);
	}
}

class KoreaPerson extends Person{
	public void speak() {
	}
}

class JapanPerson extends Person{
	public void speak() {
	}
}


public class PersonAnimal {

	//main에서 test(검증)하는것.
	public static void main(String[] args) {
		Person pa = new Person();
		pa.speak("홍길동", 23, "사람");
		KoreaPerson kp = new KoreaPerson();
		kp.speak("개똥이", 43, "한국사람");
		JapanPerson jp = new JapanPerson();
		jp.speak("켄조", 33, "일본사람");

	}

}
---------------------------------------------------------------------------
/*Object Class*/
1. 최상위 클래스
2. 다른 모든 클래스(Interface제외)들은 명시적으로 상속받지 않아도 Object class를 상속 받고 있다.
protected Object clone() // 객체 자신의 복사본을 반환
public boolean equals(Object obj) // 객체 자신과 객체Obj가 같은 객체인지를 알려준다
public String toString() // 객체 자신의 정보를 문자열로 반환

*자바에서 생략된 형태들
default 생성자 : 클래스 내부에 아무런 생성자를 만들지 않으면 JVM은 자동적으로 default 생성자를 호출
this 예약어 : 클래스 멤버는 static을 제외하고는 모두 this객체를 통해 접근
0번째 매개변수 : static 메소드가 아닌 메소드엔 첫번째 매개변수 "자기클래스명 this"가 생략되어 있다.
toString() : 객체 이름을 출력하면 자동적으로 toString메소드를 출력한다
Object 클래스 상속 : 모든 Clsss 는 자동적으로 java.lang.Object 클래스가 상속되었다고 JVM이 인식

package Week01;

public class EqualsEx1 {

	public static void main(String[] args) {
		Value v1 = new Value(10); //값은 같지만 인스턴스는 다르므로
		Value v2 = new Value(10); // 주소값이 다르다.
		
		if(v1.equals(v2)) { //다르다. 주소값이므로 재정의 필요 . object는 주소값을 비교.
			System.out.println("v1과 v2는 같습니다.");
		} else {
			System.out.println("v1과 v2는 다릅니다.");
		}
		
		v2 = v1;
		
		if(v1.equals(v2)) { //같다
			System.out.println("v1과 v2는 같습니다.");
		} else {
			System.out.println("v1과 v2는 다릅니다.");
		}
	} //main
}

class Value{
	int value;
	
	Value(int value){
		this.value = value;
	}
}
---------------------------------------------------------------------------
package Week01;

class Person2{
	long id;
	//Object의 equals를 Overriding
	public boolean equals(Object obj) { //object에 대해서 재정의됨.
		if(obj!=null && obj instanceof Person2) { //obj가 Person2의 Instance
			return id ==((Person2)obj).id; // 값이 같은지 비교하는 equals? object?로 재정의됨.
		} else {
			return false;
		}
	}
	Person2(long id){
		this.id = id;
	}
}

public class EqualsEx2 {

	public static void main(String[] args) {
		Person2 p1 = new Person2(801108111222L);
		Person2 p2 = new Person2(801108111222L);
		
		if(p1==p2) //다르다
			System.out.println("p1과 p2는 같은 사람입니다.");
		else
			System.out.println("p1과 p2는 다른 사람입니다.");
		
		if(p1.equals(p2)) //같다. 재정의되어 같다고 표시
			System.out.println("p1과 p2는 같은 사람입니다.");
		else
			System.out.println("p1과 p2는 다른 사람입니다.");

	}

}
---------------------------------------------------------------------------
package Week01;

class Card2{
	String kind;
	int number;
	
	Card2(){
		this("SPADE", 1); // Card(String kind, int number)를 호출
	}
	
	Card2(String kind, int number){
		this.kind = kind;
		this.number = number;
	}
	
	//재정의
	public String toString() {
		//Card 인스턴스의 kind와 number를 문자열로 반환한다.
		return "kind : " + kind + ", number : " + number;
	}
}

public class CardToString2 {

	public static void main(String[] args) {
		Card2 c1 = new Card2();
		Card2 c2 = new Card2("HEART", 10);
		System.out.println(c1.toString());
		System.out.println(c2.toString());

	}

}
---------------------------------------------------------------------------
package Week01;

class Point implements Cloneable{
	int x;
	int y;
	
	Point(int x, int y){ //인터페이스 받는것은 반드시 재정의해줘야함.
		this.x = x;
		this.y = y;
	}
	
	public String toString() {// override
		return "x= " + x + ", y = " + y;
	}
	
	public Object clone() { //override
		Object obj = null;
		try {
			obj = super.clone(); //clone()은 반드시 예외처리를 해주어야 한다.
		} catch(CloneNotSupportedException e) {}
		return obj;
	}
}

public class CloneEx1 {

	public static void main(String[] args) {
		Point original = new Point(3, 5);
		Point copy = (Point)original.clone();
		System.out.println(original);
		System.out.println(copy);

	}

}
---------------------------------------------------------------------------
package Week01;

import java.util.Arrays;

public class CloneEx2 {

	public static void main(String[] args) {
		int[] arr = {1,2,3,4,5};
		
		//배열 arr을 복제해서 같은 내용의 새로운 배열을 만든다.
		int[] arrClone = arr.clone();
		arrClone[0] = 6;
		
		System.out.println(Arrays.toString(arr));
		System.out.println(Arrays.toString(arrClone));

	}

}
---------------------------------------------------------------------------
package Week01;
//재귀함수
public class PowerTest {

	public static void main(String[] args) {
		int x = 2;
		int n = 5;
		long result = 0;
		
		for(int i=1; i<=n; i++) { // 1<=5,
			result+=power(x,i); // (2,1), 
		}
		System.out.println(result); // 62
	}
	static long power(int x, int n) { // (2,5)
		if(n==1) return x;	// 
		return x*power(x, n-1); // 2*power(2,4)
	}

}

	// a, b, c, d의 최댓값을 구하여 반환
	static int max4(int a, int b, int c, int d) {
		int max = a; 	// 최댓값
		if (b > max)
			max = b;
		if (c > max)
			max = c;
		if (d > max)
			max = d;

		return max;
	}
    
       // a, b, c의 최솟값을 구하여 반환
   static int min3(int a, int b, int c) {
      int min = a;         			// 최솟값
      if (b < min) min = b;
      if (c < min) min = c;

      return min;
   }
   
   	// a, b, c의 중앙값을 구하여 반환(모든 조합의 대소관계에 대하여 검증)
	static int med3(int a, int b, int c) {
		if (a >= b)
			if (b >= c)
				return b;
			else if (a <= c)
				return a;
			else
				return c;
		else if (a > c)
			return a;
		else if (b > c)
			return c;
		else
			return b;
	}

1. 태그가 차지하는 공간
<h1> 태그와 같이 제목으로 지정된 태그는 화면 전체(좌에서 우 끝까지)를 차지합니다. block level element(화면전체)
<a> 태그와 같이 화면 전체를 차지하지 않아 줄바꿈이 되지 않는 태그도 있습니다. inline level element(자기크기)
왜 각 태그가 차지하는 공간이 다를까요?

이를 확인하기 위해 태그가 차지하는 범위를 알아봅시다.
<h1>, <a> 태그에 동일한 CSS <style> 태그를 지정해 {border:5px solid red;}를 설정하면 뚜렷하게 외곽선이 표시되어 태그가 차지하는 '공간'의 크기를 알수있습니다. <h1> 태그는 화면 전체를 차지하고, <a>태그는 본인의 부피만큼만 차지합니다.

이렇게 차지하는 공간이 차이나는 이유는, <h1>태그는 기본값이 style="display:block" 으로, <a>태그는 기본값이 style="display:inline" 으로 적용되었기 때문입니다.
"display:block" 은 화면 전체를 차지하고, "display:inline"은 자신의 부피만큼을 차지합니다. 

이 기본값은 CSS를 통해 본인이 마음대로 바꿀수 있습니다. 예시로 <h1>태그에 style="display:inline"을 적용시키면 더이상 화면 전체를 차지하지 않습니다.


2. 태그가 차지하는 공간을 수정
"display:inline, block, none" 등을 통해 차지하는 크기를 조절할수 있습니다.( none : 사라짐)
"padding:--px" 를 통해 태그와 문자 사이 여백을 조절할수 있습니다.(바깥 : 패딩잠바)
"margin:--px" 를 통해 태그와 다른 태그 사이의 간격을 조절할수 있습니다. (테두리와 테두리 : 마진)
"width:--px" 를 통해 너비를 조절할수 있습니다.
"height:--px" 를 통해 높이를 조절할수 있습니다.
이처럼 CSS 속성을 통해 태그가 차지하는 공간을 자유롭게 수정할수 있습니다.[★핵심]

3. ★검사기
html문서에 마우스 우클릭을 통해 검사기, 요소 검사를 실행할수 있습니다.
해당되는 태그가 어떤 요소를 가지고있고, 어떤 CSS스타일이 적용되었는지 일목요연하게 확인할수 있어 굉장히 유용합니다.

4.박스모델 써먹기 -> 디자인 적 측면에서 매우 중요
실제로 사용할때 나누고싶은 선은 테두리를 이용합니다. border: 값을 이용해 원하는 테두리의 위치, 색, 크기, 모양을 지정하고. 내부의 여백이나 마진값 등을 조절해 원하는 형태로 문서를 구분지을수 있습니다.
방금 언급했던 개발자 도구를 적극 활용해 기획한대로 웹페이지를 만들수 있습니다.

<!DOCTYPE html>
<html>
  <head>
    <meta charset="utf-8">
    <title></title>
    <style>
      h1{
        border:5px solid red;
        padding:20px;
        margin:20px;
        display:block;
        width:100px;
      }
    </style>
  </head>
  <body>
    <h1>CSS</h1>
    <h1>CSS</h1>
  </body>
</html>
---------------------------------

<!doctype html>
<html>
<head>
  <title>WEB - CSS</title>
  <meta charset="utf-8">
  <style>
    body{
      margin:0;
    }
    #active {
      color:red;
    }
    .saw {
      color:gray;
    }
    a {
      color:black;
      text-decoration: none;
    }
    h1 {
      font-size:45px;
      text-align: center;
      border-bottom:1px solid gray;
      margin:0;
      padding:20px;
    }
    ol{
      border-right:1px solid gray;
      width:100px;
      margin:0;
      padding:20px;
    }
  </style>
</head>
<body>
  <h1><a href="index.html">WEB</a></h1>
  <ol>
    <li><a href="1.html" class="saw">HTML</a></li>
    <li><a href="2.html" class="saw" id="active">CSS</a></li>
    <li><a href="3.html">JavaScript</a></li>
  </ol>
  <h2>CSS</h2>
  <p>
    Cascading Style Sheets (CSS) is a style sheet language used for describing the presentation of a document written in a markup language.[1] Although most often used to set the visual style of web pages and user interfaces written in HTML and XHTML, the language can be applied to any XML document, including plain XML, SVG and XUL, and is applicable to rendering in speech, or on other media. Along with HTML and JavaScript, CSS is a cornerstone technology used by most websites to create visually engaging webpages, user interfaces for web applications, and user interfaces for many mobile applications.
  </p>
  </body>
  </html>

<JAVA의 메모리 구조와 호출스택>

class Test{
	private static int a = 1; //static : new 없어도 호출가능
    private int b = 2; // 멤버변수
    void testMethod(int parameter){ // 매개변수
    	int k = param;   // k: 지역변수
}

<객체지향 - 다형성>
for(1~100){ // 다형성 안썼을때. 일일이 구분해야함.
	if(한국사람)한국person 말하다
    if(미국사람)미국person 말하다
    ...
} 
for(1~100){ // 다형성 썼을때
	person 말하다
}

<지역변수와 매개변수>
void test(int Param){ //매개변수
	int i = param //지역변수
}
void test(String Param){
	String s = param // 'call by value'
}

<변수의 종류 - 실습>
package Week01;

public class PassingValueType {

	public static void main(String[] args) {
		PassingValueType test = new PassingValueType();
		int iValue = 1;
		System.out.println("test01 before:" + iValue); //1
		test.test01(iValue);
		//call by reference로 파라미터를 넘기는 언어에서는 2로 값이 변경된다.
		System.out.println("test01 after:" + iValue); //1
		
		Box box = new Box();
		System.out.println("test02 before:" + box.x); //0
		test.test02(box);
		System.out.println("test02 before:" + box.x); //0
		
		Box box2 = new Box();
		System.out.println("test03 before:" + box2.x); //0
		test.test03(box2);
		System.out.println("test03 before:" + box2.x); //1
	}
	void test03(Box box) {
		box.x = 1;
	}
	void test02(Box box) { // box 매개변수로 받음.
		box = new Box(); //새로이 인스턴스 생성
		box.x = 1;
	}
	void test01(int param) {
		param = 2;
	}
}
class Box{ //new를 통해 인스턴스화하지않으면 사용불가능.
	public int x; //멤버변수. int x는 0임.
}
------------------------------------------
package Week01;

import java.util.Scanner;

public class GradeCalcTest {

	public static void main(String[] args) {
		
		// 국어, 영어, 수학 점수를 받아서 총점, 평균 출력하기.
		int kor, eng, math, tot;
		float avg;
		
		Scanner scanner = new Scanner(System.in);
		System.out.println("국어 = ");
		kor = Integer.parseInt(scanner.nextLine());
		System.out.println("영어 = ");
		eng = Integer.parseInt(scanner.nextLine());
		System.out.println("수학 = ");
		math = Integer.parseInt(scanner.nextLine());
		tot = kor + eng + math;
		avg = tot / 3.0f ;
		System.out.printf("총점 : %d 점 %n,", tot);
		System.out.printf("평균 : %.2f 점 %n,", avg);

	}

}

<기본자료형 배열>
int[] a = new int[3];
a[0] = 1;
a[1] = 2;
a[2] = 3;

<참조자료형 배열>
Dog[] pets = new Dog[3];
pets[0] = new Dog(); //참조자료형이기 때문에 new로 인스턴스를 새로만듬 -> heap 영역에 있는것을 가리킴.
pets[1] = new Dog();
pets[2] = new Dog();

<다차원 배열>
[][]
첫번째 []는 참조영역
두번째 []는 실질적인 위치영역

--------------------------------------
<Overloading>
- 이름은 같지만 파라미터의 개수나 데이터형이 다른 여러개의 메소드를 정의 하는 것.
- 조건 : 같은 클래스, 같은 메소드 이름, 메소드의 파라미터개수가 다르거나 데이터형이 달라야함, 메소드의 리턴형은 가아도 되고 달라도 됨.
- 존재 이유 : 같은 메소드 이름을 사용할수 있게함.

package Week01;

public class OverloadTest {

	public static void main(String[] args) {
		f('c');
		byte i = 2;
		f('i');
		short j = 2;
		f('j');
		f(2);
		f(2L);
		f(2.0);
	}
	private static void f(double d) {}
	
	private static void f(long l) {}
	
	private static void f(int i) {}
	
	private static void f(short j) {}
	
	private static void f(byte i) {}
	
	private static void f(char c) {}

}
---------------------------------------
<배열>
초기화방법
- 자료형[] 배열명 = {값1, 값2, 값3...}
- 배열명 = new 자료형[개수]
- 배열명 = new 자료형[]{값1, 값2, 값3...}

package Week01;

public class VarArgsEx {

	public static void main(String[] args) {
		String[] strArr = {"100", "200", "300"};
		
		System.out.println(concatenate("", "100", "200", "300"));
		System.out.println(concatenate(",", strArr));
		System.out.println(concatenate(",", new String[] {"1", "2", "3"}));
		System.out.println("["+concatenate(",", new String[0]+"]"));
		System.out.println("["+concatenate(",") +"]");

	}

	//가변인자 : 타입...변수명
	//가변인자는 항상 마지막 매개변수
	static String concatenate(String delim, String...args) {
		String result ="";
		for(String str:args) { // args를 배열안에 1개씩 넣어줌.
			result+= str + delim;
		}
		return result;
	}

}
----------------------------------------

package Week01;

public class Dog {
	
	String name;//String의 초기값은 null이다.

	public static void main(String[] args) {
		Dog dog1 = new Dog();
		dog1.bark();
		dog1.name = "Bart";
		
		//Dog배열을 만듭니다. (Dog참조변수)
		Dog[] myDogs = new Dog[3];
		//개를 몇마리 집어 넣습니다.
		myDogs[0] = new Dog();
		myDogs[1] = new Dog();
		myDogs[2] = dog1;
		
		//배열 레퍼런스를 써서 Dog객체에 접근합니다.
		myDogs[0].name = "Fred";
		myDogs[1].name = "Marge";
		
		System.out.println("마지막 개의 이름: ");
		System.out.println(myDogs[2].name);
		
		int x = 0;
		while(x<myDogs.length) {
			myDogs[x].bark();
			x = x +1;
		}

	}

	//메소드는 main 밖에 넣어야함.
	public void bark() {
		this.name = ""; //this 로 초기화함.
		System.out.println(name + "이 왈!하고 짖습니다.");
	}
	public void eat() {
	}
	public void chaseCat() {
	}
}
-------------------------------------

package Week01;

//최대값/최소값 구하기
public class ArrayEx6 {

	public static void main(String[] args) {
		
		int i;
		int[] score = {79, 88, 91, 33, 100, 55, 95};
		int max = score[0]; //배열의 첫번째 값으로 최대값을 초기화한다.
		int min = score[0]; //배열의 첫번째 값으로 최소값을 초기화한다.
		for(i=0; i<score.length;i++) {
			if(max<score[i]) //현재값이 최대값이면 그 값을 최대값으로 update
				max = score[i];
			if(min>score[i]) //현재값이 최소값이면 그 값을 최소값으로 update
				min = score[i];
		}
		
		System.out.println("최대값:" + max);
		System.out.println("최소값:" + min);
		

	}

}
-------------------------------------------

package Week01;

//내림차순 정렬하기
public class ArrayEx10 {

	public static void main(String[] args) {
		
		int[] score = {79, 88, 91, 33, 100, 55, 95};
		for(int i=0; i<score.length; i++) {
			for(int j=0; j<score.length; j++) {
				if(score[i]>score[j]) {
					int temp = score[i];
					score[i]=score[j];
					score[j]=temp;
				}
			}
		}
		for(int k=0;k<score.length; k++) {
			System.out.println(score[k] + " ");
		}

	}

}
------------------------------------------------

package Week01;

public class ClassTest {
	
	private int[] sub; //field
	private float avg; //field
	
	public ClassTest() { //Construct
		sub = new int[4];
		avg = 0.0f;
	}
	
	public void calc() { //메소드
		int tot = 0;
		for(int a = 0; a<sub.length; a++) {
			tot+=sub[a];
		}
		avg = tot/sub.length;
	}
	
	public static class ClassTest_Inner{ // Nested class
		private String[] subname = {"국어", "영어", "수학"}; //field
		
		public String getSubname(int x) { //메소드
			return subname[x];
		}
	}

}

2015.12.13 기준 최신 웹 기술인 HTML에서 추가된 기능들을 알아봅니다. 

################ 비디오 - video ################

1. <video>태그 : 동영상을 문서에 삽입하는 기능
　<video width="수치" controls>
　　<source src="URL">
　</video>

2. 웹브라우저간 호환성 문제
　웹브라우저마다 지원하는 동영상 포멧이 다르므로 여러가지 형태(확장자)의 동영상을 기술하면
　웹브라우저는 자신이 지원하는 기능 중 가장 선호하는 형식의 동영상을 선택해서 화면에 표시한다.

################ Can I use ################

HTML5같이 웹 최신 기술을 웹페이지에 사용하면 예전 버전 웹브라우저를 사용하는 사용자같은 경우는 사용할 수 없는 호환이 안되는 문제가 생길 수 있다.
이런 최신 기술들을 사용해도 되는지에 대한 의사결정에 도움을 주는 사이트 caniuse.com
- 어떤 기술들이 각 웹브라우저에서 지원되는지, 전세계적으로 얼마나 이 기술을 사용할 수 있는지 알 수 있다.

################ HTML5의 입력양식 ################

HTML5부터 input type값이 대폭 추가됨.
이것들의 전반적인 특징은 사용자 입력값을 받을 때 좀더 강한 규제, 강제, 유도를 할 수 있다는 것과
모바일에서 사용자들이 좀 더 값에 맞게 입력하기가 쉬워졌다는 것.

• color : 칼라선택
• date : 날짜선택
• datetime : 국제표준시
• datetime-local  : 현재 살고있는 지역 시간대
• email : 이메일 정보 입력강제
• month : 연, 월 입력강제
• number : 숫자 입력강제
• range : 슬라이더(범위 값).
• search : 시각장애인용, 정보설명으로서의 역할
• tel : 전화번호
• time : 시간
• url : url정보입력
• week : 몇번째 주 입력강제

################ HTML5의 입력양식의 속성들 ################

<input> 태그의 속성들
1. autocomplete="on/off" : 사용자가 한 번 입력했던 정보를 기억한 뒤, 자동완성 시켜주는 기능
　 만일 모든 <input>태그들에 동일하게 적용하려면 상위 태그인 <form>태그에 on으로 적용후
　 필요할 경우 특정 <input>태그에만 off로 설정

2. placehorder="내용" : 입력창에 디폴트값으로 내용을 표시, 사용자가 직접 입력시 해당 내용은 사라짐.

3. autofocus : 특정 <input>태그에 입력해두면 사용자가 페이지에 접속시 해당 태그를 오토포커스 해줌.

################ HTML5 입력 값 체크 ################

<input>태그의 유효성 검사 기능을 갖는 속성들
1. required : 사용자가 반드시 정보값을 채워야만 제출이 가능해짐.(필수입력)

2. pattern : 사용자가 정보값을 입력할때 특정 양식을 따르도록 강제하는 속성

※ pattern 속성의 속성값은 "정규표현식"으로 입력해야한다.(정규표현식은 html과는 별개의 언어)

정규표현식강의 -> https://opentutorials.org/course/909/5142

1. <iframe>태그 : 외부의 컨텐츠를 문서로 불러와 보여주는 기능
　<iframe src="URL" frameborder="수치" width="수치" height="수치"></iframe>

2. sandbox 속성 : iframe으로 불러온 페이지에 포함된 javascript나 <input>태그 등의 기술을 차단하는 속성값
　<iframe src="URL" ~~~ sandbox></iframe>
※ 출처가 의심되는 사이트를 iframe으로 가져오면 방문자들에게 피해를 줄 수 있으므로 보안의
　 측면에서는 상당히 취약한 기술이다. 이에 대한 대책으로 sandbox 속성값을 사용한다.

viewport 속성 : <meta name="viewport" content="width=device-width, initial-scale=1.0">
- 웹브라우저의 화면을 각 디바이스에 최적화 된 크기로 표현해준다.
- 코드 작성시 위의 태그를 기계적으로 입력해주면 된다.

package Abstract;

//추상클래스 : abstract class A {
//하나 이상의 추상 메소드가 있으면, 그 클래스는 추상 클래스이어야 합니다.
//추상 메소드와 추상변수로 이루어진다.
//다른 점 : 객체를 절대로 생성이 불가합니다.
abstract class Shape{
	abstract void draw(); //설계만 하고, 내용이 없습니다.
}

class Rectangle extends Shape{

	@Override // : 추상 메소드 오버라이딩
	void draw() {
		System.out.println("1. 사각형을 아주 멋지게 만듭니다.");
	}
	
}

class Circle extends Shape{

	@Override
	void draw() {
		System.out.println("2. 원형을 아주 예쁘게 만듭니다.");
	}
	
}

class Triangle extends Shape{

	@Override
	void draw() {
		System.out.println("3. 삼각형을 아주 멋드러지게 만듭니다.");
	}
	
}

public class AbstractSample1 {

	public static void main(String[] args) {
		
		Rectangle rt = new Rectangle();
		Circle cc = new Circle();
		Triangle tg = new Triangle();
		rt.draw();
		cc.draw();
		tg.draw();
		

	}

}
--------------------------------------------------------------

package Abstract;

/* 현대 자동차가 있습니다.
 * 자동차에 대하여 상태를 표시하는 메소드를 구현하여 보세요.
 * 1. 자동차가 출발합니다.
 * 2. 자동차가 운행중입니다.
 * 3. 자동차가 좌회전을 합니다.
 * 4. 자동차가 우회전을 합니다.
 * 5. 자동차가 후진을 합니다.
 * 6. 자동차가 정지합니다.
 */

abstract class State{
	abstract void gear();
}

class Start extends State{
	void gear(){
		System.out.println("1. 자동차가 출발합니다.");
	}
}

class Drive extends Start{
	void gear(){
		System.out.println("2. 자동차가 운행중입니다.");
	}
}

class Left extends Drive{
	void gear(){
		System.out.println("3. 자동차가 좌회전을 합니다.");
	}
}

class Right extends Left{
	void gear(){
		System.out.println("4. 자동차가 우회전을 합니다.");
	}
}

class Back extends Right{
	void gear(){
		System.out.println("5. 자동차가 후진을 합니다.");
	}
}

class Stop extends Back{
	void gear(){
		System.out.println("6. 자동차가 정지합니다.");
	}
}

public class AbstractSample2 {

	public static void main(String[] args) {
		
		Start st = new Start();
		Drive dr = new Drive();
		Left le = new Left();
		Right ri = new Right();
		Back ba = new Back();
		Stop so = new Stop();
		st.gear();
		dr.gear();
		le.gear();
		ri.gear();
		ba.gear();
		so.gear();

	}

}

주요내용 : 상속

package OOP;

//번호, 이름, 주민번호로 입력하여 출력. 상속 이용.

class People{
	
	String name;
	String ssn;
	int no;
	
	public People(String name, String ssn, int no){
		this.name = name;
		this.ssn = ssn;
		this.no = no;
	}
		
	
}


class Student extends People{
	int sum=0;
	
	public Student(String name, String ssn, int no) {
		super(name, ssn, no);
	}
	
	public int bak() {
	for(int i=1; i<=100; i++) {
		sum+=i;
	}
		return sum;
	}
	
}

public class InherSample4 { //public 클래스는 유일하게 1개여야함.

	public static void main(String[] args) {
		
		Student std = new Student("홍길동", "123456-1234567", 1);
		System.out.println("Name = " + std.name);
		System.out.println("Ssn = " + std.ssn);
		System.out.println("No = " + std.no);
		
		System.out.println("1~100 합은 = " + std.bak());

	}

}

-------------------------------------------------------------

package OOP;

import java.util.Scanner;

class A {
	
	public void call() {
	int size, number = 0;

	Scanner sc = new Scanner(System.in);
	System.out.println("배열의 크기를 입력해 주세요.");
	size = sc.nextInt();

	int array[] = new int[size];

	//데이터 입력
	for(int i=0; i < array.length; i++) {
		array[i] = sc.nextInt();
	}System.out.println();

	//데이터 출력
	for(int i=0; i < array.length; i++) {
		System.out.print(array[i] + " ");
	}System.out.println();
	}
}

class B extends A {

	public void call(int m) {
		int number=0;

		int array[] = {12, 24, 13, 140, 550};
					
		for(int i=0; i<array.length; i++) {
			if(array[i]%2==0) {
				number++;
				System.out.println("번호" + number + ", 짝수는 = " + array[i]);
			}else {
				System.out.println("짝수 X");
			}
		}System.out.println();
	}
}

class C extends B {
	public void call(String name, int y) {
		
		int array[] = {12, 24, 13, 140, 550, 321, 34};
		
		int baesu=0;
		for(int i=0; i<array.length; i++) {
			if(array[i]%5==0) {
				baesu++;
				System.out.println("번호" + baesu + ", 5의 배수는 = " + array[i]);
			}else {
				System.out.println("배수 X.");
			}
		}
		}
	}

public class InherSample13 {	

	public static void main(String[] args) {
		int m=5;

		C d = new C();
		d.call();//
		d.call(5);
		d.call("홍길동", 7);
		
	}

}
----------------------------------------------------------

package OOP;

import java.util.Scanner;

/* Car 클래스가 있는데, 이름과, 속도가 정의되어 있습니다.
 * 여기에, InherSample6 클래스를 사용하여 이름과 속도를 입력하여 사용해 보세요.
 * Car : 버스
 */

class Car{
	
	public void name(String n){
		System.out.println(n + "자동차");
	}
	
	public void velocity(int v){
		v+=100;
		System.out.println(v + "km");
	}
	
	public void color(String c){
		System.out.println(c + "색");
	}
	
}

class Truck extends Car{
	
}


public class InherSample6 {

	public static void main(String[] args) {
		
		Truck tcr = new Truck();
		tcr.name("말리부");
		tcr.velocity(100);
		tcr.color("RED");
		

	}

}
----------------------------------------------------------

package OOP;

/*문제] 
 * 저축은행이 있습니다. 이 은행에 계좌 개설하고, 저금을 합니다.
 *1.계좌생성
 *2.저축: 1000 + 2000 + 3000
 *3.출금: 500
 *4.잔액: 5500
 *5.임금액에 대한 체크, 출금액도 체크 합니다.
 * 상속 이용하여 코딩.
 * 
 */

class AccountOutput  {	
	protected static int val;//1000원 저장, 3000, 6000, 5500
	
	AccountOutput(int init){ 
		val = init;//1000
	}
	
	protected void accumulate(int su){ 
		if(su < 0){ 
			return;
		}
		val+=su;	//1000 + 2000 = 3000 + 3000 = 6000		
	}
	
	protected int getAccVal(){
		return val;//5500
	}		
}

class AccountInput extends AccountOutput {
	
	public AccountInput(int initValue)	{ //1000
			super(initValue);  //1000    
	}
	public void deposit(int money) { //입금
		accumulate(money);
	}
	public void withdraw(int money){ 
		if(val < money) //6000 < 500
			return;
		val = val - money;// 6000 - 500 = 5500
	}
	
	public void showSavedMoney()	{
		System.out.print("지금까지의 누적금액: ");
		System.out.println(getAccVal() + "원 입니다.");//5500
	}
}

public class InherSample7 {

	public static void main(String[] args) {
		AccountInput ac = new AccountInput(1000);
		ac.deposit(2000);//입금
		ac.deposit(3000);//		
		ac.withdraw(500);//출금
		ac.showSavedMoney();//잔액
	}
}
------------------------------------------------------------

package OOP;

import java.util.Scanner;

/*한국은행에 계좌를 개설하고 저축을 합니다.
 * 현재 입금된 금액은 0원입니다.
 * 저축을 하면서 상속을 이용하여 누적 금액을 알아보고, 입금 횟수를 카운트하여 출력해 보세요.
 * 단, 키보드로부터 입력을 받습니다.
 */
class SaveMoney {
	static int count=0;
	int money=0;
	static int totalmoney=0;
	 
	
	public void inputSave() {	 
		while(true) {
	 Scanner sc = new Scanner(System.in);
	 System.out.println("입금액을 기재하세요.");
	 money = sc.nextInt();
	 
	 if(money == 0) {
		 break;		 
	 	}
	 	totalmoney +=money;
	 	count++;	 
	 	}
	}

}

class TotalMoney extends SaveMoney {

	public void total() {
		System.out.println("누적 금액은 = " + totalmoney);
		System.out.println("카운트 = " + count);
	}
}

public class InherSample8 {

	public static void main(String[] args) {
		SaveMoney sm = new SaveMoney();
		sm.inputSave();

		TotalMoney tm = new TotalMoney();
		tm.total();
	}
}


---------------------------------------------------------

package OOP;

class Adder{

	public static void Adder() {//4번 메소드 정의부(선언부 포함), 리턴할필요없으므로 void, static(다른클래스에서 이 메소드를 사용할수있다. 참조가능)
		int i, sum1 = 0;
		for(i=0;i<=100;i++) {
			sum1+=i;
		}
		System.out.println("1~100 사이의 합은 " + sum1);
	}
}

class Subtr extends Adder{

	public static void Subtract() {
		int x = 500, y = 300, sum2 = 0;
		sum2 = x - y ;
		System.out.println("1~100 사이의 차는 " + sum2);
		}

}

public class InherSample9 {

	public static void main(String[] args) {
		
		Subtr su = new Subtr();
		su.Subtract();
		su.Adder();

	}

}
-----------------------------------------------------------

package OOP;

//상속과 오버라이딩

//옛날 옛적에 스노우 타이어와 일반 타이어가 살았습니다.
//부모님은 스노우 타이어를 좋아하셨고, 자식은 일반 타이어를 선호 했습니다.
//run()를 이용하여 메소드 오버라이딩 하세요.

//abstract class Parent{ // 추상 클래스
//	//추상메소드와 final 변수
//	final static double pi = 3.14;
//	public void run(){
//		System.out.println("스노우 타이어");
//	}
//	//public abstract는 생략가능
//	public void run2() {
//		// body가 존재하지 않는다.
//	}
//}

class Parent{
	
	public void Hi() {
		System.out.println("방가방가");
	}
	
	public void Hi(String msg) {
		System.out.println(msg);
	}
	
	public void Hi(String name, int kor) {
		System.out.println("당신의 이름은 " +name + "이고, 국어 점수는 = " + kor);
	}
	
}

class Child2 extends Parent{
	
	public void Hi(String msg) {
		System.out.println(msg);
	}
	
	public void run(){ //일반 메소드는 추상클래스안에 쓸수 없다.
		System.out.println("일반 타이어");
	}
	//추상 메소드 오버라이딩
	public void run2() {
		int sum = 100 + 200;
		System.out.println(sum);
	}
}

public class InherSample11 {

	public static void main(String[] args) {
		Parent p = new Parent();
		p.Hi();
		
		Child2 c = new Child2();
		c.run();
		c.Hi("홍길동", 70);

	}

}
-----------------------------------------------------------

package OOP;

import java.util.Scanner;

/*오버라이딩 문제
 * 책방에서 부모님은 3000원을 할인하고,
 * 자식들은 3500원을 할인받습니다.
 * 이를 상속과 오버라이딩을 이용하여 처리하세요. 
 */

class MF{
	
	public void discount(int book){
		int sum = book - 3000;
		System.out.println(sum + " 원입니다.");
	}
	
}

class CD extends MF{
		
	public void discount(int book){
		int sum = book - 3500;
		System.out.println(sum + " 원입니다.");
	}
}

public class InherSample12 {

	public static void main(String[] args) {
		
		while(true) {
			System.out.println("당신의 신분을 입력하시오. 1(부모) 2(자식) 3(종료)");
			Scanner sc = new Scanner(System.in);
			int a = sc.nextInt();
			System.out.println("구입하고자하는 책값을 입력하세요.");
			int b = sc.nextInt();
			switch(a) {
			case 1:
				MF mf = new MF();
				mf.discount(b);
				continue;
			case 2:
				CD cd = new CD();
				cd.discount(b);
				continue;
			case 3:
				System.out.println("책방할인시스템을 종료합니다.");
				System.exit(0);
			}
		}
		
		
		
		
		

	}

}
--------------------------------------------------------------

package OOP;

import java.util.Scanner;

class A {
	
	public void call() {
	int size, number = 0;

	Scanner sc = new Scanner(System.in);
	System.out.println("배열의 크기를 입력해 주세요.");
	size = sc.nextInt();

	int array[] = new int[size];

	//데이터 입력
	for(int i=0; i < array.length; i++) {
		array[i] = sc.nextInt();
	}System.out.println();

	//데이터 출력
	for(int i=0; i < array.length; i++) {
		System.out.print(array[i] + " ");
	}System.out.println();
	}
}

class B extends A {

	public void call(int m) {
		int number=0;

		int array[] = {12, 24, 13, 140, 550};
					
		for(int i=0; i<array.length; i++) {
			if(array[i]%2==0) {
				number++;
				System.out.println("번호" + number + ", 짝수는 = " + array[i]);
			}else {
				System.out.println("짝수 X");
			}
		}System.out.println();
	}
}

class C extends B {
	public void call(String name, int y) {
		
		int array[] = {12, 24, 13, 140, 550, 321, 34};
		
		int baesu=0;
		for(int i=0; i<array.length; i++) {
			if(array[i]%5==0) {
				baesu++;
				System.out.println("번호" + baesu + ", 5의 배수는 = " + array[i]);
			}else {
				System.out.println("배수 X.");
			}
		}
		}
	}

public class InherSample13 {	

	public static void main(String[] args) {
		int m=5;

		C d = new C();
		d.call();//
		d.call(5);
		d.call("홍길동", 7);
		
	}

}

package OOP;

import java.util.Scanner;

class Sawon {
	
	String dept;
	int salary;
	String name;
	int commition;

	public Sawon(String name, String dept, int salary, int commition) {
		 this.name =  name;
		 this.dept = dept;
		 this.salary = salary;
		 this.commition = commition;				 
	 }
	
	public void Sales(String name, String dept, int salary, int commition) {
		 this.name =  name;
		 this.dept = dept;
		 this.salary = salary;
		 this.commition = commition;				 
	 }	
	
}

 class Sales extends Sawon {
	private String name;
	private String dept;
	private int commition;
	private int salary;
	private int sum;

	public Sales(String name, String dept, int salary, int commition) {
			super(name, dept, salary, commition); 
	 }	 
	 
	 public String Information() {
		 return "이름: " + name + ", 부서: " + this.dept + ", 연봉: " + 
				 this.salary + "수당: " + this.commition + ", 합계: " + sum;
	 }
	 
 }
//이름과 부서 그리고 연봉, 수당을 입력받아서 연산하는 프로그램 작성합니다.

public class 과제0704 {
	private static String name;
	private static String dept;
	private static int salary;
	private static int commition;
	private static int sum;
	
	public static void main(String[] args) {
		
		System.out.println("이름, 부서, 연봉, 수당을 입력하세요.");
		Scanner sc = new Scanner(System.in);
		 name = sc.next();
		 dept = sc.next();
		 salary  = sc.nextInt();
		 commition = sc.nextInt();
		 sum = salary + commition;
		
		Sales sales = new Sales(name, dept, salary, commition);
		sales.Information();
		System.out.println(name +"님의 부서는 " + dept+"팀이고, 연봉은 " +salary+"원 이고, 수당은 " +commition+"원 이고, 총 " +sum+"원 입니다.");

	}

}
-----------------------------------------------------------------

package OOP;

public class 과제0704_2 {

	public static void main(String[] args) {
		
/*과제2-3> 다음과 같이 출력하시오.
 * 1 2 3 4 5
 * 16 17 18 19 6
 * 15 24 25 20 7
 * 14 23 22 21 8
 * 13 12 11 10 9 
 */
		
		int gj23[][] = new int[6][6];
		int num = 0;
		int var = 5;
		int sw = 1;
		int i=1, j=0;
        //입력
		do{        
	       for(int k=1;k<=var;k++){ // 시작은 1~5            
	           num=num+1;
	           j=j+sw; //행고정 열변화
	           gj23[i][j] = num;                               
	       }          
	       var=var-1;
	           
	       if(var>0){               
	          for(int k=1;k<=var;k++){             
	            num=num+1;
	            i=i+sw; //열고정 행변화
	            gj23[i][j] = num;                               
	            }              
	            sw = sw*(-1); // 스위칭             
	       }else{             
	           break; //반복문 빠져나감.
	       }          
		}while(true);
		
        //출력
		for(i=1;i<gj23.length;i++) {
			for(j=1;j<gj23[i].length;j++) {
				System.out.print(gj23[i][j] + " ");
			}
			System.out.println();
		}

/*과제2-4> 다음과 같이 출력하시오.
 * 0 0 1 0 0 
 * 0 3 5 7 0 
 * 9 11 13 15 17
 * 0 19 21 23 0
 * 0 0 25 0 0 
 */
		
		int gj24[][] = new int[5][5];
		int i, j;
		int n=1;
		//입력하면서 감소하는 부분.
		for(i=0; i<3; i++) { 
			for(j=2-i; j<=i+2; j++) {
				gj24[i][j] = n;
				n=n+2;
			}
		}
		//입력하면서 증가하는 부분.
		for(i=3;i<5; i++) { 
			for(j=i-2; j<=6-i; j++) {  
				gj24[i][j] = n;
				n=n+2;
			}
		}
		//배열 출력
		for(i=0; i<5; i++) {
			for(j=0; j<5; j++) {
				System.out.print(gj24[i][j] + "\t");
			}
			System.out.println(); 
		}
		
/*과제2-5> 다음과 같이 출력하시오.
 * 1 2 3 4 5
 * 10 9 8 7 6
 * 11 12 13 14 15
 * 20 19 18 17 16
 * 21 22 23 24 25 		
 */
		int gj25[][] = new int[5][5];
		int count = 1;
		for(int i = 0; i < gj25.length; i++){
			if(i % 2 == 0){ // 짝수 0 2 4 번 배열
				for(int j = gj25[i][0]; j < gj25.length;j++){
					gj25[i][j] = count;
					count++;
				}
				count +=5;
			}
			else{ // 홀수 1 3 번 배열
				int count1 = 0;
				for(int j = gj25[i-1][gj25.length-1] + 5 ; j > gj25[i][gj25.length-1];j--){
					gj25[i][count1] = j;
					count1++;
				}
			}
		} 
        //출력
		for(int i=0;i<gj25.length;i++) {
			for(int j=0;j<gj25[i].length;j++) {
				System.out.print(gj25[i][j] + " ");
			}
			System.out.println();
		}
		
/*과제2-6> 다음과 같이 출력하시오.
 * 1
 * 2 3
 * 4 5 6
 * 7 8 9 10
 * 11 12 13 14 15 
 */
		
		int gj26[][] = new int[5][5];
		int temp=1; //표시할 값 temp
        //입력
		for(int i = 0; i<gj26.length; i++) { //i는 행 0 1 2 3 4 
			for(int j = 0 ; j<=i; j++) { //j는 열   0 01 012 0123 01234
				gj26[i][j]=temp++; //[0][0] = 1, [1][0] = 2, [1][1] = 3....
			}
		}
        //출력
		for(int i = 0; i<gj26.length; i++) {
			for(int j = 0 ; j<=i; j++) {
				System.out.print(gj26[i][j] + " ");
			}
			System.out.println();
		}
		
		
		
		
		
		
	}

}