Java의 세터와 게터의 요점은 무엇입니까? [복제하다

Question

이 질문은 이미 여기에 답이 있습니다.

• 왜 게터와 세터/액세서를 사용합니까? [닫은 38 답변

길이를 용서 해주십시오. 그러나 여기에는 정확히 동일하지만 세트가없는 두 가지 프로그램이 있습니다.

나는 전에 기본적인 C ++ 클래스를 가져 갔고 그것에서 이것들 중 어느 것도 기억하지 못합니다. 현재 나는 그들의 요점을 보지 못합니다. 누군가가 Lamen의 용어로 설명 할 수 있다면 감사합니다 .. . 순간에 그들은 코드를 더 길게 보이게하는 우주 낭비자에 지나지 않는 것처럼 보이지만 교사는 중요하다고 말합니다 (지금까지는 그게 그다지).

미리 감사드립니다! 그리고 이제 코드는 다음과 같습니다. MILEAGE.JAVA :

package gasMileage;

import java.util.Scanner; //program uses class Scanner

public class Mileage 
{
    public int restart;
    public double miles, gallons, totalMiles, totalGallons, milesPerGallon;
    public Mileage(int newRestart, double newMiles, double newGallons, 
                   double newTotalMiles, double newTotalGallons, double newMilesPerGallon)
    {
        setRestart(newRestart);
        setMiles(newMiles);
        setGallons(newGallons);
        setTotalMiles(newTotalMiles);
        setTotalGallons(newTotalGallons);
        setMilesPerGallon(newMilesPerGallon);
    }
    public void setRestart(int newRestart)
    {
        restart = newRestart;
    }
    public int getRestart()
    {
        return restart;
    }
    public void setMiles(double newMiles)
    {
        miles = newMiles;
    }
    public double getMiles()
    {
        return miles;
    }
    public void setGallons(double newGallons)
    {
        gallons = newGallons;
    }
    public double getGallons()
    {
        return gallons;
    }
    public void setTotalMiles(double newTotalMiles)
    {
        totalMiles = newTotalMiles;
    }
    public double getTotalMiles()
    {
        return totalMiles;
    }
    public void setTotalGallons(double newTotalGallons)
    {
        totalGallons = newTotalGallons;
    }
    public double getTotalGallons()
    {
        return totalGallons;
    }
    public void setMilesPerGallon(double newMilesPerGallon)
    {
        milesPerGallon = newMilesPerGallon;
    }
    public double getMilesPerGallon()
    {
        return milesPerGallon;
    }
    public void calculateMileage()
    {
        Scanner input = new Scanner(System.in);
        while(restart == 1)
        {
            System.out.print("Please input number of miles you drove: ");
            miles = input.nextDouble();
            totalMiles = totalMiles + miles;
            System.out.print("Please input number of gallons you used: ");
            gallons = input.nextDouble();
            totalGallons = totalGallons + gallons;
            milesPerGallon = miles / gallons;
            System.out.printf("Your mileage is %.2f MPG.\n", milesPerGallon);
            System.out.print("Would you like to try again? 1 for yes, 2 for no: ");
            restart = input.nextInt();
        }
        milesPerGallon = totalMiles / totalGallons;
        System.out.printf("Your total mileage for these trips is: %.2f.\nYour total gas consumed on these trips was: %.2f.\n", totalMiles, totalGallons);
        System.out.printf("Your total mileage for these trips is: %.2f MPG", milesPerGallon);
    }
}

milagetest.java :

package gasMileage;

public class Mileagetest 
{
    public static void main(String[] args) 
    {
        Mileage myMileage = new Mileage(1,0,0,0,0,0);
        myMileage.calculateMileage();
    }
}

그리고 지금은 세터와 게터가없는 사람을 위해 :

testmileage.java :

package gasMileage;

import java.util.Scanner;

public class Testmileage 
{
    int restart = 1;
    double miles = 0, milesTotal = 0, gas = 0, gasTotal = 0, mpg = 0;
    Scanner input = new Scanner(System.in);
    public void testCalculate()
    {
        while(restart == 1)
        {
            System.out.print("Please input miles: ");
            miles = input.nextDouble();
            milesTotal = milesTotal + miles;
            System.out.print("Please input gas: ");
            gas = input.nextDouble();
            gasTotal = gasTotal + gas;
            mpg = miles/gas;
            System.out.printf("MPG: %.2f", mpg);
            System.out.print("\nContinue? 1 = yes, 2 = no: ");
            restart = input.nextInt();
        }
            mpg = milesTotal / gasTotal;
            System.out.printf("Total Miles: %.2f\nTotal Gallons: %.2f\nTotal MPG: %.2f\n", milesTotal, gasTotal, mpg);
    }
}

testmileagetest.java :

package gasMileage;

public class Testmileagetest 
{

    /**
     * @param args
     */
    public static void main(String[] args) 
    {
        Testmileage test = new Testmileage();
        test.testCalculate();
    }

}

다시 한 번 감사드립니다!

Answer 1

게터와 세터의 요점, 언어에 관계없이, 기본 변수를 숨기는 것입니다. 이를 통해 값을 설정하려고 할 때 검증 로직을 추가 할 수 있습니다. 예를 들어 생년월일의 필드가있는 경우 과거에 해당 필드를 한 시간으로 만 설정할 수 있습니다. 필드에 공개적으로 액세스 할 수 있고 수정 가능한 경우이를 시행 할 수 없습니다. 게터와 세터가 필요합니다.

아직 검증이 필요하지 않더라도 앞으로도 필요할 수 있습니다. 이제 Getters와 Setters를 작성하면 인터페이스가 일관성이 유지되므로 변경할 때 기존 코드가 파손되지 않습니다.

Answer 2

다른 답변은 일반적으로 Getters and Setter를 사용하는 몇 가지 이유에 대한 좋은 아이디어를 제공하지만, 왜 유용한 지에 대한 다소 완전한 예를 제시하고 싶습니다.

예를 들어 파일을 가져 가자 ( File 자바에서 수업). 이것 File 클래스에는 파일 유형 (.pdf, .exe, .txt 등)을 저장하기위한 필드가 있습니다 ... 다른 모든 것을 무시할 것입니다.

처음에 당신은 그것을 a로 보관하기로 결정했습니다 String 게터와 세터가없는 :

public class File {
   // ...
   public String type;
   // ...
}

Getters 및 Setter를 사용하지 않는 문제는 다음과 같습니다.

필드 설정 방법에 대한 제어가 없습니다.

수업의 모든 고객은 원하는 것을 할 수 있습니다.

public void doSomething(File file) {
   // ...
   file.type = "this definitely isn't a normal file type";
   // ...
}

나중에 당신은 아마도 그들이 그렇게하기를 원하지 않을 것이라고 결정합니다 ... 그러나 그들이 당신의 수업에서 필드에 직접 접근 할 수 있기 때문에, 당신은 그것을 막을 방법이 없습니다.

내부 표현을 쉽게 변경할 수 없음 :

나중에 여전히 파일 유형을 호출 된 인터페이스 인스턴스로 저장하려고합니다. FileType, 일부 동작을 다른 파일 유형과 연결할 수 있습니다. 그러나 수업의 많은 고객이 이미 파일 유형을 다시 검색하고 설정하고 있습니다. String에스. 그래서 당신은 거기에 문제가있을 것입니다 ... 당신은 많은 코드를 깨뜨릴 것입니다 (당신은 당신이 방금 필드를 String a FileType.

게터와 세터가 이것을 해결하는 방법

이제 대신 유형 필드를 만들었다고 상상해보십시오. private 그리고 만들어졌습니다

public String getType() {
   return this.type;
}

public void setType(String type) {
   this.type = type;
}

속성 설정에 대한 제어 :

이제 특정 문자열 만 유효한 파일 유형이고 다른 문자열을 방지해야한다는 요구 사항을 구현하려면 다음과 같이 쓸 수 있습니다.

public void setType(String type) {
   if(!isValidType(type)) {
       throw new IllegalArgumentException("Invalid file type: " + type);
   }
   this.type = type;
}

private boolean isValidType(String type) {
   // logic here
}

내부 표현을 쉽게 변경하는 기능 :

변경 String 유형의 표현은 비교적 쉽습니다. 당신이 있다고 상상해보십시오 enum ValidFileType 그것을 구현합니다 FileType 유효한 유형의 파일이 포함되어 있습니다.

클래스에서 파일 유형의 내부 표현을 쉽게 변경할 수 있습니다.

public class File {
   // ...
   private FileType type;
   // ...
   public String getType() {
      return type.toString();
   }

   public void setType(String type) {
      FileType newType = ValidFileType.valueOf(type);

      if(newType == null) {
         throw new IllegalArgumentException("Invalid file type: " + type);
      }

      this.type = newType;
   }
}

수업의 고객이 전화를했기 때문에 getType() 그리고 setType() 어쨌든, 그들의 관점에서 아무것도 변하지 않습니다. 다른 클래스가 사용하는 인터페이스가 아니라 클래스의 내부 만 변경되었습니다.

Answer 3

캡슐화

액세서 방법 ( "세터 및 getters")은 객체의 데이터가 저장되는 방법에 대한 세부 사항을 숨기려고 시도합니다. 실제로, 그들은 객관적이지 않은 방식으로 데이터를 저장하고 검색하는 영광스러운 수단입니다. 액세서는 다음 두 코드 사이에 실질적인 차이가 거의 없다는 점에서 효과적으로 아무것도 캡슐화하지 않습니다.

Person bob = new Person();
Colour hair = bob.getHairColour();
hair.setRed( 255 );

이:

Person bob = new Person();
Colour hair = bob.hairColour;
hair.red = 255;

두 코드 스 니펫은 사람이 머리카락에 밀접하게 결합되어 있다는 아이디어를 드러냅니다. 이 단단한 커플 링은 코드베이스 전체에 걸쳐 자체적으로 나타나서 부서지기 쉬운 소프트웨어를 나타냅니다. 즉, 사람의 머리카락이 저장되는 방식을 바꾸는 것이 어려워집니다.

대신에:

Person bob = new Person();
bob.setHairColour( Colour.RED );

이것은 "Tell, Do n't Ask"의 전제를 따릅니다. 다시 말해, 객체는 (다른 객체에 의해) 특정 작업을 수행하도록 지시해야합니다. 이것이 객체 지향 프로그래밍의 요점입니다. 그리고 거의 사람들이 그것을 얻는 것 같습니다.

두 시나리오의 차이점은 다음과 같습니다.

• 첫 번째 상황에서 밥은 머리카락이 어떤 색이 될지 통제 할 수 없었습니다. 붉은 머리를위한 렌트가있는 헤어 스타일리스트에게는 좋습니다. 그 색상을 멸시하는 밥에게는 그리 좋지 않습니다.
• 두 번째 상황에서 Bob은 시스템의 다른 물체가 Bob의 허가없이 해당 색상을 변경할 수 없기 때문에 머리카락이 어떤 색상이 될지 완전히 제어합니다.

이 문제를 피하는 또 다른 방법은 Bob의 머리 색깔 (새 인스턴스)의 사본을 더 이상 Bob과 결합하지 않는 것입니다. 나는 다른 계급이 사람의 머리카락을 사용하여 더 이상 사람 자체와 관련이없는 행동이 있기 때문에 우연한 해결책이라는 것을 알았습니다. 이는 코드를 재사용하는 기능을 줄이며, 이로 인해 복제 된 코드가 발생합니다.

데이터 유형 숨기기

리턴 유형에 의해서만 다른 두 개의 메소드 서명을 가질 수없는 Java에서는 실제로 객체에서 사용하는 기본 데이터 유형을 숨기지 않습니다. 당신은 다음을 거의 보지 못할 것입니다.

public class Person {
  private long hColour = 1024;

  public Colour getHairColour() {
    return new Colour( hColour & 255, hColour << 8 & 255, hColour << 16 & 255 );
  }
}

일반적으로 개별 변수에는 해당 액세서를 사용하여 데이터 유형 노출 구두가 있으며이를 변경하려면 리팩토링이 필요합니다.

public class Person {
  private long hColour = 1024;

  public long getHairColour() {
    return hColour;
  }

  /** Cannot exist in Java: compile error. */
  public Colour getHairColour() {
    return new Colour( hColour & 255, hColour << 8 & 255, hColour<< 16 & 255 );
  }
}

그것은 추상화 수준을 제공하지만 느슨한 커플 링을 위해 아무것도하지 않는 얇은 베일입니다.

묻지 마세요

이 접근법에 대한 자세한 내용은 읽으십시오 묻지 마세요.

파일 예제

Colind의 답변에서 약간 수정 된 다음 코드를 고려하십시오.

public class File {
   private String type = "";

   public String getType() {
      return this.type;
   }

   public void setType( String type ) {
      if( type = null ) {
        type = "";
      }

      this.type = type;
   }

   public boolean isValidType( String type ) {
      return getType().equalsIgnoreCase( type );
   }
}

방법 getType() 이 경우에는 중복되며 필연적으로 (실제로) 다음과 같은 중복 코드로 이어집니다.

public void arbitraryMethod( File file ) {
  if( file.getType() == "JPEG" ) {
    // Code.
  }
}

public void anotherArbitraryMethod( File file ) {
  if( file.getType() == "WP" ) {
    // Code.
  }
}

문제 :

• 데이터 형식. 그만큼 type 속성은 문자열에서 정수 (또는 다른 클래스)로 쉽게 변경할 수 없습니다.
• 묵시적 프로토콜. 특정 유형에서 유형을 추상화하는 데 시간이 많이 걸립니다 (PNG, JPEG, TIFF, EPS) 장군에게 (IMAGE, DOCUMENT, SPREADSHEET).
• 버그를 소개합니다. 묵시적 프로토콜을 변경하면 컴파일러 오류가 발생하지 않아 버그가 발생할 수 있습니다.

다른 클래스를 방지하여 문제를 피하십시오 질문 데이터 용 :

public void arbitraryMethod( File file ) {
  if( file.isValidType( "JPEG" ) ) {
    // Code.
  }
}

이것은 변화를 의미합니다 get 액세서 방법 private:

public class File {
   public final static String TYPE_IMAGE = "IMAGE";

   private String type = "";

   private String getType() {
      return this.type;
   }

   public void setType( String type ) {
      if( type == null ) {
        type = "";
      }
      else if(
        type.equalsIgnoreCase( "JPEG" ) ||
        type.equalsIgnoreCase( "JPG" ) ||
        type.equalsIgnoreCase( "PNG" ) ) {
        type = File.TYPE_IMAGE;
      }

      this.type = type;
   }

   public boolean isValidType( String type ) {
      // Coerce the given type to a generic type.
      //
      File f = new File( this );
      f.setType( type );

      // Check if the generic type is valid.
      //
      return isValidGenericType( f.getType() );
   }
}

시스템의 다른 코드는 File 클래스는 묵시적 프로토콜을 특정 유형 (예 : JPEG)에서 일반 유형 (예 : 이미지)으로 전환합니다. 시스템의 모든 코드는 다음을 사용해야합니다 isValidType 유형을 호출 객체에 제공하지 않지만 말한다 그만큼 File 유형을 검증하기 위해 클래스.

Answer 4

아이디어는 클라이언트 클래스가 Get/Set 기능을 호출하면 나중에 수행하는 작업을 변경하고 발신자가 절연된다는 것입니다. 공개 변수가 있고 직접 액세스하는 경우 나중에 액세스하거나 설정할 때 동작을 추가 할 수있는 방법이 없습니다.

간단한 예에서도 더 활용할 수 있습니다.

사용하는 대신:

milesPerGallon = miles / gallons;

Calculatemileage ()에서

setmiles () 및 setgallons ()를 변경하여 MilesperGallon이 호출 될 때 업데이트 할 수 있습니다. 그런 다음 setmilespergallon ()을 제거하여 읽기 전용 속성임을 나타냅니다.

Answer 5

요점은 클래스가 해당 분야에 직접 액세스 할 수 없어야한다는 것입니다. 이는 구현 별이기 때문입니다. 다른 데이터 저장소를 사용하기 위해 나중에 클래스를 변경할 수 있지만 "사용자"에 대해 클래스를 동일하게 유지하거나 필드를 포함 할 수없는 인터페이스를 만들 수 있습니다.

살펴보십시오 위키 백과 기사 주제에.

Answer 6

그들은 당신의 수업에 대한 공개 인터페이스와 캡슐화의 일부를 제공합니다. getters and setters없이 공개 데이터에 어떻게 액세스하는지 고려하십시오.

Mileage m = new Mileage();
m.miles = 5.0;
m.gallons = 10.0;
...

이제 클래스에 검증을 추가하기로 결정한 경우 필드에 직접 액세스 한 모든 곳에서 코드를 변경해야합니다. 처음부터 getters and setter를 사용하는 경우 (필요한 곳에 만) 그 노력을 피하고 한 곳에서만 코드를 변경할 수 있습니다.

Answer 7

getters and setters를 사용하면 나중에 구현을 변경할 수있는 유연성이 제공됩니다. 당신은 당신이 그것을 필요로한다고 생각하지 않을 수도 있지만, 때로는 당신은 그렇게합니다. 예를 들어, 프록시 패턴을 사용하여 사용 비용이 많이 드는 물체를 게으른로드 할 수 있습니다.

class ExpensiveObject {
    private int foo;

    public ExpensiveObject() {
       // Does something that takes a long time.
    }

    public int getFoo() { return foo; }
    public void setFoo(int i) { foo = i; }
}

class ExpensiveObjectProxy extends ExpensiveObject {
    private ExpensiveObject realObject;

    public ExpensiveObjectProxy() { ; }

    protected void Load() {
       if ( realObject == null ) realObject = new ExpensiveObject();
    }

    public int getFoo() { Load(); return realObject.getFoo(); }
    public void setFoo(int i) { Load(); realObject.setFoo(i); }
}

class Main {
    public static void main( string[] args ) {
         // This takes no time, since ExpensiveOjbect is not constructed yet.
         ExpensiveObject myObj = new ExpensiveObjectProxy();

         // ExpensiveObject is actually constructed here, when you first use it.
         int i = myObj.getFoo();
    }
}

이것이 종종 플레이하는 곳은 ORM을 통해 객체를 데이터베이스에 매핑 할 때입니다. 필요한 물건 만로드 한 다음 데이터베이스로 돌아가서 실제로 사용되는 경우 나머지를로드하십시오.

Answer 8

일반적인 세터와 게터는 초기 GUI Builders (Borland)의 나쁜 해킹으로 모든 변수가 비공개 여야한다는 사실을 해결했습니다 (실제로는 절대적으로 필요합니다).

어떤 사람들은 그들을 추상화라고 부르지 만 그렇지 않습니다. 보일러 플레이트 세터/getter는 공개 회원보다 낫지 않습니다. 클래스가 제어 할 수없고 클래스 내 변경 사항을 제한하는 경우에도 여전히 변수에 대한 전체 액세스를 허용합니다 (변수가 int 인 경우에도 세터를 호출하는 모든 것을 변경하여 변수를 문자열로 변경해야합니다. )

Getters and Setters는 클래스 외부에서 클래스의 데이터에 액세스 할 것을 권장합니다. 클래스의 구성원에게 액세스하는 모든 코드는 해당 클래스 내에 (디자인 상태로) 존재해야하므로 세터 나 게터가 필요하지 않아야합니다. 그들은 불필요해야합니다.

또한 모든 수업에 세터를 강요하는 것은 끔찍한 일입니다. 그것은 수업이 단순히 불변 할 수 없지만 실제로 수업을 변동시킬 수있는 좋은 이유가 있어야한다는 것을 의미합니다.

즉, 그들은 값을 얻고 설정할 수있는 영구 엔진 및 GUI 빌더와 같은 문제를 교차 절단하는 데 유용하며, 클래스는 얻거나 변경 한 내용을 모니터링하고 수정하거나 검증 할 수 있습니다.

크로스 컷 변수 액세스가 필요한 시스템의 더 나은 패턴은 반사를 통해 변수에 직접 액세스하는 것입니다. 그러나 가능한 경우 세터와 getter를 비공개로 만드는 세터 또는 getter를 호출하는 것입니다.

이를 통해 NonoO Cross-Cutting Code가 올바르게 작동 할 수 있으며, 클래스가 세트를 수정하고 필요할 때 얻을 수 있으며 필요한 경우 Getters (때로는 유용한 경우)를 허용합니다.

Answer 9

액세서 방법의 지점, 즉. getters and setters는 acapsulation 일명 정보 숨기기를 제공하는 것입니다. 객체 지향 프로그래밍의 기본 원칙 중 하나입니다.

액세서 방법

정보 숨기기/캡슐화

Answer 10

한 단어의 대답은입니다 인터페이스.

인터페이스는 필드가 아닌 메소드를 허용하므로 확립 된 규칙은이 목적을 위해 getx 및 setx 방법을 갖는 것입니다.

(그리고 인터페이스는 Java의 구현에서 기능을 분리하는 방법입니다)

Answer 11

당신의 예는 부조리의 시점까지 극단적입니다. 그렇습니다. 모든 getters and setters는 코드를 부풀리고 해당 경우 가치를 추가하지 않습니다. 그러나 캡슐화에 대한 근본적인 아이디어는 소규모 자체 포함 된 프로그램이 아닌 많은 상호 작용 구성 요소로 구성된 더 큰 시스템을위한 것입니다.

유용하고 현명한 게터 및 세터 사용의 특성 :

• 다른 많은 클래스에서 사용하는 클래스 (구현 세부 정보 숨기기는 클라이언트를 더 쉽게 할 수 있습니다)
• 실제로 필요한 필드에 대해서만 getters and setter는 가능한 한 적은 적은 수의 개인이어야하며 수업 내에서만 사용해야합니다.
• 일반적으로 세터가 거의 없음 : Mutable Fields는 읽기 전용 필드보다 프로그램 상태를 추적하기가 훨씬 어렵습니다.
• 실제로 그 자리와 세터 하다 Fied에 액세스하는 것 외에도 잘못된 값에 대한 예외를 제외하거나 "마지막 수정 된"타임 스탬프를 업데이트하는 세트 또는 기본 필드에 의존하지 않고 즉시 값을 계산하는 getter

Answer 12

몇 달을 빨리 감습니다. 교사가 원격 버전의 마일리지 클래스를 구현 해달라고 요청할 수도 있습니다. 아마도 웹 서비스로서 다른 것일 수도 있습니다.

getter/setters가 없으면, 당신은 마일리지를 악화시키는 모든 코드를 변경해야합니다. getter/setters는 거의 완벽한 세계에서 마일리지 유형의 생성을 변경해야합니다.

Answer 13

getters and setter를 사용하면 객체 내에서 데이터에 액세스하고 돌연변이하는 데 유용한 바로 가기를 구축 할 수 있습니다. 일반적으로 이것은 다음과 같이 값을 얻고 설정하는 데 사용되는 객체를 가진 두 가지 기능을 갖는 대안으로 볼 수 있습니다.

{
    getValue: function(){
        return this._value;
    },
    setValue: function(val){
        this._value = val;
    }
}

이러한 방식으로 JavaScript를 작성하는 데있어 명백한 장점은 사용자가 직접 액세스하기를 원하지 않는 모호한 값을 사용할 수 있다는 것입니다. 다음과 같은 것과 같은 최종 결과 (새로 구성된 필드의 값을 저장하기 위해 폐쇄를 사용) :

function Field(val){
    var value = val;

    this.getValue = function(){
        return value;
    };

    this.setValue = function(val){
        value = val;
    };
}

Setter 및 Getter 방법 추가 관리 Bean의 상태를 액세스 할 수있게하려면 해당 상태의 세터 및 getter 메소드를 추가해야합니다. CreateSalutation 메소드는 Bean'Sgreet 메소드를 호출하고 GetSalutation 메소드는 결과를 검색합니다. 세터와 getter 방법이 추가되면 Bean이 완료됩니다. 최종 코드는 다음과 같습니다. 패키지 인사말;

import javax.inject.Inject;
import javax.enterprise.context.RequestScoped;
import javax.inject.Named;

@Named
@RequestScoped
public class Printer {

    @Inject @Informal Greeting greeting;

    private String name;
    private String salutation;

    public void createSalutation() {
        this.salutation = greeting.greet(name);
    }

    public String getSalutation() {
        return salutation;
    }
    public String setName(String name) {
       this.name = name;
    }

    public String getName() {
       return name;
    }
}

Answer 14

캡슐화 그리고 코드 재사용 가능성 객체 지향 프로그래밍의 아름다움입니다. 코드에서 민감한 데이터를 다루는 경우 개인 데이터 필드로 선언하는 경우 데이터에 액세스 할 수 없도록 데이터를 캡슐화합니다. 해당 데이터 필드에 액세스하려는 사람은 세터와 getters를 사용해야합니다. 즉, 민감한 데이터 필드를 처리하기위한 제어 된 액세스 메커니즘. 다음 예제는 세터와 게터의 장점과 중요성을 이해하는 데 도움이 될 수 있습니다.

• Days 변수를 사용하는 클래스를 구현했습니다.
• 내 수업에서 아무도 365보다 더 많은 며칠을 설정할 수 없습니다.
• 어떤 사람은 내 수업에서 상속하기를 원합니다. (코드 재사용 성).
• 이제 그가 365보다 많은 날의 가치를 입력하면 내 클래스의 모든 기능이 실패합니다.
• 따라서 Days 변수를 개인 데이터 필드로 선언해야했습니다.
• 이제 Days Data Field를 비공개로 선언 한 경우 입력에 대한 언급 된 한계가있는 세터 기능을 구현했을 때 아무도 365 이상의 값을 설정할 수 없었습니다.