랜덤 정수 출력

Math.random()

랜덤으로 숫자선택 : Math클래스의 random() 클래스 사용

임의의 0~0.9999…의 더블값을 반환

(0단계) 0 <= Math.random() >= 1 // 0~0.999999999까지 반환
(1단계) 0 <= (Math.random() * 10) < 10 // 0~9.99999
(2단계) 1 <= Math.random() * 10 + 1 < 11 // 1~10.99999	
(3단계) 1 <= (int)(Math.random() * 10 + 1) < 11 //  1~10 // 정수로 강제 형변환
// 강제형변환으로 maxNumber의 소수점 짤라줌

ex)사용 예제

 1부터 10 사이의 임의의 난수를 정해 1부터 난수까지의 정수 합계 (난수 임의의 숫자)

// 1부터 10 사이의 임의의 난수를 정해 1부터 난수까지의 정수 합계 (난수 임의의 숫자)

int random = (int)(Math.random() * 10 + 1);
int sum = 0; // 변수 초기화
		for(int i=1; i<=random; i++) {
				sum = sum + i;
//			sum += i;       위와 같은 코드
		}
System.out.println("1부터 "+random+"까지의 정수합계 : "+sum);

1부터 50까지의 임의의 난수를 뽑아 홀수인지 짝수인지 판별

public void method05_1() {		
    // 1부터 50까지의 임의의 난수를 뽑아 홀수인지 짝수인지 판별

    // 0~1
    // 1~10
    // 1~50 for문 최대치 +@
    // random 수의 범위 늘리기

    int random = (int)(Math.random() * 50 + 1); // 변수 선언

//		// 디버깅용 for문
//		for(int i=1; i<=random; i++) {
//			System.out.println("i="+i+" random="+random+"\n");
//		}

    if(random%2 == 0) {
        System.out.println(random+"은 짝수");
    }else {
        System.out.println(random+"은 홀수");
    }
}

db연결할 때 드라이버, 주소, sql 로그인 아이디, 비번 등

그리고 쿼리문을

코드 내부에 통합해서 작성할 수도 있지만,

외부 파일에 모아서 한번에 해결 가능하다 

이때 사용하는 자바 클래스 Properties

외부파일 확장자도 .properties이다

ex) sqlDriver.properties

어디서든 접근할 수 있게 선언은 필드로 한다

Dynamic Web프로젝트 파일에서의 Properties클래스 선언 및 외부파일 경로 지정

// 외부파일 로드용 클래스 Properties 선언
Properties prop = new Properties();

// 외부 파일 경로지정
public NoticeDAO() {
    String fileName = NoticeDAO.class.getResource("/sql/notice/notice-query.properties").getPath();

    try {
        prop.load(new FileReader(fileName));
    }catch(FileNotFoundException e) {
        e.printStackTrace();
    }catch(IOException e) {
        e.printStackTrace();
    }
}

쿼리문 사용 방법 예시

String query = prop.getProperty("selectList");

	public ArrayList<Notice> selectList(Connection conn) {
		// 고정값(공지사항)을 조회하는 거기에 Statement 사용
		Statement stmt = null;
		ResultSet rset = null;
		ArrayList<Notice> list = new ArrayList<>();
		
		String query = prop.getProperty("selectList");
        ...

드라이버 세팅 외부파일 처리

아래 이미지는 1번 파일을 0번 파일이 상속했다

자식 클래스 부모 클래스의 이름을 눌러보면 부모클래스와 연결되어있는 코드들의 색깔이 진해진다

이 코드들은 중복이기에 삭제하여도 부모와 자식 클래스의 정보가 연동된다

삭제 전

삭제 후

0번 parent 

1번 child1

2번 child2

상속관계가 0 -> 1 -> 2

1번이 0번을 상속하고 2번이 1번을 상속한 것

1번 child1에서 parent에 받았던 a,b부분들을 주석 처리해서 2번 child2에서 보면 정보가 그대로인 걸 알 수 있다

public class practice_everyday04 {
	public static void main(String[] args) {
		
		// run
		practice_everyday04_0 pe1 = new practice_everyday04_0();
		pe1.println();
		
		practice_everyday04_1 pe2 = new practice_everyday04_1();
		pe2.println();
		
		practice_everyday04_2 pe3 = new practice_everyday04_2();
		pe3.println();
		
	}	
}

public class practice_everyday04_0 {
	
	// Parent
	private int a;
	private int b;
	
	public practice_everyday04_0() {}
	public practice_everyday04_0(int a, int b) {
		this.a = a;
		this.b = b;
	}
	//getter & setter
	public int getA() {
		return a;
	}
	public void setA(int a) {
		this.a = a;	
	}
	public int getB() {
		return b;
	}
	public void setB(int b) {
		this.b = b;
	}
	
	
	public void println() {
		System.out.println("parent");
	}
	
}

public class practice_everyday04_1 extends practice_everyday04_0 {
		
	// child1
//	private int a;
//	private int b;
	private int c;
	
	public practice_everyday04_1() {}
	public practice_everyday04_1(int a, int b, int c) {
//		this.a = a;
//		this.b = b;
		this.c = c;
	}
	
	// getter & setter
	// setter : 데이터를 변수에 저장하는 메소드
	// getter : 저장된 데이터를 불러오는 메소드
//		public int getA() {
//			return a;
//		}
//		public void setA(int a) {
//			this.a = a;	
//		}
//		public int getB() {
//			return b;
//		}
//		public void setB(int b) {
//			this.b = b;
//		}
		public int getC() {
			return c;
		}
		public void setC(int c) {
			this.c = c;
		}
		
	@Override	
	public void println() {
		System.out.println("child1");
	}
	
}

// 상속 & overriding
public class practice_everyday04_2 extends practice_everyday04_1{
	
	// child2
	private int a;
	private int b;
	private int c;
	private int d;
	
	public practice_everyday04_2() {}
	public practice_everyday04_2(int a, int b, int c, int d) {
		this.a = a;
		this.b = b;
		this.c = c;
		this.d = d;
	}
	
	// getter & setter
		public int getA() {
			return a;
		}
		public void setA(int a) {
			this.a = a;	
		}
		public int getB() {
			return b;
		}
		public void setB(int b) {
			this.b = b;
		}
		public int getC() {
			return c;
		}
		public void setC(int c) {
			this.c = c;
		}
		public int getD() {
			return d;
		}
		public void setD(int d) {
			this.d = d;
		}
	@Override
	public void println() {
		System.out.println("child2");
	}
		

	
	
		
}

StringBuffer & StringBuilder 클래스는

불변 클래스인 String 클래스랑 다르게 문자열 수정이 가능한 가변 클래스다

String이 수정이 불가능하다니 무슨 말일까?

String 타입의 변수에 값을 넣어보면 언제든 바꿀 수 있는걸 알 것이다. 근데 사실 이게 데이터 자체가 수정되는게 아니라 시스템 내부에서는 String 타입의 변수에 값이 들어오면 메모리에 새로운 공간과 주소값을 생성시키고 기존의 것을 삭제하고 대체하는 식으로 작동한다. 그럼 주소값도 달라지고 눈에 보이는건 수정된 걸로 보이지만 말이다. 근데 이 둘 StringBuffer & StringBuilder은 말그대로 데이터 자체를 수정시킨다. 주소값 변함없이.

String 클래스와 이 둘의 차이

 - String : 변경이 적고 읽기만 많은 경우에 유리. 수정불가.

 - StringBuffer & StringBuilder : 문자열에 대한 수정이 많이 일어나는 경우 유리. 수정가능.

StringBuffer & StringBuilder의 차이는?

StringBuffer 동기화 o / 상대적으로느림 / 안전

StringBuilder 동기화 x / 빠름

둘이 동기화처리 빼고는 기능이 모두같다

동기화가 들어가면 상대적으로 안전하다. 데이터에 대해 락을 걸어놓고 진행하기에 처리속도가 상대적으로 느릴 수 있고 동기화가 안들어가면 락이 없어 그마만큼 속도가 다소 빠르다.

StringBuffer & StringBuilder

메모리 관리를 위해 에전에는 String대신 쓰기도 했다고 하나 요새는 성능들도 많이 좋아지고 String을 대개 많이쓴다고한다. 퍼나빌더를 쓴다고 눈에띄게 빨라지는게 아니라고 한다. 또한 자동으로 수용량(capacity)가 증가한다.

StringBuffer 안에 쓸 수 있는 많이 쓰는 메소드들

1) append()

받아온 값을 뒤에 추가로 이어주는 메소드

2) insert()

원하는 자리에 값 추가 시킬 수 있는 메소드

3) delete()

데이터 삭제하는 메소드

delete(int start, int end) : StringBuffer

deleteCharAt(int index) : StringBuffer

4)reverse()

앞뒤 거꾸로 값을 바꿔놓는 메소드

상속과 관련된 중요 키워드

this는 자기 자신

super는 자신의 부모

cal3클래스의 sum메소드는 부모클래스인 cal의 sum메소드를 오버라이딩하고 있음

이 코드가 엄청나게 복잡한 코드였다면 같은 기능의 코드를 중복해서 쓰는 낭비가 많았을 것

class Cal111 {
	public int sum(int v1, int v2) {
		return v1+v2;
	}
	public int sum(int v1, int v2, int v3) { // 같은 이름 메소드 // int v3 추가
		return v1+v2+v3;
	}
}
class Cal333 extends Cal11{		// extends : Cal1을 상속
	public int minus(int v1, int v2) {
		return v1-v2;			// Cal3는 이제 부모 클래스가 없는 마이너스 기능도 탑재
	}
	public int sum(int v1, int v2) {
		System.out.println("Cal3!!");
		return v1+v2;
	}
}

이럴 때 계승 발전 시키면 매우 유리할 것

자식 클래스의 메소드(sum)가 부모 클래스의 메소드(sum)를 호출하고 그 결과를 이용할 수 있다면 편리할 것. 이때 쓰는 것이 super

super.

자식 클래스의 메소드가 부모 클래스의 메소드를 호출하고 그 결과를 이용하는 것

super.부모클래스의 메소드명;

public int sum(int v1, int v2){
		return super.sum(v1,v2);
}

super가 잘 작동하는지 체크해보고 싶다면?

브레이크포인트 걸고 디버깅 해볼 것

this.

class Cal111 {
	// this
	// 자기 자신을 뜻함
	public int sum(int v1, int v2, int v3) { 
		return this.sum(v1,v2)+v3;	    // .sum() 자기자신
	}
}

전체코드

// Java 상속 - 4. this & super

class Cal111 {
	public int sum(int v1, int v2) {
		return v1+v2;
	}
	// this
	// 자기 자신을 뜻함
	public int sum(int v1, int v2, int v3) { // 같은 이름 메소드 // int v3 추가
		return this.sum(v1,v2)+v3;	// .sum() 자기자신
	}
}
class Cal333 extends Cal11{		// extends : Cal1을 상속
	public int minus(int v1, int v2) {
		return v1-v2;			// Cal3는 이제 부모 클래스가 없는 마이너스 기능도 탑재
	}
	
	// super
	// 부모를 뜻함
	public int sum(int v1, int v2) {
		System.out.println("Cal3!!");
		return super.sum(v1,v2);	// .sum()은 부모클래스 sum()
	}
}

public class Inheritance04 {
	public static void main(String[] args) {

		Cal111 c1 = new Cal111();
		System.out.println(c1.sum(2,1));
		System.out.println(c1.sum(2,1,1));
		
		Cal333 c3 = new Cal333();
		System.out.println(c3.sum(2,1));
		System.out.println(c3.minus(2,1));	// 자식클래스에 추가된 minus기능
		
	}
class Cal222 {
	public int sum(int v1, int v2) {
		return v1+v2;
	}
	public int minus(int v1, int v2) {
		return v1-v2;
	}
}
}

어떨 때에 인스턴스를 쓰는게 좋을까?

<클래스화를 계속 써야할 상황>

1)공급가액 파라미터가 한번 세팅이 되고나서 내부적 상태가 바뀌지 않고 getVAT(), Total() 같은메소드들로 부가가치세, 총액 같은 값만 받으면 되는 간단한 상태면 클래스 사용하면 된다

또는

2)내부적인 상태가 한번 세팅이되면 여러 작업들이 끝나고 그 다음에 새로운 내부적인 상태가 변화가 오는 케이스에서도 클래스를 인스턴스화 시킬 필요는 없다고 본다

<인스턴스화를 써야할 상황>

그런데 클래스의 상태가 계속 바뀌어야하는 상황이라면?

ex) 공급가액(vauleOfSupply) 1만 세팅에서 2만,3만 등 경우의수가 엄청나게 많아지고 계속 바꿔가면서 써야한다면?

(즉, 클래스의 상태가 계속 바뀌어야하는 상태일 때는?)

Accounting08_2.valueOfSupply = 10000.0;		
System.out.println("Value of supply : " + Accounting.valueOfSupply);
System.out.println("VAT : " + Accounting.getVAT());
System.out.println("Total : " + Accounting.getTotal());

Accounting08_2.valueOfSupply = 20000.0;		
System.out.println("VAT : " + Accounting.getVAT());

Accounting08_2.valueOfSupply = 50000.0;		
System.out.println("VAT : " + Accounting.getVAT());

Accounting08_2.valueOfSupply = 900.0;		
System.out.println("Total : " + Accounting.getTotal());

공급가액(vauleOfSupply)이 하나가 아닌 내부적으로 수십개의 값들이 있고 계속 바꿔야한다면 버그 발생 확률 고위험

하나의 클래스를 여러 상태에서 돌려써서 버그발생 확률이 높아지게 되는 것

이럴 때 인스턴스화

독립된 인스턴스기에 상태별로 인스턴스를 만들어서 분리시키고 개별맞춤으로 관리가능

인스턴스가 생성될 때, 인스턴스가 내부적으로 꼭 가져야될 값(valueOfSupply)을 생성자 레벨에서 강제하고 싶다면?

A.아래의 코드 추가 및 인스턴스 생생코드 new Accounting(생성자); 생성자 인자부분 채우기

// 생성자가 호출될 때 인자를 매개변수로 전달하고 싶기에 public accounting() {}에 valueOfSupply를 넣는다
public Accounting08_3(double valueOfSupply) { 
		this.valueOfSupply = valueOfSupply;
}
// 생성자 인자 넣기
Accounting08_3 a1 = new Accounting08_3(**10000.0**);
        a1.valueOfSupply = 10000.0;

public accounting() {} 구현해주면 된다

생성자가 호출될 때 인자를 매개변수로 전달하고 싶기에 public accounting() {}에 valueOfSupply를 넣어주고 this.valueOfSupply 추가

위의 코드 this.valueOfSupply와 = valueOfSupply;가 가리키는 곳은?

this 키워드

전체코드

// OOP 8.2. 활용 - 인스턴스화

// 클래스화 to 인스턴스화

 
//class Accounting08_2{		// 클래스화
//
//    public static double valueOfSupply;		
//    public static double vatRate = 0.1;		
//    public static double getVAT() {
//        return valueOfSupply * vatRate;
//    }
//    public static double getTotal() {
//        return valueOfSupply + getVAT();
//    }
//}
//					클래스화
//      ↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓
//					인스턴스화

class Accounting08_2{		// 인스턴스화
	// 인스턴스 소속, static 제거
	// static은 클래스소속이고 클래스가 인스턴스에 접근하면 에러나는건 어떤 인스턴스인지 모르기때문 a1?a2?
	public double valueOfSupply;		
	public static double vatRate = 0.1;	// 부가가치세는 어느 인스턴스나 10% 고정이기에 static설정이 유리	
	public double getVAT() {			// 인스턴스 만들 때마다 메모리 사용하지 않아도 되고, 
	    return valueOfSupply * vatRate; // vatRate파라미터는 얘 하나로 조절 가능해서 유지보수 용이
	}
	public double getTotal() {
	    return valueOfSupply + getVAT();
	}
}

public class OOP08_2 {
	public static void main(String[] args) {		

//        Accounting08_2.valueOfSupply = 10000.0;		
//        System.out.println("Value of supply : " + Accounting.valueOfSupply);
//        System.out.println("VAT : " + Accounting.getVAT());
//        System.out.println("Total : " + Accounting.getTotal());
//        
//        Accounting08_2.valueOfSupply = 20000.0;		
//        System.out.println("VAT : " + Accounting.getVAT());
//        
//        Accounting08_2.valueOfSupply = 50000.0;		
//        System.out.println("VAT : " + Accounting.getVAT());
//        
//        Accounting08_2.valueOfSupply = 900.0;		
//        System.out.println("Total : " + Accounting.getTotal());
    
				Accounting08_2 a1 = new Accounting08_2();
		    a1.valueOfSupply = 10000.0;
		    
		    Accounting08_2 a2 = new Accounting08_2();
		    a2.valueOfSupply = 20000.0;
		    
		    System.out.println("Value of supply : " + a1.valueOfSupply);
		    System.out.println("Value of supply : " + a2.valueOfSupply);
		    
		    System.out.println("VAT : " + a1.getVAT());
		    System.out.println("VAT : " + a2.getVAT());
		    
		    System.out.println("Total : " + a1.getTotal());
		    System.out.println("Total : " + a2.getTotal());    
	}
}

메소드 사용방식에서 클래스화 시키면서 정리정돈

1. 새클래스 생성
2. 관련 카테고리의 기존 메소드들을 새클래스 안으로 이주
3. 기존 메소드들 앞에 클래스명 추가 : Accounting.

+@ 클래스를 따로 파일화해서 분리관리

목차

1. 기존 메소드 방식 코드
2. 클래스화된 코드

1.기존 메소드 방식 코드

public class OOP08_1 {
	 public static double valueOfSupply = 10000.0;
	 public static double vatRate = 0.1;
	 public static double  getVAT() {
		 return valueOfSupply * vatRate;
	 }
	 public static double getTotal() {
		 return valueOfSupply + getVAT();
	 }
	 public static void main(String[] args) {
		 System.out.println("Value of supply : " + valueOfSupply);
		 System.out.println("VAT : " + getVAT());
		 System.out.println("Total : " + getTotal());
	 }
 }

2.클래스화된 코드

class Accounting{
    public static double valueOfSupply;		// 공급가액	// 파라미터는 메인메소드 안에서 설정함
    public static double vatRate = 0.1;		// 부가가치세율
    public static double getVAT() {
        return valueOfSupply * vatRate;
    }
    public static double getTotal() {
        return valueOfSupply + getVAT();
    }
}

public class OOP08_1 {
	public static void main(String[] args) {
		
        Accounting.valueOfSupply = 10000.0;		// 공급가액 파라미터
        System.out.println("Value of supply : " + Accounting.valueOfSupply);
        System.out.println("VAT : " + Accounting.getVAT());
        System.out.println("Total : " + Accounting.getTotal());
	}
}

에러나는 코드 원문

class Accounting08_2{		// 인스턴스화
// 인스턴스 소속, static 제거
// static은 클래스소속이고 클래스가 인스턴스에 접근하면 에러나는건 어떤 인스턴스인지 모르기때문 a1?a2?
    public static double valueOfSupply;		
	public static double vatRate = 0.1;		
	public static double getVAT() {
	    return valueOfSupply * vatRate;
	}
	public static double getTotal() {
	    return valueOfSupply + getVAT();
	}
}

public class OOP08_2 {
	public static void main(String[] args) {
		
		Accounting08_2 a1 = new Accounting08_2();
        a1.valueOfSupply = 10000.0;
        
        Accounting08_2 a2 = new Accounting08_2();
        a2.valueOfSupply = 20000.0;
        
        System.out.println("Value of supply : " + a1.valueOfSupply);
        System.out.println("Value of supply : " + a2.valueOfSupply);
        
        System.out.println("VAT : " + a1.getVAT());
        System.out.println("VAT : " + a2.getVAT());
        
	}

}

JAVA 객체 지향 프로그래밍 - 4.1. 클래스 - 존재 이유와 기본형식

클래스 존재 이유 : 정리정돈

 - 메소드 코드가 1억줄이라면 복잡성은 헬

새로 클래스를 생성하고 전에 수업에서 만든 메소드들을 class 안으로 이사시키자

그리고 메인 메소드에서 해당 메소드들을 호출하는 명령어 코드 앞에 클래스명 추가(경로지정 작업)

전체코드

// OOP 4.1 : 클래스 - 존재 이유와 기본형식

class Print04_1 {
	public static String delimiter = ""; 
	public static void A() {
		// ... 1억줄 코드
		System.out.println(delimiter); // printA() 메소드 안에  delimiter가 없다면
		System.out.println("A");	   // 이 파일 클래스(메인 메소드 위에)에서 찾아서 사용
		System.out.println("A");	   // 
	}
	public static void B() {
		// ... 1억줄 코드
		System.out.println(delimiter);
		System.out.println("B");
		System.out.println("B");
	}
	// 메소드가 1억개라면 헬 난이도 복잡도
	// 구원자는 class
	// 새로운 클라스를 만들어서 정리하자
	// class print04를 생성하고 같은 주제인 메소드들을 안으로 이사시킴
}

public class OOP04_1 {
	public static void main(String[] args) {
		
		Print04_1.delimiter = "----";	// 추가 경로지정 : 클래스명. 추가
		Print04_1.A();					
		Print04_1.A();	
		
		Print04_1.delimiter = "====";	
		Print04_1.B();
		Print04_1.B();			
	}
}

JAVA 객체 지향 프로그래밍 - 2. 남의 클래스 & 남의 인스턴스

OOP(objected Oriented Programming)

System.out.println(Math.PI);
// 결과값 : 3.141592653589793

math라고 하는 클래스에 PI라는 변수가 있는 것이고, 그 변수 안에 3.14의 구체적인 숫자가 적당한 정밀도로 적혀있는 것

System.out.println(Math.PI);
System.out.println(Math.floor(1.8)); // 내림
System.out.println(Math.ceil(1.8));  // 올림

Math는 클래스이고, 클래스 안에는 수학과 관련된 PI라고 하는 변수도 있고 floor,ceil과 같은 메소드들도 들어 있는 것.

즉, 코드가 많아짐에 따라서 서로 연관된 같은 주제를 가지고 있는 변수와 메소드를 그루핑한 껍데기가 클래스

FileWriter f1 = new FileWriter(”data.txt”)

new를 붙이므로써 FileWriter라는 클래스의 복제본f1을 만들겠다

FileWriter f1 = new FileWriter("data.txt"); // new를 붙이므로써 FileWriter라는 클래스의 복제본을 만들겠다
f1.write("Hello");
f1.write("Java");
f1.close();

일회용으로 작업을 끝내면 되는 것들은 메소드나 변수를 클래스에 소속된 그냥 클래스에 있는거 그냥 사용합니다

ex) Math.floor()나 Math.ceil()

하지만 긴 맥락을 가지고 작업해야하는 것들은 클래스를 직접 사용하지 않고 인스턴스를 사용해서 복제본을 사용해서 관리한다

ex) f1인스턴스를 계속 write write close까지 길게 여러번

		FileWriter f1 = new FileWriter("data.txt"); // FileWriter의 복사본
		f1.write("Hello");
		f1.write("Java");

				
		FileWriter f2 = new FileWriter("data2.txt"); // FileWriter의 또 다른 복사본
		f2.write("Hello");
		f2.write("Java2");
		f2.close();
		
		f1.write("!!!");  				// 긴 맥락의 작업
		f1.close();

아래에서

클래스 : System, Math, FileWriter

인스턴스 : f1, f2

import java.io.FileWriter;
import java.io.IOException;

public class OOP02 {

	public static void main(String[] args) throws IOException {
		// class : System, Math, FileWriter
		// Instance : f1, f2 
		System.out.println(Math.PI);
		System.out.println(Math.floor(1.8));
		System.out.println(Math.ceil(1.8));
		
		FileWriter f1 = new FileWriter("data.txt"); // FileWriter의 복사본
		f1.write("Hello");
		f1.write("Java");

				
		FileWriter f2 = new FileWriter("data2.txt"); // FileWriter의 또 다른 복사본
		f2.write("Hello");
		f2.write("Java2");
		f2.close();
		
		f1.write("!!!");  				// 긴 맥락의 작업
		f1.close();
	}
}