개발일기

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

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

for(Contact data : contactList) {
     Log.i("MyContact", "id : " + data.id + " , name : "+data.name + " , phone : " + data.phone);
}

오른쪽에있는 것을 하나씩 꺼내서 왼쪽에 대입한다.

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 한다.

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 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를 통해서 부모 클래스의 메소드를 접근했다.

public class Parent {
	String name;
	int age;
	private int money;
	
	Parent() {
		System.out.println("Parent 생성자 호출됨");
	}
	
	void print() {
		System.out.println("name : " + name);
		System.out.println("age : " + age);	
	}
	
	public int getMoney() {
		return money;
	}

	public void setMoney(int money) {
		this.money = money;
	}
	
}

public class Child extends Parent {
	// 이 클래스는, Parent 클래스가 가지고 있는
	// 속성들을, 상속받을 것이다.
	
	String hobby;
	
	Child() {
		System.out.println("Child 생성자 호출됨");
	}
	
	// setMoney()
	// getMoney()
	// print()
	
	// Method Overriding 메소드 오버라이딩
	// 상속받는 클래스엣!! 즉 자식클래스에서
	// 부모 클래스에 들어있는 함수 이름을 그대로 사용하되!!
	// 내가 원하는대로 내용만 바꿔서 사용하는거!!
	void print() {
		super.print();
		System.out.println("hooby : " + hobby);
	}
	// Method Overloading :
	// 하나의 클래스 안에서!! 똑같은 이름의 함수를 여러개 만드는거!!
}

public class ParentMain {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		
		// Parent 클래스를 변수로 생성 (객체 생성)
		Parent p = new Parent();
		p.name = "부모";
		p.age = 50;
		p.setMoney(1000000000);
		p.print();
		System.out.println("돈은 : " + p.getMoney() + "원");
		
		System.out.println();
		
		// 상속받은 Child 클래스를 메모리에 생성(객체 생성)
		Child c = new Child();
		c.name = "자식";
		c.age = 20;
		c.hobby = "게임";
		c.setMoney(1000000);
		System.out.println(c.getMoney());
		c.print();
		
		System.out.println();
		
		c.print();
		
		// name :
		// age :
		// hobby :
	}

}

부모클래스의 모든 속성을 상속받지만 private 변수는 억세스가 제한되고 getter setter를 이용해서 접근해야한다.