객체지향프로그래밍 (한화인턴교육)

 생성자메소드

package java03_oop;

import java.util.Scanner;
import java.util.Calendar;

// public 
class ClassTest {
		// 멤버영역(Field변수): class가 실행되고 나면 없어짐
		// 변수 선언하고 객체를 생성
		int num = 100;
		String name;
		double data = 13.3;
		Scanner sc = new Scanner(System.in);
		
		// 실행문은 사용할 수 없다
		System.out.println("멤버영역에서 메소드 호출");
		
		// 실행문을 사용하려면
		static {
			System.out.println("멤버영역에서 메소드 호출");
		}
		int result = (int)(num+data);
		
		
		// 생성자메소드 Constractor method
		// 메소드명이 클래스명과 같아야함
		// 반환형이 없다
		// 생성자메소드는 여러 개 만들 수 있음 
		// (단, 매개변수의 개수 or 데이터형이 달라야햠)
		// 생성자메소드는 객체 생성 시 한번 실행되고 끝임
		
		ClassTest(){
			System.out.println("ClassTest()....");
		}
		
		ClassTest(int n){
			System.out.println(n+"->ClassTest(int n)...");
		}
		
		ClassTest(String n){
			System.out.println(n+"->ClassTest(String n)...");
		}
		
		ClassTest(int n, String name){
			System.out.println(n+", "+name+"->ClassTest(int n, String name)....");
		}
		
		// 메소드 : 하나의 작업단위
		// 접근제한자 반환형: void -> 메소드의 실행결과가 돌아오는 값이 없다.
		// 메소드명은 소문자로 시작. 합성어일 경우 두번째 단어부터 첫글자를 대문자로 한다
		
		// Main 안에다가 다 만들면 재사용이 안됨 (ex. Calendar.class) 
		// 메소드로 만들면 필요한 기능들을 가져다가 쓸수 있음. 재활용 가능
		public void sum() {
			// 실행문 (if문 for문 등등..)
			int tot = 0;
			for(int i=1; i<=100; i++) {
				tot += i;
			}
			System.out.println("합은="+tot);
			// 같은 클래스 내 메소드끼리는 호출 가능
			int tot2 = total(200);
			System.out.println("total->" + tot2);
		}
		
		// 반환형이 있는 경우
		public int total(int max) {
			int sum=0;
			for(int i=1; i<=max; i++) {
				sum += i;
			}
			return sum; // sum, i, max 세개의 변수 중 어떤것을 반환할지 지정
		}

}

 

- 클래스 객체 생성

public class ClassTestMain {

	public static void main(String[] args) {
		// 생성자 메소드의 종류만큼 객체를 생성하는 방법이 생긴다
		ClassTest ct = new ClassTest(100, "홍길동");
		
		// 1~100 까지 합 구하는 기능이 필요함 -> sum()을 포함하고 있는 클래스를 객체로 생성
		// 객체.메소드명()
		ct.sum();
		int result = ct.total(50); // int가 반환됐으므로 보관해야함
		System.out.println(result);
		
	}

}

 

root - 클래스 생성

ㄴ> 폴더 - 클래스생성

 

생성자 메소드는 class명과 같다.

단, 매개변수는 모두 달라야함

 

 

 

예제)

1. 메소드1

단을 매개변수로 받아 해당 단을 출력하는 메소드

 

2. 메소드2

구구단 2-9단 까지 한번에 출력하는 메소드

 

2. 메소드3

콘솔에서 num을 입력받는 메소드

 

 

public class CalculatorEx {
	int plus(int n1, int n2) {
		return n1+n2;
	}

	int minus(int n1, int n2) {
		return n1-n2;
	}

	int multiple(int n1, int n2) {
		return n1*n2;
	}		
	
	int divide(int n1, int n2) {
		return n1/n2;
	}
	
	// 같은 클래스 내 다른 메소드를 호출해서 결과 반환
	void calculator(int n1, int n2) {
		System.out.println(n1+"+"+n2+"="+plus(n1,n2));
		System.out.println(n1+"-"+n2+"="+minus(n1,n2));
		System.out.println(n1+"*"+n2+"="+multiple(n1,n2));
		System.out.println(n1+"/"+n2+"="+divide(n1,n2));
	}

}

 

import java.util.Scanner;

public class GuGuDan {
	CalculatorEx cc = new CalculatorEx(); // 해당클래스가 메소드1,2 모두 필요하므로 멤버영역에 정의
	
	// 메소드1: 입력받은 단만
	void gugudan(int dan) {
		// CalculatorEx cc = new CalculatorEx();  // multiple메소드를 가진 클래스(CalculatorEx)를 호출
		for(int i=2; i<=9; i++) {
			System.out.printf("%d*%d=%d\n", dan, i, cc.multiple(dan, i));
		}
	}
	
	// 메소드2: 전체 단
	void allGugudan() {
		for(int dan=2; dan<=9; dan++) {
			for(int i=2; i<=9; i++) {
				System.out.printf("%d*%d=%d\n",dan, i, cc.multiple(dan, i));
			}
		}
		
	}
	
	// 메소드3: 콘솔에서 정수입력받는 메소드
	int consoleInput(String msg) {
		Scanner scan = new Scanner(System.in);
		System.out.print(msg+"=");
		return scan.nextInt();
	}

}

public class GuGuDanMain {

	public static void main(String[] args) {
		GuGuDan gugu = new GuGuDan();
		gugu.allGugudan();
		
		// 10단만 출력
		gugu.gugudan(10);
		
		int d = gugu.consoleInput("단을 입력하시오");
		gugu.gugudan(d);

	}

}

 

예제) Calendar 만들었던 것을 객체지향으로 변환

 

1. 클래스 생성

import java.util.Calendar;
import java.util.Scanner;

public class CalendarObject {
	// 메소드1: 년월 입력
	int yearMonthInput(String msg) {
		Scanner sc = new Scanner(System.in);
		System.out.print(msg + "=");
		return sc.nextInt();	
	}
	
	// 메소드2: 요일 반환
	int weekDay(int year, int month) {
		Calendar date = Calendar.getInstance();
		date.set(year, month-1, 1);
		return date.get(Calendar.DAY_OF_WEEK);
	}
	
	// 메소드3: 해당 월의 마지막 날짜 (31,30,28or29)
	int lastDay(int year, int month) {
		int lastday = 31;
		switch(month) {
		case 4:
		case 6:
		case 9:
		case 11: lastday = 30; break;
		case 2:
			// 윤년인 경우와 아닌 경우
			if(year%4==0 && year%100!=0 || year%400==0) {
				lastday = 29;
			}else {
				lastday = 28;
			}
		} return lastday;		
		}
	
	// 메소드4: 달력 프린트
	void printCal(int year, int month, int week, int lastday) {
		// 헤더출력
		System.out.println("\t\t"+year+"년 "+month+"월");
		System.out.println("일\t월\t화\t수\t목\t금\t토");
	
		// 공백출력
		for(int space=1; space<week; space++) {
			System.out.print(" \t");
		}
		
		// 날짜 출력
		for(int day=1; day<=lastday; day++) {
			System.out.print(day+"\t");  // 옆으로만 쭉쭉 나열하게 됨
			if((day+week-1)%7==0) {
				System.out.println();    // 7개마다 한줄씩 내려라
			}
		}
		System.out.println();	
	}
	
	
	// 메소드5: 계속여부 확인
	boolean question() {
		Scanner sc = new Scanner(System.in);
		System.out.print("계속하시겠습니까? ");
		String res = sc.nextLine();
		if(res.equals("y")) {
			return true;
		}else {
			return false;
		}
	}
	
	// 전부 다 출력해주는 메소드
	void myCal() {
		GuGuDan gugu = new GuGuDan();
		do {
			int y = gugu.consoleInput("년도");
			int m = gugu.consoleInput("월");
			int w = weekDay(y,m);
			int lastday = lastDay(y,m);
			
			printCal(y,m,w,lastday);
			
		}while(question());
	}
	

}

 

2. 메인메소드

 

public class CalendarMain {

	public static void main(String[] args) {
		CalendarObject cal = new CalendarObject();
//		GuGuDan gugu = new GuGuDan();
//		int year = gugu.consoleInput("연도");
//		int month = gugu.consoleInput("월");
//		
////		int year = cal.yearMonthInput("년도");
////		int month = cal.yearMonthInput("월");
//		
//		
//		int week = cal.weekDay(year, month);
//		int lastday = cal.lastDay(year, month);
//		
//		cal.printCal(year, month, week, lastday);
		
		cal.myCal();
		

	}

}

 

< 접근제한자 >

 

 

<상속(inheritance)>

자동차에 들어가는 엑셀,브레이크,최고속도,컬러 등의 기본 정보를 처리하는 class

--> 버스&세단&트럭 에 들어가는 프로그램을 작성할때 해당 class를 활용

 

- 클래스는 한개만 상속받을 수 있음

- 여러개를 상속받고 싶으면 연달아서 받으면 됨

   C클래스 -> B클래스 -> A클래스

   (A는 B, C 두개의 클래스를 상속받음)

 

• 추상 클래스란?

- 추상클래스는 추상메소드를 1개 이상 포함하고 있는 클래스
- 추상메소드는 메소드명과 반환이 정해지고 싱행부는 없는 메소드를 말한다.
- 추상클래스는 객체를 생성할 수 없으며, 반드시 상속받아서 추상메소드를 오버라이딩 해주어야함

 

- 코드 입력시: 

1) 추상클래스는 class키워드 왼쪽에 abstract를 표기

2) 추상메소드는 반환형 왼쪽에 abstract키워드를 표기해야 함

 

 

• 추상 메소드의 사용 목적

자바에서 추상 메소드를 선언하여 사용하는 목적은 추상 메소드가 포함된 클래스를 상속받는 자식 클래스가 반드시 추상 메소드를 구현하도록 하기 위함입니다.

만약 일반 메소드로 구현한다면 사용자에 따라 해당 메소드를 구현할 수도 있고, 안 할 수도 있습니다.

하지만 추상 메소드가 포함된 추상 클래스를 상속받은 모든 자식 클래스는 추상 메소드를 구현해야만 인스턴스를 생성할 수 있으므로, 반드시 구현하게 됩니다.

 

 

public abstract class AbstractTest { // 추상클래스는 class키워드 왼쪽에 abstract를 표기

	int data = 200;
	public AbstractTest() {}; // 생성자는 무조건 만들어 두는게 좋음
	
	// 메소드 - 합, 차, 곱, 몫을 구하는 기능
	
	// 합
	// 추상메소드: 반환형 왼쪽에 abstract키워드를 표기해야 함
	public abstract int add(int n1, int n2);
	
	
	// 차
	public void minus(int n1, int n2) {
		int result = n1-n2;
		output(n1, n2, result, "-");
	}
	
	// 곱
	// 추상메소드
	public abstract void multiple(int n1, int n2);
	
	
	// 몫
	public void divide(int n1, int n2) {
		int result = n1/n2;
		output(n1, n2, result, "/");
	}	
	
	// 출력하는 메소드 별개로
	public void output(int n1, int n2, int result, String operator) {
		System.out.printf("%d %s %d = %d\n", n1, operator, n2, result);
	}

}

 

• Main메소드
  - 추상클래스를 상속받으면 모든 추상메소드는 하위클래스에서 오버라이딩 되어야 한다

(다시정리)

- 추상화: 클래스간 공통점을 찾아서 공통의 부모를 설계
- 구체화: 상속을 통해 클래스를 설계, 확장하는 작업
- 여러 객체에 공통되는 사항을 추출 -> 부모클래스에 선언,구현 -> 자식클래스에는 특징을 구현
  
  예) 부모클래스(추상클래스:운송수단) --> 자식클래스(택시객체,버스객체)에서 상속 받아 기능구현  
  공통된 두 기능(이동,지불)을 추상클래스 내 추상메소드로 선언
  자식클래스에서 상속 받아 클래스별 특성(버스,택시)에 맞게 재구현 (오버라이딩)
  '탑승' 메소드는 추상클래스에서 기능구현까지 완료

 

추상클래스/추상메소드 선언

자식클래스에서 메소드 기능 구현

실행클래스 생성 후 실행 결과

 

 

• 내부 클래스란?
  클래스 내부의 클래스

- 외부클래스의 변수를 내부클래스에서 활용 가능 (반대는 안됨)

1. 멤버영역의 내부클래스
2. 메소드 내의 내부클래스
3. 익명의 내부클래스

 

<멤버영역의 내부클래스>

public class Outer {
	int num = 1234;
	String name = "홍길동";
	public Outer() {
		System.out.println("Outer()....");
	}
	public void output() {
		System.out.println("번호=" + num);
		System.out.println("이름=" + name);
		// 외부클래스에서 내부클래스의 멤버변수는 접근할 수 없다
		// System.out.println("전화번호="+tel);
	}
	
	// 내부클래스
	class Inner{
		int num = 5678;
		String tel = "010-6675-1374";
		Inner(){
			System.out.println("Inner()....");
		}
		void getMember() {
			// 내부클래스는 외부클래스의 모든 멤버변수를 접근할 수 있다.
			System.out.println("num="+num+", tel="+tel +",이름="+name);
			// 외부클래스와 멤버변수가 겹칠 경우 super호출 불가
			//System.out.println(super.num);
		}
	}
	
	public static void main(String a[]) {
		Outer outer = new Outer();
		outer.output();
		
		// 내부클래스 객체 생성하기
		Outer.Inner i = new Outer().new Inner();
		Outer.Inner ii = outer.new Inner();
		
		i.getMember();
		ii.getMember();
	}

}
=

실행결과 풀이

 

<메소드내의 내부클래스>

public class MethodInner {
	String email = "goguma777@nate.com";
	MethodInner(){}
	public void createInner() { // 메소드
		String addr = "서울시 영등포구 여의도동";
		//내부클래스: 객체를 생성하여 사용해야 한다
		class InnerTest{
			int num = 5555;
			String userid = "abcd";
			InnerTest(){}
			void getInformation() {
				System.out.println("번호="+num);
				System.out.println("아이디="+userid);
				System.out.println("이메일="+email);
				System.out.println("주소="+addr);
			}
		}
		// 객체생성은 여기서
		InnerTest it = new InnerTest();
		it.getInformation();
	}
		
	public static void main(String[] args) {
		new MethodInner().createInner();
	}
}

실행결과

 

<익명의 내부클래스>

- 클래스명이 존재하지 않는 클래스

 

public class AnonymousInner {
	public AnonymousInner() {
		
	}
	
	public void start() {
		// Sample클래스에 있는 기능이 필요
		// 익명의 내부클래스: 클래스명이 존재하지 않는 클래스
		
		Sample sam = new Sample() {
			// 필요한 기능을 추가 or 오버라이딩 기술 - Sample클래스에 있는 sum기능을 오버라이딩
			public void sum() {
				int i=0;
				for(int j=1; j<=100; j+=2) {
					i += j;
				}
				System.out.println("i="+i);
			}
			// 새로생성된 메소드
			public void output() {
				System.out.println("새로 추가된 메소드...");
			}
		};//.output();//sum();
		sam.sum();
		// sam.output();  --클래스명을 만들지 않았기 때문에 기존에 없던 새로운 기능은 호출 불가
	}

	public static void main(String[] args) {
		new AnonymousInner().start();	
	}

}