TIL 0305

MATH 실습 4

[실습]
로또 프로그램 제작
길이가 6인 int형 배열을 생성하고 1~45 숫자 범위로 난수를 발생시킨다.
중복되지 않은 6개의 숫자를 생성해서 배열에 저장하고 출력하라.
난수 생성 : Math.random () 또는 Random 클래스의 nextInt 메서드를 사용한다.

package kr.s20.object.lang;
import java.util.*; // array 관련 함수 쓰기 위해 필요함

public class MathMain04_test {

	public static void main(String[] args) {
		
		int [] lotto = new int [6];
		
		for(int i = 0; i < lotto.length; i++) {
			lotto [i] = (int)(Math.random() * 45) + 1 ;// 1~ 45
			
			//중복된 숫자가 있는지 검증하기
			for (int j = 0 ; j < i; j++) {
				if (lotto[j] == lotto[i]) {
					i--; //중복되면 생성한 난수를 불허한다
						//i의 값을 1 줄여서 중복된 값을 제거하고
						//새로운 값을 저장한다.
					break;
				}
			}
	
		}
		
		Arrays.sort(lotto); // 오름차순 정렬
		for(int num : lotto ) {
			System.out.print(num + "\t");
		}
	}

}

📺 INTERFACE

• 클래스가 멤버필드(변수,상수)와 실행 가능한 메서드를 구성요소로 한다면 인터페이스는 상수와 추상메서드를 구성요소로 한다.
  상수는 static한 상수이기 때문에 객체 생성 없이 호출이 가능하지만 추상메서드는 일반클래스에 구현되어야만 사용이 가능하다.

• 인터페이스를 이용하면 정의해야 하는 메소드(프로그램기능)을 표준화하고 강제할 수 있다.
  또한 메소드화 시켜야 하는 기능을 분류해야 하는 고민 없이 구현만 하면 되므로 개발시간을 단축 시킬 수 있다.
  일반 클래스 상속을 이용해서 자식 클래스들의 관계를 맺는 것보다 간편하게 관계를 맺을 수 있다.

📺 INTERFACE 실습 1

package kr.s23.object.inter;

//인터페이스
interface A1 {//상수는 그냥 호출이 가능함
	public static final int W = 10; 	//원형
	int X = 20;				  //public static final 생략
	static int Y = 30;		 //생략된 형태 ----> 상수
	final int Z = 40;		//생략된 형태 ---> 상수
}

public class InterfaceMain01 {
	public static void main(String[] args) {
		//인터페이스는 객체 생성이 불가능하다.
		//A1 ap = new A1();
		//X는 상수이기 때문에 변경이 불가능하다.
		//A1.X = 50;
		
		System.out.println("W : " + A1.W);
		System.out.println("X : " + A1.X);
		System.out.println("Y : " + A1.Y);
		System.out.println("Z : " + A1.Z);
	
	}

}

📺 INTERFACE 실습 2

package kr.s23.object.inter;

//인터페이스 : 형식만 있고 내용이 없음

interface A2 {
	// 추상메소드
	public abstract void abc (); 
	void def(); //public abstract 생략된 형태
}

class B2 implements A2 {
	//인터페이스에 추상메소드를 구현한다
	@Override
	public void abc() {
		System.out.println("abc 메소드");
	}
	@Override
	public void def() {
		System.out.println("def 메소드");
	}
}

public class InterfaceMain02 {
	public static void main(String[] args) {
		B2 bp = new B2 ();
		bp.abc();
		bp.def();
	}

}

📺 INTERFACE 실습 3

package kr.s23.object.inter;

//인터페이스 : 형식만 있고 내용이 없음

interface CookieMold {//쿠키틀
	// 추상 메소드
	public abstract void makeStar();
	public abstract void makeCircle();
	public abstract void makeDiamond();
}

class Cookie implements CookieMold {
// 인터페이스가 형식을 제공하면 클래스에서 제공된 형식을 이용해 내용을 채운다.	
	@Override
	public void makeStar() {
		System.out.println("Star shaped Cookie!");
	}
	
	@Override
	public void makeCircle() {
		System.out.println("Circle shaped Cookie!");
	}
	
	@Override
	public void makeDiamond() {
		System.out.println("Diamond shaped Cookie!");
	}
}

public class InterfaceMain03 {
	public static void main(String[] args) {
		
		Cookie c = new Cookie ();
		
		c.makeStar();
		c.makeCircle();
		c.makeDiamond();
		
		
	}

}

📺 INTERFACE 실습 4

package kr.s23.object.inter;

interface I {
	public abstract void play();
	
}

class	Pianist implements I {
	@Override
	public void play () {
		System.out.println("Playing the piano");
	}
}

class Cellist implements I {
	@Override 
	public void play() {
		System.out.println("Playing the Cello");
	}
}

class Stage {
	public void autoPlay (I i) {
							// 인터페이스 전달 ---> Pianist , Cellist => I
		i.play();
	}
}

public class InterfaceMain04 {
	public static void main(String[] args) {
		
		Stage s = new Stage(); // stage 호출 ...
												// Pianist  -> I
		s.autoPlay(new Pianist ());	// 클래스 타입 -> 인터페이스 타입 형변환
												// 자동적으로 형변환
												// Cellist -> I
		s.autoPlay(new Cellist());		// 클래스 타입 -> 인터페이스 타입 형변환
	}											// 자동적으로 형변환

}

📺 INTERFACE 실습 5

package kr.s24.object.enumtest;

enum Item2 {
	ADD(5), DEL(11), SEARCH(2), CANCEL(22);
	
	//위에 지정한 상수 값들을 저장하기 위한 공간
	private final int var;
	
	//생성자
	Item2 (int var) {
		this.var = var;
	}
	
	public int getVar() {
		return var ;
	}
}

public class EnumMain05 {
	public static void main(String[] args) {
		System.out.println(Item2.ADD);
		System.out.println(Item2.DEL);
		System.out.println(Item2.SEARCH);
		System.out.println(Item2.CANCEL);
		
		System.out.println("-------------------");
		
		System.out.println(Item2.ADD.getVar());
		System.out.println(Item2.DEL.getVar());
		System.out.println(Item2.SEARCH.getVar());
		System.out.println(Item2.CANCEL.getVar());
	}

}

ENUM

• 열거 형은 상수를 가지고 생성되는 객체들을 한 곳에 모아둔 하나의 묶음이다.
  자바에서 열거 타입이 있기 전에는 코드화된 정수나 문자를 이용하여 해당 값을 표현한다.

• 클래스에 종속된 열거 타입
  • 클래스/인터페이스 안에 선언된 열거 타입은 그 클래스/인터페이스에 종속됨
  

• values 메소드와 valueOf 메소드
  • 열거 타입은 컴파일하고 나면 내부적으로 클래스가 됨
  -> 그 클래스에는 values와 valueOf라는 정적 메소드가 자동으로 추가됨
  • values 메소드 : 모든 열거 상수를 리턴하는 메소드
  • valueOf 메소드 : 주어진 문자열에 해당하는 열거 상수를 리턴하는 메소드

ENUM 실습 1

package kr.s24.object.enumtest;

public class EnumMain01 {
	//문자열 상수
	public static final String JAVA = "JAVA";
	public static final String XML = "XML";
	public static final String JSP = "JSP";
	
	public static void main(String[] args) {
		//문자열 상수 호출
		System.out.println(JAVA);
		System.out.println(XML);
		System.out.println(JSP);
		
	}

}

ENUM 실습 2

package kr.s24.object.enumtest;

//열거형 객체
enum Lesson {
	//열거형 상수
	//문자열 상수
	JAVA, XML, JSP

}
public class EnumMain02 {
	public static void main(String[] args) {
		System.out.println(Lesson.JAVA);
		System.out.println(Lesson.XML);
		System.out.println(Lesson.JSP);
		
		System.out.println("------------------");
		
		System.out.println(Lesson.JAVA.toString());
		System.out.println(Lesson.XML.toString());
		System.out.println(Lesson.JSP.toString());
		
		System.out.println("------------------");
		
		// 열거형 객체의 문자열을 반환한다
		System.out.println(Lesson.JAVA.name());
		System.out.println(Lesson.XML.name());
		System.out.println(Lesson.JSP.name());
		
		System.out.println("------------------");
		
		//열거 객체의 순번을 가져올 수 있다. (0부터 시작)
		System.out.println(Lesson.JAVA.ordinal());
		System.out.println(Lesson.XML.ordinal());
		System.out.println(Lesson.JSP.ordinal());
	}
}

ENUM 실습 3

package kr.s24.object.enumtest;

enum Gender {
	MALE , FEMALE ;
	
	//메소드 재정의
	@Override
	public String toString() {
		
		switch(this) {
		case MALE : 
			return "남자";
		default :
			return "여자";
		}
		
	}
	
}

public class EnumMain03 {
	public static void main(String[] args) {
		System.out.println(Gender.MALE);
		System.out.println(Gender.FEMALE);
		
		System.out.println("-----------------");
		
		System.out.println(Gender.MALE.toString());
		System.out.println(Gender.FEMALE.toString());
		
		System.out.println("-----------------");
		
		System.out.println(Gender.MALE);
		System.out.println(Gender.FEMALE);
	
		System.out.println("-----------------");
	
	
	
	}

}

ENUM 실습 4

package kr.s24.object.enumtest;

enum Item{
	ADD, DEL, SEARCH, CANCEL
}

public class EnumMain04 {
	public static void main(String[] args) {
		//values() 메소드는 열거 타입의 모든 열거 객체들을 배열로 만들어 반환
		//반환
		Item []	items = Item.values()	;
		
		//반복문을 이용한 열거 타입 상수 호출
		for ( Item n : items ) {
			System.out.println(n + " : " + n.ordinal());
		}
	}

}

ENUM 실습 5

package kr.s24.object.enumtest;

enum Item2 {
	ADD(5), DEL(11), SEARCH(2), CANCEL(22);
	
	//위에 지정한 상수 값들을 저장하기 위한 공간
	private final int var;
	
	//생성자
	Item2 (int var) {
		this.var = var;
	}
	
	public int getVar() {
		return var ;
	}
}

public class EnumMain05 {
	public static void main(String[] args) {
		System.out.println(Item2.ADD);
		System.out.println(Item2.DEL);
		System.out.println(Item2.SEARCH);
		System.out.println(Item2.CANCEL);
		
		System.out.println("-------------------");
		
		System.out.println(Item2.ADD.getVar());
		System.out.println(Item2.DEL.getVar());
		System.out.println(Item2.SEARCH.getVar());
		System.out.println(Item2.CANCEL.getVar());
	}

}

내부 클래스

• 특정 클래스 내에 또 다른 클래스가 정의되는 것을 의미한다.
  이런 내부 클래스가 필요한 이유는 지금까지 작업해 왔던 클래스들과는 다르게 독립적이지는 않지만 하나의 멤버처럼 사용할 수 있는 특징이 있다.

• 내부 클래스 종류
  

• 멤버 내부 클래스

  • 객체를 생성해야만 사용할 수 있는 멤버들과 같은 위치에 정의되는 클래스를 말한다.
    즉 내부 클래스를 생성하려면 외부 클래스의 객체를 생성한 후에 생성할 수 있다.

• 로컬 내부 클래스

  • Local 내부 클래스는 특정 메서드 안에서 정의되는 클래스를 말한다.
    다시 말해서 특정 메서드 안에서 선언되는 지역변수와 같은 것이다.
    메서드가 호출될 때 생성할 수 있으며 메서드의 수행력이 끝나면 지역변수와 같이 자동 소멸된다.

• Static 내부 클래스

  • static 내부 클래스로 어쩔 수 없이 정의하는 경우가 있는데 그것은 바로 내부 클래스 안에 static변수를 가지고 있다면 어쩔 수 없이 해당 내부 클래스는 static으로 선언하여야 한다.

• 익명 내부 클래스

  • 익명이란? 이름이 없는 것을 의미한다.
    이것을 자바의 프로그램적으로 해석하면 정의된 클래스의 이름이 없다는 것이 된다.

내부 클래스 실습 1

package kr.s25.object.inner;

class Outer{
	// Outer 클래스의 멤버 변수
	int x = 100;
	
	//내부 클래스 (멤버 내부 클래스)
	class Inner {
		//Inner의 멤버 변수
		int y = 200;
	}

}

public class MemberMain01 {
	public static void main(String[] args) {
		Outer ot = new Outer();
		
		
		//Outer 내부 클래스인 Inner클래스를 객체 생성
		Outer.Inner oi = ot.new Inner();
		
		//Outer의 멤버변수 호출
		System.out.println(ot.x);
		System.out.println(oi.y);
	}
	
}

내부 클래스 실습 2

package kr.s25.object.inner;

class Outer2 {
	// Outer2의 멤버 변수
	private int x = 100;
	//내부 클래스
	class Inner2 {
		private int y = 200;
		
		public void make() {
			System.out.println("x = " + x);
			System.out.println("y = " + y);
		}
	}
}


public class MemberMain02 {
	public static void main(String[] args) {
		Outer2 ot = new Outer2 ();
		Outer2.Inner2 oi = ot.new Inner2();
		oi.make();
		}
}

내부 클래스 실습 3

package kr.s25.object.inner;

public class LocalMain01 {
	public void InnerTest() {
		
		//로컬 내부 클래스 : 매소드내에 클래스를 정의
		class Inner{
		
			public void getData() {
				System.out.println("Local 내부 클래스");
			}
		
		}
		//내부클래스 객체 생성
		Inner i = new Inner();
		i.getData();
	}
public static void main(String[] args) {
	
		LocalMain01 m = new LocalMain01 ();
		m.InnerTest();
	
	}
}

내부 클래스 실습 4

package kr.s25.object.inner;

public class LocalMain02 {
	// 멤버 변수
	int a = 100;

	//멤버 메소드
	public void innerTest() {
		// 지역 변수
		int b = 500;

		//내부 클래스
		class Inner {
			public void getData()	{
				// 멤버 변수 호출
				System.out.println("변경 전 : " + a);
				System.out.println("-----------------");
				a = 200;
				System.out.println("변경 후 : " + a);
				System.out.println("-------------------------");

				//지역 변수 호출
				System.out.println("지연 변수 변경 전 : " + b);
				//로컬 내부 클래스가 포함된 매소드의 지역 변수를 호출할 때 자동으로 상수화가 일어난다.
				//데이터를 변경할 수 없다.
				// b = 800;
			}
		}
		//내부클래스 객체 생성
		Inner i = new Inner();
		i.getData();
	}
	public static void main(String[] args) {
		LocalMain02 m = new LocalMain02	();
		m.innerTest();
	}
}

내부 클래스 실습 5

package kr.s25.object.inner;

public class StaticMain {
	//static 내부 클래스
	//static 내부 클래스를 포함한 클래스를 먼저 객체 생성하는 것이 아니라 static 내부 클래스를 단독으로 객체 생성하여 사용한다.
	public static class Inner{
		//인스턴스 변수
		int iv = 100;
		//static 변수
		static int cv = 200;
		
		//static 메소드
		public static void make() {
			System.out.println("HAHAHAHA");
			}
	}

	public static void main(String[] args) {
		//StaticMain s = new StaticMain();
		//StaticMain.Inner si = s.new Inner();
		
		//static 내부 클래스 객체 생성
		Inner i = new Inner ();
		
		//인스턴스 변수 호출
		System.out.println(i.iv);
		
		// static 변수 호출
		System.out.println(Inner.cv);
		
		//static 메소드 호출
		Inner.make();
	}

}

내부 클래스 실습 6

package kr.s25.object.inner;

class Inner7 {
	
	public void disp() {
		System.out.println("부모 클래스의 disp");
		}
	
}

public class AnonymousMain {
	
	public void make () {
		//익명 내부클래스 : 클래스를 정의하는 부분과 객체를 생성하는 부분이 합쳐진 형태
		//Inner7 클래스가 상속된 이름 없는 클래스를 객체 생성
		// 객체 생성하는 부분 ...     //
		Inner7 i = new Inner7()	{
			// 클래스를 정의하는 부분 ...
			@Override
			public void disp() {
				System.out.println("익명 내부 클래스의 disp");
				}
			
			} ;
			
			i.disp(); //매서드 호출
			
		}
	
	
	/* 익명 X
	  public void make () {
	 
		//로컬 내부 클래스
		class Inner extends Inner7 {
			@Override
			public void disp() {
				System.out.println("내부 클래스의 disp");
			}
		}
		
		Inner i = new Inner ();
		i.disp();
		}
		*/
	
	public static void main(String[] args) {
		AnonymousMain am = new AnonymousMain ();
		am.make();
	}

}

🆖 Exception

• 예외와 예외처리 : 예상하지 못한 일들을 ‘예외’라 하고 이를 대비하고 준비하는 것이 바로 ‘예외처리’다.
• 예외처리에 대한 필요성과 이해
  • 자바에서 프로그램의 실행하는 도중에 예외가 발생하면 발생된 그 시점에서 프로그램이 바로 종료가 된다.
    때에 따라서는 예외가 발생 했을 때 프로그램을 종료시키는 것이 바른 판단일 수도 있다.
    하지만 가벼운 예외이거나 예상을 하고 있었던 예외라면 프로그램을 종료시키는 것이 조금은 가혹하다고 느껴진다.
    그래서 ‘예외처리’라는 수단(mechanism)이 제안되었고 예외 처리를 통해 우선 프로그램의 비정상적인 종료를 막고 발생한 예외에 대한 처리로 정상적인 프로그램을 계속 진행할 수 있도록 하는 것이 예외처리의 필요성이라 할 수 있다.
• 오류의 구분
  
• 예외의 종류
  

🆖 Exception 실습 1

• 테스트용으로 없는 인덱스 3을 호출해서 예외를 발생시킨다다.
  예외가 발생하면 예외가 발생한 지점에서 프로그램이 강제로 종료된다.
  예외가 발생하고 프로그램이 멈춘다.
  예외가 발생하면 예외 정보를 담고 있는 예외 객체가 생성이 된다.
  예외 문구가 콘솔에 출력된다.

package kr.s26.exception;

public class ExceptionMain01 {
	public static void main(String[] args) {
		
		int [] array = {10, 20, 30};
		for(int  i = 0; i <= array.length; i++) {
			System.out.println("array [" + i + "] : " + array[i]);
		}
		System.out.println("프로그램 끝!");
	}

}

🆖 Exception 실습 2

• 예외처리 : 예외가 발생해도 정상 종료 될 수 있도록 프로그램적으로 처리하는 것을 의미함
  예외가 발생할 가능성이 있는 코드를 명시한다.
  만약 예외가 발생하면 예외가 발생한 코드의 실행을 멈추고 catch 블럭으로 이동한다.

package kr.s26.exception;

public class ExceptionMain02 {
	public static void main(String[] args) {
		
		int []	array = {10,20,30};
		
		for(int i = 0 ; i <= array.length; i++) {
			
			try {
				System.out.println("array ["+ i + "] : " + array[i]);
			}		//예외 객체가 전달 ....>
			catch(ArrayIndexOutOfBoundsException e) {
				System.out.println("없는 인덱스 호출하였습니다.");
			
			}
			
			
		} //end of for
		System.out.println("프로그램 종료");
	}

}