DecimalFormat df = new DecimalFormat("0.00"); //내 코드
DecimalFormat df = new DecimalFormat("###.00"); //강사님 코드
- 0과 #은 의미가 다르다. - ###을 넣으면 두자리여도 두자리만 표시하고 세자리면 세자리로 표시한다. - 000을 넣으면 0은 무조건 자리를 채워넣는 형식, 31.42인 값이 031.42 로 표시된다.
상속을 쓰는 이유 - 중복코드를 줄이기 위해서 - 통일성있는 클래스를 설계하기 위해서 - 그래픽프로그램에서 상속을 많이 사용한다 - 나중에 JSP model2 = MVC 패턴개발 를 할때 클래스가 많을때 사용한다
자바에서 그래픽 프로그램 - CUI(Console User Interface) - GUI(Graphic User Interface)
그래픽 프로그램 관련 패키지 - java.awt.* - javax.swing.* - javafx.* - 여기 그래픽 프로그램 만들기 위한 클래스들이 모여있다 - 그래픽 프로그램에서 상속을 많이 사용함 - 캔버스, 체크박스, 프레임, 스크롤바, 메뉴, 텍스트필드 등 만들 수 있다
패키지와 파일 - 한개 파일에 클래스 여러개 들어가도된다 - 나중에 컴파일될때 바이트코드는 클래스별로 따로따로 만들어짐 - 패키지는 폴더를 의미한다
상속 예제1 - SuperSub01.java - 자식클래스명 옆에 extends 옆에 부모클래스명을 쓰자
package p2022_07_05;
class Parent {
public void parentPrn() { //부모 클래스
System.out.println("슈퍼 클래스 메서드는 상속된다.");
}
}
//Parent를 슈퍼 클래스로 하는 서브 클래스 Child 정의
class Child extends Parent { //자식 클래스
public void childPrn() {
System.out.println("서브 클래스 메서드는 슈퍼가 사용 못한다.");
}
}
//Parent를 슈퍼 클래스로 하는 서브 클래스 Child 정의
//Parent클래스의 parentPrn() 메소드는 자식 클래스에 상속된다.
class SuperSub01 {
public static void main(String[] args) {
Child c = new Child(); // 서브 클래스로 객체를 생성
c.parentPrn(); // 슈퍼 클래스에서 상속 받은 메서드 호출
c.childPrn(); // 서브 클래스 자기 자신의 메서드 호출
System.out.println("-------------------------------------->> ");
Parent p = new Parent(); // 슈퍼 클래스로 객체 생성
p.parentPrn(); // 슈퍼 클래스 자기 자신의 메서드 호출
// p.childPrn( ); //서브 클래스 메서드는 가져다 사용 못함
}
}
- 상속은 부모가 자식에게 일방적으로 주는것만 가능하다 - 부모클래스는 자식클래스의 멤버(필드나 메소드) 사용불가!
상속 예제2 - SuperSub04.java
package p2022_07_05;
class Point2D { // 부모 클래스
protected int x = 10; // private int x=10;
protected int y = 20; // private int y=20;
}
// 부모 클래스의 필드의 접근제어자가 private이면 자식이 접근할 수 없다.(상속 불가), 여기선 오류 발생
class Point3D extends Point2D { // 자식 클래스
protected int z = 30;
public void print() {
System.out.println(x + ", " + y + ", " + z);
}
}
class SuperSub04 {
public static void main(String[] args) {
Point3D pt = new Point3D();
pt.print();
}
}
- Point2D클래스가 부모클래스, 안의 필드 x, y 의 접근제한자가 protected - Point3D클래스가 Point2D 클래스를 상속받음 - Point3D의 필드 protected int z, 메소드 print(); - 메인메소드가 있는 클래스 SuperSub04 - 메인메소드에서 Point3D 클래스로 객체를 생성하고 pt.print()로 메소드 호출 - 그럼 이 print()에서 x,y는 자기 클래스의 멤버는 아니지만 부모 클래스의 멤버이므로 자기거인것처럼 출력하는 것임
- 이때 접근 제어자, Point2D의 접근제어자를 private으로 두면? 오류발생, 자식 클래스에 상속 안된다! - 부모클래스의 필드/메소드가 private이면 자식클래스라도 외부클래스이므로 접근불가, 상속을 못함 - private만 아니면 다 됨, default, public, protected는 다 상속 된다
접근제어자 protected - 상속에선 나중에 접근제어자를 protected를 많이 씀 - 심지어 패키지가 달라져도 상속관계에 있을때는 자식이 접근 가능하다
패키지가 달라져도 접근가능한 경우 1. public인 경우 2. protected이고 상속관계인 경우 자식이 부모클래스 필드/메소드 접근
* 자바의 접근 제어자
1. 상속 관계가 있는 경우에 2개의 클래스(부모,자식 클래스)가 같은 패키지 안에 들어 있을때는 부모의 접근제어자가 default, protected, public 접근제어자인 경우에 자식클래스에서 접근 할수 있다. (단, private접근 제어자만 자식 클래스에서 접근 할 수 없음)
2. 상속 관계가 있는 경우에 2개의 클래스(부모,자식 클래스)가 다른 패키지 안에 들어 있을때는부모의 접근제어자가 protected, public 접근제어자인 경우에 자식클래스에서 접근 할수 있다.
3. 상속 관계가 없는 경우에 2개의 클래스가 서로 다른 패키지 않에 들어 있을때는 public 접근제어자로 되어 있어야만 다른 클래스에서 접근 할 수 있다.
+ 메소드 오버라이딩 - 상속에서 가장 중요한 개념 - 반드시 상속이 전제되어야만 쓸 수 있다. - 메소드는 상속이 되지만, 부모로 부터 상속받은 메소드를 이름과 형식은 같게 하지만 안의 내용을 다르게 하는것 - 나중에 자세히 공부할것
상속 예제 3-1 (필드) - SuperTest02.java
package p2022_07_05;
//부모 클래스 안에 있는 필드는 자식 클래스에게 상속된다.
class Point2D2 { //부모 클래스
protected int x = 10;
protected int y = 20;
}
class Point3D2 extends Point2D2 { //자식 클래스
protected int z = 30;
public void print() {
System.out.println(x + ", " + y + ", " + z); // x와 y는 상속 받아 사용하는 멤버변수
}
}
class SuperTest02 {
public static void main(String[] args) {
Point3D2 pt = new Point3D2();
pt.print();
}
}
+ protected이므로 상속 가능 - 이 예제는 필드 중복 그거 아니고 다음 예제이다 - 위 예제는 그냥 부모 클래스 안에 있는 필드는 자식 클래스에게 상속된다는걸 보여주는 예제
- 그럼 부모클래스에 있는 필드 x, y 를 상속받은 자식 클래스에서 똑같은 이름 x, y으로 필드를 정의해보자 - 자식클래스로 객체 만들어서 필드값출력할떄 어느값을 출력하는가? -> 새로정의한 x, y값만 출력됨. - 다음 예제에서 설명
상속 예제 3-2 (필드의 상속) - SuperTest03.java
package p2022_07_05;
//부모 클래스에 있는 필드를 자식 클래스에서 재정의(동일한 이름의 변수)하면,
//자식 클래스에서 재 정의한 필드만 사용 가능하다.
class Point2D3 { //부모 클래스
protected int x = 10; // Point3D에서 다시 한번 정의되므로 은닉 변수가 됨
protected int y = 20; // 은닉 변수는 쉐도우 변수라고도 함
}
class Point3D3 extends Point2D3 { //자식 클래스
protected int x = 40; // 슈퍼 클래스에 존재하는 멤버변수를
protected int y = 50; // 서브 클래스에 다시 한 번 정의함
protected int z = 30;
public void print() {
System.out.println(x + ", " + y + ", " + z); // x와 y는 재 정의된 Point3D 클래스 소속
}
}
class SuperTest03 {
public static void main(String[] args) {
Point3D3 pt = new Point3D3();
pt.print();
}
}
40, 50, 30
- x, y가 중첩되고 있다 - 결론은 새로정의한 x, y값만 출력됨, 즉 10, 20 대신 40, 50 이 출력됨 - 기존에 상속해준 부모 클래스의 x, y 필드는 더이상 사용이 되지않음, 은닉이된다 -> 이 변수를 은닉 변수 = 쉐도우 변수 라고 함 - 이 은닉 변수들에 굳이 접근하고 싶으면 super. 을 사용해서 접근한다!
필드의 상속 정리 - 부모 클래스에 있는 필드를 자식 클래스에서 재정의(동일한 이름의 변수)하면, 자식 클래스에서 재정의한 필드만 사용 가능하다.
은닉 변수에 접근 - super.x, super.y 하면 은닉변수에 접근가능하다 - 쓸 일이 많지 않다
은닉 변수에 접근 예시 - 은닉변수에 굳이 접근하려면 super. 해서 접근 - 부모 클래스에 접근해서 값을 구해오라는 의미 - SuperTest04.java
package p2022_07_05;
//super : 부모 클래스를 의미함
//super.x 는 부모 클래스의 은닉된 필드를 호출할 때 사용된다.
//super.x 는 "자식클래스"의 "메소드 안"에서만 사용할 수 있다. (주의)
//그 외의 장소에서 System.out.println(super.x); //오류 발생
class Point2D4 { // 부모 클래스
protected int x = 10; // 은닉 변수
protected int y = 20; // 혹은 쉐도우 변수
}
class Point3D4 extends Point2D4 { // 자식 클래스
protected int x = 40; // 슈퍼 클래스에 존재하는 멤버변수를
protected int y = 50; // 서브 클래스에 다시 한 번 정의함
protected int z = 30;
// System.out.println(super.x); 메소드 내부가 아니므로 오류
public void print() {
System.out.println(x + ", " + y + ", " + z); // x와 y는 재 정의된 Point3D 클래스 소속
}
public void print02() {
System.out.println(super.x + ", " + super.y + ", " + z); // Point2D 클래스 소속 멤버변수로 접근
}
}
class SuperTest04 {
public static void main(String[] args) {
Point3D4 pt = new Point3D4();
pt.print(); // 40, 50, 30 // Point3D의 x, y
pt.print02(); // 10, 20, 30 // Point2D의 x, y
System.out.println(pt.x); // 40
}
}
40, 50, 30 10, 20, 30 40
은닉 변수에 접근 정리 - super : 부모 클래스를 의미함 - super.x 는 부모 클래스의 은닉된 필드를 호출할 때 사용된다. - super.x 는 "자식클래스"의 "메소드 안"에서만 사용할 수 있다. (주의) - 그 외의 장소에서 System.out.println(super.x); //오류 발생
super 와 this - super : 부모 클래스를 의미하는 일종의 레퍼런스 변수 - this : 자기 클래스를 의미하는 일종의 레퍼런스 변수
* this와 super this. : 생성자와 메소드에서 매개변수와 멤버변수 이름이 동일한 경우에 사용
this() : 같은 클래스내에 있는 다른 생성자를 호출(다른 클래스 내의 생성자는 이걸로 호출하지않음) super. : 부모 클래스에 있는 은닉된 멤버변수와 메소드를 호출 할때 사용, 반드시 자식 클래스의 메소드 내에 써야만 사용가능하다. 자식 클래스의 메소드 밖이나 다른 클래스 내에서 사용불가 super() : 부모 클래스의 매개변수를 가진 생성자를 호출 할 때 사용
메소드로의 적용 (메소드 오버라이딩) - 필드에서 재정의된 필드가 사용되는 것 처럼 메소드도 마찬가지이다. - 메소드는 메소드 오버라이딩이라고 하지만 필드는 이런거 따로 부르는 이름이 없다 - 결론적으론 메소드도 새로 정의된 메소드 오버라이딩된 메소드만 호출됨
- 부모 클래스의 메소드는 은닉 메소드가 됨, 굳이 호출하고 싶으면 super.메소드() 로 호출하면된다 - 필드때처럼 부모의 메소드와 똑같은 이름 + 똑같은 형식 으로 메소드를 만들어야함 - 메소드 오버라이딩(Method Overriding), 동일이름 동일형식 다른내용 상속전제 필수
메소드 오버라이딩 예제
- SuperSub05.java
package p2022_07_05;
// 메소드 오버라이딩(Method Overriding)
// : 부모 클래스로부터 상속받은 메소드를 자식 클래스에서 재정의 해서 사용하는 것.
// 1. 부모 클래스로부터 상속받은 메소드를 자식 클래스에서 메소드 오버라이딩을 하면
// 메소드 오버라이딩 된 메소드만 호출되고, 부모 클래스의 메소드는 은닉이 되어서
// 자식클래스에 상속되지 않는다.
// 2. 부모 클래스에 은닉된 메소드를 호출할 때는 자식클래스의 메소드 안에서
// super.parentPrn() 형식으로 호출해야 된다.
class Parent05 { //부모 클래스
public void parentPrn() { //은닉 메소드가 된다
System.out.println("슈퍼 클래스 : ParentPrn 메서드");
}
}
//Parent05를 슈퍼 클래스로 하는 서브 클래스 Child05 정의
class Child05 extends Parent05 { //자식 클래스
// super.parentPrn(); //오류 발생, 자식클래스의 메소드 내부여야함
// 슈퍼 클래스에 있는 ParentPrn 메서드를 오버라이딩하면
// Child05로 선언된 객체는 슈퍼 클래스의 메서드가 은닉되어 상속 받지 못하게 된다.
public void parentPrn() { // 메소드 오버라이딩(Method Overriding), 동일이름 동일형식 다른내용 상속전제 필수
System.out.println("서브 클래스 : ParentPrn 메서드");
}
public void childPrn() { // 자식 클래스만 있는 메소드
super.parentPrn(); //부모 클래스의 은닉 메소드 호출
System.out.println("서브 클래스 : ChildPrn 메서드");
}
}
class SuperSub05 {
public static void main(String[] args) {
Child05 c = new Child05(); // 서브 클래스로 객체를 생성
c.parentPrn(); // 오버라이딩된 서브 클래스의 메서드 호출(새로 정의된, 오버라이딩된 메소드만 호출됨)
c.childPrn(); // 서브 클래스 자기 자신의 메서드 호출
System.out.println("-------------------------------------------->> ");
Parent05 p = new Parent05(); // 슈퍼 클래스로 객체를 생성
p.parentPrn(); // 슈퍼 클래스(자기 자신)의 메서드 호출
}
}
서브 클래스 : ParentPrn 메서드 슈퍼 클래스 : ParentPrn 메서드 서브 클래스 : ChildPrn 메서드 -------------------------------------------->> 슈퍼 클래스 : ParentPrn 메서드
- 은닉된 메소드도 호출할때는 super.메소드() 로 호출하면 호출된다! - super.메소드() 를 쓰는 위치는 필드랑 동일하게 자식 클래스의 메소드 안에서 사용해야함 (주의) ex) super.parentPrn();을 자식 클래스의 메소드 밖에서 쓰면 오류 발생함
- 메소드 오버라이딩을 하면 오버라이딩된 메소드만 호출된다. - 부모클래스로부터 상속된 메소드는 사용이 더이상되지않고 은닉메소드가 된다 - 은닉메소드를 굳이 호출될때는 자식 클래스의 메소드 내에서 super.메소드() 로 호출
메소드 오버라이딩(Method Overriding) 정리 - 부모 클래스로부터 상속받은 메소드를 자식 클래스에서 재정의 해서 사용하는 것. - 부모 클래스로부터 상속받은 메소드를 자식 클래스에서 메소드 오버라이딩을 하면 메소드 오버라이딩 된 메소드만 호출되고, 부모 클래스의 메소드는 은닉이 되어서 자식클래스에 상속되지 않는다. - 부모 클래스에 은닉된 메소드를 호출할 때는 자식클래스의 메소드 안에서 super.parentPrn() 형식으로 호출해야 된다.
* 메소드 오버라이딩(Method Overriding) - 부모 클래스로 부터 상속받은 메소드를 자식 클래스에서 재정의 해서 사용하는것
- Spring , JSP 할 때도 계속 따라가는 개념이므로 잘 익혀둬야 한다.
은닉 정리 - 결과적으로 자식 클래스에서 재정의 시 부모클래스안의 상속이 되는 필드, 메소드는 상속이 되지 않는다 - 은닉이 됨. 사용하려면 자식클래스의 메소드 안에서 super.필드명, super.메소드명() 으로 호출가능하다
+ 메소드 오버라이딩을 해도 되고 안해도 되지만 곧 배울 추상클래스, 인터페이스의 경우에는 반드시 메소드 오버라이딩을 해야하는 경우가 있다, 하지 않으면 오류 발생 + 상속에서는 메소드와, 메소드 오버라이딩이 제일 중요하다
생성자와 상속 - 기본적으로 생성자는 상속되지 않는다, 어떻게 쓸까? - 자식 클래스의 객체를 생성할때, 자식 클래스의 생성자가 호출되면 부모 클래스의 기본 생성자를 연쇄적으로 호출해줌 - 자식 클래스의 생성자는 기본생성자 여도 되고 매개변수를 가진 생성자여도 상관없음 - 이때 부모 클래스의 생성자는 "기본 생성자"만 호출되어 실행이됨
생성자와 상속 예제 - SuperTest05.java
package p2022_07_05;
class Point2D05 { //부모 클래스
protected int x = 10; //필드
protected int y = 20;
public Point2D05() { //부모클래스의 기본 생성자
System.out.println("슈퍼 클래스인 Point2D 생성자 호출");
}
}
class Point3D05 extends Point2D05 { //자식 클래스
protected int z = 30;
public void print() {
System.out.println(x + ", " + y + ", " + z);
}
public Point3D05() { //자식클래스의 기본 생성자
System.out.println("서브 클래스인 Point3D 생성자 호출");
}
}
class SuperTest05 {
public static void main(String[] args) {
Point3D05 pt = new Point3D05(); //자식클래스의 기본생성자 호출
pt.print();
슈퍼 클래스인 Point2D 생성자 호출 서브 클래스인 Point3D 생성자 호출 10, 20, 30
- 즉, main메소드에서 자식클래스의 생성자가 먼저 호출되었지만 실행 결과는 부모클래스의 기본 생성자의 출력문이 먼저 출력됨 - Point3D05 클래스의 기본 생성자가 호출되면 부모 클래스인 Point2D05 클래스의 기본 생성자를 호출함 - 그러므로 "슈퍼 클래스인 Point2D 생성자 호출" 출력 다음 "서브 클래스인 Point3D 생성자 호출" 메세지를 출력한다 - 부모 클래스의 기본생성자 만들어놓지 않으면 컴파일러가 자동으로 만듬 - 지금처럼 기본생성자 만들어뒀을때는 객체 생성할때 부모 클래스의 기본 생성자를 호출함
생성자와 상속 정리 * 상속에서의 생성자 1. 생성자는 기본적으로 상속이 되지 않는다 2. 자식클래스를 이용해서 객체를 생성할때 자식클래스의 생성자(기본생성자,매개변수 있는 생성자 모두 가능)가 호출되면, 부모클래스의 기본생성자가 자동으로 호출된다. 3. 매개변수가 있는 생성자가 있는 경우에는 더이상 컴파일러가 기본 생성자를 자동으로 생성해 주지 않는다. 4. 부모 클래스의 매개변수가 있는 생성자를 자식 클래스에서 호출 할때는 super()를 이용해서 호출할 수 있다. 단, super()는 자식 클래스의 생성자 안에서만 사용 가능함.
부모클래스의 기본생성자 호출 - 심지어 부모 클래스 쪽에 기본생성자가 없어도 된다. - 자식생성자가 부모 클래스의 기본생성자를 만들어서 호출해줌 - 또한 자식 클래스 쪽에 기본생성자가 없어도 된다, 컴파일러가 자동으로 기본클래스를 생성 후 부모 클래스의 기본 생성자 호출 - 만약 부모 클래스의 기본생성자가 아닌 매개변수가 있는 생성자를 호출하고 싶다면, super()로 명시적으로 호출해줘야지만 부모클래스의 매개변수가 있는 생성자를 호출 할 수 있다
- 자식클래스는 매개변수 있는 상속자여도 된다
public Point3D05(int a) { //자식클래스의 기본 생성자
System.out.println("서브 클래스인 Point3D 생성자 호출");
}
// main
Point3D05 pt = new Point3D05(30); //자식클래스의 기본생성자 호출
- 이어도 문제 없고 부모클래스의 기본생성자를 호출함 또한
public Point3D05() { //자식클래스의 기본 생성자
System.out.println("서브 클래스인 Point3D 생성자 호출");
}
- 이 코드(자식클래스의 기본생성자) 를 주석으로 막아도 컴파일러가 자동으로 기본클래스를 생성 - 또한 연쇄적으로 부모클래스의 기본 생성자도 호출됨
부모클래스의 기본생성자 호출 정리 - 자식클래스는 기본생성자여도 되고 매개변수가 있는 생성자여도 됨 - 부모클래스는 기본생성자만 연쇄적으로 자동적으로 호출해주게 되고, 매개변수가 있는 생성자는 우리가 super()로 명시해서 직접 호출해 줘야함
부모클래스에 기본생성자가 없다면 - 부모클래스에서 이미 매개변수가 있는 생성자가 있는경우 기본생성자가 자동으로 만들어지지 않는다 - 그래서 기본생성자를 내가 명시해서 만들어주지 않으면 자식클래스의 생성자에도 오류가 생김
부모클래스에 기본생성자가 없다면 예제/super() 통해서 호출하는 예제 - SuperTest06.java - 이 예제에선 부모클래스에서 이미 매개변수가 있는 생성자가 있으므로 기본생성자가 만들어지지 않는다 -> 그래서 기본생성자를 내가 명시해서 만들어주지 않으면 자식클래스의 생성자에도 오류가 생김
public Point2D06( ){ System.out.println("슈퍼 클래스인 Point2D 생성자 호출"); }
- 부모 클래스의 기본 생성자 주석을 풀어야만 자식클래스에서 오류가 생기지 않음 - 부모의 기본생성자를 자식 객체 생성될때 연쇄호출됨 - 부모 클래스에서 매개변수가 있는 생성자는 자식 클래스의 생성자에서 호출해주지 않는다, super() 로 호출해야함 - 그리고 부모 클래스에서 매개변수가 있는 생성자가 있고 기본 생성자가 적혀져있지 않으면 기본생성자는 자동으로 만들어지지 않는다 - 이런 경우에는 기본생성자를 명시해주지 않으면 자식 생성자쪽에서 오류가 남.
+ 매개변수가 있는 생성자가 있을때는 예외적으로 컴파일러가 기본생성자를 생성해주지 않는다.
- 물론 자식 클래스에서 호출하지 않을때는 안만들어도 되지만 자식 클래스 쪽에서 호출을 할떄는 부모클래스의 기본생성자가 필요하고, 부모 클래스의 기본생성자 없으면 오류남 - 지금은 자식 클래스의 생성자가 호출되므로 부모 클래스의 기본 생성자도 호출되기때문에 부모클래스의 기본 생성자가 필요하다
부모클래스의 매개변수가 있는 생성자 호출하는 방법 - 자식클래스에서 super() 형태로 호출해야함 - super()는 자식클래스의 생성자 내부 첫번째 라인에 써야함! 위치가 정해져있다
package p2022_07_05;
//super()
//1. super()는 부모 클래스의 매개변수를 가진 생성자를 호출할 때 사용한다.
//2. super()는 자식 클래스의 생성자 안에서 첫번째 라인에 사용해야 한다.
//3. super()를 이용해서 부모 클래스의 매개변수를 가진 생성자를 호출하면,
//더이상 부모클래스의 기본생성자를 호출해주지 않는다.
class Point2D06 { // 부모 클래스
protected int x = 10; // 필드
protected int y = 20;
// 매개변수가 있는 생성자가 있을때는 예외적으로 컴파일러가 기본생성자를 생성해주지 않는다.
public Point2D06() { //기본 생성자
System.out.println("슈퍼 클래스인 Point2D 생성자 호출");
}
public Point2D06(int xx, int yy) {
x = xx;
y = yy;
}
}
class Point3D06 extends Point2D06 { //자식 클래스
protected int z = 30;
public void print() {
System.out.println(x + ", " + y + ", " + z); //상속받은 필드 x, y
}
public Point3D06() { //자식 클래스의 기본 생성자
super(50,60); // 부모 클래스의 매개변수가 있는 생성자 호출
System.out.println("서브 클래스인 Point3D 생성자 호출");
}
}
class SuperTest06 {
public static void main(String[] args) {
Point3D06 pt = new Point3D06(); //자식 클래스의 생성자 호출
pt.print();
}
}
서브 클래스인 Point3D 생성자 호출 50, 60, 30
- 부모클래스의 매개변수 2개인 생성자가 호출되면서 x값이 50, y값이 60이 되는 것이다.
위 예제 처리과정 1. 메인메소드에서 먼저 Point3D06이란 자식클래스의 생성자를 호출한다 2. 자식클래스의 생성자가 호출됨, 내부 코드를 실행함 3. 원래는 자식클래스의 생성자가 호출되면 연쇄적으로 부모클래스의 기본 생성자를 호출함 4. 근데 여기선 super()를 썼으므로 super()가 우선이 됨 - super()를 통해 호출된 부모클래스의 매개변수있는 생성자가 호출되면 부모클래스의 기본생성자는 호출되지 않음 5. 그래서 "슈퍼 클래스인 Point2D 생성자 호출" 은 출력되지 않았고 값은 50, 60으로 변경됨 - 즉 매개변수를 가진생성자만 호출되었다는 의미
public Point2D06(int xx, int yy) {
x = xx;
y = yy;
}
- 이걸 호출하고 싶으면 자식클래스의 생성자 내부
public Point3D06() { //자식 클래스의 기본 생성자
super(50,60);
System.out.println("서브 클래스인 Point3D 생성자 호출");
}
- 에서 super()를 통해서 부모 클래스의 매개변수가 2개인 생성자를 호출한다 - 부모 클래스의 기본생성자 주석으로 막아도 오류 안생김
super() 유의사항 - super()는 자식클래스의 생성자 안에서만 사용가능하다 - 생성자 내부의 첫번째 라인만 가능하다! 다른 장소에 들어가면 오류 발생한다 - 자식 생성자가 호출되면 부모의 기본생성자가 호출되지만 자식 생성자 내에서 super()를 써서 매개변수 있는 생성자 호출할떄는 부모의 기본생성자는 호출되지 않는다. - super()가 우선순위 높다, super()쓰면 기본생성자 호출안해줌 - 동시에 2개(기본 생성자, 매개변수가 있는 생성자) 호출해주지 않는다 - super()는 메소드 안에 못쓴다. - super()가 우선순위 높다, super()쓰면 기본생성자 호출안해줌
super() 정리 1. super()는 부모 클래스의 매개변수를 가진 생성자를 호출할 때 사용한다. 2. super()는 자식 클래스의 생성자 안에서 첫번째 라인에 사용해야 한다. 3. super()를 이용해서 부모 클래스의 매개변수를 가진 생성자를 호출하면, 더이상 부모클래스의 기본생성자를 호출해주지 않는다.
super. 와 super()의 차이 - super. : 메소드 오버라이딩 되었을때 부모클래스 안의 필드, 메소드를 호출할 때 사용, 잘 안 쓴다 - super() : 자식클래스에서 부모 클래스의 매개변수를 가진 생성자를 호출할 때 사용, 잘 쓴다
+ super() 는 그래픽 프로그램 예제 다룰 때 썼었다 - FrameTestEx extends Frame 클래스의 생성자 첫번째 라인에서 super("Frame Test"); 라고 썼다. - 자기 부모의 매개변수가 있는 생성자를 호출하라는 의미로서 부모인 Frame클래스의 매개변수가 String인 생성자를 호출하고 있다
this. 예제 - DMBCellPhone.java
package p2022_07_05;
// p290 ~ 292
class CellPhone{ // 부모 클래스
String model; // 필드
String color;
void powerOn() { // 메소드
System.out.println("전원을 켭니다.");
}
void powerOff() {
System.out.println("전원을 끕니다.");
}
void bell() {
System.out.println("벨이 울립니다.");
}
void sendVoice(String message) {
System.out.println("자기:"+message);
}
void receiveVoice(String message) {
System.out.println("상대방:"+message);
}
void hangUp() {
System.out.println("전화를 끊습니다.");
}
}
// 부모 클래스의 필드와 메소드는 상속된다.
class DMBCellPhone extends CellPhone{ // 자식 클래스
int channel;
public DMBCellPhone(String model, String color, int channel) {
this.model = model; // 자바폰
this.color = color; // 검정
this.channel = channel; // 10
}
void turnOnDmb() {
System.out.println("채널:"+channel+"전 DMB방송 수신을 시작 합니다.");
}
void changeChannelDmb(int channel) {
this.channel = channel;
System.out.println("채널"+channel+"번으로 바꿉니다.");
}
void turnOffDmb() {
System.out.println("DMB방송 수신을 멈춥니다.");
}
}
public class DMBCellPhoneEx {
public static void main(String[] args) {
// TODO Auto-generated method stub
DMBCellPhone dmb = new DMBCellPhone("자바폰", "검정", 10);
// model, color 필드는 부모 클래스로 부터 상속 받아서 사용
System.out.println("모델:"+dmb.model);
System.out.println("색상:"+dmb.color);
System.out.println("채널:"+dmb.channel);
// 부모 클래스로 부터 상속 받아서 사용되는 메소드
dmb.powerOn();
dmb.bell();
dmb.sendVoice("여보세요");
dmb.receiveVoice("안녕 하세요! 저는 홍길동 입니다.");
dmb.sendVoice("아~ 예 반갑습니다.");
dmb.turnOnDmb();
dmb.changeChannelDmb(12);
dmb.turnOffDmb();
}
}
위 예제 부분 1
DMBCellPhone dmb = new DMBCellPhone("자바폰", "검정", 10);
- DmbCellPhone 클래스의 메소드인 changeChannelDmb()에서 매개변수와 필드가 이름이 같기때문에 여기서도 this. 를 쓴다
위 예제 부분 4
// 부모 클래스로 부터 상속 받아서 사용되는 메소드
dmb.powerOn();
dmb.bell();
dmb.sendVoice("여보세요");
dmb.receiveVoice("안녕 하세요! 저는 홍길동 입니다.");
dmb.sendVoice("아~ 예 반갑습니다.");
- 상속받은 메소드를 자기것처럼 씀
+ Ctrl키 누르고 메소드명 클릭하면 그게 정의되어있는 곳으로 감! 파일 달라도 거기로 찾아감
메소드 오버라라이딩 예제 - ComputerEx.java
package p2022_07_05;
// p296 ~ 297
// 메소드 오버라이딩(Method Overriding)
// : 부모 클래스로 상속받은 메소드를 자식 클래스에서 재정의 해서 사용하는 것
class Calculator{ // 부모 클래스
double areaCircle(double r) {
System.out.println("Calculator 객체의 areaCircle() 실행");
return 3.14159 * r * r;
}
}
class Computer extends Calculator{ // 자식 클래스
@Override
double areaCircle(double r) { // 메소드 오버라이딩
// super.areaCircle(r);
System.out.println("Computer 객체의 areaCircle() 실행");
// TODO Auto-generated method stub
return Math.PI * r * r;
}
}
public class ComputerEx {
public static void main(String[] args) {
// TODO Auto-generated method stub
int r = 10;
Calculator cal = new Calculator();
System.out.println("원의 면적:"+ cal.areaCircle(r));
// 자식클래스에서 메소드 오버라이딩 된 메소드만 호출된다.
Computer comp = new Computer();
System.out.println("원의 면적:"+ comp.areaCircle(r));
}
}
- 부모클래스로부터 상속받은 Computer 클래스는 메소드 오버라이딩을 수행한다. - 이때, 부모클래스의 이름과 형식 (매개변수, 리턴형) 그대로 해야한다 - 만약 부모클래스의 메소드를 호출하고 싶다면 return super.areCircle(r)로 super. 를 쓰면 된다.
- 클래스를 상속받을땐 메소드 오버라이딩을 해도 되고 안해도 됨. - 상속을 하더라도 메소드 오버라이딩 안해도 됨 - 이게 끝나면 추상클래스라는걸공부하는데 추상클래스가 extends뒤에 오게되면 반드시 메소드 오버라이딩을 해야함
+ 인터페이스는 클래스처럼 extends로 상속받는게 아니라 implements 키워드로 상속을 받음 + 직접 내가 클래스를 만들때 상속을 하려면 ex까지 쓰고 ctrl+ space하면 자동으로 입력됨
이클립스 메소드 오버라이딩 생성 - 이때 이클립스를 이용하면 메소드 오버라이딩 자동으로 만들어주는 기능 있다 - 주석으로 막고 이클립스로 메소드 오버라이딩 해보자
오른쪽 마우스 -> Source -> Override/Implement Methods - 부모클래스, 조상클래스(Object등)가 보이고 그 안의 오버라이딩 할 메소드 선택 가능 - 원하는 메소드만 클릭해서 오버라이딩 하면 된다
- 컴파일러가 이 어노테이션 만나면 아래쪽에 메서드가 오버라이딩 잘 되었는지 체크한다 - 이런역할을 어노테이션이 해줌 - 없어도 실행에 지장은 없다.
메소드 오버라이딩 정리 - 오버라이딩 하면 부모클래스의 메소드가 아닌 자식클래스에서 메소드 오버라이딩 된 메소드만 호출된다. - 은닉된 메소드를 굳이 호출할떄는 자식 클래스의 메소드에서 super. 으로 호출한다 - 이 내용이 그 다음의 추상클래스, 인터페이스와 연결됨 거기선 반드시 메소드 오버라이딩을 해야함
final 키워드 - 상속을 배우기 전 간단히 설명 했었다 - final 필드 : 수정 불가 필드 = 상수 - final 메소드 : 자식 클래스에서의 이 메소드 오버라이딩을 허용하지 않음 (마지막 메소드) - final 클래스 : 상속을 허용하지 않는 클래스 (마지막 클래스) - 여기서 final 메소드와 final 클래스를 볼 것
1. 상속 관계가 있는 경우 1-1. 2개의 클래스(부모,자식 클래스)가 같은 패키지 안에 들어 있을때 - 부모의 접근제어자가 default, protected, public 접근제어자인 경우에 자식클래스에서 접근 할수 있다. - (단, private 접근제어자만 자식 클래스에서 접근 할 수 없음)
1-2. 2개의 클래스(부모,자식 클래스)가 다른 패키지 안에 들어 있을때 - 부모의 접근제어자가 protected, public 접근제어자인 경우에 자식클래스에서 접근 할수 있다.
2. 상속 관계가 없는 경우 - 2개의 클래스가 서로 다른 패키지 안에 들어 있을때는 public 접근제어자로 되어 있어야만 다른 클래스에서 접근 할 수 있다.
import 기준 - 패키지가 달라질때 -> 반드시 import
패키지가 다를때 접근하는법 1. 접근제어자가 public 이면 다 됨 2. 두 클래스 상속관계 && 접근제어자 protected
+ 그래서 이 protected 접근제어자는 상속에서 많이 씀
상속과 접근제어자 1. 같은 패키지 안의 클래스 2개가 부모-자식 상속관계 -> private 빼고 다 접근가능하다 - public은 다 되고, default 는 원래부터 같은 패키지면 접근가능하고 - protected는 원래부터 같은 패키지면 접근 가능했고 또 상속관계면 다 접근 가능하기떄문에 접근 가능
2. 다른 패키지 안의 부모-자식 상속관계 -> protected, public 둘 중 하나여야만 함 - default 는 다른패키지는 접근 불가 - protected는 패키지가 달라져도 상속관계면 접근 가능함 - private은 자식 클래스라도 외부클래스이므로 접근 불가 + private은 딱 자기 클래스만 접근 가능 - 다른 패키지더라도 상속관계이고 protected면 접근 가능하다
상속과 접근제어자 예제 - 예제 중에서 부모클래스는 src - packTest - packOne - AccessTest.java(부모클래스) - 자식클래스 패키지 없기때문에 복사를 해서 바로 scr에 집어넣기, SubOne.java - 제3의 클래스 SuperSubA.java
- 부모클래스 AccessTest.java는 scr의 packTest.packOne 패키지를 만들어서 넣기 - 자식 클래스는 default package안에 들어가게됨 - 부모클래스에는 4개의 변수가 있는데 접근제어자가 다 다르다 - 원래는 public 일떄만 다른 패키지 접근 가능하지만 - 상속관계에 있고 protected 면 접근 가능하다 - 즉 부모와 자식이 서로 다른 패키지 안에 들어가있을때 4가지 접근제어자 중 어떤 접근제어자가 접근가능하게하는지 알아보는 예제임
정리 - 부모클래스 (AccessTest) -> 여기 필드값에 다양한 접근제어자가 있다 - 자식 클래스(SubOne)는 다른 패키지 안에 있을떄 protected, public이 가능함 - 제3의 클래스(SuperSubA)는 public 클래스만 접근 가능
// 부모 클래스
package packTest.packOne;
public class AccessTest { //다른 패키지에서 가져다 사용할 것임으로 pubic으로
private int a=10; //[1] private
int b=20; //[2] 기본 접근 지정자
protected int c=30; //[3] protected
public int d=40; //[4] public
public void print( ){
System.out.println("AccessTest의 print");
System.out.println(a);
System.out.println(b);
System.out.println(c);
System.out.println(d);
}
}
// 자식 클래스
import packTest.packOne.AccessTest;
//AccessTest의 서브 클래스로 SubOne을 설계
class SubOne extends AccessTest {
void subPrn( ){
System.out.println(a); //[1. Sub] private -X 에러
System.out.println(b); //[2. Sub] 기본 접근 지정자-X 에러
System.out.println(c); //[3. Sub] protected -O
System.out.println(d); //[4. Sub] public -0
}
}
// 제 3의 클래스
//AccessTest랑 상속관계가 없는 클래스
class SuperSubA{
public static void main(String[] args){
AccessTest at=new AccessTest( );
at.print( );
System.out.println("main");
System.out.println(at.a); //[1. main] private -X 에러
System.out.println(at.b); //[2. main] 기본 접근 지정자-X 에러
System.out.println(at.c); //[3. main] protected -X 에러
System.out.println(at.d); //[4. main] public -O
}
}
1. 상속 관계 있는 자식클래스 SubOne 에선 부모 클래스와 자식 클래스가 서로 다른 패키지에 있을때 - 이때 private 접근제어자로 되어있는 a는 자식이더라도 상속이 안됨(접근이 안됨) - 이때 default 접근제어자로 되어있는 b는 자식이더라도 상속이 안됨(접근이 안됨) - 이때 protected 접근제어자로 되어있는 c는 자식이라서 상속이 됨(접근 가능) - 이때 public 접근제어자로 되어있는 d는 public이니까 상속이 됨(접근 가능)
2. 상속 관계 없는 제3의 클래스 SuperSubA 에선 제3의 클래스인데 서로 다른 패키지에 있을때 - 기존 내용처럼 public 접근제어자로 되어있는 필드만 접근 가능\
- 필드의 접근제어자를 주로 protected를 많이 씀 - 두 패키지가 상속관계 && 서로다른 패키지 -> public, protected 접근 가능 - public > protected > default > private
레퍼런스 형변환 - 추상클래스, 인터페이스까지 공부 후 공부
자바 3가지 자료형변환 1. 기본자료형 변환 2. Wrapper클래스로 주로 String <-> int 형 변환 3. 레퍼런스 형변환(반드시 두 클래스 사이 상속관계 있어야만 가능함)
추상클래스 개념 1 (개념과 특징) - 이름만 있고 내용이 없는 클래스 - 자체적으로 객체를 생성할 수 없는 클래스 - 여태껏 한개의 클래스로 무한개 객체만들어냈지만 추상클래스는 객체 생성 불가
추상클래스 개념 2 (형식과 구성) - 추상클래스는 일반 클래스와 구분하기 위해서 클래스 앞에 abstract를 붙임 - 추상메소드 앞에도 반드시 abstract 붙이고 맨뒤 세미콜론 ex) abstract void Method01(); - 추상클래스에 들어가는 멤버 : 일반 멤버변수, 추상 메소드, 일반 메소드 등 있다. - 일반 클래스와 가장 큰 차이는 추상메소드를 가질 수 있다는 점 - 추상메소드를 가질 수 있다는게 가장 큰 특징 + 추상메소드는 이름만있고 내용이 없는 메소드
추상클래스 개념 3 (생성과 사용) - 추상클래스 상속 받을때는 클래스기떄문에 자식들은 일반 클래스 상속처럼 extends로 상속 - 그리고 부모 추상 클래스 나머지 안에 있는 추상메소드들을 반드시 메소드 오버라이딩 해야함 - 자체적으로 new연산자로 객체 생성 불가능한게 추상클래스 특징 - 부모 추상 메소드 : 공통적인 내용들을 넣어야함 ex) 새 클래스, 곤충 클래스, 물고기 클래스 -> 공통특징 추출해서 부모클래스 만듬 -> 부모클래스는 동물클래스 + 나중에는 부모클래스 만들때 일반클래스보다 추상클래스를 부모클래스로 많이 만듬
추상클래스 개념 4 (상속) - 자체적으로 객체 생성 안되므로 추상 클래스를 일반 클래스가 상속받아서 쓰는거다. - 추상클래스를 상속받은 일반 클래스는 추상클래스 안에 들어있는 추상 클래스를 반드시 Method Overriding을해야한다 - 부모클래스의 이름, 형식 그대로 따라서 내용을 다르게 써내려가면 된다 - 메소드 오버라이딩 안하면 오류발생 - 추상클래스도 단일상속만 가능하다,2개이상의 추상클래스 상속 불가 - 자바는 일반클래스든 추상클래스든 다중상속 허용안하기 때문임
인터페이스 + 추상클래스의 기능 있음 (추상메소드 가질수있음) + 인터페이스는 다중상속까지 허용함
+ 나중엔 추상클래스는 거의 안쓰고 인터페이스를 쓴다 + 인터페이스 쓰기위해서 추상클래스 이해하는것임 + 보통 추상클래스를 부모로 만드는게 아니라 인터페이스를 부모로 만듬
package p2022_07_11;
import java.text.SimpleDateFormat;
import java.util.Date;
public class TimeThreadHw extends Thread {
@Override
public void run() {
while (true) {
Date d = new Date();
SimpleDateFormat dd = new SimpleDateFormat("yyyy년 MM월 dd일 HH:mm:ss");
System.out.println(dd.format(d));
try {
sleep(1000);
} catch (InterruptedException ie) {
System.out.println(ie.toString());
}
}
}
public static void main(String[] args) {
TimeThreadHw tth = new TimeThreadHw();
tth.start();
}
}
출력
강사님 코드
package p2022_07_12;
import java.text.SimpleDateFormat;
import java.util.Date;
public class ThreadEx implements Runnable {
@Override
public void run() {
// TODO Auto-generated method stub
SimpleDateFormat sf = new SimpleDateFormat("yyyy년 MM월 dd일 HH:mm:ss");
while (true) {
try {
Date d = new Date();
System.out.println(sf.format(d));
Thread.sleep(1000);
} catch (Exception e) {
}
}
}
public static void main(String[] args) {
// TODO Auto-generated method stub
ThreadEx tx = new ThreadEx();
Thread t = new Thread(tx);
t.start();
}
}
복습 / 과제 설명 https://laker99.tistory.com/20?category=1065834 - Calendar 클래스 로 날짜 시간 요일 까지 출력 - 새로 만드는게 아니라 시스템으로부터 구해오는 클래스라서 Calendar 클래스는 new 연산자로 객체 못만듬
Calendar 객체 생성법 1.
Calendar c1 = new GregorianCalendar
- 이미 형성된 상속관계, 자식 클래스인 GregorianCalendar 로 객체를 만들어서 왼쪽의 부모에게 전달 = 레퍼런스 형변환 - 자식 객체가 부모에게 전달 = 업캐스팅 - 세번째 형변환인 레퍼런스 형변환이며, 두 클래스 사이에 상속관계가 전제되어야만 가능함
2.
Calendar c = Calendar.getInstance();
- Calendar 클래스 안의 정적메소드 getInstance() 메소드 사용해서 객체를 구해옴, Calnedar 객체를 받음 * 객체 = 인스턴스
- 년월일시분초 -> Calendar의 정적필드를 이용해서 구해야함(API 문서) - 클래스명.필드명 으로 필드 사용 - 연도 구해올땐 Calendar.YEAR 필드로 get함수써서 구함
int y = c.get(Calendar.YEAR);
int m = c.get(Calendar.MONTH) + 1; // 0~11 이므로 +1 해주기
int d = c.get(Calnedar.DATE);
int h1 = c.get(Calendar.HOUR); // 12시간
int h2 = c.get(Calendar.HOUR_OF_DAY); // 24시간
int ap = c.get(Calendar.AM_PM); // 오전 0 오후 1
int w = c.get(Calendar.DAY_OF_WEEK); //1~7 을 돌려줌
- 1,2,3,4,5,6,7 로 일정히 증가하므로 숫자를 요일로 변환시켜주기 위해서는 String[] 클래스 배열을 사용한다
int w = c.get(Calendar.DAY_OF_WEEK);//1~7
System.out.println("w="+w);
// 1:일, 2:월, 3:화, 4:수, 5:목, 6:금, 7:토
String[] week={"일","월","화","수","목","금","토"};
System.out.println(week[w-1]+"요일");
- 이렇게 배열인덱스와 맞춰주면 됨 - "금" 은 6이 나오는데 String배열에는 인덱스 5번이므로 -1 해줌
문자열 처리 클래스 종류 - String, StringBuffer, StringTokenizer 1. String : 문자열을 저장함, 가장 빈도 높은 사용 2. StringTokenizer : 여러 문자들을 구분기호로 파싱할때 사용 3. StringBuffer - 가장 빈도 낮지만 알아야함
문자열 처리 클래스 차이 - 3개의 클래스가 기능이 조금씩 다르다. - 메모리 상에서 데이터 처리하는데 차이가 있다 - String 클래스의 메소드 아주 많다
String 클래스와 메소드 - 자바에서 가장 사용빈도 높은 클래스 - java.lang 패키지 안, import필요 없다 - 지원되는 메소드 100개 넘음
String 클래스 예제1
- StringTest00.java
package p2022_07_01;
class StringTest00 {
public static void main(String[] args) {
String str1 = new String("Java Programming");
String str2 = new String("Java Programming");
if (str1 == str2) { // 주소 비교
System.out.println("같다");
} else {
System.out.println("다르다"); // 다르다
}
String str3 = "Java Programming";
String str4 = "Java Programming";
if (str3 == str4) {
System.out.println("같다"); // 같다
} else {
System.out.println("다르다");
}
if (str1.equals(str3)) { // 값 비교
System.out.println("같은 값");
} else {
System.out.println("다른 값");
}
}
}
다르다 같다 같은 값
- String 클래스만 new를 써도 되고 그냥 String name = "mimi" 라고 할 수도 있다 - new연산자 쓸때마다 매번 힙메모리상에 새로운 공간을 생성하라는 표시 - 힙메모리상에 "Java Programming"을 저장하고 있다
- 여기서 str3와 str2의 주솟값이 같을까? 즉 같은 "Java Programming"일까? -> 아니다 위에서든 밑에서든 new를 쓰면 그냥 단독으로 새로운 공간 가지는거임
- str3에서 힙에 Java Programming 만들어졌으므로 - String str4 = "Java Programming"; 하면 그냥 str4는 이미 str3때 만들어진 값의 주솟값을 리턴받음 -> str3 == str4 같다 (같은 주소다)
- String형 자료형과 기본자료형 변수끼리 산술적인 연산 +가 안된다 - 붙어서 geminijohnharu100이 출력되고 결과는 전체가 String형으로 바뀜
String 클래스 예제3(String과 메모리)
- StringTest01.java
package p2022_07_01;
// String 객체를 생성한 후에 메소드에 의해서 값의 변화가 일어나면
// 변경된 값을 힙메모리 영역에 다시 저장 한다.
// Garbage Collection 기능 (쓰레기 수집 기능)
// : 재사용할 수 없는 힙메모리 영역의 데이터를 모아서 지워주는 기능
class StringTest01 {
public static void main(String[] args) {
String str1 = "Java Programming";
str1.toUpperCase(); // 대문자로 변환
System.out.println(str1); //메서드 호출 후에도 str1의 내용은 수정되지 않는다.(원래값출력)
System.out.println(str1.toUpperCase()); //대문자 변환된 내용 출력
String str2=str1.toUpperCase(); //메소드의 처리 결과를 str2에 저장
System.out.println(str2); //대문자 변환된 내용 출력
}
}
str1.toUpperCase(); // 대문자로 변환
System.out.println(str1); //메서드 호출 후에도 str1의 내용은 수정되지 않는다.(원래값출력)
- 왜 위의 예제에서 str1.toUpperCase() 하면 str1의 값을 출력했을때 대문자로 변환되어 출력되지 않을까? - String class는 값의 변화가 일어나면 변경된 값을 힙메모리상에 저장시킴 - 하지만 이 변경된 값을 재사용하지 못할때는 가비지 콜렉터가 변경이 되더라도 지워버림 - 즉 대문자로 변경이 되었지만 가비지콜렉터 기능때문에 재사용을 못하기 때문에 그 값을 지워버리고 처음 원래의 값(소문자)을 출력시킴
- Java Pro 에서 str1.toUpperCase() 를 쓰면 바뀐 내용(대문자) 를 힙메모리상에 새로 저장해줌 (그림 있음 2번번호) - 하지만 접근하는방법이 없고, 재사용이 안되기 때문에 가비지 콜렉터가 지워버림 - 그래서 str1을 출력하면 원래값을 출력함 - 힙메모리상에서 값의 변화가 일어나면 매번 그걸 힙메모리상에 따로 새로 저장하기 때문이다
위 예제의 부분2
System.out.println(str1.toUpperCase());
- 한번 대문자로 출력한 후 참조하는 방법이 없으므로 없어짐(그림 3번 표시) - 이 이후 str1을 출력시 다시 Java Programming으로 나옴
변경된 값 재사용 - str2처럼 이 바뀐 결과를 저장하는 새로 힙에 생긴 공간의 주솟값을 저장을 해야함(그림 4번 표시)
위 예제의 부분3
String str2=str1.toUpperCase(); //메소드의 처리 결과를 str2에 저장
System.out.println(str2);
- 이 str2가 새로바뀐 결과가 저장된 힙메모리의 공간을 받아서 주솟값을 저장해야만 재사용가능하고 str2를 통해 그 바뀐 결과를 출력 할 수 있다 - 즉 가리켜주는 객체 없으면 값이 사라짐 재사용되지 않는 힙메모리 값은 가비지콜렉터가 지움
그림
값이 변할때 메모리 처리 - String 객체를 생성한 후에 메소드에 의해서 값의 변화가 일어나면 변경된 값을 힙메모리 영역에 다시 저장 한다.
Garbage Collection 기능 (쓰레기 수집 기능) - 재사용할 수 없는 힙메모리 영역의 데이터를 모아서 지워주는 기능 - 자동 메모리 관리 기능임 - 개발자가 메모리 관리 신경 크게 안써도 됨
+ StringBuffer 클래스 - 메모리상에 문자열 저장하는건 공통적이지만 String과 달리 새로운 공간에 저장하진 않는다
package p2022_07_01;
public class FindBlankIndex {
public static void main( String[] args ) {
String message = "Java program creates many objects.";
// message의 길이를 구함.
// length() : 문자열의 길이를 구해준다. 글자수를 구해줌
int len = message.length();
System.out.println(len); // len = 34;
// message 중에서 ' '을 찾음
for( int i=0 ; i<len ; i++ ) {
char c = message.charAt( i );
if( c == ' ' ) { //공백의 인덱스 번호를 구해서 출력
System.out.println( "index = " + i );
}
}//for end
}
}
- 공백이나 . 까지도 한글자로 포함 - 반환형 int, 문자열의 길이를 리턴 - for문으로 루프 돌려서 0부터 len보다 작을때까지 즉 len 만큼 for문을 돌림
length vs length() vs size() - 배열의 크기를 구해주는 length 속성 -> 속성이므로 ()가 없다 - String 자료가 몇글자인지 구해주는 length() 메소드 -> 메소드이므로 () - 자료구조에 저장된 원소의 개수를 구해주는 size() 메소드 -> 메소드이므로 ()
String클래스의 중 charAt() 메소드 - 매개변수 int 이고 안에 인덱스 번호가 들어감 - 리턴형은 char임 즉 인덱스를 받아서 거기에 해당하는 문자를 가져옴. - 인덱스는 0번부터 시작
그림
String클래스의 중 charAt() 메소드 예제
package p2022_07_01;
public class FindBlankIndex {
public static void main(String[] args) {
String message = "Java program creates many objects.";
// message의 길이를 구함.
// length() : 문자열의 길이를 구해준다. 글자수를 구해줌
int len = message.length();
System.out.println(len); // len = 34;
// message 중에서 ' '을 찾음
for (int i = 0; i < len; i++) {
char c = message.charAt(i);
if (c == ' ') { // 공백의 인덱스 번호를 구해서 출력
System.out.println("index = " + i);
}
} // for end
}
}
34 index = 4 index = 12 index = 20 index = 25
- ' ' 즉 공백이 인덱스 몇변이 있는지 출력해줌 (공백을 찾아주는 코드)
String클래스의 indexOf() 메소드 - charAt과 반대기능의 메소드 - 특정 문자의 인덱스번호를 구해주는 메소드 - 찾고자하는 문자가 없을때는 -1을 리턴함 - API 문서에서 indexOf() 메소드 찾아보면 메소드 오버로딩 되어있다
String클래스의 indexOf() 메소드 예제1
String message = "Java program creates many objects.";
int index1 = message.indexOf( 'a' );
- 출력 : 1 - a란 문자의 index 번호를 구해와라 - a가 여러개 있을땐, 가장 먼저 나오는 a의 인덱스 번호를 구해라
String클래스의 indexOf() 메소드 예제2
String message = "Java program creates many objects.";
int index2 = message.indexOf( 97 );
- 출력 : 1 - 97은 10진수 아스키 코드값이므로 거기에 해당하는 영문자를 찾아줌 - 이 영문자를 찾아서 인덱스를 가져와줌 - 10진수 아스키코드(97) 에 해당되는 문자('a')의 인덱스 번호를 구함. - 이 97을 65로 바꾸면? -> 'A'를 찾는데 찾고자하는 문자가 없으므로 -1을 리턴함
String클래스의 indexOf() 메소드 예제3(매개변수가 2개)
String message = "Java program creates many objects.";
//index번호 13번째 이후에서 'a'의 인덱스 번호를 구함
int index3 = message.indexOf( 'a', 13 );
System.out.println( index3 );
- index번호가 13번 이후에 가장 먼저나오는 'a' 의 인덱스 번호를 찾아라 - 즉 c(13) 부터 찾아라 그 'a' 는 16이 나옴 - 이렇게 위치가 지정될땐 그 이후의 문자를 찾고 위치 지정이 안되었을떈 아까의 예시처럼 가장 먼저나오는 문자의 인덱스값을 찾음
String클래스의 indexOf() 메소드 예제4(매개변수가 String)
String message = "Java program creates many objects.";
// 가장 먼저 나오는 'av'의 인덱스 번호를 구함
int index4 = message.indexOf( "av" );
System.out.println( index4 );
- 출력 : 1 - Java의 av 이므로 결과는 1 - 문자 한글자가 아니라 문자열이 들어가는 경우임 - 가장 먼저 나오는 av의 인덱스 번호를 구해라
String클래스의 indexOf() 메소드 예제5(매개변수가 2개)
String message = "Java program creates many objects.";
// index번호 12번 이후에 나오는 'man'의 인덱스 번호를 구함
int index5 = message.indexOf( "man", 12 );
System.out.println( index5 );
- 이렇게 위치가 지정될땐 그 이후의 문자열의 인덱스번호를 주고 위치 지정이 안되었을떈 아까의 예시처럼 가장 먼저나오는 문자의 인덱스값을 찾음
String클래스의 indexOf() 메소드 예제6(결과가 없는 경우)
String message = "Java program creates many objects.";
// 찾는 문자가 없는 경우에는 -1을 리턴한다.
int index6 = message.indexOf( "java" );
System.out.println( index6 );
- 출력 : -1 - 소문자 java가 없다 찾고자하는 결과없으면 -1 리턴한다 - 이 indexOf 메소드는 대소문자를 구분한다
String클래스의 trim() 메소드 - 문좌열 좌,우의 공백을 없애주는 역할
String클래스의 equals() 메소드 - boolean equals() - 값을 비교하는 역할 - 가리키는 값들끼리 비교함
String클래스의 trim() 메소드 / equals() 메소드 예제
package p2022_07_01;
public class TrimTest {
public static void main( String[] args ) {
// trim() : 문좌열 좌.우의 공백을 없애주는 역할
// boolean equals() : 값을 비교하는 역할
String str1 = new String( "gemini " );
String str2 = new String( " gemini " );
System.out.println( str1.equals( str2 ));
System.out.println( str1.trim().equals( str2.trim()));
}
}
- str1 가 가리키는 gemini 문자열 오른쪽에 공백이 있다 - str2 가 가리키는 gemini 문자열 왼쪽에 공백이있다 - 공백도 메모리상에 공간을 차지함
+ String클래스는 메소드를 통해 값의 변화가 일어나면 매번 힙메모리상의 새로운공간에 바뀐값을저장함
String클래스의 substring() 메소드 - 일부 문자열만 추출 - 메소드 오버로딩되어있다 - 매개변수가 2개인 경우, 매개변수가 1개인 경우 추출하는 범위가 달라진다.
1. 매개변수 2개인경우 - 시작과 끝 인덱스를 지정한다 - 하지만 실제 우리가 추출하는건 하나 적게 추출함 즉 begInindex ~ endIndex-1까지 추출
2. 매개변수 1개인경우 - 시작 인덱스만 지정한다 - 시작 인덱스로부터 끝까지 추출하라는 의미
String클래스의 substring() 메소드 정리 - substring() : 전체 문자열에서 특정 범위의 문자를 추출하는 역할 - substring(n) : index번호 n번 부터 끝까지 추출 - substring(n1, n2) : index번호 n1번 부터 (n2-1)번 까지 추출
String클래스의 substring() 메소드 예제1(매개변수 1개)
String message = "Java program creates many objects.";
// 인덱스번호 13번 부터 끝까지 추출
String str1 = message.substring( 13 );
System.out.println( str1 );
creates many objects.
- c가 13번 위치였다. 즉 13부터 모두 추출 - 13은 인덱스 번호 13번부터 끝까지 추출해서 결과를 str1 변수에 저장하고 출력시켜라는 의미
String클래스의 substring() 메소드 예제2(매개변수2개)
String message = "Java program creates many objects.";
// 인덱스번호 13번 부터 15번까지 추출
String str2 = message.substring( 13, 16 );
System.out.println( str2 );
- 여기서 str1과 str2는 변경된 문자열을 가리킴(저장) - 자바는 substring 메소드만 제공함
String클래스의 substring() 메소드 예제3 - SubstringEx.java - substring() 이용해서 한글자 추출하기 - substring(그 글자 인덱스, 그 다음글자 인덱스) + string값 비교에 == 쓰지말고 equals쓰기
package p2022_07_01;
public class SubstringEx {
public static void main(String[] args) {
//아래와 같이 주민번호가 있을때, 남자인지 여자인지 판별하는 프로그램을 작성하세요?
String jumin = "900101-2233456"; // 2000년 이후 남자는 3번, 여자는 4번
String gender = jumin.substring(7, 8);
if (gender.equals("1") || gender.equals("3")) {
System.out.println("남자");
} else if (gender.equals("2") || gender.equals("4")) {
System.out.println("여자");
}
}
}
- 문자끼리 비교하는거니 gender.equals("1") 라고 "1"이라고 문자를 넣어야지 숫자 1을 넣으면 안됨! - if-else로 해도 되지만 주민번호 첫자리 수 5(귀화한분들) 이런 경우도 있으므로 안전상 if-elseif로 해야한다
위 예제 부분1
String gender = jumin.substring(7, 8);
- 이렇게 해야 7번 인덱스의 문자열을 가져옴
String클래스의 substring() 메소드 예제4
- 키보드로 주민번호를 입력받는다, 주민번호 문자로 받아야함(문자열 클래스로 이것저것 할 것 이므로) - 앞자리 6자리가아니면 메세지 뿌림 - 뒷자리 7자리가아니면 메세지 뿌림 - 이런걸 유효성 검사라고 한다 - 그리고 이 모든게 완벽한 값이면 입력한 주민번호가 남자인지 여자인지도 판별
package p2022_07_01;
import java.util.Scanner;
public class JuminCheck {
public static void main(String[] args) {
// 키보드로 주민번호를 입력 받아서 남자인지 여자인지를 판별하는 프로그램을 작성하세요?
// 단, 주민번호 앞자리는 6자리, 뒷자리는 7자리 인지를 유효성 검사를 한다.
// 키보드로 주민번호 입력받기
Scanner sc = new Scanner(System.in);
System.out.println("주민번호 앞자리를 입력 하세요?");
String jumin1 = sc.nextLine();
System.out.println("주민번호 뒷자리를 입력 하세요?");
String jumin2 = sc.nextLine();
// 남녀
String g = jumin2.substring(0, 1); // 0번 인덱스 추출한다는 의미
// 유효성 검사 & gender
if (jumin1.length() != 6) {
System.out.println("주민번호 앞자리 6자리를 입력하세요.");
} else if (jumin2.length() != 7) {
System.out.println("주민번호 뒷자리 7자리를 입력하세요.");
} else if (g.equals("1") || g.equals("3")) {
System.out.println("남자");
} else if (g.equals("2") || g.equals("4")) {
System.out.println("여자");
} else {
System.out.println("똑바로 입력 하세요.");
}
}
}
- if-elseif-else문 처리기때문에 처음 주민번호 앞자리 6자리가 아니면 더이상 아래쪽을 실행안함. - 주민번호 앞자리 6자리인데 뒷자리 7자리 아니면 두번째에 걸림 아래 실행 안함 - 둘다 개수가 맞으면 이제야 남/녀 검사를함 - 주민번호는 6,7 다 맞는데 뒷자리 첫번째가 1234가 아니면 마지막인 else 구문에서 걸린다
+ String클래스의 split() 메소드 - 이후 뒤에서 자세히 설명함(StringTokenizer 클래스 공부 이후) - 전체 문자에서 구분기호를 가지고 문자를 추출할때 사용함 - @ 나 / 등의 정규 표현식을 구분자로 해서 문자를 자름 이걸 파싱이라고함 - 결과를 돌려주는 자료형은 String형 1차원 배열로 돌려줌
+ Strping클래스의 split() 메소드는 은 StringTokenizer 와 비슷한 역할을 하지만 더 쓰기 편하다
- 공통적 특징 : 힙메모리상에 문자를 저장함 - 하지만 메모리상에 데이터를 처리하는부분이 다름 (메모리상에 문자를 저장하는 방식이 다름) - String : 메소드에서 값의 변화가 일어나면 변경된 값을 힙 메모리에 매번 새로운공간을 만들어서 사용함 - StringBuffer : 버퍼라는 기억장소를 쓰기때문에 값의 변화가 일어나더라도 새로운 공간에 값을 저장하지 않음. 시작 주소값이 바뀌지 않음. 값을 계속 누적하는 경우에 이 클래스 쓰는 경우가 있다
StringBuffer - 사용빈도 낮음 - StringBuilder 와 비슷한 기능(이건 안함) - StringBuffer도 java.lang에 있어서 import 안해도 됨 - Buffer라는 임시 기억공간에 문자열을 저장함, 기능적으로 String과 다르다
StringBuffer 생성자 - 매개변수가 int capacity로 된 생상자가 있다, 버퍼라는 임시기억장소의 크기를 생성하는 거임 - 크기를 지정하면 지정된크기로 만들어줌, 크기 설정 따로 안해도 버퍼라는 임시기억소 만듬 - 설정안하면 기본적으로 16characther임 16글자 저장하기위한 힙메모리상의 공간을 만들어줌
StringBuffer 예제 - StringBufferTest.java
package p2022_07_01;
public class StringBufferTest {
public static void main(String[] args) {
StringBuffer sb1 = new StringBuffer("gemini");
System.out.println("sb1.length() : " + sb1.length()); //6
System.out.println("sb1.capacity() : " + sb1.capacity()); //22
sb1.append("A string buffer implements" + "a mutable sequence of characters");
System.out.println("sb1.length() : " + sb1.length()); //64
System.out.println("sb1.capacity() : " + sb1.capacity()); //64
StringBuffer sb2 = new StringBuffer();
System.out.println("sb2.length() : " + sb2.length()); //0
System.out.println("sb2.capacity() : " + sb2.capacity()); //16
}
}
위 예제 부분1(매개변수가 있는 생성자)
StringBuffer sb1 = new StringBuffer("gemini");
- 매개변수가 있는 생성자로 객체를 생성하고 있다 - "gemini"가 힙메모리 상에 저장되고, sb1이 이 주소를 갖고 있다.
- 동적으로 공간을 늘려주는 기능도 있다 자동으로 늘려줌 - 만약 22보다 큰 크기의 문자열을 넣으면 동적으로 공간을 늘려줌 - 다시 length()를 구했을때 64가 나옴 - 처음에 22바이트였던 공간을 64만큼 늘려줌
위 예제 부분2(기본생성자)
StringBuffer sb2 = new StringBuffer();
- 기본생성자로 객체를 생성하고 있다 - 길이 length 는 0임 - 자동으로 16바이트(16글자공간 만들어줌) 로 만들어줌 - 아무것도 안가리키기 때문에 length()는 0
StringBuffer와 값의 변화 - StringBuffer는 값의 변화가 일어나더라도 시작주소값이 바뀌지 않는다 - String과 다른 특징
StringBuffer와 값의 변화 예제 - AppendStringBuffer.java
package p2022_07_01;
public class AppendStringBuffer {
public static void main( String[] args ) {
// StringBuffer 객체 생성
StringBuffer sb1 = new StringBuffer( "gemini" );
System.out.println( "sb1 = " + sb1 );
// StringBuffer sb1에 문자열을 추가해 새로운 객체 생성
StringBuffer sb2 = sb1.append( " is beautiful" );
System.out.println( "sb2 = " + sb2 );
System.out.println( "sb1 = " + sb1 );
if(sb1 == sb2) {
System.out.println("같은 주소"); //같은 주소
}else {
System.out.println("다른 주소");
}
// 정수형 데이타 형을 추가
System.out.println( sb1.append( 1004 ));
System.out.println( "sb1 = " + sb1 );
System.out.println( "sb2 = " + sb2 );
String str = new String(sb1); // StringBuffer를 String으로 변환
System.out.println(str.toUpperCase());
}
}
sb1 = gemini sb2 = gemini is beautiful sb1 = gemini is beautiful 같은 주소 gemini is beautiful1004 sb1 = gemini is beautiful1004 sb2 = gemini is beautiful1004 GEMINI IS BEAUTIFUL1004
위 예제 부분1
// StringBuffer 객체 생성
StringBuffer sb1 = new StringBuffer( "gemini" );
System.out.println( "sb1 = " + sb1 );
- 힙메모리상에 "gemini"라는 값이 저장되고 그걸 sb1이 시작주소를 가지고 있다
위 예제 부분2
// StringBuffer sb1에 문자열을 추가해 새로운 객체 생성
StringBuffer sb2 = sb1.append( " is beautiful" );
System.out.println( "sb2 = " + sb2 );
System.out.println( "sb1 = " + sb1 );
- append() 함수 : 기존 문자열에 새로운 문자열을 이어 붙여줌 (String클래스엔 이 함수 지원안됨) - 그리고 이걸 sb2가 주소를 가지게 함
- 출력 : 같은 주소 - 문자열이 변경되었지만 새로운 힙공간에 저장하지 않음 그러니 sb1과 sb2가 가리키는건 같음! - 둘다 같은 문자열이 출력됨 - 즉 같은 주소, 같은 값 같은걸 가리키고 있음
그림
String vs StringBuffer 차이 정리 - String : 값의 변화 일어나면 새로운 공간에 그 결과 저장. 원래 값의 주솟값 != 바뀐 값의 주솟값 - StringBuffer : 값의 변화 일어나도 기존 공간에 적용, 변경된 값의 시작주솟값이 바뀌지 않음
위 예제 부분4
// 정수형 데이타 형을 추가
System.out.println( sb1.append( 1004 ));
System.out.println( "sb1 = " + sb1 );
System.out.println( "sb2 = " + sb2 );
String str = new String(sb1); // StringBuffer를 String으로 변환
System.out.println(str.toUpperCase());
- sb1에 append(1004) 함 - 그 후에 sb1출력하나 sb2 출력하나 같은 gemini is beautiful1004 가 출력됨 - 같은주소를 리턴받았었기때문에 그렇다
StringBuffer로 저장된 문자열을 대문자로 바꾸기 - StringBuffer 클래스는 toUperCase() 메소드가 없어서 못쓴다 (langth()는 있음) - String과 StringBuffer 사이는 상속관계 없으므로 String 클래스 안에 있는걸 StringBuffer가 상속받아 쓸수도 없음
-> String 클래스의 생성자를 활용해서 대문자로 바꿔주면 된다. -> String 클래스 생성자를 찾아보면 매개변수가 StringBuffer인 생성자가 있다 - String(StringBuffer buffer) 생성자 - 이 생성자를 통해서 StringBuffer -> String 으로 변환 가능 - String 객체로 받아서 toUpperCase 해서 대문자 변환하기
StringBuffer로 저장된 문자열을 대문자로 바꾸기 예제 - InsertStringBuffer.java - StringBuffer 클래스의 append() 메소드 : 기존 문자열에 끝 추가 - StringBuffer 클래스의 insert() 메소드 : 지정된 특정 위치에 문자열을 삽입 시킴
package p2022_07_01;
public class InsertStringBuffer {
public static void main(String[] args) {
StringBuffer sb1 = new StringBuffer("gemini is beautiful");
System.out.println(sb1);
// 인덱스 10번 위치에 very 문자를 삽입
sb1.insert(10, "very");
System.out.println(sb1);
// 인덱스 0번 위치에 1004 를 삽입하라(숫자로 써도 문자가됨)
sb1.insert(0, 1004);
System.out.println(sb1);
}
}
gemini is beautiful gemini is verybeautiful 1004gemini is verybeautiful
- 처음엔 인덱스 10번위치에 "very"란 문자열을 삽입시켜라는 의미 - is beautiful 사이의 공백이 인덱스 10이다. 그 10번 뒤에 삽입 됨-> is verybeautiful - 이후 인덱스 0번위치에 1004를 삽입하라는 의미
StringBuffer 클래스의 사용 - 문자열 처리 보통은 String 클래스로 다 처리가능함 - 값을 계속 누적시키거나 하는 특별한 경우들에만 StringBuffer를 사용함
+ 문자열 분리 방법 2가지 - 구분기호를 가지고 문자를 추출하는, 잘라서 토큰으로 추출하는 역할 1. java.util.StringTokenizer이용 2. String의 split() 메소드 활용
StringTokenizer 클래스 - 앞의 두 클래스와 기능이 좀 다름 - 특정 문자를 구분기호를 가지고 토큰을 구해오는 역할을 함 - 문자를 파싱해서 처리해주는 역할을 한다 - java.util 안에 있다
StringTokenizer 클래스 생성자 - 매개변수 1,2,3개인 3개의 생성자 중 StringTokenizer(String str, String delim) 을 주로 사용한다 - 첫번째 매개변수에는 전체 문자열 또는 그 문자열을 담은 변수명이 온다 - 두번째 매개변수에는 구분기호가들어간다, 구분기호는 @ # / 등이 될 수 있다.
StringTokenizer 클래스 예제1 - StringTest04.java
package p2022_07_01;
import java.util.*;
class StringTest04 {
public static void main(String[] args) {
StringTokenizer str = new StringTokenizer("이순신#을지문덕#강감찬#광개토대왕", "#");
// System.out.println(str.nextToken());
// System.out.println(str.nextToken());
// System.out.println(str.nextToken());
// System.out.println(str.nextToken());
// System.out.println(str.nextToken()); // 예외발생
// 파싱된 문자열이 모두 몇 개인지 되는지 알려줌
int cnt = str.countTokens();
System.out.println("파싱할 문자열의 총갯수-> " + cnt);
// System.out.println(str.nextToken());
while (str.hasMoreTokens()) { // 토큰이 있으면
System.out.print(str.nextToken() + "\t");// 차례대로 파싱된 문자열을 얻어온다.
}
} // main() end
}
StringTokenizer 클래스 사용예시(위 예제 부분1)
StringTokenizer str = new StringTokenizer("이순신#을지문덕#강감찬#광개토대왕", "#");
- 이렇게 쓰고 두번째 자리에는 구분기호가 들어감 - 이 #으로 전체문자열을 파싱 = 자른다 - 파싱을 하고 리턴되는 "이순신" "을지문덕" 등을 토큰이라고함 - nextTokens() 메소드 : 이 토큰들을 구해오는 메소드
- 이렇게 더 하면 이순신, 을지문덕 출력됨 - nextToken()메소드는 String형으로 리턴한다
StringTokenizer str = new StringTokenizer("이순신#을지문덕#강감찬#광개토대왕", "#");
System.out.println(str.nextToken());
System.out.println(str.nextToken());
System.out.println(str.nextToken());
System.out.println(str.nextToken());
이순신 을지문덕 강감찬 광개토대왕
- 가져올토큰 없는데 한번 더 nextToken() 메소드를 쓰면? - 예외가 발생해서 프로그램이 비정상적으로 멈추게됨
Exception in thread "main" java.util.NoSuchElementException at java.util.StringTokenizer.nextToken(Unknown Source) at p2022_07_01.StringTest04.main(StringTest04.java:14)
- NoSuchElementException 예외 발생 * 예외 : 예상하지못했던 프로그램상 오류 -> 가져올 토큰이 있는지 없는지 판별을 해야함
가져올 토큰이 있는지 판별(위 예제 부분2) - 가져올 토큰이있는경우에만 출력하기
// 파싱된 문자열이 모두 몇 개인지 되는지 알려줌
int cnt = str.countTokens();
System.out.println("파싱할 문자열의 총갯수-> " + cnt); //4출력
- String 객체 source1에 문자열들이 있다 - - StringTokenzier 는 구분기호를 1개밖에 쓰지 못한다! - "-" 같은거까지 더 구분 못함 - split()은 여러개 구분기호로 파싱 가능 - nextToken() 의 리턴형은 String - nextToken() 으로 토큰 구해와서 String 객체에 저장했다.
StringTokenizer 클래스 예제3(매개변수가 3개) - StringTokenizerTest2.java
package p2022_07_01;
import java.util.StringTokenizer;
public class StringTokenizerTest2 {
public static void main(String[] args) {
String source1 = "한국 미국 태국 중국 이란";
StringTokenizer st1 = new StringTokenizer(source1, " ");
while (st1.hasMoreTokens()) {
System.out.println("st1.token:" + st1.nextToken());
}
System.out.println();
System.out.println();
String source2 = "푸들,삽살개,풍산개,진돗개";
StringTokenizer st2 = new StringTokenizer(source2, ",");
while (st2.hasMoreTokens()) {
System.out.println("st2.token:" + st2.nextToken());
}
System.out.println();
System.out.println();
// true : 구분기후(,)를 토큰으로 처리해준다.
StringTokenizer st3 = new StringTokenizer(source2, ",", true);
while (st3.hasMoreTokens()) {
System.out.println("st3.token:" + st3.nextToken());
}
}
}
위 예제 부분1
String source1="한국 미국 태국 중국 이란";
StringTokenizer st1=new StringTokenizer(source1," ");
- 국가명 사이에 공백이 들어가있으니 공백으로 파싱하자 - 첫번째 매개변수에는 문자열 또는 문자열이 저장된 변수가 들어간다 - 두번쨰 매개변수에는 구분기호가 들어가는데 여기선 " " 공백으로 파싱
- 첫번째, 두번쨰 매개변수에 넣어야하는건 위와 같다 - 하지만 3번째 매개변수가 boolean형이다 즉 true나 false값을 써야함 - 세번째 매개변수에 true가 오면, 그 구분기호도 파싱될 토큰으로 처리하라는 의미 - 그래서 여기는 , 도 토큰기호로 인식해서 nextToken()하면 푸들 다음의 토큰으로 , 라는 토큰이옴 - false넣으면 다른 위의 예제들과 같게 구분기호는 토큰으로 인식 안함.
String클래스의 split() 메소드 - StringTokenzier과 비슷한 역할하는 "메소드" - 기능적으로 보면 split()이 쓰기가 더 편하고 여러개의 구분기호 가지고 있어도 파싱 가능함
- String[] Split(String regex) - 이 매개변수에 구분기호가 온다 - 이 파싱된 결과를 왼쪽의 String 1차열 배열로 리턴 - 첫번째 토큰은 0번방, 두번째 토큰은 1번방, 세번째 토큰은 2번방...
키보드를 통해서 각 회원들의 정보를 입력 받는 클래스(MemberInput)를 작성한다. 이때 입력 받는 회원의 정보는 성명, 나이, 이메일, 주소를 입력 받는다. 그리고 키보드로 입력한 회원의 정보는 새로운 회원정보를 저장하는 클래스(MemberInfo)의 멤버변수에 저장을 시킨후 출력하는 프로그램을 작성하시오.
(단, 1명의 회원정보를 입력 받아서 처리한다. 가능하면 2명 이상의 회원 정보도 입력 받아서 처리 해본다.)
1. 객체배열 대신에 List 자료구조를 이용해서 문제를 해결하세요. 2. MemberInfo 클래스는 필드, setters, getters method 로 작성한다.
- 여기서 new를 쓴거나 다름없으므로 힙메모리상에 1,2,3의 공간이 생긴다 - 그리고 values1이 그 주소를 가지고 있음 - 메소드를 호출할 때 이 values1이 가진 주소를 sum1메소드에 전달함 - 같은 int형 배열의 주소를 전달함 - 이 values1은 재사용 가능함 - 이 주소를 참조해서 공간에 접근이 가능하기때문에 아직 이 힙메모리의 1,2,3을 지우지 않음
int result2 = com.sum1(new int[] { 1, 2, 3, 4, 5 }); // sum1() 메소드 호출 , 배열을 만들어서 그 주소를 넘김
System.out.println("result2 : " + result2);
- 힙메모리상에 5개의 공간을 생성하라 -> 1,2,3,4,5 - 이 주솟값을 한번 메소드를 호출할때 전달했다. 사용되고 나면 이제 지워짐 - 더이상 참조가 불가능 -> 가비지 콜렉터가 지움
정적 멤버변수 - static 붙은 변수
1. 공유를 목적으로 누구나 쉽게 변수에 접근할수있도록 만드는경우 - 객체생성 없이도 접근 가능하다
2. 클래스명.변수 또는 클래스명.메소드(정적메소드) 로 사용함 - 메모리영역 : static 영역 (공유영역, 메소드영역) 에 할당 - 클래스가 로딩되지마자 메소드 영역에 할당받음!! - 일반 필드들처럼 기본자료형은 자동으로 초기값이 설정됨 - 프로그램이 종료될때까지 값을 유지한다 - 모든 필드가 정적필드면 나중에 메모리 부족함
- 싱글톤을 만들경우엔 static을 붙여 정적필드로 만들어야한다.
변수와 메모리 영역 - 지역변수(스택) - 멤버변수(힙) - 정적변수(메소드,공유,static영역)
클래스 - 클래스는 자료형이다. - 객체생성시 필드들을 위한 공간이 힙에 마련되고 기본자료형은 초기화된다 - 배열, 클래스,인터페이스 -> new 를 써서 힙메모리상에 새로 공간 마련
메소드 1. 필드값 출력 2. set 메소드로 필드값 수정 3. get메소드로 필드값 돌려주기 return
클래스의 구성 - 멤버변수 (필드) - 멤버함수 (생성자 + 메소드)
+구조체 - 클래스가 나오기 전엔 C언어의 구조체가 있었다 - C++에서 구조체를 확장한게 클래스다 - 구조체를 구성하는 건 필드밖에 없다 멤버변수뿐 - 클래스로 확장되면서 멤버변수뿐아니라 멤버함수도 추가된것임
정적필드를 쓰는 경우 - static이 붙은 정적필드/정적메소드 - 직접 정적필드 만드는 경우는 아주 제한적 -> 싱글톤 만들때 static 변수를 만듬 - jsp같은 웹프로그래밍다를때 싱글톤많이씀 - 객체생성을 한번만 해서 그걸 공유를 하도록 하는게 싱글톤
필드의 접근제어자가 private일때 값 설정 1. 생성자로 초기화 2. set메소드로 값을 초기화
객체 배열 - 여러명 저장하려면 객체 배열 또는 리스트 를써야함 - 객체의 주소를 저장하는 객체 배열, 배열은 크기가 한계, 정해져있다, 나중엔 리스트 쓸것 - do~while문으로 일단 실행을 시키고 i++시키면서 객체배열에 입력값을 저장함 - getter 로 main에서 값을 돌려주는 형태로 만들어서 값을 돌려받은 뒤 출력함 + 객체배열이 아니라 그냥 객체 m이었다면 여러명의 정보 입력해도 가장 마지막으로 입력된 정보만 가지게 됨그래서 객체배열 쓰면서 m[i] 해서 i++해서 객체 배열 안에 다 주소 저장하는것
그림
제어문
System.out.print("계속할려면 y, 멈출려면 n을 입력?");
yn = sc.nextLine();
if (yn.equals("y") || yn.equals("Y")) {
continue;
} else if (yn.equals("n") || yn.equals("N")) {
break;
}
- 중간에 그만 입력할 수 있는 코드 - 무한루프를 나올때는 break 로 빠져나오고, y 를 입력하면 continue해서 다시 반복문으로 돌아가서 다음 사람 정보를 받음 - continue를 만나면 아래의 반복문인 while(true)로 돌아가는것
System.out.print("계속할려면 y, 멈출려면 n을 입력?");
yn = sc.nextLine();
if (yn.equals("y") || yn.equals("Y")) {
continue;
} else if (yn.equals("n") || yn.equals("N")) {
break;
}
} while (true); //여기로 돌아가서 조건검사하고 완전 위로 올라감
- break는 반복문을 나가는거이므로 이 do while문을 나감 - continue는 다시 반복문으로 돌아가는 것이므로 while(true)로 돌아가서 조건을 검사하고 또 반복문을 돌림 - .equlas("") 는 리턴값이 true false
Scanner의 next()와 nextLine()
Scanner sc = new Scanner(System.in);
String name, email, address;
int age;
- scanner객체는 한번만 생성하면 됨 - next() 와 nextLine()은 둘 다 문자 받지만 - next()는 중간에 띄어쓰기가 있으면 뒤쪽이 짤림, 앞만 저장함 - nextLine()은 엔터키 눌렀던 전 그 통째로 한문장을 입력받음, 띄어쓰기 된것도 다 저장함
Scanner의 nextInt()와 nextLine()
System.out.print("성명을 입력하세요? ");
name = sc.nextLine();
System.out.print("나이를 입력하세요? ");
age = sc.nextInt(); // 숫자를 입력받은후에 enter키를
sc.nextLine(); // 누르면 null값을 return하게 됨
System.out.print("E-Mail을 입력하세요? ");
email = sc.nextLine();
System.out.print("주소를 입력하세요? ");
address = sc.nextLine();
m[i] = new MemberInfo(name, age, email, address);
// m[i].name="홍길동";
- 문제사항 : 나이를 입력하면 이메일 주소 입력 부분은 넘어가버림 - nextInt(); 다음 nextLine() 일때 생기는 문제 - nextInt()로 나이 받고 엔터키누르면 엔터키도 하나의 문자로서 이걸 email = sc.nextLine(); 에서 받아버림 - 즉, 엔터키 자체가 문자로서 email에 그게 들어감 - 그래서 엔터키를 받기 위해서 중간에 sc.nextLine()을 넣어서 엔터키로 입력을 받음 그 후에 이메일 받으면 됨. * 엔터키를 누르면 null 값을 sc.nextLine()을 통해서 리턴하게 됨
값 초기화/수정 - MemberInfo의 필드들이 모두 private이므로 객체배열 m에서는 m[i].name 처럼 접근이 불가능함 -> 값을 설정하는 법 1. 생성자의 매개변수 통해서 2. 메소드의 set메소드 통해서
DTO (Data Transfer Object) - Data 이동, 전환, 메모리 상의 값을 저장하고 돌려주는 역할을 하는 클래스 - 웹프로그래밍할때 들을 수 있다 - 이 클래스 안엔 필드, getter, setter메소드 가 들어감 - 나중엔 생성자를 쓰지 않고 setter메소드로 초기화를 시킴
객체배열 - 여기서 쓴 객체배열은 배열이다보니 크기가 정해져있다 - 자바에서는 주로 List 같은 자료구조로 다 처리함-> 크기가 계속 동적으로 늘어난다 - 나중엔 List나 ArrayList 로 주로 처리
싱글톤 - 하나의 애플리케이션 내에서 단 하나만 생성되는 객체 - 한개의 클래스가있으면 그 클래스로 객체 생성을 1번만 하는게 싱글톤임 - 클래스로 객체를 new써서 무한으로 만들 수 있지만 1번만 만드는거 - 계속 new써서 객체 생성하면 힙메모리상에 계속 새로운 공간 만들게되고, 공간을 생성하는데도 시간이 소요됨 (시간+ 힙메모리공간소요) - 정적변수로 만들어야하는 경우 : 싱글톤만들때
싱글톤을 쓰는 경우 : db - db연동하는 경우 이 싱글톤을 자주 사용함 (db연동하는 클래스로 객체 생성할때 싱글톤을 씀) - 어떤 사이트 게시판을 보면 글들이 다 연동 / 공유 됨. 수십명이 같은 게시판 을 보게됨 - 서버측에서는 db연동을 하기 위한 클래스 내부에서 돌아감 - 원래는 사용자가 db접속할떄마다 db연동하는 클래스의 객체를 계속 만들게됨(메소드나 필드를 쓰려면 객체를 만들어야하므로) - 그거의 단점(시간+공간) 막기위해 객체1번만 만드는 방법 싱글톤 사용 - 즉, 서버측에서는 db연동을 하기 위한 클래스로 객체를 1개만 만들고 그걸 공유하겠다는게 싱글톤 - 한번만 생성해서 정적으로 해서 공유를 하겠다는 개념
Q. 참조형 && 멤버변수 와 메모리(질문) - String이 멤버변수로 있다면 그 주소값은 힙이 아니라 스택에 저장됨 - 택에서 null이란 값이 있는상태임 - 만약 그게 뭘 할당받으면 그건 힙메모리에 있는 뭔가를 스택에서 가리키는거임 - 즉 멤버변수 && 참조형 -> 주소값을저장할 공간은 스택에, 나중에 그게 할당되면 그건 힙에 있다
싱글톤과 db 객체생성 - 싱글톤 : db연동 처리해주는 클래스(jsp부분) 가지고 객체 생성을 1번만 수행함 - 이 클래스 안 메소드(DAO 안 update, delete등의 메소드) 를 호출하기 위해서 해당 클래스로 객체를 1개 생성함 - 이 DAO 클래스 안에 들어있는 건 메소드 뿐이다, 그 메소드를 사용하기 위해서는 클래스로 객체를 만든다음 메소드를 사용 - 그 sql문이 각 메소드이다. 그 메소드를 호출하기 위해선 객체.메소드() 해야함 - 게시판의 사이트 들어갈때마다 목록 뽑아옴 = select란 sql문으로 db연결해서 그걸 뿌려주는 것임. 그런 작업이 내부적 서버 측에서 계속 일어남 - 그 메소드를 호출하기 위해 클래스의 객체를 매번 생성해야한다. 100명 접속하면 100개 생성해야함. 그래야 객체1.check(), 객체2.check(), 객체3.check() 로 가능 - 매번 객체 생성에 시간 소요 + 서버 측의 힙메모리 자원을 계속 쓰게 됨 = 서버측 부하 - 이 부하를 줄이기 위해 객체 생성을 1번만 하고 이 객체를 정적메소드로 공유를 하겠다는 거임
Q. 정적메소드해서 그냥 클래스명.메소드 하면 되지 않나요? 왜 객체를 생성해야하는지? Q. 물론 객체명.메소드로도 정적메소드 호출 할 수 있지만 굳이?
싱글톤 구현 방법
package p2022_06_30;
// p244
class Singleton {
// 싱글톤(Singleton) : 객체 생성을 1번만 수행하는 것을 의미함
// 이 클래스로 객체를 1번만 생성할 것임, 외부에선 접근 못하도록 접근제어자 private을 보통 붙임
// 같은 클래스 내에서만 접근가능하도록
// 정적필드
private static Singleton s = new Singleton();
// 모순발생 private(보호) + static(공유) -> 모순발생하기떄문에 이 필드로 다이렉트로 접근 불가
// 이거 필드임! static이 붙은 정적필드, 메모리영역에 로딩되며 공유되지만 private이므로 안됨, 아래 정적메소드 만들어서 그걸로
// 주고받고
// 정적메소드 public + static + 리턴자료형은 Singleton(자기의 클래스 자료형) + 메소드이름getInstance
public static Singleton getInstance() {
return s; // 위에서 만든 이 객체를 리턴
}
public void check() {
System.out.println("메소드 호출 성공1");
}
public void check1() {
System.out.println("메소드 호출 성공2");
}
// 이 메소드 쓰려면 매번 new해서 객체 생성해야함. 계속 메소드를 통해서 db연동할때 매번 객체를 생성해야한다
// 서버는 몇천명이 동시에 접속함, 그래서 매번 객체 생성하면 서버측에 큰 부하가 걸림
// 효율적으로 하기 위해 객체를 메소드 영역(정적필드) 에 만들어놓고 이걸로 계속 사용
}
public class SingletonEx {
public static void main(String[] args) {
Singleton obj1 = Singleton.getInstance();// 객체를 new로 생성하는게 아니라 이미 만들어진 s를 가져옴
// 정적메소드라 클래스명.메소드() 로 호출
Singleton obj2 = Singleton.getInstance();
System.out.println(obj1);
System.out.println(obj2);
if (obj1 == obj2) {
System.out.println("같은 주소"); // 같은 주소
} else {
System.out.println("다른 주소");
}
obj1.check();
obj1.check1();
obj2.check();
obj2.check1();
}
}
- 객체를 "클래스 내부" 에서 생성한다. - static 인 정적필드는 메소드 영역(공유 영역) 에 저장됨, 하지만 private으로 외부 클래스 접근을 막아둔다 - 모순발생 private(보호) + static(공유) -> 모순발생하기떄문에 이 필드로 직접 접근 불가 - 그걸 getInstance() 라는 정적 메소드를 통해서 공유를 한다. - getInstance() 를 통해 그 객체를 이 Singleton 클래스 쓰는곳에(main에) 돌려줌 - main에서 돌려받은 객체 s로 check()와 check1()을 호출할 수 있다
getInstance() (위 예제 부분1)
// 정적메소드 public + static + 리턴자료형은 Singleton(자기의 클래스 자료형) + 메소드이름 getInstance
public static Singleton getInstance() {
return s; // 위에서 만든 이 객체를 리턴
}
//#main
Singleton obj1 = Singleton.getInstance()
- 이 getInstance는 정적메소드이기때문에 클래스명.메소드 해서 사용하면됨 Singleton.getInstance() 하면됨 - 물론 이름은 Singleton 이어야만하는건아님
돌려받은 객체의 주솟값 (위 예제 부분2)
public static void main(String[] args) {
Singleton obj1 = Singleton.getInstance();//객체를 new로 생성하는게 아니라 이미 만들어진 s를 가져옴
//정적메소드라 클래스명.메소드() 로 호출
Singleton obj2 = Singleton.getInstance();
System.out.println(obj1);
System.out.println(obj2);
}
- obj1,obj2 출력하면 주솟값나옴 - 스택에서 주소를 저장하고 그 값은 s가 가진 주솟값과 같고 s와 이 obj1, obj2는 위에서 만든 객체를 가리킴 그 값은 힙에 있다 - 메소드 영역에 저장된 객체 s를 , 즉 그 주솟값을 받았으므로 같은 주솟값을 출력함 - 그래서 println() 출력값이 같은 주소가 나온다.
DB에서 사용하는 싱글톤 정리1(맛보기) - 원래는 계속 main 쪽에서 new로 클래스를 생성해왔지만 부하막기위해서 메소드를 호출해서 sql문 수행할때, 하나의 객체로 하기 위해 정적메소드를 활용해서 Singleton s를 공유하는것 = private + static = 모순발생, 비공개+공개 , 결과적으론 접근안됨 - 그래서 정정메소드로 이 객체를 돌려줌. 리턴값이 Singleton 자료형 - 내부적 동작 : 게시판 클릭하면 sql select문을 수행함 + main에서 Singleton.getInstance() 했을때 그 결과는 Singleton 클래스 객체로 받아줘야함
DB애서 사용하는 싱글톤 정리2(맛보기) +Db연동하는 클래스인 DAO(Data Access Object) 클래스 만들것 이 클래스는 메소드만으로 구성되어있음. + 이 객체를 1개 만들어서 나중에 BoardDBBean이란 DAO쪽의 메소드에 전달해서 계속 글 작성 ,업데이트 등 하는것
- 원래는 이 DAO 클래스 를 new해서 10번 목록을 클릭하면 목록을 10개뽑아야함 (메소드) -> 내가 목록 버튼 누를떄마다 실행됨 - 이때 메소드를 호출하려면 DAO 클래스 를 new해서 많이 객체 만들고 객체.메소드 로 접근해야함 - new마다 서버측 부담 + 시간 -> BoardDBBean 클래스 : 싱글톤으로 만들어져있음
private static BoardDBBean instance = new BoardDBBean();
public static BoardDBBean getInstance()
{
return instance;
}
- 해서 DAO를 싱글톤으로 구현하면 나중에 게시판 출력하는 클래스에서 BoardDBBean dao = BoardDBBean.getInstance(); 로 그 객체 불러옴 - 그리고 list = dao.getList 나 count = da.getCount() 해서 메소드 사용.이걸 반복문으로 계속 돌림 - 그래서 class안에 1번생성후 getInstance를 여러번 할수있는 구조로 만드는것 - DAO 클래스 안에서만 이 싱글톤이 사용됨 - 이 DAO 클래스의 메소드 호출(sql문)은 이 싱글톤 한개의 객체로 부터 호출한다 - DTO 가 계속해서 매개변수나 리턴자료형에 쓰임 - 목록 검색하는경우 그 검사결과를 돌려줘야하므로 그런 자료가 있는 자료형인 DTO를 리턴으로 돌려줌
final
- 사전적의미는 마지막, 이때 final이 어디에 붙냐에 따라서 의미가 달라짐 - 클래스, 필드, 메소드 앞에 붙을 수 있고, 어디 앞에 붙냐에 따라 의미가 달라짐
final 이 사용되는 경우 1. final이 멤버변수에 사용될 경우 - 마지막으로 저장되는 값이란 의미 - static final 이라 해도 되고 final 이라 해도 됨 - final붙은 값은 수정할 수 없는 상수이다.
2. final이 메소드에 사용될 경우 - 메소드 오버라이딩을 허용하지 않는다는 의 * 메소드 오버라이딩 : 부모클래스로부터 메소드 상속받아서 이름은 그대로 쓰지만 메소드 안의 내용을 다르게 쓰는것
3. final이 클래스에 사용될 경우 - 마지막 클래스라는 의미 - 상속을 허용하지 않는다는 의미
final 이 멤버변수에 사용될 경우 예제 - FinalTest01.java
package p2022_06_30;
class FinalMember {
final int a = 10; // 상수
public void setA(int a) {
this.a = a; // a는 상수이기 때문에 값을 수정할 수 없다.
}
}
public class FinalTest01 {
public static void main(String[] args) {
FinalMember ft = new FinalMember();
final int a = 1000;
ft.setA(100);
System.out.println(a);
}
}
- final이 멤버변수에 사용될 경우 : 상수가 됨 Constant (상수) - setA메소드 호출하면서 매개변수에 전달된 값을 필드를 초기화하는데 쓰려했는데 필드가 final필드이므로 수정안됨. 오류발생
final 이 메소드에 사용될 경우
+ 상속 간단히 정리 - API에서 제공되는 클래스들은 상속관계가 형성되어있다 - 1개의 클래스 구성하는 멤버는 3개 = 필드, 생성자, 메소드 - 필드, 메소드 가 상속되고 생성자는 상속되지 않음 - 이때 상속을 해주는 클래스를 부모 클래서 상속을 받는 클래스를 자식 클래스라고 한다 - 자식클래스는 부모클래스로부터 상속받는것도 자기꺼고 자기꺼도 자기꺼임 - 상속받는법 : 자식 클래스 뒤에 extends 부모클래스 쓰기 그래픽프로그램 쓰기 위해 상속 많이 씀
+ 메소드 오버라이딩 간단히 정리 - 상속이 된 상태에서 부모클래스로부터 상속받은 메소드들을 이름과 형식은 그대로 따르지만 안의 내용은 바꿔쓰는 것 - "부모클래스안에 있는 메소드"에 final이 적혀있다? -> 그럼 그 메소드 오버라이딩 허용하지 않겠다는 의미
final 이 메소드에 사용될 경우 예제
- FinalTest02.java - 메소드 앞에 final이 붙은 경우 - 파일안에 클래스 3개
package p2022_06_30;
class FinalMethod { //부모 클래스
String str = "Java ";
// public void setStr(String s) {
// final 붙이면 서브(자식) 클래스에서 오버라이딩이 불가.
public final void setStr(String s) {
str = s;
System.out.println(str);
}
}
class FinalEx extends FinalMethod { //자식 클래스
int a = 10; // final 붙이면 밑에서 a값 대입 불가.
public void setA(int a) {
this.a = a;
}
public void setStr(String s) { // 메소드 오버라이딩, 여기 오류생김!
str += s;
System.out.println(str);
}
}
public class FinalTest02 {
public static void main(String[] args) {
FinalEx ft = new FinalEx();
ft.setA(100);
ft.setStr("hi");// 슈퍼 클래스의 setStr을 실행.
FinalMethod ft1 = new FinalMethod();
ft1.setStr("hi");// 자신의 클래스의 setStr을 실행.
}
}
1. FinalMethod 클래스 : 부모클래스 2. FinalEx 클래스 : FinalMethod클래스를 상속받는 FinalEx자식클래스 3. FinalTest02 클래스 : main 메소드가 있는 클래스 - FinalClass엔 str이란 필드랑 setStr이란 메소드가 있다 - 이 setStr이 public final void setStr(String s){} - final이 붙었으므로 상속은 되지만 메소드 오버라이딩은 안됨! - 메소드 오버라이딩을 시도하는 자식클래스 쪽에 오류를 발생시킴
final 이 클래스에 사용될 경우 예제
- FinalTest03.java
package p2022_06_30;
// 상속을 허용하지 않는다.
final class FinalClass { // 부모 클래스
String str = "Java ";
public final void setStr(String s) {
str = s;
System.out.println(str);
}
}
class FinalEx extends FinalClass { // 자식 클래스, 여기서 오류 발생
int a = 10;
public void setA(int a) {
this.a = a;
}
public void setStr(String s) {
str += s;
System.out.println(str);
}
}
public class FinalTest03 {
public static void main(String[] args) {
FinalEx fe = new FinalEx();
}
}
- final class FinalClass란 부모클래스를 상속받는 곳에서 오류를 발생시킴 이거 실행 안됨 - final이 붙은 클래스라서 상속을 안해주는 클래스임
상수 만들떄 - final만 붙여도 상수 되고 - static final만 붙여도 상수 됨 - 보통은 static final 붙이는 경우가 더 많음
패키지 - 쉽게 말하면 폴더 - 비슷한 기능 가진 클래스끼리 모아둔 게 패키지 - api에서 제공되는 클래스들은 이미 패키지가 다 분류되어있다 - 사용자 정의로 만들어지는 클래스들도 같은 패키지 안에 들어가있으면 같은 폴더안에 들어가있는거임 - 폴더가 다르면 서로 다른 패키지 안에 들어가있는것
import문 - java.lang 패키지 안 클래스 사용할때는 import생략 가능 - 그 외 다른 api 제공 클래스 사용할때는 import를 써야한다. * api에서 제공되는 클래스들은 비슷한 기능하는 클래스끼리 패키지로 이미 묶여져 있음 * 가장 사용빈도 높은 클래스 묶어둔게 java.lang 패키지, 기본패키지 라고도 한다. * java.lang.Integer, java.lang.System, java.lang.String
+ 난수 발생 방법 1. Math.random() 2. Random 이란 클래스 사용 - Random클래스는 java.util 패키지 사용해야하므로 이 클래스 import해야함
자바에서 import하는 방법 1. 자동 import = ctrl + shift + O - 또는 Random을 쓰면서 ctrl + space 하면 이것저것 목록 나타나는데 그 중 선택하면 import됨 2. import 안쓰고 쓰는법 - java.util.Random r = new java.util.Random();
Random클래스 - java.util 안에 있다 - 필드 - 생성자 : 우리는 기본생성자 형태를 쓰고 있다 - 메소드 : 정수형태 난수발생시킬떄는 random클래스의 메소드 중 nextInt()라는 메소드를 쓴다 - nextInt()가 메소드 오버로딩 되어있음 매개변수없는것도 있고 매개변수가 int 형 1개인것도 있다 - nextInt(int bound) : 0포함 , 0부터 시작해서 bound까지인데 , 0은 포함, bound는 미포함(즉, 미만)
import 예제 (난수발생 예제)
- RandomTest.java
package p2022_06_30;
import java.util.Random;
public class RandomTest {
public static void main(String[] args) {
// 난수 발생 방법 : 1. Math.random()
// 2. Random 클래스
// 자동 import 단축키 : Ctrl + Shift + O
Random r = new Random();
// java.util.Random r = new java.util.Random(); 도 가능
int n1 = r.nextInt(10); // 0 ~ 9
System.out.println("n1 = " + n1);
// 1 ~ 45 사이의 난수 발생
int n2 = r.nextInt(45) + 1;
System.out.println("n2 = " + n2);
// 0.0 <= Math.random() < 1.0 난수 발생 (추가)
int n3 = (int) (Math.random() * 45 + 1);
System.out.println("n3 = " + n3);
}
}
- int n2 = r.nextInt(45) 하면 0부터 44까지가 랜덤임 그래서 +1 해줘야하는 것임.
Date 클래스 - 날짜 시간 클래스 - Date클래스는 크게 2개의 패키지 안에 들어가있다, import해야함 - Date d = new Date(); 한상태로 ctrl + shift + O 하면 두개의 패키지 java.util, java.sql 뜬다 - 두개의 패키지 안에 들어가있어서 자동이 아니라 선택해야함 - 일반적으로 java.util 패키지의 date를 써야한다 - java.sql 안의 date는 기능이 좀 다름
import 예제 (날짜시간 예제)
import java.util.Date;
Date d = new Date();
System.out.println(d);
- 영미권에서 사용하는 날짜, 시간 포맷으로 출력됨 ex) Thu Jun 30 12:44:35 KST 2022 - api에서 제공되는 클래스는 java.lang뺴고 다 모두 import해야함 - 패키지 import아니라 클래스를 import하는거임 - import문 뒤에 ; 를 붙여야한다
import 할때 클래스명있는 쪽에 * ex) import java.util.*; - java.util. 안의 모든 클래스를 다 불러오겠다는 의미 한꺼번에 불러온다 - 이러면 Date,Random등 다 쓸 수 있다
import 정리 1. api에서 제공되는 클래스일때 - java.lang 을 빼고 모두 import해야한다.
2. 사용자 정의 클래스일때 - 패키지가 다를떄만 import한다! - 같은 패키지안의 class끼리는 import하지 않아도 그 클래스 사용가능(객체 생성가능) - 접근제어자와 관련있음(이제 공부할 것) - 같은폴더 = 같은패키지, 다른폴더 = 다른패키지
접근 제어자 - 4가지가 있다, 이걸로 접근 허용할지 말지를 제어함 - public : 가장 넓은 접근 허용 - private : 가장 좁은 접근, 같은 클래스 내에서만 접근 가능, 다른 클래스/다른 패키지의 접근허용안함 - default : 중간정도 접근허용, 생략된 경우임, 같은 클래스, 같은 패키지(같은 폴더) 안에선 접근 가능 - protected : 상속에서만 사용, default 보다 접근범위 넓음, 하위클래스에서 접근가능
- 클래스, 필드, 생성자, 메소드 앞에 접근제어자 붙일 수 있다 - 클래스로 접근할때는 접근제어자가 접근 허용해야만 접근 가능 - 필드로 접근할때도 접근제어자가 접근 허용해야만 접근 가능
* 자바의 접근 제어자 접근제어자 자신의클래스 같은패키지 하위클래스 다른패키지 private O X X X 생략(default) O O X X protected O O O X public O O O O
- 같은 클래스내에서는 접근제어자 쓰는게 의미가 없다 - 같은 클래스내에선 다 접근 가능하기때문에 (private을 쓰더라도)
접근제어자 예시 - 사용자 정의로 클래스 2개 만들었을때 - 같은 패키지 안의 두개의 다른 클래스끼리는 접근할때는 import 안해도된다 - 같은 패키지 안의 두개의 다른 클래스끼리는 접근할때는 public이나 default면 됨 - 서로 다른 패키지 안의 두개의 다른 클래스는 접근할때는 import 해야한다. - 서로 다른 패키지 안의 두개의 다른 클래스는 접근할때는 pulbic 이어야 한다.
1. 같은 패키지 안에 들어 있는 클래스 - src - p2022_06_30 - Called.java : check()메소드 - src - p2022_06_30 - Calling.java : main() 메소드 - 두 클래스가 같은 패키지 안에 있을때 접근제한자와 import 여부를 알아보자
package p2022_06_30;
public class Calling {
public static void main(String[] args) {
Called c = new Called(); //클래스 접근
c.check(); //메소드 접근
}
}
package p2022_06_30;
public class Called {
public void check() {
System.out.println("메소드 호출 성공");
}
}
클래스 접근 - Calling 클래스에서 Called 클래스로 객체만들어서 check()메소드 호출하자 - Calling 클래스에서 Called 클래스로 객체 만들기 = 그 클래스에 접근하는 거임 - 하지만 두 클래스는 같은 패키지 안에 있으므로 import가 필요없다, - 그리고 Called 의 클래스의 접근제어자가 public이므로 접근해서 객체 생성이 가능했던것
- private class Called 로 바꾸면 Calling에서 Called 클래스로 객체 생성 불가 (접근 불가) - 같은 패키지에 있는 class로 접근할때는 import안써도 되고 접근제어자는 private만 아니면 된다 - public default protected 는 다 접근가능하다
메소드 접근 - 그리고 생성된 객체를 통해 메소드를 호출하는 c.check()가 가능한 이유는 check() 메소드의 접근제어자가 public이라서이다. - default도 접근 가능하다, private이면 접근안됨, 즉 private이면 메소드 호출안될것
필드 접근 + 필드의 접근제어자도 같은 패키지 안 다른 클래스일때, default나 public으로 되어있어야 접근가능함
같은 패키지일때, 접근제어자와 import여부 정리 1) 같은 패키지 안에 들어 있는 클래스에 접근 하기 위해서는 접근 제어제가 public이나 default 접근 제어자로 되어 있어야 한다. 2) 같은 패키지 안에 들어 있는 클래스에 접근 하기 위해서는 import 를 하지 않아도 된다.
2. 다른 패키지 안에 들어 있는 클래스 - src - a - b - Called.java : check()메소드 - src - Calling.java : main() 메소드 - 두 클래스가 다른 패키지 안에 있을때 접근제한자와 import 여부를 알아보자
+ 패키지 생성 - scr 아래 a 패키지 내 , b패키지 내 Called 클래스 만드는법 - 패키지명을 : a.b 라고 하면 됨 -> a폴더하위에 b폴더 하위에 Called.java생기게됨 - Called.java 는 a패키지 안에 b패키지 안에 Called.java 파일이 있는것 - scr 바로 아래 Calling 클래스 만들것 -> 즉 서로 다른 패키지 안에 있다.
package a.b;
public class Called { //이게 default나 private이면 아래 객체생성코드에서 오류발생
public void check() { //이게 default나 private이면 아래의 c.check();에서 오류남. 접근불가
System.out.println("다른 패키지에서 호출");
}
}
import a.b.Called;
public class Calling {
public static void main(String[] args) {
Called c = new Called(); //클래스가 public이면 접근된다
c.check(); //메소드가 public이면 접근된다
}
}
- Calling 클래스에서 Called 클래스로 객체 만들기 = Called 클래스 접근 - import하지 않아서 만들면 빨간줄 뜬다, import해준다 - public이어도 import 안되어있으면 접근안됨 - 접근제어자는 무조건 public이어야만 접근된다 - 서로 다른 패키지 안의 클래스로 접근하고싶으면 접근제어자가 public이어야만함 import도 필수임 - 패키지가 다를때는 클래스,필드,생성자,메소드 전부 public으로 만들어야 접근해서 쓸 수 있음
다른 패키지일때, 접근제어자와 import여부 정리 1) 다른 패키지 안에 들어 있는 클래스에 접근 하기 위해서는 접근 제어제가 public 접근 제어자로 되어 있어야 한다. 2) 다른 패키지 안에 들어 있는 클래스에 접근 하기 위해서는 해당 클래스를 import 를 해야된다.
import와 접근제어자 정리 1. api 제공 클래스인경우 - 모두 import, 예외) java.lang 2. 사용자 정의 클래스 인 경우 2-1 ) 같은 패키지내 : public, protected, default 인 경우 접근 가능 / import 불필요 2-2 ) 다른 패키지내 : public 인 경우만 접근 가능 / import 필요
패키지와 접근제어자 예시 - PackageHelloWorld.java 파일 열어보면 패키지가 Hello 라 되어있음 -> 패키지 Hello 만든뒤 그 안에 넣자 - UsePackageHelloWorld.java는 열어보면 패키지 안적혀있다 (패키지 없는것) -> 그냥 src에 파일 넣으면 디폴트 패키지속으로 들어감
import 여부 - 패키지가 다르므로 UsePackageHelloWorld.java에서 hello.PackageHelloWorld 클래스 를 import 해야한다
접근제한자 - PackageHelloWorld 클래스와 그 안의 printHello 메소드는 public이다. - 그럼 PackageHelloWorld 로 객체를 만들 수 있고 그 객체를 통해 printHello 메소드가 잘실행됨
- DTO 클래스 = MemberInfo 클래스 - MemberInfo 클래스의 필드들 접근제어자가 private이었다 -> 클래스가 달라지면 이 필드값을 객체로 접근해서 입력/수정/출력 등이 안됨, 접근이 안됨 - m[i].name = "홍길동" 으로 값을 셋팅할 수 없다. - 두가지 방법 1. 생성자의 매개변수로 필드값 초기화 2. setter메소드 를 통해서 접근해서 입력/수정/출력함
캡슐화 - 이런개념이 "캡슐화" 이다. - 정보를 캡슐씌우듯 보호함. 접근제어자 로 외부 다이렉트 접근 못하도록 private으로 막는 것 = 보호
날짜, 시간 관련 클래스 - Date, Timestamp, Calendar 라는 3개의 클래스 - 클래스마다 날짜시간 형식에 차이가 있다 - java.util.Date : 간단날짜 - java.sql.Timestamp : 정교한 날짜 작업할때 사용 - java.util.Calendar : 날짜시간, 캘린더 만들떄도 사용
Date 클래스 - Date는 java.util과 java.sql둘다 들어있다 - 지금 필요한건 java.util.Date 임 import해주자
Date d = new Date();
System.out.println(d);
출력 : Thu Jun 30 15:37:02 KST 2022
- 날짜 시간 간단히 출력시 Date 클래스 - 하지만 날짜시간 포맷이 불편함, 영미권에서 많이 쓰는 날짜 포맷임 - Date 클래스 자체적인 기능으로 다른 포맷으로 바꾸는 기능은 없지만 다른 클래스의 도움을 받으면 원하는 날짜 포맷으로 설정하면 원하는 날짜 포맷으로 출력 가능
SimpleDateFormat 클래스 - 날짜 시간 포맷 바꿔주는 클래스 - import java.text.SimpleDateFormat;
SimpleDateFormat 클래스 사용 java.lang.Object (최상위클래스, 슈퍼클래스) java.text.Format java.text.DateFormat java.text.SimpleDateFormat
- 패턴을 지정하는 방법을 나타낸 표들이 있다 - ex) yyyy.MM.dd G 'at' HH:mm:ss z
- 필드 : 위로부터 상속됨 - 생성자 : 두번째 생성자 보면 SimpleDataFormat(String pattern) 임 - 여기에 String형으로 Date and Time Pattern 에 적힌대로 패턴을 써주면 된다 . ex) yyyy는 4자리 연도 나타냄
SimpleDateFormat sd = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
- 연월일시분초로 패턴을 지정하겠다는 의미임 + "yyyy년 MM월 dd일" 이렇게 해도 됨 - Date 클래스 자체 기능은 없지만 SimpleDataFormat 클래스의 도움을 받아서 원하는 포맷으로 날짜시간 출력가능
SimpleDateFormat 으로 포맷 적용하기 - 메소드 : format() 메소드로 지정 + API 문서 보면 SimpleDateFormatt 클래스 내엔 format() 메소드 없다. -> 부모나 조상으로부터 상속받았을것!
+ format(Object obj) 이 Format 클래스에 보면 있다(조상) + format(Date date) 이 DateFormat 클래스에 있다(부모)
날짜시간 원하는 포맷으로 출력 예시
Date d = new Date();
System.out.println(d);
SimpleDateFormat sd = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss EEE요일");
System.out.println(sd.format(d));
출력 Thu Jun 30 15:52:24 KST 2022 2022-06-30 15:52:24 목요일
+ 운영체제가 한글이라서 영향을 받아서 Thu 대신 목 이라고 출력하는거임
SimpleDateFormat sd1 = new SimpleDateFormat("yyyy-MM-dd a hh:mm:ss EEE요일");
SimpleDateFormat sd2 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss EEE요일");
System.out.println(sd1.format(d));
System.out.println(sd2.format(d));
출력 2022-06-30 오후 04:07:51 목요일 2022-06-30 16:07:51 목요일
- HH포멧은 24시간 시간제 - hh포멧은 12시간 시간제 - a 는 오전 오후 - 나중에 게시판에 작성시간 출력 포맷 지정할 때 쓴다
Timestamp 클래스 - 자바에서 가장 많이 사용되는 날짜 클래스 - 정교하고 자세한 날짜시간을 알려줌 - java.security , java.sql 두개의 패키지에 있는데 우리는 java.sql 쓸것 security 패키지의 것은 기능이 좀 다름 - 기본생성자 지원안함 - 3개의 생성자 있는데 일반적으로는 매개변수가 long형으로 되어있는 Timestamp(long time)생성자를 쓴다
Timestamp 클래스 사용 java.lang.Object java.util.Date java.sql.Timestamp
- 아까의 Date 클래스가 Timestamp의 부모 클래스이다.(상속) - 필드 : 없다 - 생성자 : Timestamp(long time), Timestamp(int year,int month, int date ...)
Timestamp(long time) - Timestamp 생성자 - 천분의 일초 ms를 구해줌 - 시스템에 대한 날짜 시간 을 ms단위로 가져옴 - 매개변수에는 System 클래스에서 제공되는 정적메소드 System.currentTimeMillis() 를 써야함 - 이 메소드는 정적메소드이므로 .으로 접근해서 호출함, 리턴자료형이 long형
Timestamp ts = new Timestamp(System.currentTimeMillis());
System.out.println(ts);
출력 : 2022-06-30 16:16:52.966
- 1000분의 1초 단위인 ms 단위까지 구해줌 - 일반인들이 이 정도 자세하게는 볼 필요가 없음 -> Timestamp도 SimpleDateFormat으로 형식 지정해서 쓰면 된다
Timestamp ts = new Timestamp(System.currentTimeMillis());
System.out.println(ts);
SimpleDateFormat sd3 = new SimpleDateFormat("yyyy년 MM월 dd일 HH:mm:ss");
System.out.println(sd3.format(ts));
출력 2022-06-30 16:20:37.122 2022년 06월 30일 16:20:37
- 즉 형식 포맷을 지정할 수 있으므로 Date 든 Timestamp든 뭘 써도 상관없다
Calendar 클래스 - java.util 안에 있는 클래스 - 앞의 Date, Timestamp 와는 기능이 좀 다르다 - 날짜시간 불러올떄도 쓰지만 캘린더를 만들떄도 씀
Calendar 클래스 객체 생성시 주의
Calendar c1 = new Calendar(); // 오류발생
- Calendar 클래스는 지금까지 다룬것처럼 new연산자로 객체 생성을 하면 안됨! - 거의 대부분의 객체는 생성할떄 new 써야한다. - new는 새로운 공간을 만든다는 의미인데 Calendar클래스는 새로운 날짜를 하는게 아니라 그냥 시스템의 날짜를 구해오는 것이기 때문이다.
Calendar클래스 객체 생성하는법 2가지 방법
1. 자식클래스인 GregorianCalendar 클래스로 객체를 생성해서 전달 - Calendar 클래스의 자식 클래스는 그레고리안 캘린더 클래스임 - 이걸 활용해서 Calendar 객체를 만드는법이 첫번째 방법
Calendar c2 = new GregorianCalendar(); // 업캐스팅
- 왼쪽 클래스명과 오른쪽 생성자 호출 생성자 명이 보통은 동일하지만 지금처럼 다른 경우에는 형변환이 된 것이다.(세번째 자료형변환 : 레퍼런스 형변환) - 오른쪽의 자식 클래스인 GregorianCalendar 클래스로 객체를 생성해서 왼쪽 부모에게 전달하는것 = 레퍼런스 형 변환의 업캐스팅(반대의 경우는 다운캐스팅) - 업캐스팅하면 기능이 좀 달라지는게 있다 (나중에 공부)
2. Calendar 클래스의 정적메소드인 getInstance() 로 객체 돌려받기
Calendar c = Calendar.getInstance();
* 객체 = instance
Calendar 클래스 구조 (API 문서) 필드 : static 붙은 정적필드 들이 대부분 생성자 : 기본생성자있지만 기본생성자 쓰면 오류생김, 이런 방식으로 객체 생성 불가 메소드 : 메소드 중 getInstance() 를 보면 리턴자료형이 static Calendar 이다, 이 메소드로 객체를 구해옴
* 값을 구해오는 메소드는 getX 정해주는건 setX
Calendar 사용해서 출력
Calendar c = Calendar.getInstance();
System.out.println(c);
출력 java.util.GregorianCalendar[time=1656574659906,areFieldsSet=true,areAllFieldsSet=true,lenient=true...
- 이제 Calendar 객체가 만들어졌다 - 근데 이 객체는 년,월,일,시 등이 한번에 출력되지 않음 - 이 time은 1970년 1월 1일 00:00 부터 지난 초(sec)같은거임
진짜 출력하는 방법 : Calendar 클래스의 정적필드를 활용
ex) YEAR 이란 정적필드가 있다 -> Calendar.YEAR 로 쓰고 리턴형은 int 이다.
System.out.println(Calendar.YEAR); //1
- Calendar.YEAR 필드값은 1 - Calendar.MONTH 필드값은 2 - 이렇게 get(Calendar.YEAR) 하면 Calendar 객체인 c중에서 인덱스에 맞는걸 꺼내온다. - 우리는 필드명만 알고있으면 됨.
출력 1
- 이걸 활용해서 년 (YEAR)을 구할 수 있다
Calendar로 년 구하기
Calendar c = Calendar.getInstance();
int y = c.get(Calendar.YEAR);
System.out.println(y);
출력 : 2022
Calendar로 월 구하기
Calendar c = Calendar.getInstance();
int y = c.get(Calendar.YEAR); // 연(년) 정보
System.out.println(y);
int m = c.get(Calendar.MONTH) + 1; //월(0~11) -> 실제 사용하는 월과 맞추려면 +1해줘야함
System.out.println(y+ "-" + m);
출력 2022 2022-5
- Calendar.MONTH 필드 이용하면 0~11로 나온다. 실제 사용하는 월과 맞추려면 +1 해줘야함
Calendar로 시간구하기
int h1 = c.get(Calendar.HOUR); // 12시간제
int h2 = c.get(Calendar.HOUR_OF_DAY); // 24시간제
System.out.println(h1); //
System.out.println(h2);
출력 4 16
Calendar로 오전, 오후 구하기
int ap = c.get(Calendar.AM_PM); //오전시간은 0, 오후시간은 1 을 리턴해줌
if(ap==0) {
System.out.print("오전");
}else {
System.out.print("오후");
}
- ap는 숫자로 값을 돌려줌 - 오전시간은 0, 오후시간은 1로 리턴해줌
Calendar로 분, 초 구하기
int mm = c.get(Calendar.MINUTE); //분
int s = c.get(Calendar.SECOND); //초
System.out.println(h1 + ":" + mm + ":" + s);
System.out.println(h2 + ":" + mm + ":" + s);
- Calendar 클래스로 연월일시분초 구할땐 따로 구해야하고 제공하는 필드를 사용해야만 함
package p2022_07_07;
import java.util.Random;
import java.util.TreeSet;
public class TreeSetLottoHw {
public static void main(String[] args) {
TreeSet lotto = new TreeSet();
Random r = new Random();
while (lotto.size() < 6) {
lotto.add(r.nextInt(45) + 1);
}
System.out.println("로또 번호 : " + lotto);
}
}
- 새로 발생된 난수값과 이전의 난수값들을 비교하기 위해 중첩 for문 사용 - i-- 한 뒤 괜히 더 돌아가는걸 막기위해 break 해주는게 좋다 - 하나 중복을 발견하면 다음꺼부터는 중복일리가 없다, 이전에 이미 다 처리되었기 때문에 - 오름차순 적용
1. num[0] = 5, num[1] = 5 일때, 안의 for문이 돌아가면서 num[0] 과 num[1]을 비교해서 같으므로 i--시킴 2. 그럼 i=0이 되고 break 되어 나옴 이해 바깥 for문에 의해 ++ 되며 i=1 이 됨 3. 다시 num[1]값을 랜덤으로 받는것
오름차순하기 - 정렬알고리즘 통해서 (버블정렬 = 자신의 옆자리에 있는 것과 비교) - Arrays 클래스의 sort()함수이용해서 num 배열이름 넘겨주면 오름차순 정렬해줌(java.util.Arrays)
필드 = 멤버변수 - 메소드 바깥쪽에 정의됨 - 기본자료형은 초기화가 됨
파일 생성 - 메인메소드를 가진 클래스만 public class가 될 수 있다! + 생성자의 접근제어자 주로 public 이다.
클래스 실행하기 1. 클래스 안에 메인메소드 넣기(독립적실행가능) 2. 메인 메소드가 있는 클래스에서 실행시켜주기
필드로 직접 접근하기 예제
class Korean{
//필드
String nation = "대한민국";
String name;
String ssn; //전화번호
public Korean(String name, String ssn) {
this.name = name;
this.ssn = ssn;
}
}
public class KoreanEx {
public static void main(String[] args) {
Korean k1 = new Korean("박자바","011225-1234567");
System.out.println("k1.name : " + k1.name);
System.out.println("k1.ssn : " + k1.ssn);
Korean k2 = new Korean("김자바","930525-0654321");
System.out.println("k2.name : " + k2.name);
System.out.println("k2.ssn : " + k2.ssn);
}
}
- k1객체 만든 후 k1. 통해서 필드로 접근 - k2객체 만든 후 k2. 통해서 필드로 접근 - 필드 name, ssn을 private으로 바꾸게 되면 KoreanEx클래스에서 k1.name k2.ssn 해서 접근 불가(출력 불가) 다른 클래스라서, 다이렉트 접근을 막는다
필드값 - nation은 "대한민국"으로 초기화 - name과 ssn은 객체를 생성할때 생성자를 통해 전달된 값으로 각각 초기화됨
할당 시점 - new연산자로 힙메모리에 새로운 공간 생성할때 힙메모리상에 새로운 공간 할당받음(참조형은 다 마찬가지) - 자료형이 String이라서(필드값) null로 자동초기화되지만 여기선 객체생성시 생성자호출시 받는 값으로 초기화 (name,ssn) - 주소를가진 레퍼런스 변수 : k1, k2 - 필드들 nation, name, ssn 의 접근제어자가 default이므로 같은 패키지 내는 모두 접근 가능. 그래서 다른 클래스에서 k1.ssn 가능
그림
자바의 접근 제어자 정리
접근제어자 자신의클래스 같은패키지 하위클래스 다른패키지
private O X X X 생략(default) O O X X protected O O O X public O O O O
+ 같은 클래스 내 : 접근 제어자 의미 없다. 뭐든 접근 된다. - private : 오직 같은 클래스에서만 됨 , 다른 클래스에서 접근하는걸 허용하지 않음, 가장 좁은 접근허용 - public : 가장 넓은 접근 허용함, 다른 패키지(폴더) 안의 클래스까지 접근가능 - default : 중간정도 접근 범위, 같은 패키지(폴더) 내에선 다 가능 - protected : 상속관련, 상속 배우고 난후 공부
접근제어자 범위 비교 가장넓음 public > default > protected > private 가장좁음
생성자 오버로딩 - 생성자 여러개 생성 - 구분되는 점이 있어야함
생성자 오버로딩 구분 1. 매개변수 자료형 2. 매개변수 개수 3. 매개변수 순서
메소드 - 언어에 따라 함수라고도 한다 - 쓰는 이유 : 객체의 동작 + 여러개 코드를 모아두고 한번 메소드가 정의되면 호출을 통해 재사용하기 위해서
package p2022_06_29;
class Calculator {
// 메소드
void powerOn() {
System.out.println("전원을 켭니다.");
return;
}
int plus(int x, int y) { // 지역변수 : x, y, result
int result = x + y;
return result;
// System.out.println("test");
}
//return문 : plus() 메소드를 호출한 곳에 값을 돌려주는 역할
//return문은 메소드 가장 마지막 줄에 사용해야한다.
double divide(int x, int y) {
double result = x / (double) y;
return result;
}
void powerOff() {
System.out.println("전원을 끕니다.");
return;
}
}
public class CalculatorEx {
//p217 ~ 218
public static void main(String[] args) {
Calculator cal = new Calculator();
cal.powerOn();
int result1 = cal.plus(5, 6);
byte x = 10;
byte y = 4;
double result2 = cal.divide(x,y);
System.out.println("result2 : " + result2);
cal.powerOff();
}
}
- Calculator 클래스 앞에 private 쓰면 CalculatorEx 클래스에서 객체를 만들 수 없음(클래스 접근 불가) - Calculator 클래스의 메소드 powerOff 앞에 private쓰면 cal.powerOn() 을 할 수 없음(메소드 접근 불가)
패키지 = 폴더 - 같은 폴더 안 = 같은 패키지 안 - 서로 다른 폴더 안 = 서로 다른 패키지 안 = public만 접근가능
위 예제의 부분1
int plus(int x, int y) { // 지역변수 : x, y, result
int result = x + y;
return result;
//System.out.println("test"); 오류남
}
+ return문 : plus() 메소드를 호출한 곳에 값을 돌려주는 역할 + return문은 메소드 가장 마지막 줄에 사용해야한다. - 메소드가 실행되는동안 필요한 값들을 매개변수로 전달해줌(매개변수 = 지역변수) - 메소드 실행되는동안만 스택에 값 존재, return되면 자동으로 지워짐 - 그래서 메모리 관리 크게 신경안써도 된다.
위 예제의 부분2
cal.powerOn();
- 메인 메소드 안에서 객체 생성하며 생성자 호출후 메소드 호출 - 필드처럼 메소드에 접근할때도 객체.메소드() 로 호출함 (정적메소드가 아닌경우)
위 예제의 부분3
int result1 = cal.plus(5, 6);
- Call by Value로 값 전달하며 메소드 호출 - plus()는 결과를 리턴자료형 int로 돌려줌 그래서 int result1으로 받아야하는것
위 예제의 부분4 (주의)
double divide(int x, int y) {
double result = x / (double) y;
return result;
}
- 리턴자료형이 double이므로 double형 값을 돌려준다 - int형인 x와 int형인 y를 산술연산시 int형으로 처리됨 ex) x = 10 , y = 4 이면 다 잘리고 2만 나온다. (손실 발생) - 손실 발생을 막기 위해서 (double)을 붙여줘서 강제 형변환 -> 2.5 - 그걸 double로 return 시켜줌 - (double) 을 빠뜨리면 자동형변환되어서 2 -> 2.0 이 나옴(손실발생) - 10/4 는 2.5이므로 살리려면 (double)해서 강제형변환시켜서 값이 double로 처리되도록 해야함.
위 예제의 부분5(CalculatorEx의 main 메소드 내부)
byte x = 10;
byte y = 4;
double result2 = cal.divide(x,y);
System.out.println("result2 : " + result2);
+ byte는 1바이트 정수형 자료형 - cal.divide에서 매개변수로 byte를 넘김 -> 근데 devide 메소드의 매개변수는 int 형 4바이트 이다. - 4바이트짜리 변수에 1바이트 짜리 값을 할당 => 컴파일러가 자동형변환시켜줌. 큰자료형으로 작은값으로 들어가므로 - 자동형변환되어서 위 코드 가능함
+ plus와 divide 메소드의 매개변수 이름들이 같지만 그 메소드 내에서만 사용되는 지역변수이므로 충돌이 발생하지 않음
메소드의 매개변수에 참조형이 오는 예제 - 값이 아닌 주솟값을 전달해야한다. - sum1은 배열에 전달된 값들의 합을 돌려주는 함수
package p2022_06_29;
//p220 ~ 221
class Computer {
// 주솟값 전달에 의한 메소드 호출(Call by Reference 방식)
int sum1(int[] values) {
int sum = 0;
for (int i = 0; i < values.length; i++) {
sum += values[i];
}
return sum;
}
// vargus : 전달된 값은 배열로 받음
int sum2(int... values) {
int sum = 0;
for (int i = 0; i < values.length; i++) {
sum += values[i];
}
return sum;
}
}
public class ComputerEx {
public static void main(String[] args) {
Computer com = new Computer();
int[] values1 = { 1, 2, 3 };
int result1 = com.sum1(values1); // sum1() 메소드 호출 , 주솟값을 가진 values1을 넘김
System.out.println("result1 : " + result1);
int result2 = com.sum1(new int[] { 1, 2, 3, 4, 5 }); // sum1() 메소드 호출 , 배열을 만들어서 그 주소를 넘김
System.out.println("result2 : " + result2);
int result3 = com.sum2(1, 2, 3); // sum2() 메소드 호출 ,
System.out.println("result3 : " + result3);
int result4 = com.sum2(1, 2, 3, 4, 5); // sum2() 메소드 호출 ,
System.out.println("result4 : " + result4);
}
}
- "같은 int형 배열"의 주소값을 써서 메소드를 호출해야함 - Computer 클래스의 참조형변수인 int[] values는 아직 주솟값이 없는 상태 , new를 써서 int형 배열을 만들어 주솟값을 가진 걸 넘겨줘야함 - 그래서 main쪽에 int형 1차원배열을 만들어줌 - sum1에서 참조형이 매개변수로 왔으므로 같은 int형 배열의 주솟값을 넘겨야함 - new연산자를 아직 안썼으므로 아직 int[] values는 가리키는게 없음 - 주솟값 전달에 의한 메소드 호출임 + 값전달보다 주솟값 전달이 더 효율적이고 빠른 방식임
vargus (...) - ...은 vargus 라고 함 - 전달된 값들은 1개일수도 여러개일수도 있지만 전달되는 값들은 모두 배열로 받음 - 매개변수가 있으면 매개변수의 개수대로 메소드 호출시 써줘야하지만 ... 은 int값을 1개 전달하든 여러개 전달하든 모두 배열로 처리됨
Call by Reference - values1 int형 배열 힙메모리상에 4바이트 공간 3개 만들어지고 1,2,3이 들어가있고, 그 걸 values1이 그 스택에서 그 배열의 주소를 가지고 있음
int result1 = com.sum1(values1)
- 에서 주솟값을 담고있는 values1을 전달 = 주소를 전달 = Call by Reference - 주솟값이 없었던 Computer 클래스의 sum1의 values는 주솟값을 전달받아서 Computer 클래스의 values는 이제 이 {1,2,3} 배열을 가리키게됨 - 합을 구해서 리턴형 int로 result1에 값을 돌려줌
- 매개변수 중에서 참조형이 오는 경우 중 클래스/인터페이스가 가장 많다(배열은 많진 않다) - API 제공 클래스 + 사용자 정의 클래스 => 이것들도 자료형이다 - 참조형변수는 주솟값을 가진다
매개변수에 주소값을 전달하는 법(위 예제 부분)
int[] values1 = { 1, 2, 3 };
int result1 = com.sum1(values1); // sum1() 메소드 호출 , 주솟값을 가진 values1을 넘김
System.out.println("result1 : " + result1);
int result2 = com.sum1(new int[] { 1, 2, 3, 4, 5 }); // sum1() 메소드 호출 , 배열을 만들어서 그 주소를 넘김
System.out.println("result2 : " + result2);
1.이렇게 values1 처럼 만들어진 배열공간의 주소값을 전달하는방법이 있다. - values1이 가진 주솟값을 전달
2.(new int[] { 1, 2, 3, 4, 5 } 처럼 오른쪽의 new연산을 써서 새로운 공간을 만들어서 그것의 주솟값을 넘겨줄 수도 있음 - 기억공간이 만들어지고 그거의 주솟값이 sum1 메소드의 매개변수로 넘어감 - 값을 받는 변수가 없기 때문에 이건 재사용이 안된다. 이후 가비지 콜렉터가 이 힙메모리상 배열을 지워버린다. - 더이상 이 힙메모리에 접근할수없을때 해제된다. - 할당시점은 new를 썼을때 할당된다
그림
+ 배열 생성
int[] score = {80,90,100} // new안쓰지만 힙메모리에 데이터 개수만큼 공간 만들어짐
int[] score = new int[]{80,90,100}
// vargus : 전달된 값은 배열로 받음
int sum2(int... values) {
int sum = 0;
for (int i = 0; i < values.length; i++) {
sum += values[i];
}
return sum;
}
- 메소드의 매개변수가 2개면 2개 전달 1개면 1개 전달 해야했었다. - but vargus쓰면 1개 전달하든 2개전달하든 3개전달하든 모두 매개변수로 받을 수 있다 - 전달된 값은 모두 배열로 처리됨 ex) 첫번째 전달된값은 0번방 두번째 전달된 값은 1번방... - 다만 자료형은 맞춰줘야함 int ... values 면 몇개이든 int형 값을 전달해야함
2. 일반메소드에서 메소드 호출시(같은 클래스 내부) - 객체.메소드() 가 아니라 객체없이 그냥 메소드() 만으로 호출 가능하다!
ex)
double result = avg(7, 10);
- avg() 메소드 호출 그냥 avg(7,10)만으로 호출했음
위 예제 흐름 - JVM이 main메소드 실행 -> mycal.execute() 호출함-> execute()이 실행됨 -> 그 메소드에서 avg메소드를 호출하면서 매개변수를 7, 10 넘겨줌 -> avg 매개변수의 x에 7, y에 10이 들어감, avg에서 다시 plus() 메소드를 7,10을 넘겨주며 호출 -> plus() 메소드에서 합을 구해서 합을 result 해서 plus()를 "호출"한곳에 값을 돌려줌 즉 avg로 돌아감 -> 그걸 avg의 sum이 받아서 %2 한뒤 돌려줌 - (주의) plus()가 돌려줄땐 int형인 17을 돌려줌, 근데 sum을 double로 받았으므로 17.0 해서 /2 해서 8.5가 result가 됨 -> 그 8.5 값을 avg를 호출한 execute()에 돌려줌, 그걸 println()메소드에 결과값을 넘겨서 -> println()이 출력시킴
+ 자바는 객체지향언어라서 호출할 메소드가 뒤에있어도 상관없다 + execute() 아래 println() 있지만 execute()에서 println() 호출가능 + 일반 메소드끼리는 메소드 이름만으로 서로를 호출한다
메소드 오버로딩(Method Overloading) - 1개의 클래스 안에 동일한 이름을 가진 메소드를 여러개 정의하는 것. - 생성자 오버로딩 처럼 메소드도 한개의 클래스 안에 동일한 이름의 클래스 여러개 정의할 수 있다
메소드 오버로딩 구분하는 법 1. 매개변수 자료형 2. 매개변수 개수 3. 매개변수들의 순서
- 한가지를 이상을 만족해서 구분이 되어야만 올바르게 메소드 오버로딩 시킨것임 * 나중에 메소드 오버라이딩과의 차이를 알아야 한다. 완전히 다른 개념 + 메소드 오버라이딩 : 두 클래스 사이에 상속이 정의되어야만 사용가능
String 클래스 (API 문서) - 필드 생성자 메소드 순 - 필드 : 메서드 바깥쪽에 정의되는 변수
- 생성자 : 클래스명과 동일, 형식상 괄호가 반드시 있다 - 매개변수가 없는 생성자는 기본생성자 - 나머지는 클래스명과 동일하게 생성자가 만들어지는데 구분이 되도록 정의됨 -> 생성자 오버로딩
- 메소드도 똑같은 이름을 가진 메소드들이 있다 ex) copyValueOf(char[] data) 와 copyValueOf(char[] data, int offset, int count) - equlas 메소드, format 메소드들은 같은이름인 메소드가 여러개다 -> 메소드 오버로딩
- 메소드가 같은 이름이다 - 매개변수가 1개인 areaRectangle 과 매개변수가 2개인 areaRectangle - 매개변수의 개수가 다르므로 올바르게 메소드 오버로딩 되었음 - 매개변수 1개 전달하면 매개변수 1개인 areaRectangle() 이 호출되고 2개 전달하면 매개변수 2개인 areaRectanble()이 호출됨 - 메소드 오버로딩은 아무 언어나 되는게 아니라 객체지향언어만됨(c++,java는 되고 c는 안됨)
앞으로 공부할 내용
1. static이 붙은 정적 필드(정적변수) 2. static이 붙은 정적 메소드
변수 지역변수 멤버변수 정적변수 중에서 정적변수를 하는 것이다
3. 상수를 만드는 법 (Constant) - final을 붙이거나 static final 을 붙인다 - 기존 변수에 final 붙이면 상수가 되는것 - final을 클래스, 필드, 메소드 에 붙일 수 있다-> 어디에 붙이냐에 따라 의미가 달라짐 4.접근제한자와 패키지 의 관계 5. getter와 setter 메소드
정적 필드 (정적 변수)
- static 이 붙은 변수
ex)
static int a; // 그냥 변수앞에 static을 붙이면 정적변수가 됨
- static : 공유를 목적으로 해서 누구나 쉽게 접근하도록 만들때만 static 붙인 정적 필드형태로 만듬 - API 보면 클래스들 정적필드, 메소드들 정적메소드들 엄청 많다
ex) Math 클래스안엔 정적필드랑 정적메소드뿐 - 정적 필드는 클래스명.필드 로 사용 - 누구나 쉽게 생성할수있도록 따로 객체생성없이 클래스명.필드로 사용함
ex)
int n = Integer.parseInt(String s);
- 에서 parseInt는 정적메소드라서 이렇게 클래스명.parseInt()로 사용함 - 세번째 변수인 정적멤버변수(정적 필드) - 정적 필드 = 정적 멤버변수 = 정적 변수 - 메모리상에 할당되는 시점과 저장되는 영역이 (지역변수,멤버변수, 정적변수) 다 다르다(잠시 후 공부)
Math 클래스(정적 필드/메소드 예시) - 내부에 정적 필드 뿐이다 - 정적필드 정적메소드 뿐 - 정적필드 E , PI 는 Math.E 로 접근가능 - 정적 메소드 , 정적 필드뿐이라 객체 생성할 필요가 없음 - math클래스는 생성자가 아무것도 없다 -> 생성자 자체를 못씀 - random() 메소드의 타입은 static double이다. 즉 정적메소드이고 리턴값이 double - 정적 메소드 이므로 Math.random()으로 사용할수있다
정적변수의 메모리 할당 시점/장소 - 할당 시점 : 정적 멤버변수는 클래스가 메모리에 로딩되면(실행될때) 할당됨 - 초기화 : 자동으로 설정되고 (정수형 0 실수형 0.0 논리형 false) - 값 유지 : 프로그램이 종료될때까지 값을 유지한다 - 저장 영역 : 메모리의 static영역 (공유영역)에 자동으로 할당됨 - 저장 영역 : 공유영역 = 메소드영역 = static 영역 <->힙,스택과 다름 - 주의 : 장 오래 메모리에 상주하므로 많이쓰면 메모리가 부족해짐, 특별한경우아니면 만들지 않음
+ 특별한 경우, 반드시 정적멤버변수 만들어야하는 경우 - 싱글톤 : 객체생성을 1번만 하는 것, 이 경우엔 정적필드를 만들어야함
자동초기화 - 정적멤버변수는 자동초기화 된다. - 배열과 마찬가지로 int는 0 , double 은 0.0, boolean은 false로 초기화 된다. - 메소드영역에 값을 저장하고 한번 저장된값은 프로그램이 완전히 종료될때까지 값을 유지
정적 멤버변수에 접근하는 방법 - 정적 변수를 가지고 있는 클래스명으로 직접 접근 할 수 있다.
class StaticTest{
satic int a;
public static void main(String[] args) {
System.out.println(StaticTest.a)
}
}
- 정적메소드 사용시 클래스명.메소드()
정적 필드 / 정적 메소드 정리 - 정적 필드 = static이 붙은 변수 - 정적 메소드 = static이 붙은 메소드 - static이 붙은 필드를 가진 클래스가 로딩이 되면 이 정적필드는 메소드 영역에 저장이되고 자료형에 따라 기본자료형 변수들은 자동초기화됨
package p2022_06_29;
public class NoneObject {
static int number = 3; // 정적 필드
public static void printNumber() { // 정적 메소드
System.out.println("number = " + number);
}
}
- 메인메소드없으므로 독립적 실행은 안됨, - 정적필드하나 정적메소드 하나 있는 NoneObject 클래스 - 이 클래스의 필드에 접근하고 메소드를 호출해보자
package p2022_06_29;
public class UseNoneObject {
public static void main( String[] args ) {
//이 방식 잘 안쓴다
NoneObject no = new NoneObject();
System.out.println("no.number = " + no.number);
no.printNumber();
//아래방식을 주로 쓴다
System.out.println("NoneObject.number = " +
NoneObject.number);
NoneObject.printNumber();
}
}
출력 no.number = 3 number = 3 NoneObject.number = 3 number = 3
- NoneObject 클래스는 정적필드와 정적메소드를 가지고 있다 - UseNoneObject 클래스에서 접근할때 객체를 생성한 후 필드와 메소드를 사용할 수도 있지만 - 정적 필드와 정적메소드이므로 이렇게 안쓴다 (가능은 하지만 안쓴다) - 필드 접근/메소드 호출하는 법 : NoneObject 클래스에서 .을 찍어서 정적필드, 정적메소드 로 접근
정적 필드 / 정적 메소드 접근 정리 - 누구나 쓸수있도록 하려고 static 붙인거임-> 객체생성해서 접근하지 않는다 - 결론 : 정적필드 , 정적메소드는 클래스명.필드, 클래스명.메소드() 해서 접근해라
정적 필드의 자동초기화 - 예제 : NoneObject.java 파일
package p2022_06_29;
public class NoneObject {
static int number = 3; // 정적 필드
public static void printNumber() { // 정적 메소드
System.out.println("number = " + number);
}
}
- 에서 static int number 에 3 초기화 안시킨다면? - 자동으로 0으로 초기화시켜주므로 UseNoneObject 에서 실행해보면 0으로 출력됨
정적 멤버변수의 메모리 할당/해제(위 예제) - NoneObject클래스가 로딩되자마자 number는 공유영역에 저장되면서 int형이니 0으로 초기화됨 - number의 값은 프로그램 종료시까지 계속 메모리에 상주함 - static 정적 필드 많이쓰면 메모리 부족
객체를 생성해서 정적필드/정적메소드에 접근(위 예제 부분)
//이 방식 잘 안쓴다
NoneObject no = new NoneObject();
System.out.println("no.number = " + no.number);
no.printNumber();
- 가능은 하다 Q. 그럼 이때 new를 쓰면 정적필드는 어디로 저장될까? (질문하기) -> 그래도 메소드 영역
메모리 정리 - 힙 메모리에 저장 : JVM 시작할때 생성, 객체와 배열 저장, 가비지 콜랙터가 참조되지 않는 즉, 사용될수 없는 객체 제거 - 메소드영역 메모리 : static이 붙은 필드를 가진 클래스가 로딩이 되면 이 정적필드는 메소드 영역에 저장이됨.
static 필드의 의미(그 안의 값)
정적 필드 값의 유지 예시1 : StaticCount.java, Shared.java / 메인메소드는 Shared 클래스에만 있다
package p2022_06_29;
public class StaticCount {
static int number = 3;
}
- 정적 필드 하나만 있다. 프로그램 종료까지 값을 계속 유지함 - 정적필드는 싱글톤을 만들때만 주로 쓴다. 객체를 1개만 생성해서 공유를 한다는 개념인 싱글톤
- 에서 StaticCount 클래스로 sc1라는 객체를 만들었음 - (정적필드, 정적메소드 가진 클래스로 객체 만드는건 자주안하지만 가능하긴 함) - sc1을 통해서 접근 된다!
값의 변화(값이 유지됨) 1. 처음 sc1.number 출력했더니 3 을 출력함 = 초기값이 3임 2. sc1.number++; 해서 sc1통해서 증가시킴 3. sc1.number 출력시 4를 출력함
- 그 후 같은 StaticCount로 sc2 라는 새로운 객체도 만듬
4. 근데 힙메모리 영역이 아니라 메소드 영역이라는 공유영역이기 떄문에 sc2.number로 sc2에 접근해서 출력해도 number는 3이 아닌 가장 마지막에 저장한 값 4를 출력시킴 5. sc2.number 로 또 접근해서 ++ 증가시킴 6. sc2.number 출력시 5를 출력
- 마지막엔 객체가 아닌 StaticCount.number 로, 즉 클래스 명으로 접근한다 6. StaticCount.number 를 ++ 7. 출력하면 6이 나옴
정적 필드 값의 유지 예시2 : StaticTest01.java
package p2022_06_29;
class StaticTest {
static int a = 10; // 정적 필드 : 메소드영역(공유영역) 에 저장
int b = 20; // 인스턴스 멤버변수 : heap 메모리에 저장
}
class StaticTest01 {
public static void main(String[] args) {
System.out.println("StaticTest.a->" + StaticTest.a);
StaticTest s1 = new StaticTest();
StaticTest s2 = new StaticTest();
System.out.println("s1.a->" + s1.a + "\t s2.a->" + s2.a);
System.out.println("s1.b->" + s1.b + "\t s2.b->" + s2.b);
s1.a = 100;
System.out.print("s1.a->" + s1.a);
System.out.println("\t s2.a->" + s2.a + " ");
System.out.println(StaticTest.a);
s1.b = 200;
System.out.print("s1.b->" + s1.b);
System.out.println("\t s2.b->" + s2.b);
}
}
- StaticTest01이 메인메소드가지고 있다 - StaticTest 클래스에는 static 정적 변수 1개, 일반적인 필드 1개 이렇게 있다 - 이런 일반적인 필드 는 instance 변수 또는 instance 필드 라고 부름 - 즉 a는 정적필드 b는 인스턴스필드
정적필드와 인스턴스 필드 비교 - StaicTest.a 는 정적필드기 때문에 클래스명. 으로 접근 가능 - 이때 초기값이 10으로 있기떄문에 10으로 출력됨
- 그 후 StaticTest 클래스로 new해서 객체 2개를 생성함 s1, s2 - new연산자로 할떄마다 힙메모리상에 새로운 공간을 할당받음 - 그래서 인스턴스 멤버변수인 b는 힙 메모리상에 할당받음 - 정적 변수인 a는 그대로 공유 영역에 있음
현재 상태 a=10 //정적 멤버변수 (공유영역)
s1 -------> b=20 s2 -------> b=20
(Stack영역) (Heap영역)
초기 상태 - b는 s1의 b, s2의 b 각각 있고, 힙메모리 상에 20으로 각각 있다. - 이 값의 주소를 s1, s2가 스택메모리에서 갖고 있음
- a는 정적멤버변수라서 공유영역(메소드영역) 에 초기값 10을 저장하고 있는 상태 - 그래서 s1.a, s2.a는 10으로 출력됨 s1.b나 s2.b는 20으로 출력됨
변화 - s1.a 에 접근해서 값을 100으로 수정함 - s1.b 에 접근해서 값을 200으로 수정함
a=100 //정적멤버변수 (공유영역)
s1 -------> b=200 s2 -------> b=20
(Stack영역) (Heap영역)
변화된 상태 - s1.a 와 s2.a 모두 출력시 100이 나옴 - 또한 클래스명으로 접근한 StaticTest.a 해도 100이 출력됨 - 즉 a는 가장 마지막으로 저장된 값이 공유됨
정적필드와 인스턴스 필드의 비교 - 정적 필드들은 마지막에 저장된 값을 계속 공유함 - 인스턴스 필드들은 클래스를 가지고 객체 생성할때마다 힙 공간 할당받으며 각각 초기값을 가지게 됨
정적 필드와 접근제어자 예제 : StaticTest02,03,04
StaticTest02.java
package p2022_06_29;
class StaticTest2 {
private static int a = 10; // 정적 필드
private int b = 20; // 인스턴스 필드
public static void setA(int new_a) { // 정적 메소드
a = new_a;
}
public static int getA() { // 정적 메소드
return a;
}
}
public class StaticTest02 {
public static void main(String[] args) {
// System.out.println(StaticTest2.a); //a가 private으로 선언되어서 컴파일 에러 발생
System.out.println(StaticTest2.getA());
StaticTest2 s1 = new StaticTest2();
StaticTest2 s2 = new StaticTest2();
s1.setA(10000);
int res1 = s1.getA();
System.out.println(res1);
System.out.println(s2.getA());
}
}
출력 10 10000 10000
- StaticTest2.a 로 접근이 안된다. - 이유 : 아무리 정적필드라도 외부클래스의 접근을 허용하지 않는 private 이 a 앞에 붙어서 다른 클래스인 StaticTest02 에서 접근시 에러 생김
private static int a = 10;
- 모순이 발생한다 - static은 공유를 하겠다는거고 private은 보호를 하는거라서 컴파일상 오류를 발생시키며 접근이 불가능하다. - 결과적으로는 클래스명으로 접근하는 것이 허용되지 않음
private인 static 필드값 가져오는 방법 - getA() 메소드를 이용해서 접근한다 - getA() 메소드는 정적 메소드이고 public 이라 클래스명으로 접근가능하다\ ex)
System.out.println(StaticTest2.getA());
- 가능하다, 10이 출력됨
private인 static 필드값 설정하는 방법 (위 예제 부분)
StaticTest2 s1 = new StaticTest2();
StaticTest2 s2 = new StaticTest2();
s1.setA(10000);
int res1 = s1.getA();
System.out.println(res1);
System.out.println(s2.getA());
- StaticTest2로 새로운 객체 2개 s1, s2 생성함 - setA 메소드는 public static 이라 호출 가능하다. 클래스명으로 접근 가능하지만 이렇게 s1.setA(10000)처럼 객체로 접근도 되긴함 - s1.set(10000)으로 a값을 10000으로 셋팅 - s1.getA() 해서 접근도 되고, s2.getA() 해서도 됨 둘다 출력시 10000 됨
정적 필드와 접근제어자 결론 - private static하면 모순이 생겨서 결국은 다른 클래스에서 접근 못하는 필드임 - 그래서 StaticTest2.a가 에러생김(다른 클래스에서 호출하였기 떄문에) -> private이 붙으면 정적 static 필드라도 다른 클래스에서 접근이 불가능함
정적 필드와 접근제어자 주의 - 정적 메소드 안에는 정적 필드만 사용가능함 (중요) - 정적 메소드 안에 일반적인 필드 쓰면 오류발생 (저장영역과 기능이 다르기 떄문에) - 정적메소드와 일반메소드는 기능이 다름
정적 필드 / 정적 메소드 주의 예제1 : StaticTest03
package p2022_06_29;
class StaticTest3 {
private static int a = 10; // 정적 필드
private int b = 20;
public static void printA() { // 정적 메서드에서는 this를 사용하지 못함
System.out.println(a);
// System.out.println(b); //정적메소드 안에는 일반적인 필드 사용불가
// System.out.println(this.a); //컴파일 에러 발생
}
public void printB() { // this는 인스턴스 메서드에서 여러 객체에 의해서
System.out.println(b); // 메서드가 호출될 때 이를 구분하기 위해서 사용된다.
}
}
public class StaticTest03 {
public static void main(String[] args) {
StaticTest3.printA();
StaticTest3 s1 = new StaticTest3();
StaticTest3 s2 = new StaticTest3();
s1.printB();
s2.printB();
}
}
정적메소드를 쓸 때 주의사항
1. 정적 메소드에서는 this 레퍼런스 변수를 사용할 수 없다. - this.는 힙메모리의 주소를 참조하는게 this.이고, this.는 개별적인 객체에 대한 주소를 가진 레퍼런스 변수라서 정적메소드 안에선 this. 를 사용할 수 없다
2. 정적 메소드에서는 일반적인 변수(인스턴스 필드)를 사용할 수 없다. - 정적 메소드에서는 정적멤버변수만 사용가능함 - 일반적인 필드 = 힙메모리 이고, 정적필드 = 메소드 메모리(영역) 이라서 영역이 다르기 때문
3. 정적 메소드는 메소드 오버라이딩되지 않는다. - static이 붙은 정적메소드는 메소드 오버라이딩이 되지 않는다.
+ 메소드 오버라이딩 : 두 클래스 사이 상속관계가 있을때, 부모로부터 상속되는 필드와 메소드 중, 메소드를 상속받을때, 이름과 형식은 똑같이 하면서 내부 내용은 다르게 쓰는 것.
정적 필드 / 정적 메소드 주의 예제2 : StaticTest04
package p2022_06_29;
class StaticTest4 {
private static int a = 10; // 정적필드
private int b = 20;
public static void printA() {
System.out.println(a);
// System.out.println(b); //컴파일 에러 발생 : 정적메소드 안 일반필드
}
public void printB() {
System.out.println(b);
}
}
public class StaticTest04 {
public static void main(String[] args) {
StaticTest4.printA();
StaticTest4 s1 = new StaticTest4();
StaticTest4 s2 = new StaticTest4();
s1.printB();
s2.printB();
}
}
- 정적메소드 안에는 정적필드만 사용가능하다 - 일반 메소드 안에서만 일반필드 사용가능 - 정적 메소드 , 정적 필드는 클래스명. 해서 사용함 ! StaticTest4.printA(); - 하지만 객체를 만들어서 객체.메소드 해서도 메소드 호출가능, 객체.필드 해서 필드 접근하는것도 가능
StaticTest4 s1 = new StaticTest4();
StaticTest4 s2 = new StaticTest4();
s1.printB();
s2.printB();
Math 클래스 (API 문서)
- 모두 정적필드 뿐 - 모두 정적메소드 뿐 - Math 클래스를 가지고 정적 필드와 정적메소드를 사용해보자
Math의 정적필드 2개 - E - PI
Math의 생성자 - 생성자 자체가 없다 - 생성자는 제공되지 않는데 쓸수없다 Math 클래스로 new해서 객체생성하면 오류발생
Math의 메소드 - 모두 static 붙은 정적 메소드 -> 굳이 객체를 생성할 필요도 없다 - 그냥 Math.E , Math.random() 으로 쓰면됨
Math 클래스의 필드 사용 예제 + Math라는 이름으로 사용자 지정 클래스 생성할 수 없다. 라이브러리에 이미 쓰고 있는 이름이라서
ex) max(int a, int b) , max(double a, double b) 등 - 2개짜리 매개변수 있는 메소드들만 있다 - 자바에는 2개짜리만 제공함 -> 3개 이상이 필요하면 내가 만들어서 써야함 (파이썬은 제한 없음) - 10과 20중 큰 값을 return 구문으로 돌려줌
우리가 쓰는 Scanner 객체 생성하고 안에 System.in 썼던 이유 - Scanner 클래스를 찾아보면 Scanner(InputStream source)라는 생성자 가 있다. - Scanner 생성자의 매개변수가 InputStream 타입이라서 - Scanner 객체 생성할때 생성자의 매개변수가 System.in 이었다 - System.in의 리턴형을 보면 InputStream 이다 + in은 static이 붙은 정적필드라서 System.in 이라고 쓴다.
