• 자료구조 용어
    • 리스트(List): 순서를 가지고 있으며, 중복을 허용하는 보관 구조(인덱스 번호가 중요한 역할을 한다.)
    • 세트(set): 순서를 가지지 않고, 데이터의 중복을 허용하지 않는 구조
    • 맵(Map): 키와 값을 가지며, 키를 가지고 원하는 데이터를 검색하는 구조

  • ArrayList
    • 순서대로 데이터를 이용할때 쓰면 유리함.

  • HashMap
    • 원소들을 이름/값 쌍 형식으로 저장하고 접근할 수 있게 해준다.
    • Map계열은 도서관 사물함 같은거다.
    • new HashMap<키 타입, 값 타입>();

  • Anonymous Class (익명클래스)
    • 특정 코드의 안쪽에 ‘이름이 없는 클래스의 형태로 직접 코드를 작성하는 클래스’
    • 고정된 추상 메소드를 이용했을 때의 문제점을 해결해줄 수 있는 편리한 방법.
    • 어떤 추상 클래스나 인터페이스의 객체의 코드가 들어가는 부분에 직접 일회용으로 코드를 만들어서 사용하는 것.
    • 익명 클래스는 바깥쪽 클래스의 모든 변수나 메소드를 사용할 수 있다.
    • final로 선언된 로컬 변수에만 접근 할 수 있다.

  • 다음은 ArrayList와 Anonymous Class 예제.
package HashEx;

import java.util.*;

public class LottoBall {
	private int num;

	public LottoBall(int num) {
		super();
		this.num = num;
	}

	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + num;
		return result;
	}

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

	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		LottoBall other = (LottoBall) obj;
		if (num != other.num)
			return false;
		return true;
	}

	public static void main(String[] args) {
		List<LottoBall> list = new ArrayList<LottoBall>(); // ArrayList
		for (int i = 0; i <= 45; i++) {
			LottoBall b1 = new LottoBall(i);
			list.add(b1);
		}

		Collections.shuffle(list);

		System.out.println(list);

		List<LottoBall> result = new ArrayList<LottoBall>();

		for (int i = 0; i < 6; i++) {
			result.add(list.remove(0));
		}

		final int target = 10;

		Collections.sort(result, new Comparator<LottoBall>() { // Anonymous
																// Class (익명클래스)
					public int compare(LottoBall b1, LottoBall b2) {
						int gap1 = Math.abs(target - b2.num);
						int gap2 = Math.abs(target - b1.num);

						return gap1 > gap2 ? -1 : 1;
					}
				});

		System.out.println(result);
	}

}

'공대생 > Java Programming' 카테고리의 다른 글

[Java] 09. 상속, 추상클래스, 인터페이스  (0) 2014.04.07
[Java] 08. 상속  (0) 2014.04.06
[Java] 07. 객체지향(2)  (0) 2014.04.04
[Java] 06. 객체지향(1)  (0) 2014.04.04
[Java] 05. 배열(2)  (0) 2014.04.03
Posted by 믐믐믐믐믐
,
  • 인터페이스 (Interface)
    • 클래스에 필요한 메소드들에 대한 약속.
    • 어떤 기능이 있어야한다. 라고만 정하고 그 메소드가 어떻게 돌아가는지는 상관 없음.
    • 그저 스펙을 정의.

  • 추상클래스 (Abstract class)
    • 클래스의 용도가 객체 생성 용도로 사용하지 않는 경우에 사용함.
    • 클래스의 객체 생성의 용도가 아니라면 변수의 타입으로 선언하는 용도와 상속의 본연의 기능으로 특정한 코드를 하위 클래스로 물려주는 기능을 활용할 때 사용함.
    • 객체를 생성하지는 않으나 변수 선언 용도로 사용됨.
    • 상속의 고유 기능인 하위 클래스에 같은 데이터와 기능을 가지도록 물려주는 기능

  • 상속 (Inheritance)
    • 특정 클래스를 구성할 때 기존 클래스의 데이터(속성)와 메소드를 상위(부모) 클래스에서 그대로 물려받아서 중복적인 코드를 줄인다는 장점.
    • 하나의 변수 타입으로 여러 종류의 객체를 의미하는 추상화된 방식의 프로그램이 가능하게 하는 객체지향 기법

  • 인터페이스 vs 추상클래스
    • 공통점
      • 추상 메소드를 가진다.
      • 객체 생성이 불가능하고 타입으로만 사용됨.
    • 차이점
      • 인터페이스는 스펙이나 원하는 기능을 정의하고자 쓰지만, 추상 클래스는 ‘상속+약간의 강제성이 목적’이다.
      • 인터페이스는 상수, 추상 메소드만 존재하지만, 추상클래스는 상속이 원래 목적이므로 실제 변수나 메소드를 그대로 가지고 있다.
      • 인터페이스는 부채만 남겨주지만, 추상 클래스는 재산도 남겨준다.
      • 인터페이스는 다중 상속(?)도 가능하지만, 추상 클래스는 단일 상속만 가능.


'공대생 > Java Programming' 카테고리의 다른 글

[Java] 10. 자료구조  (0) 2014.04.08
[Java] 08. 상속  (0) 2014.04.06
[Java] 07. 객체지향(2)  (0) 2014.04.04
[Java] 06. 객체지향(1)  (0) 2014.04.04
[Java] 05. 배열(2)  (0) 2014.04.03
Posted by 믐믐믐믐믐
,
  • Head First 시리즈는 항상 소설같은 느낌을 준다. 고등학교 시절 누드교과서라는 한때 유행했던 (지금은 어떤지 잘 모르겠지만..) 수험서가 있었는데 그 책도 소설같은 구성으로 당시 인기가 참 많았었다. 물론 너무 소설같이 죽죽 읽어나가서 딱히 성적이 올랐던거 같지는 않지만. 
    이번에 읽은 Head First는 Object-Oriented Analysis & Design. 한국어 번역본 제목은 ‘세상을 설계하는 객체지향 방법론’이 되겠다. 사실 막상 읽으면서 느꼈던 점은 제목이 좀 거창하지 않았나 싶다. 

  • 책을 시작하기전에 기대했던 바는 객체지향에 대한 구체적인 설명, 구현방법 등과 같은 테크티컬한 부분이었으나 오히려 이 책은 객체지향에 대한 직접적인 설명보다는 소프트웨어공학(이하 SE) 서적인가 싶을 정도로. 요구사항, 아키텍쳐, 테스팅, UML등 SE적인 부분들을 많이 다루고 있었다. 타이틀에 요구사항 수집, 변경이라는 문구가 나왔을때는 앗 이거 SE책인가? 했을 정도니…(그래서 본 글도 Software Engineering 카테고리에…)

  • 책의 구성은 아래와 같다.
    • (잘 설계된 프로그램이 세상을 뒤흔든다) 위대한 소프트웨어는 여기에서 시작된다.
    • (요구 사항 수집) 그들에게 원하는 것을 주세요
    • (요구 사항 변경) 당신을 사랑해요. 당신은 완벽해… 그런데 이건 좀 바꿨으면
    • (분석) 여러분의 소프트웨어를 실제 세상으로…
    • part1. (좋은 디자인 = 유연한 소프트웨어) 변하지 않는 것은 없다.
    • part2. (좋은 디자인 = 유연한 소프트웨어) 여러분의 소프트웨어를 운동시켜서 튼튼하게 만드세요
    • (정말 큰 문제들 해결하기) “내 이름은 아트 반델리… 나는 건축가예요”
    • (아키텍처) 혼란스러운 세상에 질서를
    • (디자인 원리들) 독창적인 디자인은 정도껏
    • (반복하기, 테스팅하기) 소프트웨어는 여전히 고객을 위한 것입니다.
    • (OOA&D 생명주기) 종합하기

  • 사실 애초에 목적했던 바는 책에 있는 예제들을 하나하나 다 따라가 보는 것이었지만 애초에 프로그래밍 언어를 학습하는 책도 아니었거니와 내용이 기존에 공부했던 SE와 너무 비슷해서는 그야말로 정말 소설읽듯이 페이지를 넘기기 바빴던 것 같다. 그동안 공부했던 것들이 알고보니 다 객체지향적인 것들이었던 것.. Use case라던가 아키텍쳐설계, 테스트 기법 등등..

    책을 읽으며 주요 문장들을 따로 정리해놓긴 했지만(‘문제를 해결하면서 새로운 문제를 만들지 말 것.’ 과 같은…) 포스팅하기에는 너무 책 내용을 바로 인용해온 것이라 저작권.. 이랄까 좀 걱정되는 부분이 있어서 개인적으로 참고만 해야할 듯 하고 앞으로 공부해 나가면서 짜는 코드들, 특히 프로젝트에 들어가서는 책의 내용을 참고하여 따라가보면 좋을 듯.

  • 복습할 겸 빠르게 한번정도 더 읽고 다음으로 'Java 언어로 배우는 디자인 패턴 입문'으로 들어갈 예정. 지금 클린코드라는 책도 같이 왔다갔다 하며 읽고 있는데 리팩토링을 할만한 프로젝트가 없다는게 아쉽다.


'공대생 > Software Engineering' 카테고리의 다른 글

[Clean Code] 0. Contents  (0) 2014.03.29
이클립스 업데이트 하기  (0) 2013.09.09
Posted by 믐믐믐믐믐
,

  • 자바 프로그래밍에서 '상속'을 설명할 때 주로 재활용, 재사용이라는 말을 많이 한다. 재사용은 객체 지향적인 프로그래밍에서 얻을 수 있는 큰 이점 중 하나인데 상속은 어떤 기존의 클래스의 특징을 그대로 재사용하여 다른 클래스를 만들 수 있게 해주는 기법으로써 코드를 재사용할 수 있는 기법이다.

  • 상속의 구현은 만약 Bullet이라는 클래스가 있고 이 Bullet의 특성을 물려받는 다른 종류의 Bullet, 예를들어 LightBullet 클래스를 만든다고 하면 

class LightBullet extends Bullet{

//...

}

과 같이 자식클래스 명 옆에 'extends  조상클래스명'을 써주는 것으로 가능하다.

이때, 두 클래스는 상속관계에 있으며
    Bullet 클래스는 상속을 해주는 클래스이며, 조상 클래스, 부모 클래스, 상위 클래스 등과 같이 부르고 
    LightBullet 클래스는 상속을 받는 클래스이며, 자손 클래스, 자식 클래스, 하위 클래스 등과 같이 부른다.


  • 다음은 총을 쏘는 Gun 클래스, 총알인 Bullet 클래스, Bullet 클래스를 상속받은 다른 종류의 총알인 BombBullet 클래스, LightBullet클래스로 구성된 예제이다.

package BulletEx;
public class Gun {
	private Bullet[] bullets; //총알이 담길 Bullets배열 생성.
	private int index;

	public Gun(Bullet[] bullets) {
		super();
		this.bullets = bullets;
	}

	public Bullet fire() {
		return bullets[index++];
	}

	public static void main(String[] args) {

		Bullet[] arr = new Bullet[20];

		for (int i = 0; i < arr.length; i++) {
			if (i % 5 == 0) {
				arr[i] = new LightBullet();
				continue;
			}
			if (i % 6 == 0) {
				arr[i] = new BombBullet();
				continue;
			}
			arr[i] = new Bullet();
		}

		Gun gun = new Gun(arr);

		for (int i = 0; i < 20; i++) {

			Bullet bullet = gun.fire();

			bullet.effect();

		}
	}
}

package BulletEx;
class Bullet {
	public void effect() {

		System.out.println("탕탕탕");

	}
}

package BulletEx;

public class LightBullet extends Bullet { 

	@Override
	public void effect() {
		System.out.println("------------------------");
		super.effect(); // bullet에 있는 effect를 한 번 호출해주고 내려온다 super 은 상속받은 곳 안에서만
						// 쓸 수 있음
		System.out.println("번쩍번쩍");
		System.out.println("------------------------");
	}
}

package BulletEx;

public class BombBullet extends Bullet {

	@Override
	public void effect() {
		// TODO Auto-generated method stub
		System.out.println("------------------------");
		super.effect();
		System.out.println("펑펑펑");
		System.out.println("------------------------");
	}

}


'공대생 > Java Programming' 카테고리의 다른 글

[Java] 10. 자료구조  (0) 2014.04.08
[Java] 09. 상속, 추상클래스, 인터페이스  (0) 2014.04.07
[Java] 07. 객체지향(2)  (0) 2014.04.04
[Java] 06. 객체지향(1)  (0) 2014.04.04
[Java] 05. 배열(2)  (0) 2014.04.03
Posted by 믐믐믐믐믐
,
  • 객체지향에 관한 예제들.
    • 다음은 속도가 다른 두 기차(여기서는 ktx와 통일호)가 서로 다른 역을 출발해서 속도가 더 빠른 기차(ktx)가 언제 속도가 더 느린 기차(통일호)를 추월하는지를 계산해 내는 예제이다.
package Train;
public class Main {
	public static void main(String[] args) {
		TrainCalculator calc = new TrainCalculator(); // TrainCalulator객체 생성.
		Train ktx = new Train("ktx", 300, 0); // ktx 객체 생성. 시속 300km. 처음 시작점은 0.
		Train union = new Train("union", 88, 90); // 통일호 객체 생성. 시속 88km. 처음 시작점은
													// 90km.
		System.out.println(calc.calcTime(ktx, union));// 결과 출력.
	}
}

package Train;

public class Train {
	String name; // 기차이름.
	float speed; // 기차속도.
	float position; // 기차 위치.

	public Train(String name, float speed, float position) { // 생성자.
		super();
		this.name = name;
		this.speed = speed;
		this.position = position;
	}

	public float runTrain() {// 기차 위치 계산.
		// 기차의 위치를 가장 잘 아는 것은 기차 자신이다!
		this.position += (speed / (float) 60);
		return this.position;
	}

}

package Train;

public class TrainCalculator { // 빠른기차가 느린기차를 언제 추월하는지 계산.
	public int calcTime(Train t1, Train t2) {
		int count = 0;
		while (true) {
			count++;

			if (t1.runTrain() > t2.runTrain()) {
				break;
			}
		}

		return count;
	}

}

    • 다음은 카페에서 점원이 매출기록을 작성하는 예제이며 수입과 지출을 입력하고 합산한 금액을 확인, 이전 기록 삭제, 입력한 내용 보기를 지원한다. 
      • Main class
      • Record class: 금액과 항목을 담고있는 하나의 레코드.
      • RecordManager class: 기록들을 담아놓은 배열을 관리. 입력받은 항목의 이름과 금액을 배열에 추가하며 이전 기록을 삭제. 입력된 항목들의 총 합을 계산함.
      • RecordUI class: 사용자(점원)에게 메뉴를 보여주고 사용자의 입력을 받음. 결과출력.
package StubCoffee;

public class Main {
	public static void main(String[] args) {
		RecordUI ui = new RecordUI();
		ui.totalUI();
	}
}

package StubCoffee;

public class Record {
	String name;
	int amount;

	public Record(String name, int amount) { // 하나의 레코드에는 반드시 항목의 이름과 금액이 존재해야
												// 함.
		super();
		this.name = name;
		this.amount = amount;
	}

	@Override
	public String toString() { // 객체내의 변수들을 string으로 보여주기 위해 이클립스에서 자동 생성 메소드.
		return "Record [name=" + name + ", amount=" + amount + "]";
	}

}

package StubCoffee;

import java.util.Arrays;

public class RecordManager {
	Record[] records; // 레코드들을 담아 놓을 records배열. 레코드들이 들어갈 배열이기때문에 타입은 Record.
	int idx; // 추가되거나 삭제될 경우 idx변수를 이용해 담고 삭제할 레코드의 위치(index)를 알 수 있다.

	public RecordManager() { // 초기에 100개의 공간을 만들어 놓음.
		records = new Record[100];
		idx = 0;
	}

	public void removeRecord() { // removeRecrod함수가 호출될 당시의 idx값을 null로 변경하고
									// 카운트는 1내림.
		records[--idx] = null;
	}

	public Record[] getRecord() { // 리스트확인을 요청할 경우 records배열을 리턴.
		return records;
	}

	public void addRecord(Record record) { // 사용자로부터 입력받은 record객체를 배열에 담음.
		records[idx++] = record;
	}

	public int getTotalAmount() { // 사용자가 금액들의 합을 요청하는 경우 records배열의 amount들을 모두
									// 더해서 리턴함.
		int sum = 0;
		for (int i = 0; i < idx; i++) {
			sum += records[i].amount;
		}
		return sum;
	}

}

package StubCoffee;

import java.util.Scanner;

public class RecordUI {
	Scanner scanner;
	RecordManager manager;

	public RecordUI() {
		scanner = new Scanner(System.in);
		manager = new RecordManager();
	}

	public void totalUI() { // 메뉴 출력. 사용자 입력 받음.
		System.out.println("1.Add Record");
		System.out.println("2.View Total");
		System.out.println("3.Remove Record");
		System.out.println("4.Show List");
		System.out.println("5.Quit");

		String oper = scanner.nextLine();

		switch (oper) {
		case "1":
			addJob();
			break;
		case "2":
			viewSum();
			break;
		case "3":
			removeJob();
			break;
		case "4":
			viewList();
		case "5":
			return;

		}
		totalUI();

	}

	private void viewList() { // idx값 만큼 반복해서 getRecord method를 반복하여 입력된 항목들의
								// 리스트를 보여줌.
		// TODO Auto-generated method stub
		for (int i = 0; i < manager.idx; i++) {
			System.out.println(manager.getRecord()[i].toString());
		}

		totalUI(); // 리스트를 다 보여주고 나면 다시 초기 메뉴를 보여줌.

	}

	private void removeJob() { // 최근 항목 삭제.
		// TODO Auto-generated method stub
		manager.removeRecord();
		System.out.println("삭제되었습니다.");
	}

	public void viewSum() { // 금액들의 모든 합을 보여줌.
		int total = manager.getTotalAmount();
		System.out.println(total);
	}

	public void addJob() { // 항목명과 금액을 사용자로부터 입력받아 record객체를 생성후 manager객체의
							// addRecord method에 parameter로 넘겨줌.
		while (true) {
			System.out.println("TITLE: ");
			String title = scanner.nextLine();

			System.out.println("AMOUNT: ");
			int amount = Integer.parseInt(scanner.nextLine());

			Record record = new Record(title, amount);
			manager.addRecord(record);

			System.out.println("CONTINUE:1 BREAK:2"); // 항목을 추가한 뒤 계속 항목 추가 작업을
														// 진행 할지 여부.
			String oper = scanner.nextLine();
			if (oper.equals("2")) {
				break;
			}

		}
	}


'공대생 > Java Programming' 카테고리의 다른 글

[Java] 09. 상속, 추상클래스, 인터페이스  (0) 2014.04.07
[Java] 08. 상속  (0) 2014.04.06
[Java] 06. 객체지향(1)  (0) 2014.04.04
[Java] 05. 배열(2)  (0) 2014.04.03
[Java] 04. 배열(1)  (0) 2014.04.01
Posted by 믐믐믐믐믐
,
  • 자바는 흔히들 객체지향 프로그래밍(Object-Oriented Programming, OOP) 언어라 부른다.

    객체지향은 우리가 알고 있는 대표적인 프로그래밍 언어인 C가 비교적 명령어의 목록으로 구성되는 것과 달리 컴퓨터 프로그램을 여러 객체들의 모임으로 바라보는 것이다. 이때 객체는 서로 메시지를 주고받고 데이터를 처리한다.

    처음 객체지향이라는 것을 접했을 때는 평소 잘 쓰이지 않는 단어인 객체라는 것에 대한 이해가 정말 어려웠고 아직까지도 누군가 객체가 뭐냐고 물어봤을때 확신을 가지고 설명하기엔 부족함이 많다. 다만 지금까지 봐온 객체와 관련된 많은 설명중 개인적으로 가장 와닿는 말은 '객체란 메소드와 그에 관련된 변수들을 묶어 놓은 것.'

  • 자바에서 새로운 객체를 생성하는 방법은 다음과 같다.
    • 클래스명 변수명;
    • 변수명 = new 클래스명();
    • 위 문장은 클래스명 변수명 = new 클래스명(); 과 같이 작성 가능하며 앞의 클래스명의 경우 인스턴스의 타입을 나타내는 것이다.

  • 다음은 45개의 후보 공들 중 6개를 뽑는 로또예제이다.
    • 이 예제는 45개 각각의 공들을 만들어 낼 수 있는 LottoBall클래스, 45개의 공들을 만들어 담고 그중 6개의 당첨 공을 뽑아내는 LottoMachine, LottoMachine의 객체를 생성하여 결과를 출력하는 Main클래스로 이루어져 있다.

package Lotto; 
public class Main {
    public static void main(String[] args) {
 
        LottoMachine machine = new LottoMachine(); // LottoMachine객체 생성.
        for (LottoBall balls : machine.selectBalls()) {// 생성된 객체에서
                                                        // selectBalls메소드를 통해
                                                        // balls배열에 결과를 넣고
            System.out.println(balls.num);// 결과 출력.
        }
    }
}

package Lotto;
 public class LottoMachine {
 
    LottoBall[] balls; // LottoBall type의 balls배열 생성. 45개의 로또볼들을 담을 곳.
 
    public LottoMachine() { // 45개의 공을 생성하여 balls배열에 담음.
        balls = new LottoBall[45];
        for (int i = 1; i <= 45; i++) {
            balls[i - 1] = new LottoBall(i);
        }
    }
 
    public LottoBall[] selectBalls() { // 6개의 당첨공을 랜덤함수로 뽑고 중복을 방지하기 위해 ball이
                       // 선택되었던 공인지 확인함.
        LottoBall[] resultBalls = new LottoBall[6];
        for (int i = 0; i < 6; i++) {
            int index = (int) (Math.random() * balls.length);
            LottoBall ball = balls[index];
            if (ball.isSelected()) {
                i--;
                continue;
            }
 
            resultBalls[i] = ball; // 선택되었던 공이 아닐경우 결과 배열에 그 공을 담음.
 
        }// end for
        return resultBalls;
    }
 
}

package Lotto;

public class LottoBall {
	int num; // 공의 번호
	boolean selected; // 중복당첨 방지를 위한 선택되었던 공인지 아닌지 판별 boolean 변수

	public LottoBall(int num) { // 생성될때 공은 자신의 번호를 반드시 가지고 있어야 하므로 생성자 생성.
		super();
		this.num = num;
	}

	public boolean isSelected() { // 공 자기자신이 선택되었던 공인지 아닌지를 알고 있음.
		boolean result = false;
		if (selected == false) {
			result = false;
			selected = true;
		} else {
			result = true;
		}
		return result;
	}
}


  • 다음은 도넛의 면적을 구하는 예제이며 도넛의 바깥원의 넓이에서 안쪽 구멍부분의 넓이를 빼줌으로써 결과를 구하게 된다.

    • 이 예제는 바깥 원과 안쪽 원 객체를 각각 생성할 수 있는 Circle클래스, 생성된 원들의 넓이의 차를 구해 결과적으로 도넛의 넓이를 계산하는 CircleManager클래스, 사용자로부터 바깥 원과 안쪽 원의 반지름을 입력받고 결과를 출력하는 CircleUI클래스, Main클래스로 구성되어있다.

    • 본 예제에서 흥미있는 부분은 각 원들의 넓이를 Circle클래스에서 구한다는 점인데 이는 각 원들이 자기 자신의 반지름 뿐만이 아니라 넓이도 가장 잘 알고있다는 사실을 반영한 것이다. 보통 원의 넓이를 구하는 계산은 CircleManager에서 다뤄야 할 것 같지만 조금 더 생각해보면 각각의 원들은 자신의 넓이를 다른 누구보다 자신들이 가장 잘 알고 있을테다.

package Circle;
 
public class Main {
    public static void main(String[] args) {
        CircleUI ui = new CircleUI();
        ui.calcResult();
    }
}

package Circle;
 
import java.util.Scanner;
 
public class CircleUI {
    CircleManager manager;
    Scanner scanner;
 
    public CircleUI() {
        manager = new CircleManager();
        scanner = new Scanner(System.in);
    }
 
    public void calcResult() {
        System.out.println("outer");
        Double outer = Double.parseDouble(scanner.nextLine()); // 바깥 원의 반지름
                                                                // 입력받음.
 
        System.out.println("inner");
        Double inner = Double.parseDouble(scanner.nextLine()); // 안쪽 원의 반지름
                                                                // 입력받음.
 
        Double result = manager.calcDonutArea(new Circle(outer), new Circle(inner));
        System.out.println(result);// 입력받은 반지름으로 결과출력.
    }
 
}

package Circle;
 
public class CircleManager {
 
    public double calcDonutArea(Circle outer, Circle inner) { // 바깥 원과 안쪽 원의 넓이를
                                                                // 받아서 차이를 통해
                                                                // 도넛의 넓이를 구함.
        return outer.getArea() - inner.getArea();
    }
}

package Circle;
 
public class Circle {
    double radious; // 원의 반지름
 
    public Circle(double radious) {
        super();
        this.radious = radious;
    }
 
    public double getArea() { // 반지름으로 생성될 원의 넓이를 구함. 원의 넓이는 원 객체 자신이 가장 잘 알고
                                // 있다!
        return (this.radious * this.radious) * Math.PI;
    }
}


'공대생 > Java Programming' 카테고리의 다른 글

[Java] 08. 상속  (0) 2014.04.06
[Java] 07. 객체지향(2)  (0) 2014.04.04
[Java] 05. 배열(2)  (0) 2014.04.03
[Java] 04. 배열(1)  (0) 2014.04.01
[Java] 03. 반복문  (0) 2014.03.31
Posted by 믐믐믐믐믐
,
  • 다음은 유저가 입력한 두 단어가 아나그램(anagram:철자 순서만 바뀐 단어)인지를 판별하는 예제이다.
import java.util.Arrays;
import java.util.Scanner;
 
public class Anagram {
    // main method에서 입력받은 string타입의 두 단어를 parameter로 받아서 아나그램인지 판별하는 method.
    // 아나그램일경우 true, 아나그램이 아닐경우 false값을 리턴함.
    public static boolean isAnagram(String str1, String str2) {
        boolean result = true; // result의 기본값은 true이며 아래의 판별과정에서 아나그램이 아닐경우
                          // false.
 
        char[] arr1 = str1.toCharArray(); // str1 parameter의 string값을 char타입의
                             // arr1배열에 넣은 후
        Arrays.sort(arr1); // 알파벳 순서대로 정렬.
        System.out.println(Arrays.toString(arr1)); // arr1배열에 정렬된 결과 출력.
 
        char[] arr2 = str2.toCharArray();
        Arrays.sort(arr2);
        System.out.println(Arrays.toString(arr2));
 
        // 먼저 입력받은 두 단어의 길이가 다를 경우 아나그램이 아니므로 false값 리턴후 종료.
        if (arr1.length == arr2.length) {
            for (int i = 0; i < arr1.length; i++) { // 두 단어의 길이가 같은 경우 arr1과
                                      // arr2의 내용이(알파벳이)같은지 확인.
                if (arr1[i] != arr2[i]) { // 확인 과정 중 같지않은 경우가 나오면 result값을
                                  // false로 바꾸고 종료.
                    result = false;
                    break;
                }
            }
        } else {
            result = false;
        }
        return result;
    }
 
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
 
        System.out.println("첫 번째 문자열을 입력해주세요.");
        String str1 = scanner.nextLine();
 
        System.out.println("두 번째 문자열을 입력해주세요.");
        String str2 = scanner.nextLine();
 
        if (isAnagram(str1, str2) == true) { // isAnagram method로 두 단어를
                                // parameter로 넘겨준 후 결과가 true일 경우.
            System.out.println("두 문자열은 Anagram이 확실합니다.");
 
        } else { // isAnagram method로 두 단어를 parameter로 넘겨준 후 결과가 false일 경우.
            System.out.println("두 문자열은 Anagram이 아닙니다.");
        }
    }
}

  • 다음은 [Java] 02. 제어문에서 다뤘던 'FindNearestPoint'예제에 배열을 적용하여 다시 짜본 예제이다.
import java.util.Arrays;
 
public class DistanceCalculator {
 
    public static double calcDistance(int[] p1, int[] p2) { // 정의된 다섯개의 좌표와 유저가
                                                            // 입력한 좌표에 대한 값을
                                                            // parameter로 받아서
                                                            // 각각의 거리를 계산.
        return Math.sqrt(Math.pow(p1[0] - p2[0], 2) + Math.pow(p1[1] - p2[1], 2));
    }
 
    public static void main(String[] args) {
        int[][] dataArr = { { 2, 4 }, { 4, 6 }, { 10, 4 }, { 3, 2 }, { 9, 2 } };// 미리
                                                                                // 정의된
                                                                                // 다섯개의
                                                                                // 좌표.
        int[] targetPoint = { 3, 4 }; // 임의의 유저입력 좌표.
        int[] minPoint = null;
 
        double minDistance = Double.MAX_VALUE;
 
        for (int[] temp : dataArr) {
            double distance = calcDistance(temp, targetPoint); // 미리 정의된 다섯개의
                                                                // 좌표와 유저입력 좌표와의
                                                                // 거리 계산.
            if (distance < minDistance) {
                minDistance = distance;
                minPoint = temp;
            }
 
            System.out.println(distance);
        }
        System.out.println("-----------");
        System.out.println(minDistance);
        System.out.println(Arrays.toString(minPoint));
    }
}

  • 배열을 공부하면서 가장 크게 느낀 점은 배열 자체의 내용보다 오히려 '타입'에 대한 것이 크다. 배열이라는 것이 같은 '타입'에 대한 것들을 한꺼번에 다루는 것이기에 '타입'에 대한 고민을 할 수밖에 없었는데 이는 자바를 공부하면서 가장 애매했던 것 중의 하나였다. 특히 사용자(개발자)가 정의하는 '타입'이 주는 어려움과 편리함에 이해하고 나서 자바라는 언어를 조금이나마 더 이해할 수 있게 됐달까. 지금 이 포스팅에서 자바의 '타입'에 대해 더 깊이 다룰 순 없지만, 누군가 배열에 대한 궁금함을 안고 이 글을 보게 된다면 배열뿐만이 아니라 아마도 나와 같은 고민을 하게 될 것이라..!


'공대생 > Java Programming' 카테고리의 다른 글

[Java] 07. 객체지향(2)  (0) 2014.04.04
[Java] 06. 객체지향(1)  (0) 2014.04.04
[Java] 04. 배열(1)  (0) 2014.04.01
[Java] 03. 반복문  (0) 2014.03.31
[Java] 02. 제어문  (0) 2014.03.31
Posted by 믐믐믐믐믐
,
  • 배열(Array)은 자바에서 같은 타입의 변수들을 한꺼번에 다룰 수 있게 해준다. 

  • 배열을 선언하는 방법은
    • 타입[] 변수이름;
      • Ex. int[] score;
    • 타입 변수이름[];
      • Ex. int score[];
    • 위 두 가지가 있는데 보통 전자를 많이 사용한다. 

  • 이렇게 선언된 배열을 실제로 생성하기 위해서는 연산자 'new'와 배열의 타입과 크기를 지정해 주어야 한다.
    • Ex. int[] score;
           score = new int[5];
    • 위의 문장은 int[] score = new int[5]; 와 같이 쓸 수도 있다.

  • 다음은 23명으로 이루어진 반에서 4개의 조로 임의로 조편성을 하는 예제 코드이다.

import java.util.Arrays;
 
public class JoPyunSung {
    public static void main(String[] args) {
        // 23명으로 이루어진 반의 멤버들을 담을 member 배열 생성후 메모리에 String타입의 23개의 빈 공간을 생성하고,
        // 4개의 조와 각 조별로 인원이 들어갈 5혹은 6개의 공간을 마련하기위해 다차원 배열 team을 만들어줌.
        String[] member = new String[23];
        String[][] team = new String[4][];
 
        // 4개의 조에 각각 인원수만큼의 공간을 만들어줌.
        team[0] = new String[6];
        team[1] = new String[6];
        team[2] = new String[6];
        team[3] = new String[5];
 
        // member 배열에 23명의 반 인원들의 이름을 넣어줌. 본 예제에서는 임의로 0번 부터 22번까지의 숫자로 이름을 부여.
        for (int i = 0; i < member.length; i++) {
            member[i] = i + "번 사람";
        }
 
        // 반 인원수가 23명이므로 먼저 20명에 대해 랜덤으로 조편성을 해줌.
        // 이때, 중복으로 선택되는 것을 방지하기 위해 조편성이 된 인원에 해당하는 member배열은 x값으로 바꿔줌.
        for (int i = 0; i < 5; i++) {
            for (int j = 0; j < team.length;) {
                int k = (int) (Math.random() * 100 % 23);
                if (!member[k].equals("x")) {
                    team[j][i % 6] = member[k];
                    member[k] = "x";
                    j++;
                }
            }
        }
 
        // team[0]부터 team[2]까지 남은 3명의 인원에 대한 조편성 마무리.
        for (int j = 0; j < team.length - 1;) {
            int k = (int) (Math.random() * 100 % 23);
            if (!member[k].equals("x")) {
                team[j][5] = member[k];
                member[k] = "x";
                j++;
            }
        }
 
        // 결과 출력.
        System.out.print("전체: " + Arrays.toString(member));
        System.out.println();
        for (int i = 0; i < team.length; i++) {
            System.out.println(i + 1 + "조: " + Arrays.toString(team[i]));
        }
    }
}

  • 다음은 임의의 6명의 인원에 대한 제비뽑기(등수매기기)예제이다.


import java.util.*;
 
public class ArrayEx1 {
 
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Scanner scanner = new Scanner(System.in);
 
        // 제비뽑기 참여 인원 6명의 숫자를 위한 공간과 각각에 해당되는 이름을 위한 String타입의 다차원배열 arr생성.
        // 6은 참여인원 수. 2는 6명 각각의 번호와 이름을 위한 공간.
        String[][] arr = new String[6][2];
 
        // 6개의 공간에 해당 숫자와 이름을 할당.
        for (int i = 0; i < arr.length; i++) {
            arr[i][0] = i + 1 + "번";
            System.out.println(arr[i][0] + " 이름을 입력해주세요.");
            arr[i][1] = scanner.nextLine();
        }
        // 중복방지.
        int[] index = new int[6];
        int[] tmp = { 0, 0, 0, 0, 0, 0 };
 
        for (int i = 0; i < index.length;) {
            int j = (int) (Math.random() * index.length * 120 % 6);
            if (tmp[j] == 0) {
                tmp[j] = 1;
                index[i] = j;
                i++;
            }
        }
 
        // System.out.println(Arrays.toString(index));
        // 결과출력.
        for (int i = 0; i < arr.length; i++) {
            System.out.println(Arrays.toString(arr[i]) + (index[i] + 1) + "등");
        }
    }
}

'공대생 > Java Programming' 카테고리의 다른 글

[Java] 06. 객체지향(1)  (0) 2014.04.04
[Java] 05. 배열(2)  (0) 2014.04.03
[Java] 03. 반복문  (0) 2014.03.31
[Java] 02. 제어문  (0) 2014.03.31
[Java] 01. 자료형  (0) 2014.03.31
Posted by 믐믐믐믐믐
,
  • 반복문은 어떤 작업이 반복적으로 수행되도록 할 때 사용됨.

  • for문: 반복될 작업의 횟수를 비교적 명확히 알 수 있을 때 사용.

    • for (초기화; 조건식; 증감식){
           // 실행문
          // 조건식이 참일 때 수행될 내용을 적음.
      }

      • 초기화: int i = 0과 같이 조건식과 증감식에 사용될 변수를 초기화 시켜주며 
        조건식: i < 10과 같이 수행될 횟수를 조건식으로 줘서 조건식이 참인 경우 실행문을 반복하며 거짓인 경우 수행을 그만둠.
        증감식: i++ 과 같이 반복문의 실행문이 실행된 후 i값을 증가시켜 카운트 해줌.

      • 초기화, 조건식, 증감식은 모두 생략이 가능하며 꼭 설명한 위치가 아니라도 적어줄 수 있다.

    • 다음은 최근 모 방송에서 화제가 되었던 헨리의 수학문제를 반복문으로 구현해 본 것이다.

      • 헨리의 수학문제:  
        • 5 ※ 2 = 11
        • 2 ※ 4 = 14
        • 3 ※ 2 = 7
        • 4 ※ 5 = 30
        • 8 ※ 4 = ?

      • 답은 38이며 ※ 앞의 숫자와 그 이후의 숫자들을 ※뒤의 숫자 개수까지 더해서 구할 수 있다.

public class Henry {
    public static void main(String[] args) {
 
        Scanner scanner = new Scanner(System.in);
 
        // ※(당구장표시) 앞의 숫자를 입력받음
        System.out.print("input initValue:");
        int initValue = scanner.nextInt();
 
        // ※(당구장표시) 뒤의 숫자를 입력받음
        System.out.print("input nxtValue:");
        int nxtValue = scanner.nextInt();
 
        int result = 0;
        int tmp = initValue;
 
        // for문에서 초기, 조건, 반복식에 사용 될 int형 변수 i를 선언하고 0으로 초기화함
        // for문은 사용자가 두번째에 입력한 nxtValue값 만큼 반복되며 한번 반복 될 때마다 i는 1씩 증가.
 
        for (int i = 0; i < nxtValue; i++) {
            result = tmp + result;
            tmp++;
        }
        // 결과 출력.
        System.out.println(result);
    }
 
}  


'공대생 > Java Programming' 카테고리의 다른 글

[Java] 06. 객체지향(1)  (0) 2014.04.04
[Java] 05. 배열(2)  (0) 2014.04.03
[Java] 04. 배열(1)  (0) 2014.04.01
[Java] 02. 제어문  (0) 2014.03.31
[Java] 01. 자료형  (0) 2014.03.31
Posted by 믐믐믐믐믐
,
  • if 문
    • if(조건식1){
             조건식1이 참일 때 수행될 내용
      } else if(조건식2){
             조건식2가 참일 때 수행될 내용
      } else {
             조건식1 혹은 2 어느 조건식도 만족하지 않을 때 수행될 내용. 
      }
    • 조건식에는 true 혹은 false값을 가지는 수식만 사용될 수 있음

  • 다음은 2차원 그래프상에 미리 지정된 5개의 좌표와 사용자가 입력한 좌표에 대해 가장 가까운 거리를 찾는 예제.


public class FindNearestPoint {
    public static void main(String[] args) {
        // 미리 지정된 5개 2좌표. 각 좌표에서 원점까지의 거리 계산.
        double a1 = (double) Math.sqrt(4 * 4 + 6 * 6);
        double a2 = (double) Math.sqrt(10 * 10 + 4 * 4);
        double a3 = (double) Math.sqrt(9 * 9 + 2 * 2);
        double a4 = (double) Math.sqrt(2 * 2 + 4 * 4);
        double a5 = (double) Math.sqrt(3 * 3 + 2 * 2);
 
        // 사용자 좌표 입력
        Scanner scanner = new Scanner(System.in);
        System.out.println("x:");
        double x = scanner.nextDouble();
        System.out.println("y:");
        double y = scanner.nextDouble();
        // 사용자 좌표와 원점까지 거리계산
        double a6 = (double) Math.sqrt(x * x + y * y);
 
        // tmp 변수에 a1과 사용자 좌표 a6의 차이를 담음.
        // valName 변수에 차이가 가장 작은 좌표의 이름을 담음.
        double tmp = Math.abs(a1 - a6);
        String valName = "A1";
 
        // 나머지 좌표 A2~A5까지 비교하여 가장 차이가 작은 좌표를 찾음.
        // 이때, 모든 좌표에 대해 비교하기 위해 if문으로만 구성.
        if ((Math.abs(a2 - a6) < tmp) || (Math.abs(a2 - a6) == tmp)) {
            tmp = Math.abs(a2 - a6);
            valName = "A2";
        }
        if ((Math.abs(a3 - a6) < tmp) || (Math.abs(a3 - a6) == tmp)) {
            tmp = Math.abs(a3 - a6);
            valName = "A3";
        }
        if ((Math.abs(a4 - a6) < tmp) || (Math.abs(a4 - a6) == tmp)) {
            tmp = Math.abs(a4 - a6);
            valName = "A4";
        }
        if ((Math.abs(a5 - a6) < tmp) || (Math.abs(a5 - a6) == tmp)) {
            tmp = Math.abs(a5 - a6);
            valName = "A5";
        }
        // 결과 출력.
        System.out.println("가장 가까운 좌표는" + valName + "이며, " + "거리는 " + tmp);
    }
}

'공대생 > Java Programming' 카테고리의 다른 글

[Java] 06. 객체지향(1)  (0) 2014.04.04
[Java] 05. 배열(2)  (0) 2014.04.03
[Java] 04. 배열(1)  (0) 2014.04.01
[Java] 03. 반복문  (0) 2014.03.31
[Java] 01. 자료형  (0) 2014.03.31
Posted by 믐믐믐믐믐
,