12일차_클래스

-----------------------------
클래스 선언하기

1. 클래스 기본형식

[접근제어자(접근지정자)] class 클래스이름 {

 //멤버변수
 private 자료형 변수명;
 //멤버변수를 위한 getter, setter 메소드 등록
 public void set변수명(외부 데이터) {
  this.변수명 = 외부 데이터;
 }
 public 자료형 get변수명() {
  return this.변수명;
 }

 //메소드
 public 자료형 메소드이름(매개변수) {
  //액션 코드
 }

}

2. 기본 규칙

- class 키워드

- 클래스 이름은 첫 글자를 대문자로 지정하고, 식별자 작성 규칙을 따른다.

- 클래스 범위는 { } 로 표기.

- 클래스 내부에는 멤버를 자유롭게 구성. 멤버변수, 메소드(일반, getter, setter,  생성자)로만 구성된다.

- 멤버변수는 클래스의 객체 상태를 저장할 때 사용. 속성으로 표현되기도 한다.

- 메소드는 클래스의 기능을 구현할 때 사용. 특수 목적으로 setter, getter, 생성자 메소드가 있다.

 

- 접근지정자(접근제어자)는 주로 public 를 사용하거나, 생략하는 경우만 있다. public를 사용하는 경우는 독립적인 물리적 저장이 가능한 상태이고, 외부에서 해당 클래스를 접근할 수 있다는 의미이다. 생략하는 경우는 독립적인 물리적 저장은 가능하지만, 외부에서 접근이 제한된다.

- 물리적 .java 파일은 하나의 클래스만 존재하는 경우가 일반적이지만 물리적 .java 파일 하나 안에 두 개 이상의 클래스가 존재할 수 있다. 이때는 물리적 파일명과 같은 이름을 가진 클래스가 존재해야 하고, public 접근지정자가 붙어 있어야 한다. 다른 클래스는 접근지정자를 붙일 수 없다.

- 클래스는 서로 독립적인 상태이므로 필요시 다른 클래스의 객체를 생성해서 사용할 수 있다. 클래스의 객체가 생성된 후에는 해당 클래스의 접근 가능한 멤버를 사용할 수 있다.

 

 

//Sample01.java
public class Sample01 {
 //사용자 지정 멤버가 존재하지 않는 경우
 //모든 클래스는 내부적으로 기본 멤버를 가지도록 되어 있다.
}

 

//Main01.java
package com.test;

public class Main01 {

 public static void main(String[] args) {
  
  Sample01 sample1 = new Sample01();
  System.out.println(sample1.toString());

  Sample01 sample2 = new Sample01();
  System.out.println(sample2.toString());

 }

}

 

 

//Sample02.java
package com.test;

public class Sample02 {
 
 //멤버변수만 있는 경우
 //멤버변수 역할
 //-> 객체의 상태값 저장
 //-> 외부의 직접적인 영향에 대해 독립적인 것이 좋다.
 //private 자료형 변수명; //->자동 초기화
 //private 자료형 변수명 = 초기값;
 int a = 10;  //-> default 접근제어자
 private int b = 20; //-> private 접근제어자
 public int c = 30; //-> public 접근제어자

}

 

//Main02.java
package com.test;

public class Main02 {

 public static void main(String[] args) {

  Sample02 sample = new Sample02();
  
  sample.a = 100; //직접 영향
  System.out.println(sample.a);
  //sample.b = 200; //X -> private 멤버는 접근 불가
  sample.c = 200; //직접 영향
  System.out.println(sample.c);

 }

}

 

 

 

//Sample03.java
package com.test;

public class Sample03 {
 
 //멤버변수만 있는 경우
 //멤버변수 역할
 //-> 객체의 상태값 저장
 //-> 외부의 직접적인 영향에 대해 독립적인 것이 좋다.
 //private 자료형 변수명; //->자동 초기화
 //private 자료형 변수명 = 초기값;
 private int a = 10;
 private int b = 20;
 private int c = 30;
 
 public void setA(int a) {
  this.a = a;
 }
 public int getA() {
  return this.a;
 }
 public void setC(int c) {
  if (c>=0 && c<=100) {
   this.c = c;
  }
 }
 public int getC() {
  return c;
 }

}

 

 

//Main03.java
package com.test;

public class Main03 {

 public static void main(String[] args) {

  Sample03 sample = new Sample03();

  /*
  sample.a = 100; //X -> setter 대체
  System.out.println(sample.a); //X -> getter 대체
  //sample.b = 200; //X -> private 멤버는 접근 불가
  sample.c = 200; //X
  System.out.println(sample.c); //X
  */
  sample.setA(100); //->간접적인 방법으로 데이터 저장
  System.out.println(sample.getA());
  sample.setC(200); //데이터 저장 거부. 0~100만 허용.
  System.out.println(sample.getC()); //초기값 30 출력

 }

}

 

 

 

 

//Sample04.java
class Sample04 {
 
 //접근지정자(public)가 생략된 클래스 작성
 //외부(패키지)에서 접근이 제한된 클래스가 된다.
 //내부(패키지)에서는 접근이 가능하다.

}

 

//Main04.java -> 같은 패키지
package com.test;

public class Main04 {

 public static void main(String[] args) {

  Sample04 sample = new Sample04(); //O
  System.out.println(sample.toString());

 }

}

 

//Main04.java -> 다른 패키지
package com.sist;

import com.test.*;

public class Main04 {

 public static void main(String[] args) {

  Sample04 sample = new Sample04(); //X
  System.out.println(sample.toString());
  
 }

}

 

//Sample05.java
//나머지 클래스는 접근지정자 생략 (같은 패키지 내에서만 접근 가능)
class Sample06 {
 
}

//물리적 파일명과 일치하는 클래스만 public 지정
public class Sample05 {

}

//Sample07.java
class Sample08 {
 public void method() {
  System.out.println("Sample08 클래스의 메소드!");
 }
}

public class Sample07 {
 public void method() {
  Sample08 s8 = new Sample08();
  s8.method();
 }
}

----------------------------------------
산술연산 메소드가 포함된 클래스 작성

산술연산 목표->클래스->Calculator->멤버 구성->더하기 기능을 가진 메소드, 빼기, 곱하기, 나누기 기능을 가진 메소드 구성

//Calculator.java
package com.test;

public class Caculator {
 
 //산술적 연산 수행하는 계산기 기능 구현
 //더하기, 빼기, 곱하기, 나누기
 //외부 데이터 -> 2개 -> 정수 -> 매개 변수 2개 준비
 //결과값은 더하기, 빼기, 곱하기인 경우 정수
 //결과값은 나누기인 경우 실수
 
 //더하기 메소드
 public int add(int op1, int op2) {
  //지역변수
  int result = 0;
  result = op1 + op2;
  return result;
 }
 
 //빼기 메소드
 public int sub(int op1, int op2) {
  int result = 0;
  result = op1 - op2;
  return result;
 }
 
 //곱하기 메소드 -> multi
 public int multi(int op1, int op2) {
  int result = 0;
  result = op1 * op2;
  return result;
 }
 
 //나누기 메소드 -> div
 //정수/정수 -> 정수(몫)
 //정수/(double)정수 -> 실수
 //-> 0으로는 나눌 수 없습니다(예외)
 public double div(int op1, int op2) {
  double result = 0;
  result = op1 / (double)op2;
  return result;
 }
 
 
 //10진수 입력(int)시 2진수 반환(String) 메소드 -> bin

 public String bin(int dec) {
  String result = "";

  do {
  
   result = String.valueOf(dec%2) + result;
   dec /= 2;

  }while(dec>0);

  return result;
 }

 

 

 

 

 

}

 

//Main05.java
package com.test;

public class Main05 {

 public static void main(String[] args) {
  
  Caculator cal = new Caculator();
  
  int op1 = 10;
  int op2 = 20;
  System.out.printf("%d + %d = %d %n"
     , op1, op2, cal.add(10, 20));
  System.out.printf("%d - %d = %d %n"
    , op1, op2, cal.sub(10, 20));

  //곱하기 결과
  System.out.printf("%d * %d = %d %n"
    , op1, op2, cal.multi(10, 20));
  
  //나누기 결과 -> 실수
  System.out.printf("%d / %d = %f %n"
    , op1, op2, cal.div(10, 20));
  
  //2진수 반환 결과 -> 문자열
  /*
  System.out.printf("%d -> %s %n", op1, cal.bin(op1));
  System.out.printf("%d -> %s %n", op2, cal.bin(op2));
  */
  
 }

}

 

 

//Sample58.java
package com.test;

public class Sample58 {

 public static void main(String[] args) {
  
  //멤버가 없는 클래스에 대한 객체 생성
  ClassTest01 test01 = new ClassTest01();
  //멤버가 없는 클래스이지만 내부적으로 기본 멤버가 존재한다.
  System.out.println(test01.toString());
  
  //멤버가 있는 클래스에 대한 객체 생성
  ClassTest02 test02 = new ClassTest02();
  //setter 메소드 호출
  test02.setA(10);
  //void 가 지정된 메소드는 출력 대상이 될 수 없다.
  //System.out.println(test02.setA(10));
  //getter 메소드 호출
  System.out.println(test02.getA());
  
  //같은 .java 파일 안에 있는 클래스들의 객체 생성
  SubClassTest03 subtest03 = new SubClassTest03();
  subtest03.method();
  ClassTest03 test03 = new ClassTest03();
  test03.method();
  
  //계산기 클래스에 대한 객체 생성
  Calculator cal = new Calculator();
  //더하기 기능을 가진 메소드 호출
  System.out.println(cal.add(10, 20));
  //문제) 빼기, 곱하기, 나누기 연산 메소드 호출
  
  

 }

}

 

 

//ClassTest01.java
package com.test;

public class ClassTest01 {
 
 //멤버가 없는 클래스

}

 

 

//ClassTest02.java
package com.test;

public class ClassTest02 {
 
 //멤버변수
 private int a;
 //getter
 public int getA() {
  return this.a;
 }
 //setter
 public void setA(int a) {
  this.a = a;
 }
 
 //메소드
 //return 값이 없는 메소드에는 void 키워드 지정
 public void method() {
  
 }

}

 

//ClassTest03.java
package com.test;

//물리적 .java 파일 안에 논리적 클래스 추가가 가능하다
//public 접근지정자는 사용할 수 없다.
//논리적으로는 서로 독립된 상태이다.
class SubClassTest03 {
 public void method() {
  
 }
}

public class ClassTest03 {
 public void method() {
  //같은 .java 파일 안에 있는
  //다른 클래스에 대한 객체 생성 과정
  SubClassTest03 sub = new SubClassTest03();
  sub.method();
 }
}

 

//Calculator.java
package com.test;

public class Calculator {
 
 //산술 연산 기능을 메소드로 추가
 //add, sub, multi, div
 public int add(int op1, int op2) {
  return op1 + op2;
 }
 
 public int sub(int op1, int op2) {
  return op1 - op2;
 }
 
 //문제) 곱하기, 나누기 연산 메소드 추가
 public int multi(int op1, int op2) {
  return op1 * op2;
 }
 
 public double div(int op1, int op2) {
  //return op1 / op2; //암시적 형변환
  return op1 / (double)op2; //명시적 형변환
 } 

}

 

 

 

----------------------------------
자료형으로서의 클래스 사용

이름, 국어, 영어, 수학이라는 자료를 저장하고 처리하는 과정

이름 -> String
국어, 영어, 수학 -> int
총점 -> int

한 명분의 성적을 처리하는 데는 String, int 변수만 있어도 가능.
여러 명분의 성적을 처리하려면 배열을 준비해야 한다.
배열 여러개를 준비해야만 모든 자료를 처리할 수 있습니다.

성적 데이터의 구성 요소 -> 이름, 국어, 영어, 수학, 총점

성적 데이터를 표현 -> ? 자료형 -> 복합적인 자료를 하나의 데이터를 취급 -> 클래스(사용자 정의 자료형)

성적 클래스 정의
-> 멤버 : 이름, 국어, 영어, 수학, 총점
-> 멤버변수:이름(String), 국어(int), 영어(int), 수학(int)
   메소드:총점(int, 국어+영어+수학 연산)

//Score.java
package com.test;

public class Score {
 
 //사용자 정의 자료형 클래스
 //멤버변수 -> 이름, 국어, 영어, 수학 데이터
 private String name;
 private int kor, eng, mat;
 
 //getter, setter 메소드 추가
 /*
 public 자료형 get변수명() {
  return this.변수명;
 }
 public void set변수명(자료형 변수명) {
  this.변수명 = 변수명;
 }
 */
 public void setName(String name) {
  this.name = name;
 }
 public String getName() {
  return this.name;
 }
 public void setKor(int kor) {
  this.kor = kor;
 }
 public int getKor() {
  return this.kor;
 }
 public void setEng(int eng) {
  this.eng = eng;
 }
 public int getEng() {
  return this.eng;
 }
 public void setMat(int mat) {
  this.mat = mat;
 }
 public int getMat() {
  return this.mat;
 }
 
 public int getTotal() {
  int result = 0;
  result = kor + eng + mat;
  return result;
 }
 
 //문제) 평균 계산 메소드 추가 -> getAve()
 public double getAve() {
  double result = 0;
  result = (kor + eng + mat)/3.0;
  return result;
 }
 
 

}

 

 

//Main05.java
package com.test;

public class Main05 {

 public static void main(String[] args) {
  
  Score score = new Score();
  score.setName("HONG");
  score.setKor(100);
  score.setEng(100);
  score.setMat(100);

  System.out.printf("%s %d %d %d %n"
    , score.getName()
    , score.getKor()
    , score.getEng()
    , score.getMat());
  
 }

}

 

 

//Main06.java
package com.test;

public class Main06 {

 public static void main(String[] args) {
  
  //Score 객체 여러개를 저장할 수 있는 배열 준비
  Score[] array = new Score[5];
  
  //입력 과정
  Score score = new Score();
  score.setName("PARK");
  score.setKor(100);
  score.setEng(100);
  score.setMat(100);
  array[0] = score;

  //출력 과정
  System.out.printf("%s %d %d %d %d %n"
    , score.getName()
    , score.getKor()
    , score.getEng()
    , score.getMat()
    , score.getTotal());

 }

}

 

 

 

//Main07.java
package com.test;

import java.util.*;

public class Main07 {

 public static void main(String[] args) {

  //입력 과정 -> 외부 입력
  Scanner sc = new Scanner(System.in);
  System.out.print("입력 범위(1~n)?");
  int n = sc.nextInt();
  Score[] array = new Score[n];
  for (int i=0; i<array.length; ++i) {
   System.out.printf("이름(%d) 국어 영어 수학?", (i+1));
   Score score = new Score();
   score.setName(sc.next());
   score.setKor(sc.nextInt());
   score.setEng(sc.nextInt());
   score.setMat(sc.nextInt());
   array[i] = score;
  }
  sc.close();
  
  //출력 과정
  System.out.println("이름 국어 영어 수학 총점 평균");
  for (int i=0; i<array.length; ++i) {
   Score score = array[i];
   System.out.printf("%s %d %d %d %d %f %n"
     , score.getName()
     , score.getKor()
     , score.getEng()
     , score.getMat()
     , score.getTotal()
     , score.getAve());
  }

 }

}

 

 

 

 

 

-----------------------------------------
자료형으로서의 클래스 사용

이름, 전화번호, 이메일 저장용 클래스 작성 및 데이터 저장,출력 액션.

회원 클래스
-> 멤버 : 이름, 전화번호, 이메일
-> 멤버변수 : 이름(String), 전화번호(String), 이메일(String)
   메소드 : getter,setter

실행 예)
회원 추가 ----------------------
입력 범위(1~n)?2
회원(1)?kim 010-111-2222 kim@test.com
회원(2)?park 010-233-1233 park@nate.com

-------------------------------
kim 010-111-2222 kim@test.com
park 010-233-1233 park@nate.com
--------------------------------
총 2명
--------------------------------

//MemberInfo.java
package com.test;

public class MemberInfo {
 
 //이름, 전화번호, 이메일 저장용 클래스
 //멤버변수, getter, setter
 /*
 private String name;
 private String telephone;
 private String email;
 */
 private String name, telephone, email;
 
 public String getName() {
  return name;
 }
 public void setName(String name) {
  this.name = name;
 }

 //문제) telephone, email 멤버변수에 대한 getter, setter 작성.
 public String getTelephone() {
  return telephone;
 }
 public void setTelephone(String telephone) {
  this.telephone = telephone;
 }
 public String getEmail() {
  return email;
 }
 public void setEmail(String email) {
  this.email = email;
 }
 
}

 

 

//Main.java
package com.test;

import java.util.*;

public class Main {

 public static void main(String[] args) {
  
  //입력 과정 -> 화면 구성, 액션
  //저장소->배열
  //->이름, 전화번호, 이메일 정보 저장
  //->MemberInfo 클래스
  //->배열의 자료형 -> MemberInfo 클래스 자료형
  //->MemberInfo 객체 저장 액션
  Scanner sc = new Scanner(System.in);
  
  //배열의 크기 지정하는 과정
  System.out.print("입력범위(2~n)?");
  int n = sc.nextInt();
  MemberInfo[] array = new MemberInfo[n];
  
  //배열 크기 만큼 반복해서 입력 받는 과정
  for (int i=0; i<array.length; ++i) {
   //이름, 전화번호, 이메일 정보를 입력 받는 과정
   System.out.print("이름 전화번호 이메일?");
   //한 명분의 정보를 저장할 수 있는 MemberInfo 객체 생성하는 과정
   MemberInfo memberInfo = new MemberInfo();
   //한 명분의 이름, 전화번호, 이메일 정보를
   //외부에서 받고, 그 정보를 객체에 저장하는 과정
   memberInfo.setName(sc.next());
   memberInfo.setTelephone(sc.next());
   memberInfo.setEmail(sc.next());
   //외부 데이터가 저장된 MemberInfo 객체의
   //참조주소를 배열에 저장하는 과정
   array[i] = memberInfo;
  }
  
  sc.close();
  
  //출력 과정 -> 화면 구성, 액션
  System.out.println("-------------------------------------");
  System.out.printf("총 %d명 %n", n);
  System.out.println("-------------------------------------");
  //출력서식에서 %-10s는 10자리 공간에 문자열 출력하되, 왼쪽부터 출력된다는 뜻
  System.out.printf("%-10s %-15s %-15s %n"
    , "NAME","TELEPHONE", "EMAIL");
  //배열(저장소)에 저장된 MemberInfo 객체를
  //순차적으로 꺼내서 화면에 출력하는 과정
  for (int i=0; i<array.length; ++i) {
   MemberInfo memberInfo = array[i];
   //출력 서식의 갯수(자료형)와
   //데이터의 갯수(자료형)는 일치해야 한다.
   //정수 출력시->%d
   //실수 출력시->%f
   //문자열 출력시->%s
   //줄바꿈->%n
   System.out.printf("%-10s %-15s %-15s %n"
     ,memberInfo.getName()
     ,memberInfo.getTelephone()
     ,memberInfo.getEmail());
  }

 }

}

 

-------------------------------------------------
요약

1. 클래스 - 데이터 표현하는 방법

2. 객체 지향 프로그래밍의 기본적인 단위.
객체 지향 프로그램 -> 클래스(기관차, 객차, 식당차...)의 집합 또는 조합.

3. 클래스 설계 -> 멤버 구성 -> 멤버변수, 메소드(일반, getter, setter, 생성자)

4. 멤버변수는 접근지정자(접근제어자)를 private으로 지정. 외부에서 접근 불가능. 외부에서 멤버변수 접근을 위해서 getter, setter 준비.

5. 메소드는 접근지정자(접근제어자)를 public으로 지정. 외부에서 접근 가능.

6. 객체 생성 과정을 통해서 클래스 사용. new 연산자 이용.

 

 

 

 

 

----------------------------------------