Java에서 연산자를 사용하는 방법

저자는 Write for DOnations 프로그램을 선택했습니다.

소개

연산자는 잘 알려진 산술 연산자 빼기(-) 및 더하기(+) 또는 고급 instanceof. 값이나 변수에 연산자를 적용하면 연산 결과를 얻게 됩니다. 이러한 작업은 결과가 변수에 할당되거나 프로그램의 최종 목표가 달성될 때까지 추가로 평가되기 때문에 프로그래밍에서 기본입니다.

이 자습서에서는 연산자가 적용되는 값 또는 변수인 피연산자에 대해 잘 알고 있어야 합니다. 피연산자의 수에 따라 연산자는 세 그룹으로 나눌 수 있습니다. 첫째, 연산에 피연산자가 하나만 있는 경우 연산자를 단항이라고 합니다. 마찬가지로 이항 연산자에는 두 개의 피연산자가 포함됩니다. 마지막으로 세 개의 피연산자가 있는 경우 연산자는 삼항입니다. 이 분류에 따라 이 자습서는 각 연산자 유형에 대한 세 가지 주요 부분으로 구성됩니다.

이 자습서에서는 세 가지 유형의 연산자를 모두 사용하여 수학 방정식과 같은 기본 데이터 유형을 조작합니다. 또한 참조 유형이 있는 고급 시나리오에서 연산자를 사용하고 연산자 우선 순위에 대한 몇 가지 규칙을 살펴봅니다.

전제 조건

이 자습서를 따르려면 다음이 필요합니다.

• 예제와 함께 Java 프로그램을 실행할 수 있는 환경입니다. 로컬 컴퓨터에서 이를 설정하려면 다음이 필요합니다.\n
  • JDK(Java Development Kit)에서 제공하는 컴파일러와 함께 컴퓨터에 Java(버전 11 이상)가 설치되어 있습니다. Ubuntu 및 Debian의 경우 Java 설치를 위한 다운로드 옵션 단계를 따르십시오.
  • 코드 예제를 컴파일하고 실행하기 위해 이 자습서에서는 Introduction to JShell 가이드를 사용합니다.

  Java 및 객체 지향 프로그래밍에 익숙해야 합니다. Java로 첫 번째 프로그램을 작성하는 방법 튜토리얼에서 찾을 수 있습니다.

  자습서인 Java의 데이터 유형 이해에서 설명하는 Java 데이터 유형에 대한 이해

  단항 연산자

  단항 연산자는 하나의 피연산자에 적용되므로 가장 간단합니다. 단항 연산자는 코드를 더 간결하고 읽기 쉽게 만들기 때문에 자주 사용됩니다. 값 증가 및 감소와 같은 작업을 명시적으로 설명할 필요가 없습니다. 그러나 다른 연산자와 결합하면 이 섹션의 뒷부분에서 알게 되겠지만 단항 연산자도 사용하기 어려울 수 있습니다.

  다음으로 단항 연산자를 사용하여 값을 늘리거나 줄이고 부울 값을 뒤집습니다.

  증가 및 감소 연산자

  증가 및 감소 연산자는 이름에서 알 수 있듯이 숫자를 늘리거나 줄입니다. 증가 연산자는 두 개의 더하기 기호(++)의 조합이고 감소 연산자는 두 개의 빼기 기호(--)입니다. 이러한 연산자는 피연산자 앞과 뒤에 사용됩니다.

  사전 증가 및 사전 감소

  피연산자 앞에 연산자를 사용하면 ++ 또는 --사전 증가 또는 사전 감소가 됩니다. 코드>. pre 연산자를 사용하는 경우 피연산자를 사용하기 전에 피연산자의 값을 변경합니다. 따라서 실제로 값을 사용하면 이미 변경된 값입니다.

  정보: 이 자습서의 예제 코드를 따라하려면 jshell 명령을 실행하여 로컬 시스템에서 Java Shell 도구를 엽니다. 그런 다음 jshell> 프롬프트 뒤에 예제를 추가하고 ENTER를 눌러 예제를 복사, 붙여넣기 또는 편집할 수 있습니다. jshell을 종료하려면 /exit를 입력합니다.

  선행 증가 연산자를 사용하려면 jshell에 다음을 입력하십시오.

  int theAnswer = 42;
  System.out.println("Preincrementing: " + ++theAnswer);
  
  

  첫 번째 줄에서 값 42로 변수 theAnswer를 정의합니다. 두 번째 줄에서 println() 메서드를 사용하여 인쇄하고 어떻게 변경되었는지 보여줍니다.

  위의 예에서 선행 증가 연산자는 ++이며 theAnswer 앞에 배치됩니다. 이러한 방식으로 선행 증가 연산자를 사용하면 먼저 theAnswer의 값을 43으로 증가시킵니다. 그 후 println()이 이를 처리하면 이미 43이므로 다음과 같이 출력됩니다.

  Output
  theAnswer ==> 42
  Preincrementing: 43
  

  사전 감소는 유사하게 작동하지만 증가하는 대신 피연산자의 값을 감소시킵니다. 연습으로 선행 증가 연산자 ++ 대신 선행 감소 --를 사용하도록 위의 예를 수정합니다.

  후증가 및 후감소

  pre 연산자와 달리 post 연산자는 피연산자가 사용된 후 값을 변경합니다. post 또는 pre 연산자가 일반적으로 사용되는 특정 경우가 있지만 전체적으로는 개인 취향의 문제입니다.

  post 연산자의 작동 방식을 보여주기 위해 theAnswer 값을 사후 증가시키고 해당 값이 어떻게 변경되는지 살펴봅니다. jshell에 다음 줄을 추가합니다.

  int theAnswer = 42;
  System.out.println("Postincrementing: " + theAnswer++);
  System.out.println("Final value: " + theAnswer);
  
  

  변수 theAnswer는 먼저 42와 같습니다. 그런 다음 인쇄되고 후증가됩니다. 마지막 줄에서 최종 값을 보기 위해 다시 인쇄합니다.

  출력은 다음과 같아야 합니다.

  Output
  theAnswer ==> 42
  Postincrementing: 42
  Final value: 43
  

  보시다시피 theAnswer는 후증가하는 동안 42로 유지됩니다. 43(최종 값: 43)이 되는 것은 후증가 후 다시 인쇄했을 때입니다.

  사후 감소는 같은 방식으로 작동합니다. 값은 먼저 검색되어 사용되고 그 후에만 감소됩니다. 연습으로 후행 증가 연산자 ++를 후행 감소 연산자 --로 바꾸거나 pre 연산자 중 하나를 포함시키십시오.

  NOT 연산자

  논리 보수 연산자라고도 하는 NOT 연산자는 부울 피연산자의 값을 뒤집습니다. 느낌표 !로 표시됩니다. 일반적으로 부울 변수나 값이 있고 반대 값과 함께 재사용하려는 경우 NOT 연산자를 사용합니다. 따라서 불필요하게 반대 값으로 또 다른 변수를 생성할 필요가 없습니다.

  다음은 NOT 연산자의 작동 방식에 대한 예입니다. 간단히 하기 위해 true 값을 뒤집습니다.

  boolean isJavaFun = !true;
  System.out.println(isJavaFun);
  
  

  부울 변수 isJavaFun을 true로 정의합니다. 그러나 NOT 연산자는 true보다 우선합니다. 따라서 true의 값은 false로 반전됩니다. 위의 코드를 실행하면 다음 출력이 인쇄됩니다.

  Output
  isJavaFun ==> false
  false
  

  이것이 NOT 연산자가 작동하는 방식입니다. 때때로 혼란스럽고 찾기 어려울 수 있으므로 드물게 사용해야 합니다.

  위의 경우 !true 대신 false를 사용할 수 있습니다. 더 깨끗하고 직관적이기 때문에 올바른 접근 방식입니다. 일반적으로 추가 작업이 필요한 대안보다는 리터럴이나 메서드를 직접 사용하는 것이 가장 좋습니다. 그러나 어떤 경우에는 항상 이치에 맞지 않거나 가능하지 않을 수도 있습니다. 예를 들어 부울 메서드의 결과를 뒤집기 위해 NOT 연산자를 사용하는 것이 일반적입니다.

  예를 들어 문자열에 다른 문자열이 포함되어 있는지 확인하려면 contains() 메서드를 사용할 수 있습니다. 그러나 그 반대를 확인하려는 경우(즉, 문자열에 다른 문자열이 포함되어 있지 않은 경우) 대체 내장 메서드가 없습니다. NOT 연산자와 함께 contains()를 사용해야 합니다.

  Java is smart.라는 문자열이 있고 다음을 확인하고 싶다고 가정해 보십시오.

  1. 문자열에 smart가 포함되어 있습니다.
  2. 문자열에 hard가 포함되어 있지 않습니다.

  이를 확인하려면 다음 코드를 사용합니다.

  String javaIsSmart = "Java is smart.";
  boolean isSmartPartOfJava = javaIsSmart.contains("smart");
  boolean isHardNotPartOfJava = !javaIsSmart.contains("hard");
  
  

  첫 번째 줄에서 String 변수 javaIsSmart를 정의합니다. 두 번째 줄에서 부울 변수 isSmartPartOfJava를 메서드 contains()의 작업 결과로 정의합니다. 이 경우 문자열 smart는 javaIsSmart 문자열의 일부입니다. 마찬가지로 세 번째 줄에서 부울 변수 isHardNotPartOfJava를 정의합니다. 이 변수는 hard가 javaIsSmart<에서 발견되지 않는지 여부에 따라 결정됩니다. /코드>.

  jshell에서 이 코드를 실행하면 다음과 같은 결과가 표시됩니다.

  Output
  javaIsSmart ==> "Java is smart."
  isSmartPartOfJava ==> true
  isHardNotPartOfJava ==> true
  

  위의 출력에 따르면:

  • isSmartPartOfJava는 smart가 javaIsSmart에서 발견되기 때문에 true입니다.
  • isHardNotPartOfJava도 true입니다. hard가 javaIsSmart에서 발견되지 않기 때문입니다.

  이 섹션에서는 하나의 피연산자를 사용하여 증가, 감소 및 NOT 연산자를 탐색했습니다. 이러한 연산자에는 피연산자가 하나만 있지만 NOT 연산자에서 알 수 있듯이 사용하기 어려울 수 있습니다. 다음 단계에서는 피연산자가 두 개인 연산자를 사용하여 이 지식을 기반으로 합니다.

  이진 연산자

  이항 연산자는 두 개의 피연산자에 작용하며 일반적으로 더하기 및 빼기와 같은 산술 연산과 관련됩니다. 논리 연산자 및 특수 관계 연산자 instanceof와 같은 다른 비수학 관련 이항 연산자도 있습니다. 이 섹션에서는 더 친숙할 수 있는 산술 이항 연산자부터 시작합니다.

  산술 이진 연산자

  이들은 더하기(+) 및 빼기(-)와 같은 산술 연산에 사용되는 잘 알려진 연산자입니다. 다음은 추가된 예입니다.

  int theAnswer = 40 + 2;
  System.out.println("The result is: " + theAnswer);
  
  

  첫 번째 줄에서 40을 2에 추가하고 그 결과를 theAnswer 변수에 할당합니다. 인쇄하면 최종 값 42를 얻습니다.

  Output
  The result is: 42
  

  **참고:** 산술 연산 외에도 더하기 기호(+)도 문자열을 연결하는 데 사용됩니다. 위와 같이 값을 인쇄하는 대부분의 예제에서 실제 작동하는 것을 보았습니다. 여기에서 더하기 기호를 사용하여 \The result is: \를 변수 theAnswer와 연결했습니다. 그러나 이 더하기 기호 사용은 예외이며 다른 산술 연산자는 참조 형식에서 유사하게 사용할 수 없습니다. 예를 들어 빼기 기호를 사용하여 문자열의 일부를 제거할 수 없습니다.

  추가 연습을 위해 Java 설명서에서 찾을 수 있는 다른 산술 연산자를 사용해 보십시오.

  할당 연산자

  할당 연산자는 왼쪽 피연산자를 오른쪽 피연산자의 값에 할당합니다. 일반적으로 왼쪽 피연산자는 변수이고 오른쪽 피연산자는 개체에 대한 값 또는 참조입니다. 모든 예제에서 이러한 할당을 사용했기 때문에 이것은 친숙하게 들릴 수 있습니다. 이 섹션에서는 기본 할당 연산자, 일부 복합 할당 연산자 및 캐스팅 연산자를 사용하여 연습합니다.

  기본 할당 연산자(=)는 잘 알려져 있고 일반적으로 사용되는 연산자입니다.

  int x = 1;
  
  

  이 예에서는 int 변수 x를 선언하고 값 1을 할당합니다. 등호(=)를 사용하면 변수에 값을 할당할 수 있습니다.

  복합 할당 연산자

  복합 할당 연산자(+=, -=, *=, \\=)는 덧셈이나 뺄셈과 같은 추가 산술 연산. 이러한 연산자를 사용하면 특히 따르고 이해하기 쉬운 산술 연산에서 상용구 코드를 피할 수 있습니다.

  예를 들어 복합 += 할당 연산자를 사용하여 다음과 같이 추가와 할당을 결합합니다.

  int x = 1;
  int y = 1;
  x += y;
  System.out.println("x is: " + x);
  
  

  처음 두 줄에서 값이 모두 1인 x 및 y라는 두 개의 정수 변수를 선언합니다. 다음으로 복합 += 할당을 사용하여 x를 다시 할당합니다. 즉, x가 y에 추가된 다음 x에 다시 할당됩니다.

  위의 코드는 다음과 유사한 출력을 반환합니다.

  Output
  x ==> 1
  y ==> 1
  $11 ==> 2
  x is: 2
  

  위의 출력에 따르면 x 및 y는 1의 값을 얻습니다. 세 번째 줄에는 임의로 이름이 지정된 임시 변수($11)가 있습니다. 복합 할당 연산의 결과로 x 값을 보유합니다. 마지막 줄에 x의 값이 인쇄됩니다: 2.

  다음과 같이 복합 할당 연산자 없이 동일한 코드를 다시 작성할 수 있습니다.

  int x = 1;
  int y = 1;
  x = x + y;
  System.out.println("x is: " + x);
  
  

  이전 예제와 달리 3행에서 x와 y를 추가하는 것을 명시적으로 설명하는 추가 코드를 작성합니다.

  이 코드를 실행하면 다음 출력이 반환됩니다.

  Output
  x ==> 1
  y ==> 1
  x ==> 2
  x is: 2
  

  궁극적으로 두 예에서 x는 2와 같습니다. 그러나 두 번째 예에서 jshell은 $11과 같은 임시 변수 이름을 인쇄하지 않았습니다. 대신 x를 직접 사용하여 값이 변경되었음을 표시했습니다(x ==> 2). 이러한 자세한 출력은 학습에 매우 유용하며 jshell에서만 사용할 수 있습니다.

  나머지 복합 연산자는 할당과 함께 빼기(-=), 곱하기(*=) 및 나누기(/=)를 결합합니다. 위의 예를 변경하여 어떻게 작동하는지 확인하십시오.

  자주 사용되는 복합 연산자에 대해 알아두면 좋습니다. 그러나 이를 사용해도 성능상의 이점이 없으므로 복합 연산자를 사용하는 것은 개인의 선택 문제입니다. 불필요하게 혼란스러워 보이면 사용할 필요가 없습니다.

  캐스팅 오퍼레이터

  검토할 마지막 대입 연산자는 (데이터 유형)과 같이 괄호로 묶인 데이터 유형인 캐스팅 연산자입니다. 캐스팅 연산자는 하나의 데이터 유형을 다른 유형으로 해석하는 값을 캐스팅하는 데 사용됩니다.

  그러나 데이터 유형은 호환 가능해야 합니다. 한 데이터 유형이 다른 유형과 호환되는지 여부는 한 클래스가 다른 클래스의 부모인지 형제인지 여부와 같은 관계에 따라 결정됩니다. 예를 들어 int를 short로 변환할 수 있습니다. 두 데이터 유형 모두 정수를 저장하는 데 사용되기 때문입니다. 그러나 두 데이터 유형이 호환되지 않기 때문에 int를 boolean으로 변환할 수 없습니다.

  이 섹션에서는 캐스팅의 몇 가지 일반적인 예와 문제를 살펴봅니다. 교육 목적을 위해 부정확하고 호환되지 않는 캐스팅으로 시작합니다.

  boolean y = (boolean) 1;
  
  

  이 줄에서는 정수 1을 부울 값으로 캐스팅하고 변수 y에 할당하려고 합니다. 이것을 jshell에 붙여넣으면 다음 오류가 발생합니다.

  Output
  |  Error:
  |  incompatible types: int cannot be converted to boolean
  |  boolean y = (boolean) 1;
  |
  

  오류 메시지에서 설명하는 것처럼 int 값을 부울로 변환할 수 없습니다. 부울 값은 true 또는 false이며 어떤 부울 값 1이어야 하는지 결정하는 것은 불가능합니다.

  이제 호환되는 데이터 유형으로 예제를 시도합니다. 정수를 저장하기 위해 int 및 short의 두 가지 기본 유형을 사용합니다. 차이점은 용량, 즉 정보를 저장하는 데 사용할 수 있는 메모리의 양입니다. int는 용량이 더 크기 때문에 더 많은 수를 저장할 수 있습니다.

  jshell에 다음 줄을 추가합니다.

  int prize = 32767;
  short wonPrize = (short) prize;
  System.out.println("You won: " + wonPrize);
  
  

  첫 번째 줄에서 복권 당첨금을 값이 32767인 int 기본 유형으로 정의합니다. 그러나 두 번째 줄에서 원상의 값에 짧은 기본 유형이 더 적합할 것이라고 결정하고 상금을 캐스팅합니다. (짧은)를 사용하여 짧은로.

  jshell에서 위의 코드를 실행하면 출력은 다음과 같습니다.

  Output
  prize ==> 32767
  wonPrize ==> 32767
  You won: 32767
  

  위의 출력은 prize 및 wonPrize 값이 32767로 올바르게 설정되었음을 확인합니다. 마지막 행은 wonPrize 변수를 사용하여 획득한 금액을 나타냅니다.

  int 및 short의 경우 캐스팅이 불필요해 보일 수 있으며 실제로 이러한 캐스팅을 볼 수 없을 것입니다. 그러나 이 예제는 캐스팅 아이디어를 설명하는 데 유용합니다.

  캐스팅은 간단해 보이지만 한 가지 주의 사항이 있습니다. 용량이 더 큰 데이터 유형에서 용량이 더 작은 데이터 유형으로 캐스트할 때 오버플로라고 하는 더 작은 용량 제한을 초과할 수 있습니다. 이 문제를 시연하려면 이전 예제를 재사용하고 상금을 32767에서 32768로 다음과 같이 늘리십시오.

  int prize = 32768;
  short wonPrize =  (short) prize;
  System.out.println("You won: " + wonPrize);
  
  

  jshell에서 위의 내용을 실행하면 다음과 같은 결과가 표시됩니다.

  Output
  prize ==> 32768
  wonPrize ==> -32768
  You won: -32768
  

  이 경우 정보가 손실되고 예기치 않은 결과가 발생합니다. short로 변환하면 32768의 값은 -32768이 됩니다. short의 저장 용량이 -32768에서 32767까지이기 때문입니다. 최대값보다 큰 값을 저장하려고 하면 오버플로되어 처음부터 시작하게 됩니다. 이 경우 32768을 저장하려고 하면 최대 용량(32767)을 1 초과합니다. 이 때문에 가능한 가장 낮은 값부터 시작하여 다음 값이 할당됩니다. 이 경우 -32768의 최소값입니다.

  그렇기 때문에 위의 출력이 예상치 못한 것처럼 보입니다. 최종 상금은 음수가 되었습니다. 이러한 종류의 문제는 발견하기가 항상 쉬운 것은 아니므로 캐스팅을 신중하게 사용해야 합니다. Java 시리즈의 향후 자습서에서 다룰 더 복잡한 시나리오에서 캐스팅을 사용할 수 있습니다.

  관계 연산자

  관계 연산자는 두 피연산자를 비교하고 부울 결과를 반환합니다. 관계가 어설션되면 결과는 true입니다. 그렇지 않은 경우 결과는 false입니다.

  관계 연산자의 첫 번째 유형은 같음 == 및 같지 않음 !=입니다. 그들은 값과 객체의 동등성을 주장하는 데 사용됩니다. 프리미티브 값과 리터럴의 사용은 수학과 유사합니다.

  등호 연산자를 시연하려면 두 개의 정수 리터럴을 비교하십시오. 실제로 1과 같이 하나의 동일한 숫자가 됩니다. true 결과를 얻을 수 있도록 자신과 같은지 비교합니다. 다음 코드를 jshell에 붙여넣습니다.

  System.out.println(1==1);
  
  

  위의 코드에서 1이 1과 같은지 확인합니다. 숫자가 같으므로 이 식은 true로 평가됩니다. 따라서 println()은 true를 인쇄합니다.

  Output
  true
  

  연습으로 잘못된 결과를 얻기 위해 값 중 하나를 변경해 보십시오.

  참고: 같음 연산자 ==와 대입 연산자 =를 구별해야 합니다. 다르다는 것을 알면서도 혼동하기 쉽습니다. 코드에서 항상 구문 오류가 발생하는 것은 아니며, 이로 인해 디버그하기 어려운 문제가 발생할 수 있습니다.

  기본 값을 비교하는 것과 달리 객체가 같은지 비교하는 것은 두 변수가 동일한 객체를 가리키는지 어설션하기 때문에 더 복잡합니다. 예를 들어 두 개의 정수를 비교해 보십시오.

  Integer myAnswer = Integer.valueOf(42);
  Integer yourAnswer = Integer.valueOf(42);
  System.out.println(myAnswer == yourAnswer);
  
  

  위의 코드에서는 각각 값이 42인 두 개의 Integer 변수를 만듭니다. 마지막 줄에서 동일한지 비교하고 동일한 경우 true를 인쇄합니다. 이전 자습서 Java의 데이터 유형 이해에서 Integer.valueOf()가 먼저 동일한 값을 가진 개체의 캐시를 확인하고 이 값을 가진 개체가 이미 있는 경우 동일한 개체를 반환한다는 것을 알 수 있습니다. . 이것이 myAnswer와 yourAnswer가 동일한 객체를 수신하는 방식입니다.

  위의 코드를 jshell에 붙여넣으면 다음과 같은 결과가 표시됩니다.

  Output
  myAnswer ==> 42
  yourAnswer ==> 42
  true
  

  이러한 객체 비교는 간단해 보이지만 때로는 어렵습니다. 가장 혼란스러운 예는 문자열입니다. 동일한 값을 가진 두 문자열을 비교해보세요.

  String answer1 = new String("yes");
  String answer2 = new String("yes");
  System.out.println(answer1 == answer2);
  
  

  먼저 값이 \yes\인 두 개의 새로운 String 변수(answer1 및 answer2)를 선언합니다. 그러나 new 키워드를 사용하여 새 String 개체를 만들었습니다. 그 때문에 두 변수는 동일한 개체를 가리키지 않습니다. 실제로는 두 개의 다른 개체(동일한 값)를 가리킵니다.

  위의 코드를 jshell에 붙여넣으면 다음과 같은 결과가 표시됩니다.

  Output
  answer1 ==> "yes"
  answer2 ==> "yes"
  false
  

  answer1과 answer2가 동일한 값(\yes\)을 가지더라도 동등성은 false로 평가됩니다. 이는 그들이 동등하지 않다는 것을 의미합니다. 두 답변이 긍정적인지 여부와 같이 값을 비교하려는 경우 혼란스러울 수 있으며 기본 개체에 관심이 없습니다. 이를 위해 String을 비롯한 많은 클래스에는 동등성을 주장하기 위한 전용 메서드가 있습니다.

  String의 경우 이 메서드는 equals()입니다. 다음과 같이 equals()(== 대신)를 사용하도록 코드를 변경해 보십시오.

  String answer1 = new String("yes");
  String answer2 = new String("yes");
  System.out.println(answer1.equals(answer2));
  
  

  equals() 메서드는 비교 대상에 포함된 문자열이 동일한지 확인합니다.

  이 코드를 jshell에 붙여 넣으면 다음과 같은 결과가 표시됩니다.

  Output
  answer1 ==> "yes"
  answer2 ==> "yes"
  true
  

  위의 출력은 이전 출력과 유사하지만 true로 끝나며 두 개체의 값이 동일함을 확인합니다. 이 예제는 참조 유형을 비교할 때 주의해야 하고 가능한 경우 해당 메서드를 사용해야 함을 보여줍니다.

  !=와 같지 않은 대체 동등 연산자는 유사하게 사용되지만 두 변수 또는 값이 동일하지 않은지(또는 같지 않은지) 어설션합니다. 연습으로 이전 예제 중 일부에서 ==를 !=로 바꿔 보십시오.

  == 및 !=와 마찬가지로 다음 4개의 관계 연산자도 수학에서 가져옵니다. <보다 작거나 <=, >보다 크고 =>보다 크거나 같습니다.

  다음은 보다 큼 연산자를 사용하는 예입니다.

  System.out.println(4 > 5);
  
  

  jshell에서 이 코드를 실행하면 다음과 같은 결과가 표시됩니다.

  Output
  false
  

  위의 코드는 먼저 4가 5보다 큰지 여부를 비교합니다. 그렇지 않기 때문에 식은 false로 평가됩니다. 비교 결과(false)는 println() 메서드에 의해 인쇄됩니다.

  마지막 관계 연산자는 instanceof로, 변수가 주어진 클래스(또는 하위 클래스)의 인스턴스인지 또는 인터페이스 구현인지를 평가합니다. Java 자습서의 데이터 유형 이해에서 설명했듯이 인터페이스는 요구 사항 그룹이 있는 추상 엔터티입니다.

  다음 예를 사용하여 instanceof 작동 방식을 살펴보십시오.

  String greeting = "hello";
  System.out.println(greeting instanceof String);
  
  

  먼저 greeting이라는 문자열 변수를 만듭니다. 그런 다음 greeting이 String의 인스턴스인지 여부를 괄호 안에 평가합니다.

  jshell에 코드를 붙여넣으면 다음과 같은 결과가 표시됩니다.

  Output
  greeting ==> "hello"
  true
  

  greeting은 String의 인스턴스이므로 식은 true로 평가되며 println().

  논리 연산자

  논리 연산자는 논리 AND(&), 논리 OR(|) 및 배타적 OR입니다. (<코드>^). 모두 다음과 같이 두 값을 평가합니다.

  • 논리적 AND는 두 값이 모두 true일 때 참입니다.
  • 논리적 OR은 하나 이상의 값이 true일 때 참입니다.
  • 배타적 OR은 한 값이 true이고 다른 값이 false인 경우 참입니다.

  논리 연산자가 위의 조건에 따라 참이 아니면 거짓입니다.

  논리 AND(&) 연산자를 사용하려면 다음 예제를 jshell에 붙여넣습니다.

  boolean isJavaFun = true;
  boolean isJavaPowerful = true;
  System.out.println(isJavaFun & isJavaPowerful);
  
  

  처음 두 줄은 boolean 변수 isJavaFun 및 isJavaPowerful을 모두 true로 정의합니다. 세 번째 줄의 괄호 안에는 isJavaFun 및 isJavaPowerful에 대해 논리적 AND 연산을 수행하고 그 결과는 println( ).

  이 코드를 jshell에 붙여 넣으면 다음과 같은 결과가 표시됩니다.

  Output
  isJavaFun ==> true
  isJavaPowerful ==> true
  true
  

  두 변수 모두 true로 설정되고 마지막 true가 논리적 AND 연산의 결과로 인쇄됩니다.

  기술을 확장하려면 몇 가지 변형과 함께 이전 코드 예제를 사용해 보십시오. true와 false 사이에서 변수 값을 전환해 볼 수 있습니다. 논리 연산자를 논리 OR(|) 및 배타적 OR(^)로 변경해 볼 수도 있습니다.

  논리 연산자의 확장된 버전은 소위 단락 논리 연산자입니다. 단락 AND(&&) 및 단락 OR (<코드>||). 일반적인 논리 AND 및 OR 연산자와 유사하지만 한 가지 중요한 차이점이 있습니다. 첫 번째 연산자를 평가하는 것으로 충분하면 두 번째 연산자는 평가되지 않습니다. . 따라서 단락 AND가 참이 되려면 그것을 둘러싼 양쪽이 모두 참이어야 합니다. 그러나 왼쪽이 false이면 오른쪽은 평가되지 않습니다. 마찬가지로 단락 OR의 경우 왼쪽이 false이면 오른쪽이 평가되지 않습니다.

  다음은 단락 OR의 예입니다.

  boolean isJavaFun = true;
  Boolean isNullFun = null;
  System.out.println(isJavaFun || isNullFun);
  
  

  먼저 변수 isJavaFun을 true에 할당합니다. 이전 예제와의 일관성을 위해 이 변수는 기본 유형 boolean입니다. 그러나 다음 변수 isNullFun의 경우 Boolean 참조 유형을 사용하여 null에 할당할 수 있습니다. 예를 들어 null 포인팅 변수가 있는 것이 중요하지만 Java 데이터 유형 이해에 대한 자습서에서 기억할 수 있듯이 기본 유형은 null일 수 없으며 이것이 참조 유형을 사용하는 이유입니다. .

  짧은 회로 OR가 괄호 안에서 발생할 때 isNullFun은 왼쪽이 true이므로 무시되며 전체 표현식에 충분합니다. 참이어야 합니다. 따라서 jshell에서 코드를 실행하면 다음 출력이 인쇄됩니다.

  Output
  isJavaFun ==> true
  isNullFun ==> null
  true
  

  첫 번째와 두 번째 줄은 변수가 true 및 null에 할당되었음을 확인합니다. 단락 OR 연산이 true를 반환했기 때문에 세 번째 줄은 true를 인쇄합니다.

  위의 예는 단락 연산자가 작동하는 방식과 isNullFun이 평가되지 않음을 보여주기 위해 특별히 null로 선택되었습니다. isNullFun 평가를 보려면 단락 OR을 다음과 같이 일반 OR로 변경해 보십시오.

  boolean isJavaFun = true;
  Boolean isNullFun = null;
  System.out.println(isJavaFun | isNullFun);
  
  

  일반 논리 OR는 식의 양쪽을 모두 평가합니다.

  jshell에서 이 코드를 실행하면 다음과 같은 결과가 표시됩니다.

  isJavaFun ==> true
  isNullFun ==> null
  |  Exception java.lang.NullPointerException
  |        at (#3:1)
  

  논리적 OR이 null을 평가하려고 하면 java.lang.NullPointerException이 발생합니다. 이 때문에 단락 연산자가 선호되며 일반 논리 연산자 대신 거의 항상 사용됩니다.

  연습으로 가장 인기 있고 유용한 단락 && 및 ||를 사용하여 연습합니다.

  이 섹션에서는 기본 산술부터 개체를 동등하게 캐스팅하고 비교하는 더 어려운 연산에 이르기까지 다양한 예제에서 이항 연산자를 사용했습니다. 이 다음 섹션에서는 세 개의 피연산자로 작업합니다.

  삼항 연산자

  이전 섹션에서는 하나와 두 개의 피연산자가 있는 연산자를 사용하는 방법을 연습했습니다. 이 마지막 섹션에서는 세 개의 피연산자에 대한 유일한 연산자인 삼항 연산자를 사용합니다. 구문은 다음과 같습니다. 첫 번째 피연산자 ? 두 번째 피연산자: 세 번째 피연산자. 첫 번째 피연산자는 부울이어야 합니다. true이면 표현식에서 두 번째 피연산자가 반환됩니다. 첫 번째 피연산자가 false이면 세 번째 피연산자가 반환됩니다.

  삼항 연산자는 조건문과 같은 복잡한 명령문을 작성하고 그 결과를 임시 변수에 저장하지 않아도 되므로 널리 사용되며 자주 사용됩니다.

  다음 예제와 함께 삼항 연산자를 사용해 보십시오.

  boolean isJavaFun = true;
  String shouldILearnJava = isJavaFun ? "yes" : "no";
  System.out.println("Should I learn Java: " +  shouldILearnJava);
  
  

  isJavaFun은 true로 설정되고 shouldILearnJava 변수는 삼항 연산에서 결정됩니다. 첫 번째 피연산자 isJavaFun이 true이므로 두 번째 피연산자 문자열 \yes\가 반환됩니다. 이를 확인하기 위해 세 번째 줄은 shouldILearnJava 변수를 인쇄합니다. 이 시점에서 yes여야 합니다.

  위의 코드를 실행하면 다음과 같은 결과가 나타납니다.

  Output
  Should I learn Java: yes
  

  추가 연습을 위해 isJavaFun 앞에 NOT 연산자를 사용해 보십시오.

  boolean isJavaFun = true;
  String shouldILearnJava = !isJavaFun ? "yes" : "no";
  System.out.println("Should I learn java: " +  shouldILearnJava);
  
  

  isJavaFun의 값을 뒤집어 true에서 false로 설정합니다. 결과적으로 삼항 식은 \no\인 마지막 피연산자를 반환합니다.

  특히 NOT 연산자와 같은 추가 연산자를 사용할 때 삼항 식은 혼란스러울 수 있습니다. 그러나 일부 상용구 코드를 저장할 수 있으므로 인기가 있습니다.

  연산자 우선 순위

  중요한 연산자를 알게 되면 이들을 사용하고 결합할 수도 있습니다. 그러나 조합을 시작하기 전에 연산자 우선 순위에 대한 규칙을 알아야 합니다.

  연산자 우선 순위는 연산자가 평가되는 순서를 결정합니다. 둘 이상의 연산자를 사용할 가능성이 있으므로 연산자 우선 순위를 이해하는 것이 중요합니다. 규칙이 항상 직관적인 것은 아니지만 실제로는 몇 가지 필수 규칙만 알면 됩니다.

  연산자 우선 순위를 이해하면 최신 프로그래밍의 사실상 표준인 깔끔한 코드를 작성하는 데 도움이 됩니다. 깨끗한 코드를 작성한다는 것은 이해하기 쉽고 유지 관리할 수 있는 코드를 작성한다는 의미입니다. 연산자와 관련하여 클린 코드 패러다임은 가능한 한 적은 수의 연산자를 사용하고 연산자를 중첩 및 결합하는 대신 별도의 문을 만드는 것으로 해석됩니다.

  예를 들어 아래와 같은 문장은 너무 혼란스럽기 때문에 피해야 합니다.

  boolean isThisCleanCode = !true || false && true;
  
  

  운영자 설명서를 참조하더라도 최종 결과를 추측하지 못할 수 있습니다(isThisCleanCode는 false임).

  우선 순위가 가장 높은 규칙부터 시작하여 가장 중요하고 일반적으로 사용되는 우선 순위 규칙은 다음과 같습니다.

  • Pre 및 post 증가 및 감소 연산자: 우선 순위가 가장 높고 다른 연산자보다 먼저 적용됩니다.
  • 수학의 산술 규칙: 수학에서 유효한 모든 규칙은 Java에서도 유효합니다. 예를 들어 / 나누기는 + 더하기보다 우선 순위가 높습니다. 괄호는 우선 순위를 재정의합니다. 즉, 작업을 괄호로 그룹화할 수 있으며 작업이 우선적으로 평가됩니다.
  • 같음 및 관계 연산자: 같음 또는 관계를 평가하기 때문에 피연산자의 최종 값도 사용하므로 다른 모든 연산을 완료해야 합니다.
  • 논리 OR 및 AND 연산자(단락 포함): 삼항 연산자와 마찬가지로 모두 피연산자의 최종 값이 필요하므로 우선 순위가 낮습니다.
  • 삼항 연산자: 삼항 연산자는 첫 번째 피연산자의 최종 값이 필요합니다. 이를 위해서는 다른 모든 작업이 완료되어야 합니다. 그래서 삼항 연산자의 우선 순위가 낮습니다.
  • 할당 연산자: 다른 모든 연산이 완료되고 최종 결과가 왼쪽의 피연산자에 할당될 수 있도록 마지막으로 평가됩니다. 예를 들어 지금까지 등호로 할당한 모든 변수를 생각해 보십시오.

  이제 수학 문제를 사용하여 연산자 우선 순위를 탐색합니다.

  int x = 1 + 10 / 2;
  
  

  위의 코드를 jshell에 붙여넣으면 다음과 같은 결과가 표시됩니다.

  Output
  x ==> 6
  

  위 출력에 따르면 x는 6의 값을 가져옵니다. 다음 작업이 우선 순위가 낮아지면서 완료되었기 때문입니다.

  1. 10/2가 먼저 평가됩니다. 결과는 5입니다.
  2. 1이 첫 번째 작업 결과에 추가됩니다(5). 결과는 6입니다.
  3. 할당 연산자가 작동하고 최종 결과(6)를 사용하여 변수 x에 할당합니다.

  이 수학 방정식은 비교적 간단하지만 항상 더 장황하게 만들고 괄호를 사용하여 우선 순위를 쉽게 이해할 수 있도록 할 수 있습니다. 다음과 같이 다시 작성해 보세요.

  int x = 1 + (10 / 2);
  
  

  위의 내용을 jshell에 붙여넣으면 이전과 동일한 결과가 인쇄됩니다.

  Output
  x ==> 6
  

  마지막 예에서는 10/2 주위에 괄호를 사용하여 우선 순위를 변경하지 않았습니다. 대신, 그들의 목적은 내부 작업의 우선 순위를 보다 명확하게 만드는 것이었습니다. 이와 같이 괄호를 사용하면 코드를 보다 명확하고 이해하기 쉽게 만드는 데 도움이 되며, 이는 작업이 더 복잡할 때 특히 중요합니다.

  우선 순위 규칙은 흥미롭고 시간을 들여 학습하는 것이 좋습니다. 깨끗한 코드 패러다임을 염두에 두고 불필요한 중첩 및 연산자 결합이 코드의 약점으로 보인다는 사실을 고려하십시오.

  결론

  이 자습서에서는 Java의 기본 연산자에 대해 배웠습니다. 연산자와 관련된 가장 유용하고 흥미로운 시나리오를 본 몇 가지 테스트 코드 스니펫을 작성했습니다. 또한 깨끗한 코드와 연산자를 불필요하게 남용해서는 안 된다는 사실에 대해서도 배웠습니다.

  Java에 대한 자세한 내용은 Java로 코딩하는 방법 시리즈를 확인하십시오.