개발일기

해당 디렉토리에 jar파일이 없기때문이다.

내 경우에는 파일명에 오타가 있었다.

import java.util.ArrayList;

public class TryMain {

	// try catch finally 문법 : 예외를 처리하는 방법
	// 예외가 발생했을때, 내가 원하는 코드를 실행시키는 방법
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int[] arr = {15, 2, 7};
		
		try {
			for(int i = 0; i < 3; i++) {
				System.out.println(arr[i]);
			}
			
		ArrayList<String> myList = null;
			
		myList.add("안녕?");
			
		int k = 4 / 0;
			
		System.out.println(k);
		} catch (ArrayIndexOutOfBoundsException e) {
			System.out.println("배열 인덱스 예외발생시 처리코드");
			System.out.println(e.toString());
		} catch (ArithmeticException e) {
			System.out.println("연산 예외 발생시 처리하는 코드");
			System.out.println(e.toString());
		} catch (Exception e) {
			System.out.println("나머지 모든 예외상황은 여기서 처리");
			System.out.println(e.toString());
		} finally {
			System.out.println("예외 발생하든 발생하지 않든, 꼭 실행해야 하는 코드는 여기 작성");
		}

	}

}

try 에 있는 코드를 실행하고 에러가 나면 catch에 있는 예외상황쪽 코드를 실행하고

예외가 발생하든 발생하지 않든 끝날때는 finally를 실행한다.

import java.util.HashMap;
import java.util.Iterator;

public class MapTest {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		
		// map은 파이썬의 딕셔너리와 비슷한 데이터 스트럭쳐
		// key, value 쌍을 저장!!! 
		
		HashMap<String, String> map = new HashMap<String, String>();
		
		map.put("model", "iPhone 12");
		map.put("year", "2021");
		map.put("color", "red");
		
		System.out.println(map.get("color"));
		
		// key 만 가져올때
		Object[] keys = map.keySet().toArray();
		
		for(int i = 0; i < keys.length; i++) {
			System.out.println((String)keys[i]);
		}
		
		// value 만 가져올때
		Object[] values = map.values().toArray();
				
		for(int i = 0; i < values.length; i++) {
			System.out.println((String)values[i]);
		}
		
		// 해쉬맵에 저장된 데이터를 삭제.
		map.remove("year");
		
		// Iterator 를 이용해서 전체 데이터를 가져오는 방법 
		
		// 키를 가져오는 방법
		Iterator<String> keyIter = map.keySet().iterator();
		while(keyIter.hasNext()) {
			String key = keyIter.next();
			String value = map.get(key);
			System.out.println("key : " + key + " , value : " + value );
		}
		
		System.out.println(map.get("model"));
		
		map.clear();
		
		System.out.println(map.size());
	}

}

HashMap은 딕셔너리랑 비슷하다 키와 값으로 put 하고 키로 remove 한다.

import java.util.ArrayList;

public class ArrayListTest {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		
		// 배열은, 생성시에, 갯수를 정해줘야 한다!
		// 배열은 한번 갯수를 정하면, 그갯수 이상으로는 데이터를 추가 불가!
		String[] nameArray = new String[10];
		
		// 따라서 갯수 정하지 않고, 데이터를 마음대로
		// 추가할수도 있고, 삭제할수도 있는것이 어레이 리스트 이다.
		
		// 담고 싶은 데이터를 <> 안에 적어줘야 한다.
		// 비어있는 리스트를 만든다.
		ArrayList<String> nameList = new ArrayList<String>();
		
		nameList.add("홍길동");
		nameList.add("김나나");
		nameList.add("Mike");
		
		System.out.println(nameList.get(1));
		
		// 리스트에 있는 데이터를 모두 출력!
		
		// nameList.size() 은 저장되어있는 데이터의 갯수
		
		for(int i = 0;i < nameList.size();i++) {
			System.out.println(nameList.get(i));
		}
		
		// 홍길동, 김나나, Mike
		// Harry 를 홍길동과 김나나 사이에 추가!!
		nameList.add(1, "Harry");
		
		for(int i = 0;i < nameList.size();i++) {
			System.out.println(nameList.get(i));
		}
		
		nameList.remove(0);
		
		for(int i = 0;i < nameList.size();i++) {
			System.out.println(nameList.get(i));
		}
		
		nameList.remove("Mike");
		
		for(int i = 0;i < nameList.size();i++) {
			System.out.println(nameList.get(i));
		}
		
		// 저장된 데이터를 전부 삭제
		nameList.clear();
		
		System.out.println(nameList.size());
		
		// 리스트가 비어있는지 확인
//		nameList.isEmpty();
		
		if(nameList.isEmpty()) {
			System.out.println("비어있다.");
		} else {
			System.out.println("데이터 있음");
		}
	}

}

ArrayList<String> nameList = new ArrayList<String>() 형식으로 선언한다.

add 함수로 추가 remove함수로 제거한다. size 함수는 갯수를 반환한다.

clear함수는 데이터를 전부 삭제한다.

public interface PlayingCard {
	// 인터페이스는, 추상클래스보다 더 뼈대만 있는 것!
	
	// 인터페이스는, 멤버변수가 없고, 함수의 이름만 있는 것.
	// 단, 상수는 가능하다. 
	// (상수란, 한 번 값을 저장하면, 값을 바꿀수 없는것) 
	
	// 카드의 클로버는 1, 하트는 2, 다이아몬드는 3, 스페이드 4라고
	// 지정한다!!
	
	public static int CLOVER = 1;
	public static int HEART = 2;
	public static int DIAMOND = 3;
	public static int SPADE = 4;
	
	public String getCardNumber();
	public void print();
}

public class MyCard implements PlayingCard{

	String cardNumber;
	
	public MyCard(String cardNumber) {
		this.cardNumber = cardNumber;
	}

	public MyCard() {
		// TODO Auto-generated constructor stub
	}

	@Override
	public String getCardNumber() {
		// TODO Auto-generated method stub
		return cardNumber;
	}

	@Override
	public void print() {
		// TODO Auto-generated method stub
		System.out.println("card number : " + cardNumber);
	}
	
	
}

public class InterfacceMain {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		
		MyCard card = new MyCard();
		card.cardNumber = "7";
		
		String number = card.getCardNumber();
		System.out.println(number);
		
		card.print();
		
		MyCard card2 = new MyCard("5");
		card2.print();
		
		// 상수를 사용할때는, 보통은, 객체.상수 로 사용하지 않고,,
		System.out.println(card2.SPADE);
		// 상수를 정의한 인터페이스나 클래스명.상수 로 사용한다.
		System.out.println(PlayingCard.SPADE);
	}

}

인터페이스는 멤버 변수는 없고 함수이름만 있다. 단 상수는 가능하다.

PlayinCard를 implements 한 MyCard에서 함수 구현을 해준다.

public abstract class GrandParent {
	
	String name;
	int age;
	
	// 함수를 만드는데!
	// 함수를 이름만 만들어 놓는다!!!! (내용은 없다!)
	
	abstract void print();
	
	abstract void test();
	
}

public abstract class Parent extends GrandParent{

//	String name;
//	int age;
	
	@Override
	void print() {
		// TODO Auto-generated method stub
		System.out.println("Parent");
		System.out.println("name = " + name);
	}

	// 추상클래스를 상속받아서 개발하는 클래스는
	// 추상클래스의 모든 추상함수를 다 구현해 줘야 한다!

}

public class Child extends Parent{
	
//	String name;
//	int age;
	
	String hobby;
	
	@Override
	void test() {
		// TODO Auto-generated method stub
		System.out.println("Hobby = " + hobby);
		
	}

}

public class AbstractMain {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		
		Child c = new Child();
		c.name = "홍길동";
		c.age = 30;
		c.hobby = "영화";
		
		c.print();
		c.test();
	}

}

추상클래스에서 필요한 함수이름들을 적어두고 추상클래스를 상속받은 클래스에서 함수를 구현하도록 설계하는 것이 목적이다. 함수 설계와 구체적인 구현을 분리해서 분업할 수 있다.

클래스 앞에 abstract를 붙이면 된다. 함수를 다 구현하지 않으면 Parent 클래스처럼 abstact를 붙여서 추상클래스로 만들어 줘야한다. child 클래스에서 남은 함수들을 다 구현했다. child 클래스 객체로 상속받은 속성과 함수를 이용할 수 있다.

다운캐스팅이란 상속관계에서 상속받은 자식클래스로 캐스팅 하는 것이다.

public class Animal {
	
	private String name;
	
	public void cry() {
		System.out.println(name + "가 소리를 낸다!!");
	}

	public String getName() {
		return name;
	}

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

public class Cat extends Animal{
	
//	private String name;
	
	// Animal 클래스의 함수도 모두 상속받는다.
	
	@Override
	public void cry() {
		// TODO Auto-generated method stub
		super.cry();
		System.out.println("야옹 야옹~~~");
	}
	
	void grooming() {
		System.out.println("그루밍 한다!");
	}
	
}

public class Dog extends Animal {

//	private String name;
	
	// Animal 클래스의 함수도 모두 상속받는다.

	@Override
	public void cry() {
		// TODO Auto-generated method stub
		super.cry();
		System.out.println("멍멍멍~~~~");
	}
	
	public void run() {
		System.out.println(getName() + "가 뛴다!!!");
	}
}

public class AnimalAction {
	
	void action(Animal animal) {
		
		animal.cry();
		
		if (animal instanceof Dog) {
			((Dog)animal).run(); 
		} else if (animal instanceof Cat) {
			((Cat)animal).grooming();
		}
	}
	
}

public class AnimalMain {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		
		AnimalAction action = new AnimalAction();	
		
		Dog d = new Dog();
		d.setName("바둑이");
		
		action.action(d);
		
		Cat c = new Cat();
		c.setName("키티");
		
		action.action(c);
	
	}

}

바둑이가 소리를 낸다!!
멍멍멍~~~~
바둑이가 뛴다!!!
키티가 소리를 낸다!!
야옹 야옹~~~
그루밍 한다!

Cat과 Dog 클래스는 Animal 클래스를 상속받았다. AnimalAction 클래스의 action 함수는 Animal 객체를 파라미터로 받는 데 이때 Cat과 Dog객체를 대입해서 업캐스팅이 일어나고 이 객체를 Dog나 Cat으로 다운캐스팅 하여 자식 클래스의 함수를 실행시킨다.

업캐스팅은 상속관계일때 데이터타입을 부모클래스로 선언하는 것이다.

public class UpCastingParent {
	
	int x;
	int y;
	
	public UpCastingParent() {
		x = 10;
		y = 20;
	}
	
	public void print() {
		System.out.println(x + " , " + y);
	}
	
	public int add() {
		System.out.println("Parent 의 add() 함수 호출");
		return x + y;
	}
}

public class UpCastingChild extends UpCastingParent{
	
	int z;
	
	UpCastingChild() {
		x = 100;
		y = 200;
		z= 300;
	}

	@Override
	public void print() {
		
		System.out.println(x + " , " + y + " , " + z);
	}

	@Override
	public int add() {
		// TODO Auto-generated method stub
		System.out.println("Child 의 add() 함수 호출");
		return x + y + z;
	}
	
	public int sub() {
		return x - y - z;
	}

	public int getZ() {
		return z;
	}

	public void setZ(int z) {
		this.z = z;
	}
}

public class UpCastingMain {

	public static void main(String[] args) {

		UpCastingParent ucp = new UpCastingChild();
		
		// 변수는 부모클래스이므로, 부모클래스에 add 함수 이름이 있으므로,
		// 함수가 실행되되, 객체(Heap 메모리)가 자식클래스이고,
		// 자식 클래스가 add를 오버라이딩 했으므로,
		// 자식 클래스의 함수가 호출된다.
		int result = ucp.add();		
		System.out.println(result);
		
		// 변수는 부모클래스이므로, 부모클래스에 있는 함수 이름만 사용이 가능!
		// sub() 는 부모에는 없고, 자식에게만 있으니까 실행 못한다.
//		result = ucp.sub();
	}

}

자식 클래스인 UpCastingChild를 부모 클래스로 형변환하고

오버라이딩한 add함수를 실행한다.

오버라이딩한 결과로 600이 나온다.

sub함수는 부모에는 없고 자식에게만 있어서 실행 못한다.

public class Person {
	protected int num;
	protected String name;
	protected String dept;
	protected String address;
		
	public Person(int num, String name, String dept, String address) {
		this.num = num;
		this.name = name;
		this.dept = dept;
		this.address = address;
	}
}

public class Professor extends Person{
	
	public Professor(int num, String name, String dept, String address, String[] subjects) {
		super(num, name, dept, address);
		this.subjects = subjects;
	}
}

Professor pf = new Professor(11, "김길동", "경제학과", "인천시", new String[] {"자바", "경제", "사회"});

Person을 상속받은 Professor의 생성자 첫 줄에서 super를 통해 부모 생성자를 명시적으로 호출해서

겹치는 부분을 코드 재사용했다.

public class Car {
    //Car 클래스에는 다음과 같은 3개의 메소드가 들어있다.
    public void carOn() {
        System.out.println("시동을 겁니다.");
    }
    public void drive() {//오버라이딩 될 메소드
        System.out.println("일반 주행 중입니다.");
    }
    public void carOff() {
        System.out.println("시동을 끕니다.");
    }
}

public class SmartCar extends Car{
    public static final int NORMAL = 1;
    public static final int SMART = 2;

    public int driveMode = NORMAL;//driveMode는 기본적으로 NORMAL임

    @Override // 밑의 메소드가 오버라이딩된것이라는 것을 알려주는 어노테이션
    public void drive() {
        if(driveMode == NORMAL) {//driveMode가 NORMAL일 경우 부모 클래스인 Car 클래스의 drive 메소드를 사용.
            super.drive();
        }
        else {
            System.out.println("자동 주행 중입니다.");
        }
    }
}

public class Main {
    public static void main(String[] args) {
        SmartCar smartCar = new SmartCar(); //객체 생성
        smartCar.carOn();
        smartCar.drive();
        smartCar.driveMode = SmartCar.SMART; //driveMode를 SMART로 바꿈
        smartCar.drive();
        smartCar.carOff();
    }
}

시동을 겁니다.
일반 주행 중입니다.
자동 주행 중입니다.
시동을 끕니다.

Car 클래서에서 정의된 drive 메소드를 SmartCar에서 오버라이딩한다.

driveMode가 NORMAL이면 super 키워드를 통해 부모 클래스의 drive메소드를 실행하고

SMART이면 자동주행중입니다를 출력한다.

super를 통해서 부모 클래스의 메소드를 접근했다.