Math Class는 사용하면 아주 편리한 Class!

Java에서 제공해주는 method들로 다양한 일을 할 수 있다 :)

 

 Math Class 

- 객체화 하지 않고 사용하는 클래스

- 사용법) 클래스명.method명()

 

<종류>

 - 절대값 : 데이터형 변수명 = Math.abs(값);

 - 반올림 : 소수점 첫번째 자리에서 반올림
       : 변수명 = Math.round(값);

 - 올림 : 소수점 첫 번째 자리에서 올림 (0이외의 값을 올림)
     : Math.ceil(실수);

 - 내림 : Math.floor(실수);

 - 버림 : 없다. casting으로 처리!
     : double d = 3.14; . (int)d

 - 난수 (Random number) : double = Math.random( );
    > 약 0.0000000000000000 ~ 0.9999999999999999 사이의 수가 나옴
    > Math.random() * 범위의 수


# 오늘의 코딩 #

- Java 입문자들은 거쳐간다는 Random Password 만들기 & 로또 번호 추출하기 (중복 제거)

 

#Password 먼저!#

 

package test;

public class UseMath {

	public static final int UPPER = 0; // 영어 대문자
	public static final int LOWER = 1; // 영어 소문자
	public static final int DECIMAL = 2; // 숫자
    
	/**
	 * 영어 대소문자와 숫자를 결합한 7자리 password를 만드는 method<br>
	 * @return
	 */
		public char[] createPassword() {
		char[] tempPass = new char[7];

		// 대문자 65~90 , 소문자 97~122, 숫자 48~57
		int flag = 0; // 0 대문자 1 소문자 2 숫자
		for (int i = 0; i < tempPass.length; i++) {
			flag = (int) (Math.random() * 3); // 0,1,2 중 하나 추출
			switch (flag) {
			case UPPER:
				tempPass[i] = (char) ((Math.random() * 26) + 65);
				break;
			case LOWER:
				tempPass[i] = (char) ((Math.random() * 26) + 97);
				break;
			case DECIMAL:
				tempPass[i] = (char) ((Math.random() * 10) + 48);
			}// end switch
		} // end for
        
		return tempPass;
	} // creatPassword

	public static void main(String[] args) {

		UseMath pw = new UseMath();
		System.out.println("랜덤 패스워드 생성 : " + pw.creatPassword());
		
	}// main

}// class

- 영어 대소문자/숫자 구분 없이 모든 자릿수에 랜덤으로 들어가도록

   임의의 수(0,1,2)를 추출하고 그 값에 따라 해당 범위에 맞는 값들이 추출되도록 코딩! 

 

# 출력 결과 #

랜덤 패스워드 생성 : 1VoPD4c

>> 할때마다 다른 값이 잘 나온다 ㅎㅎ 


#이제 로또 번호#

 

package test;

import java.util.Arrays; // 배열 출력을 위한 import

public class UseMath2{

	/**
	 * 로또 번호(1~45)를 랜덤으로 추출하는 method<br>
	 * @return
	 */
	public int[] pickLottoNum() {
		int[] lottoNum = new int[6]; // 로또번호를 저장할 배열

		for (int i = 0; i < 6; i++) {
			lottoNum[i] = (int) (Math.random() * 45 + 1); // 1~45의 수 추출
			for (int j = 0; j < i; j++) { // 번호 중복 체크
				if (lotto[j] == lotto[i]) {
					i--; // 현재 방의 번호를 다시 생성
					break; // 가장 가까이에 있는 반복문 탈출!
				} // end if
			} // end for
		} // end for

		return lottoNum;
	}// pickLottoNum

	public static void main(String[] args) {

		UseMath2 lotto = new UseMath2();
		System.out.println("로또 번호 생성 : " + Arrays.toString(lotto.pickLottoNum()));

	}// main

}// class

 

- 1~45의 수를 얻기 위해 45의 range를 얻고 +1을 적용

- 배열에 난수를 할당하되, 값이 중복될 수 없으므로 if문으로 중복 check. 

  (값이 같으면 해당 횟수를 차감하고 다시 실행하는 방식)

 

# 출력 결과 #

로또 번호 생성 : [8, 34, 6, 43, 10, 22]

>> 얘도 할때마다 다른 값 & 중복없이 출력됨!

 

끄읕!

오늘은 Java의 꽃,, Interface★

 

 Interface 

- 구현클래스(자식클래스)에서 반드시 구현해야 할(Override) 일(method)의 목록을 정의한 것

 

<구조>

  interface

    상수(Constact) (*final 선언)

    abstract method

    *default method

 

       *default method : JDK1.8에서부터 method body({})가 있는 default method가 추가됨

                             : interface 내에서 업무를 구현하여 제공할 필요가 있을 때 사용

                             : 이 method도 당연히 구현 클래스에서 객체화가 진행된 후 호출할 수 있음

 

<특징>

  - 다중 상속 효과 (여러 개의 인터페이스를 한 클래스에서 구현 가능)

  - 약결합을 구현하여 객체 간의 유연성 향상

  - 인터페이스는 생성자를 가질 수 없음 (객체화 불가)

  - 인터페이스끼리 상속 가능 (여러개 가능)

  - 인터페이스는 인스턴스 변수가 존재하지 않으므로 구현클래스의 *객체 크기에 영향을 주지 않음

       *객체 크기 : heap에 적재되는 인스턴수 변수의 총 크기 

  - FunctionalInterface : interface가 abstract method를 반드시 하나를 가져야 하는 경우

                           : 편하게 사용하기 위해 Lambda식이 JDK1.8에서부터 지원됨

 

<객체다형성>  

  - is a 관계의 객체화 가능 (부모가 자식의 주소를 저장하는 것)

    > 인터페이스는 객체화가 될 수 없지만, 구현한 클래스의 객체주소를 저장할 수 있음

    > 부모클래스, 부모인터페이스의 method를 호출하면 자식이 구현한 method가 최우선적으로 호출

       (부모쪽은 abstract method라서 원래 동작하지 않아야 하지만 객체다형성으로 가능해짐)

  - interface를 매개변수로 받는 method가 있을 때,

    이 인터페이스를 구현한 class들은 모두 interface를 parameter로 하는 곳에 할당 가능함

    > 구현한 클래스의 객체명으로 할당함

    > 어느 클래스를 할당 하냐에 따라 값이 다 다르게 나올 수 있음 (구현 내용이 다 다를 수 있으니까)

    ★ 원 method 생성자의 입장에서는 부모의 기능만 잘 알고 있으면

        그것을 어떻게 구현했는지

        상세 내용을 알지 않고도

        부모의 이름으로 다양한 기능들을 호출할 수 있게 됨

 

<구현 방법>  

  - 인터페이스 생성 문법)

     접근지정자 interface 인터페이스명 [extends 부모인터페이스명,,,] { }

     > 접근지정자 : public – 패키지 외부에서 접근 가능, default(package) – 패키지 내부만 가능

     > 인터페이스명은 낙타체로 작성 (첫 글자 대문자!)

 

  - 인터페이스를 클래스에서 구현할 때)

     접근지정자 class 클래스명 [extends 부모클래스명] [implements 구현인터페이스명,,]

 

  - abstract method 문법) – abstract 생략 가능 / body({}) X

     1) abstract 생략 : 접근지정자 반환형 method명(매개변수,,,);

     2) abstract 명시 : 접근지정자 abstract 반환형 method명(매개변수,,,);

      > 접근지정자 : public, protected, default

 

  - default method 문법) – body O

    접근지정자 default 반환형 method명(매개변수,,,)  { 업무 구현 };

    > 접근지정자 : public, protected, default


# 오늘의 코딩 #

package test;

/**
 * 날기 위한 일의 목록 정의
 * 추진력, 양력이 필요
 * @author user
 */
public interface Fly {

	/**
	 * 추진력
	 * @return
	 */
	public String drivingForce();
	
	/**
	 * 양력
	 * @return
	 */
	public String upwardForce();
	
}//interface

- 날기 위한 간단한 interface를 작성해보았다. 모두 abstract method

 

package test;

/**
 * Fly interface를 구현하고 사용할 class
 * @author user
 */
 
public class Superman implements Fly {
	String name = "";

	public Superman() {
		name = "Clark";
	}// Superman

	/**
	 * interface의 abstract method 구현<br>
	 * 추진력<br>
	 */
	@Override
	public String drivingForce() {
		return "팔을 하늘로 뻗기";
	}// drivingForce

	/**
	 * interface의 abstract method 구현<br>
	 * 양력<br>
	 */
	@Override
	public String upwardForce() {
		return "슈퍼 망토";
	}// upwardForce

	public static void main(String[] args) {
    
		Superman man = new Superman();
		System.out.println(man.name + "의 추진력:" + man.drivingForce());
		System.out.println(man.name + "의 양력:" + man.upwardForce());

	}// main

}// class

- Fly interface를 구현하고 사용할 class 작성!

 

# 출력 결과 #

Clark의 추진력:팔을 하늘로 뻗기
Clark의 양력:슈퍼 망토

 

>> 잘 나오는 거 확인 ㅎㅎ 나중엔 extends까지 더해서 다중 상속해볼 예정!

1. Inner Class

- 안쪽 클래스를 instance variable처럼 사용할 때 쓰임

- 안쪽 클래스의 접근지정자는 public으로 설정

- 안쪽 클래스는 바깥 클래스의 자원을 마음대로 사용하나,

  바깥 클래스는 안쪽 클래스의 자원을 사용하기 위해 반드시 객체화를 하여 사용

- Compile 후 byte code :  바깥클래스명.class

                                  바깥클래스명$안쪽클래스명.class

- 객체화 방법 :

  1) 바깥 클래스를 객체로 생성 : 바깥클래스명 객체명 = new 바깥클래스생성자();

  2) 안쪽 클래스를 객체로 생성 : 바깥클래스명.안쪽클래스명 객체명 = 바깥클래스의 객체명.new 안쪽클래스생성자();

 

2. Nested Class

- 안쪽 클래스를 static 변수처럼 사용할 때 쓰임

- 안쪽 클래스 / 내부 변수 / method는 static을 붙여서 만듦
   (중첩클래스의 자원은 객체화없이 바로 사용 가능하도록 static으로만 구성함)

- 안쪽 클래스에서 바깥 클래스의 instance 영역은 사용할 수 없음!

   (instance영역을 사용하고 싶으면 객체화하여 사용하는 inner class를 쓰자)

- Compile 후 byte code : inner class와 같음

- static 방식으로 사용) 클래스명.변수명, 클래스명.method명

 

3. Local Class – 지역클래스

- 클래스를 method의 지역변수처럼 사용할 때 (클래스를 method안에서 생성하고 사용할 때 씀)

- 생성된 class는 method 호출이 종료되면 메모리에서 사라짐

- 안쪽 클래스와는 다르게 method 외부에서는 지역 클래스를 절대로 사용할 수 없음

- Compile 후 byte code : 바깥클래스명.class

                                 바깥클래스명$1지역클래스명.class

                                 (여기서 1은 method명. method명은 byte code에 반영되지 않음)

- 객체화 방법 : method 안에서 Local Class를 객체화

                   : Local class명 객체명 = new Local Class 생성자()

 

4. Anonymous Inner Class

- class를 arguments(method의 입력 값, 인수)로 사용

- 참조형 데이터형이 매개변수로 된 method를 호출할 때 사용

- 별도의 클래스를 작성하지 않아도 참조형데이터형을 매개변수로 선언한 method 호출 가능

- 문법) method명 ( new 부모클래스생성자() {

                                  method Override { } ,,, 

                                   } 

                         )//method

- Compile 후 byte code : 바깥클래스명.class

                                 바깥클래스명$1.class


# 오늘의 코딩 #

Anonymous Inner Class 연습!

package test;

/**
 * 부모클래스 : 상속 및 abstract <br>
 * @author user
 */
public abstract class AbsParents {

	public AbsParents() {
		System.out.println("부모클래스 생성자");
	}// AbsParents

	/**
	 * 집에서 밥을 먹는 method - 자식에 의해 구현될 method<br>
	 */
	public abstract void eat(); 

}//class

- 간단하게 어제 사용했던 abstract method의 부모 클래스를 가져왔다. anonymous class 에서 구현될 abstract method는 집에서 밥먹기!

 

 

package test;

/**
 * Anonymous Inner Class 구현할 Class<br>
 * AbstractParents의 메소드를 자식클래스 생성 없이 바로 구현<br>
 * @author user
 */
public class UseAnonyClass {

	public void anonyTest(AbsParents ap) {
		ap.eat(); // 집에서 밥먹는 abstarct method
	}// anonyTest

	public static void main(String[] args) {

		UseAnonyClass anony = new UseAnonyClass();
        
		anony.anonyTest(new AbsParents() {
			@Override
			public void eat() {
				System.out.println("집에서 밥을 먹자");
			}
		});// method

	}// main
}// class

- 자식클래스 파일을 별도로 만들지 않고 사용하는 클래스 내에서 anonymous class 를 구현했다. 

- Use Class에서 부모 추상 클래스를 매개변수로 받고(참조형 데이터형)

  method 호출을 위해 부모인 추상 클래스의 method를 Override하였다. 

 

# 출력 결과 #

부모클래스 생성자
집에서 밥을 먹자

 

>> 부모인 추상 클래스와 method가 생성되어 잘 구현되는거 확인!

 

 

'Development > Java' 카테고리의 다른 글

[Java] Date Class / SimpleDateFormat Class / Locale Class  (0) 2021.08.01
[Java] StringTokenizer  (0) 2021.07.30
[Java] Math Class  (0) 2021.07.29
[Java] Interface  (0) 2021.07.28
[Java] Overloading / Overriding / Annotaion / Abstract Class  (0) 2021.07.26

 1. Overloading(Overload) 

- method 다형성의 종류

- 하나의 클래스 안에서 같은 이름의 method를 여러 개 정의하는 것

- 생성자도 Overloading 가능

- 호출될 때 구분되도록 정의하여야 함 

- 규칙) 접근지정자&반환형 달라도 됨 / method명 같아야 함 / 매개변수 반드시 다르게 정의!

 

 2. Overriding(Override) 

- method 다형성의 종류

- 상속 관계에서 부모, 자식 클래스 간에 같은 이름의 method를 정의하는 것

- 부모 클래스에서 제공하는 기능을 덮어쓰고 자식 클래스에서 수행할 기능으로 변경하는 것

   (단, 부모 클래스의 method에서 final이 선언되어 있으면 Overriding 불가)

- 규칙) *접근지정자는 달라도 되나 반환형&method명&매개변수 반드시 같도록 정의!

           *접근지정자 정의 시, 자식 클래스의 접근지정자가 부모 클래스의 접근지정자보다 광의여야 함

            (Ex. 부모 클래스 method의 접근지정자 : protected -> 자식 클래스의 method 접근지정자 : protected/public)

 

 3. Annotation (주석 달기) 

- JDK1.5에서부터 제공하는 기능

- Compiler에게 컴파일 시에 부가적인 일을 할 수 있도록 설정하는 것 (본래의 Compiler는 문법체크의 기능만 수행함)

- 종류)

    @Override : method가 Override 되었는지 컴파일 시 체크 / method 위 정의

    @Deprecated : 비추천 method인지 체크 / method 위 정의 (Ex. date.getYear())

    @SuppressWarnings : 경고를 표시할 때 사용 / method 위, method 안에서 정의

 

 4. Abstract Class 

- 상속관계에서 부모 클래스를 작성할 때 사용하는 클래스 (상속하기 위해 만드는 클래스)

- 일반 클래스의 변수/method 외에 *abstract method(추상 메소드)가 추가됨

   *abstract method

     - 구현의 강제성이 있는 method

     - 자식 클래스에서 반드시 자신에 맞게 Override 해야 함

     - 부모 클래스에 명시된 abstract method에는 body({ })가 없으므로 업무 로직 구현 불가 

- 추상클래스는 직접 객체화 되지 않음 (자식 클래스를 통해서만 객체가 생성됨)

   > extends하더라도 자식클래스 객체명 = new 자식클래스생성자();

   > 추상클래스는 일을 하지 않는다!

- abstract class 작성법)

       접근지정자 abstract class 클래스명 [extends 부모클래스명] [implements 구현인터페이스명,,] { }

- abstract method 작성법)

       접근지정자 abstract 반환형 method명 (매개변수,,);

       *접근지정자 : public, protected만 가능

       *Overloading 가능

 


# 오늘의 코딩 #

- 추상클래스 실습!

package test;

/**
 * 부모클래스 : 상속 및 abstract <br>
 * @author user
 */
 
public abstract class AbsParents {

	public AbsParents() {
//		super(); // 모든 클래스의 생성자에는 super가 생략되어 있음. 여기서의 부모 클래스는 Object.
		System.out.println("부모클래스 생성자");
	}// AbsParents

	public void parentsMethod() {
		System.out.println("부모의 기본 method");
	}// parentsMethod

	/**
	 * 집에서 밥을 먹는 method - 자식에 의해 구현될 method<br>
	 */
	public abstract void eat(); //Overloading

	/**
	 * 밖에서 밥을 먹는 method - 자식에 의해 구현될 method<br>
	 * @param menu : 음식의 종류
	 * @param price : 음식의 가격
	 * @return
	 */
	public abstract String eat(String menu, int price); //Overloading
	
}//class

- 상속관계를 통해 자식 클래스의 생성자보다 부모 클래스의 생성자가 먼저 실행되는 것을 증명하기 위해 생성자에 println 추가

- 기본 method와 abstract method (Overload로 2개 생성)

 

package test;

/**
 * 자식클래스 : extends하고 abstract method를 구체화할 당사자
 * @author user
 */
public class AbsChild extends AbsParents {

	public AbsChild() {
		System.out.println("자식클래스 생성자");
	}// AbsChild

	/**
	 *집에서 밥 먹는 method<br>
	 */
	public void eat() { //부모 클래스의 method Override
		System.out.println("집에서 밥을 먹고 있어요");
	}// eat

	/**
	 *식당에서 외식하는 method<br>
	 */
	public String eat(String menu, int price) { //부모 클래스의 method Override
		return "식당에서 " + menu + "을(를) " + price + "원 주고 먹어요";
	}// eat
	
	public static void main(String[] args) {
		//객체화
		AbsChild ac = new AbsChild(); // 부모 생성 후 자식 생성됨
		
		//상속 및 구현된 method 사용하기
		ac.parentsMethod(); //상속. 기본 method
		ac.eat(); // Override & Overload method
		System.out.println(ac.eat("제육볶음", 8000)); // Override & Overload method
		
	}// main
}// class

- 부모 클래스에서 상속된 method & abstract mehtod를 구현하여 실행!

 

# 출력 결과 #

부모클래스 생성자
자식클래스 생성자
부모의 기본 method
집에서 밥을 먹고 있어요
식당에서 제육볶음을(를) 8000원 주고 먹어요

+ Recent posts