자바 구문

이 글은 일반적인 참고문헌 목록을 포함하고 있지만, 그에 상응하는 인라인 인용구가 충분하지 않기 때문에 대체로 검증되지 않은 상태로 남아 있다. 좀 더 정밀한 인용구를 도입하여 이 기사를 개선할 수 있도록 도와주십시오. (2014년 1월) (이 템플릿 메시지를 제거하는 방법과 시기 알아보기)

굵은 파란색 글꼴로 강조 표시된 키워드가 있는 Java 코드 조각

자바 구문은 자바 프로그램의 작성 및 해석 방법을 정의하는 규칙 집합을 가리킨다.

구문은 대부분 C와 C++에서 파생된다. C++와 달리 자바에서는 글로벌 기능이나 변수가 없지만 글로벌 변수로도 간주되는 데이터 멤버가 있다. 모든 코드는 클래스에 속하고 모든 값은 객체다. 유일한 예외는 성능상의 이유로 클래스 인스턴스로 표현되지 않는 원시 유형이다(그러나 자동 복싱을 통해 자동으로 객체로 변환될 수 있고 그 반대도 가능하다). 연산자 과부하 또는 부호가 없는 정수 유형과 같은 일부 기능은 언어를 단순화하고 프로그래밍 오류를 방지하기 위해 생략된다.

자바 구문은 수많은 주요 JDK 발매 과정에서 점차 확장되어 현재는 일반 프로그래밍, 함수 리터럴(Java에서는 람다 표현식이라고 함) 등의 기능을 지원한다. 2017년 이후, 새로운 JDK 버전이 1년에 두 번 출시되고 있으며, 각각의 발매는 언어에 점진적인 향상을 가져온다.

기본 사항

식별자

식별자는 코드에 있는 요소의 이름이다. 요소의 이름을 선택할 때 따라야 할 특정 표준 명명 규칙이 있다. 자바의 식별자는 대소문자를 구분한다.

식별자는 다음을 포함할 수 있다.

• 문자(로마 숫자와 같은 숫자 문자 포함) 또는 숫자인 모든 유니코드 문자.
• 통화 기호(예: ¥)
• 구두점 문자(예: _)를 연결하는 중.

식별자는 다음을 수행할 수 없다.

• 숫자로 시작하라.
• 예약된 키워드, null 리터럴 또는 부울 리터럴과 동일해야 한다.

키워드

리터럴스

정수 리터럴은 int 없는 한 기본적으로 타이핑하다. long 첨부하여 유형을 지정함 L 또는 l 리터럴에 접미사(예: 367L. Java SE 7 이후, 가독성을 높이기 위해 숫자의 숫자 사이에 밑줄을 포함시킬 수 있다. 예를 들어 숫자 145608987은 145_608_987로 쓸 수 있다.

변수

변수는 값과 관련된 식별자다. 변수의 유형과 이름을 작성하여 선언하고, 선택적으로 값을 할당하여 같은 문장에서 초기화한다.

인트로 수를 세다;      // 'int' 유형의 'count'라는 초기화되지 않은 변수 선언 수를 세다 = 35;     //변수 초기화 인트로 수를 세다 = 35; // 변수를 선언하고 동시에 초기화 

같은 유형의 여러 변수를 쉼표를 구분 기호로 사용하여 하나의 문장으로 선언하고 초기화할 수 있다.

인트로 a, b;         // 동일 유형의 다중 변수 선언 인트로 a = 2, b = 3; // 동일 유형의 여러 변수 선언 및 초기화 

Java 10 이후, 다음을 사용하여 변수의 유형을 자동으로 추론할 수 있게 되었다. var.

// 스트림에는 이니셜라이저에서 유추된 FileOutputStream 유형이 있음 시합을 하다 물줄기가 흐르다 = 새로운 FileOutputStream("file.txt");  // 명시적 유형의 동등한 선언 FileOutputStream 물줄기가 흐르다 = 새로운 FileOutputStream("file.txt"); 

코드블록

구분 기호 { 및 }은(는) 코드 블록과 새 범위를 의미한다. 클래스 멤버들과 방법의 본체는 다양한 맥락에서 이러한 교정기 안에서 살 수 있는 것의 예들이다.

메서드 본체 내부에서는 다음과 같이 새로운 범위를 만들기 위해 브레이스를 사용할 수 있다.

공허하게 하다 어떻게 좀 해봐.() {     인트로 a;      {         인트로 b;         a = 1;     }      a = 2;     b = 3; // 변수 b가 내부 범위에서 선언되기 때문에 불법이다. } 

평.

자바에는 전통적인 코멘트, 종단 코멘트, 문서 코멘트 등 세 가지 종류의 코멘트가 있다.

블록 코멘트라고도 하는 기존 코멘트는 /* 으로 끝나다. */, 그것들은 여러 줄에 걸쳐 있을 수 있다. 이러한 유형의 코멘트는 C와 C++에서 파생되었다.

/* 멀티라인 코멘트 입니다. 한 줄 이상을 차지할 수 있다. */ 

줄 끝 코멘트는 // 그리고 현재 줄의 끝까지 연장한다. 이 코멘트 유형은 C++와 모던 C에도 존재한다.

// 이것은 종말론이다. 

원본 파일의 문서 주석을 Javadoc 도구에 의해 처리하여 문서를 생성한다. 이 유형의 코멘트는 시작부터 시작한다는 점을 제외하면 전통적인 코멘트와 동일하다. /** 그리고 자바독 도구에 의해 정의된 규약을 따른다. 기술적으로, 이러한 코멘트는 특별한 종류의 전통적인 코멘트로서 언어 규격에 구체적으로 정의되어 있지 않다.

/**  * 설명서에 대한 설명 입니다.  *   * @ 저자 John Doe  */ 

유니버설 타입

명시적으로 가져온 유형이 동일한 이름을 가지지 않는 한, 패키지 java.lang의 클래스는 모든 프로그램으로 암시적으로 불러온다. 중요한 것은 다음과 같다.

자바.의오브젝트

자바의 탑 타입. 부모 클래스를 선언하지 않는 모든 클래스의 수퍼 클래스. 원시 값의 경우 자동 복사를 포함하지만 모든 값은 이 유형으로 변환할 수 있다.

자바.의끈

자바의 기본 문자열 유형. 불변의. 일부 방법에서는 각 UTF-16 코드 단위를 "문자"로 취급하지만, 단위를 "문자"로 변환하는 방법 int[] 사실상 UTF-32도 이용할 수 있다.

자바.의던질 수 있는

자바의 힘으로 던지거나 잡을 수 있는 모든 것의 슈퍼타입 throw 그리고 catch 진술들

프로그램 구조

Java 애플리케이션은 클래스의 모음으로 구성된다. 클래스는 패키지에 존재하지만 다른 클래스 안에 중첩될 수도 있다.

main 방법

모든 Java 애플리케이션에는 진입점이 있어야 한다. 이는 그래픽 인터페이스 애플리케이션과 콘솔 애플리케이션 모두에 해당된다. 진입점은 다음과 같다. main 방법의 a가 있는 클래스는 두 개 이상일 수 있다. main 메소드 그러나 주 클래스는 항상 외부에서 정의된다(예: 매니페스트 파일). 방법은 다음과 같아야 한다. static 문자열 배열로 명령줄 인수가 전달됨. C++ 또는 C#와는 달리 값을 반환하지 않으며 반환해야 함 void.

공중의 정태의 공허하게 하다 본래의(끈[] 아그) { } 

패키지

패키지는 클래스 이름의 일부분으로 명명된 엔티티를 그룹화 및/또는 다른 엔티티와 구분하는 데 사용된다. 패키지의 또 다른 목적은 액세스 한정자와 함께 코드 액세스를 제어하는 것이다. 예를 들어, java.io.InputStream 클래스에 대한 정규화된 클래스 이름 InputStream 포장에 있는 java.io.

파일이 시작될 때 패키지가 다음과 같이 선언된다. package 선언:

꾸러미 my appplication.mybrary.mybrary;  공중의 계급 마이클래스 { } 

와의 수업들 public 수식어를 이름과 자바 확장자가 같은 파일에 넣고 패키지 이름에 해당하는 중첩 폴더에 넣어야 한다. 위의 클래스 myapplication.mylibrary.MyClass 다음과 같은 경로를 갖는다. myapplication/mylibrary/MyClass.java.

수입신고서

수입신고서유형

형식 가져오기 선언은 패키지를 포함하는 전체 이름이 아닌 간단한 이름으로 명명된 유형을 참조할 수 있도록 한다. 가져오기 선언은 단일 유형 가져오기 선언 또는 주문형 가져오기 선언일 수 있다. 가져오기 선언은 패키지 선언 후 코드 파일의 맨 위에 배치해야 한다.

꾸러미 myPackage;  수입하다 java.util.무작위; // 단일 유형 선언  공중의 계급 가져오기테스트 {     공중의 정태의 공허하게 하다 본래의(끈[] 아그) {         /* 다음 라인은          * java.util.랜덤 랜덤 = 새로운 java.util.usil.임의();          * 수입하지 않았더라면 틀렸을 것이다.          */         무작위 무작위의 = 새로운 무작위();     } } 

주문형 수입 신고서는 코드에 언급되어 있다. "유형 가져오기"는 패키지의 모든 유형을 가져온다. "정적 수입"은 패키지의 구성원을 수입한다.

수입하다 java.util.*;  /*이러한 형태의 클래스는 모든 클래스를 만든다.     이름으로 사용 가능한 패키지 Java.util을 대신하여 사용할 수 있음     이전 예에서 수입 신고서 */ 수입하다 자바*; /*이 진술은 합법적이지만 아무 것도 하지 않는다.     패키지 자바에 직접 클래스가 없는 경우. 모두 포장되어 있다.     패키지 자바 내에서 이것은 사용 가능한 모든 클래스를 가져오지는 않는다.*/ 

정적수입신고서

이러한 유형의 선언은 J2SE 5.0 이후 사용 가능했다. 정적 가져오기 선언은 클래스 이름을 지정하지 않고 다른 클래스, 인터페이스, 주석 또는 열거형에 정의된 정적 멤버에 대한 액세스를 허용한다.

정적을 수입하다 자바.의시스템.아웃; //'out'은 java.properties의 정적 필드다.시스템  공중의 계급 안녕 세계 {     공중의 정태의 공허하게 하다 본래의(끈[] 아그) {         /* 다음 라인은 다음과 같다.    System.out.println("Hi World!");;             수입 신고서가 없었더라면 틀렸을 겁니다 */         밖으로.인쇄하다("헬로 월드!");     } } 

주문형 가져오기 선언에서는 다음과 같은 유형의 모든 필드를 가져올 수 있다.

정적을 수입하다 자바.의시스템.*;     /* 이러한 형태의 선언은 모든 것을 만든다.        java.properties의 필드이름으로 사용할 수 있으며 대신 사용할 수 있는 시스템 클래스        이전 예제의 수입 신고서. */ 

열거 상수도 정적 가져오기와 함께 사용할 수 있다. 예를 들어, 이 열거형은 호출된 패키지에 있다. screen:

공중의 열거하다 ColorName {     빨간색, 파란색, 녹색 }; 

다른 클래스에서 정적 가져오기 선언을 사용하여 열거 상수를 검색할 수 있다.

수입하다 화면.ColorName; 정적을 수입하다 화면.ColorName.*;  공중의 계급 점 {     /* 다음 줄은 'ColorName foo = ColorName'과 같다.'빨간색'        정적인 수입이 없었더라면 틀렸을 겁니다 */     ColorName foo = 빨간색;      공허하게 하다 교대시키다() {         /* 다음 라인은 다음과 같다.             if (foo == ColorName)RED) foo = ColorName.파란색; */         만일 (foo == 빨간색) foo = 파란색;     } } 

연산자

자바의 연산자는 C++의 연산자와 비슷하다. 그러나 없다. delete Java의 가비지 수집 메커니즘으로 인해 연산자가 있고, Java가 포인터를 지원하지 않기 때문에 포인터에 대한 연산이 없다. 또 다른 차이점은 Java에 서명되지 않은 우측 시프트 운영자가 있다는 것이다.>>>), C의 우측 시프트 운영자의 서명은 형식에 의존한다. 자바에 있는 연산자는 과부하될 수 없다.

제어 구조물

조건문

if 성명서

Java의 문장이 C의 문장과 유사하고 동일한 구문을 사용하는 경우:

만일 (i == 3) 어떻게 좀 해봐.(); 

if 진술서는 선택사항을 포함할 수 있다. else block, 이 경우 if-ten-time 문장이 된다.

만일 (i == 2) {     어떻게 좀 해봐.(); } 다른 {     다른 것을 해라.(); } 

C와 마찬가지로, 특별한 키워드를 포함하지 않는 경우 다음과 같은 별도의 if-ten-else 문장으로 구성된다.

만일 (i == 3) {     어떻게 좀 해봐.(); } 다른 만일 (i == 2) {     다른 것을 해라.(); } 다른 {     doSomethingDifferent(); } 

또한 ?: 연산자는 예를 들어 간단한 if 문 대신 사용할 수 있다는 점에 유의하십시오.

인트로 a = 1; 인트로 b = 2; 인트로 minVal = (a < b) ? a : b; 

switch 성명서

Java의 스위치 문 사용 가능 byte, short, char그리고 int (참고: 아님) long) 원시 데이터 유형 또는 해당 래퍼 유형. J2SE 5.0부터 열거형 사용이 가능하다. Java SE 7부터 String을 사용할 수 있다.^[2] 다른 참조 유형은 다음에 사용할 수 없음 switch 진술들

가능한 값은 다음을 사용하여 나열된다. case 꼬리표 Java의 이러한 라벨에는 상수( 열거 상수 및 문자열 상수 포함)만 포함될 수 있다. 실행은 괄호 안의 식에 해당하는 라벨 다음에 시작한다. 선택 사항 default 어떤 사례 라벨도 표현식과 일치하지 않을 경우, 라벨을 따르는 코드가 실행될 것임을 선언하기 위해 라벨이 표시될 수 있다.

각 라벨에 대한 코드는 break 키워드 생략할 수 있어 다음 라벨로 실행이 진행되지만, 일반적으로 편집 중에 경고가 보고된다.

바꾸다 (ch) {     케이스 'A':         어떻게 좀 해봐.(); // ch == 'A'일 경우 트리거됨         부숴뜨리다;     케이스 'B':     케이스 'C':         다른 것을 해라.(); // ch == 'B' 또는 ch == 'C'일 경우 트리거됨         부숴뜨리다;     체납:         doSomethingDifferent(); // 다른 경우 트리거됨         부숴뜨리다; } 

switch 표현.

Java 14 이후 새로운 화살표 구문을 사용하는 스위치 식을 사용할 수 있게 되었다.

시합을 하다 결과 = 바꾸다 (ch) {     케이스 'A' -> 결과.GREAT;     케이스 'B', 'C' -> 결과.미세한;     체납 -> 던지다 새로운 ThisIsNoGoodException(); }; 

대안으로 같은 표현을 할 가능성도 있다. yield 문장, 비록 화살표 구문이 우발적인 낙하 관통 문제를 피하기 때문에 선호할 것을 권고한다.

시합을 하다 결과 = 바꾸다 (ch) {     케이스 'A':         양보하다 결과.GREAT;     케이스 'B':     케이스 'C':         양보하다 결과.미세한;     체납:         던지다 새로운 ThisIsNoGoodException(); }; 

반복문

반복문장은 주어진 조건이 참으로 평가될 때 반복적으로 실행되는 문장이다. J2SE 5.0 이후 자바에는 4가지 형태의 그러한 문장이 있다.

while 고리를 틀다

에서 while 반복한다, 시험은 각 반복 전에 이루어진다.

하는 동안에 (i < 10) {     어떻게 좀 해봐.(); } 

do ... while 고리를 틀다

에서 do ... while 루프, 테스트는 각 반복 후에 수행된다. 따라서 코드는 항상 한 번 이상 실행된다.

// doSomething()은 한 번 이상 호출됨 하다 {     어떻게 좀 해봐.(); } 하는 동안에 (i < 10); 

for 고리를 틀다

for Java의 루프는 이니셜라이저, 조건 및 카운터 식을 포함한다. 쉼표를 구분 기호로 사용하여 같은 종류의 여러 식을 포함할 수 있다(조건에서 제외). 그러나 C와 달리 쉼표는 단지 구분자일 뿐 연산자가 아니다.

을 위해 (인트로 i = 0; i < 10; i++) {     어떻게 좀 해봐.(); }   // 두 변수를 사용하는 더 복잡한 루프 을 위해 (인트로 i = 0, j = 9; i < 10; i++, j -= 3) {     어떻게 좀 해봐.(); } 

C와 마찬가지로 세 가지 표현 모두 선택 사항이다. 다음 루프는 무한하다.

을 위해 (;;) {     어떻게 좀 해봐.(); } 

강화됨 for 고리를 틀다

J2SE 5.0 이후 향상된 루프를 사용할 수 있다. 이 유형의 루프는 배열과 컬렉션에 내장된 반복기를 사용하여 주어진 컬렉션의 각 항목을 반환한다. 모든 요소가 반환되고 코드 블록의 컨텍스트에서 도달할 수 있다. 블록이 실행되면, 다음 항목은 남아 있는 항목이 없을 때까지 반환된다. C#와는 달리, 이런 종류의 루프는 특별한 키워드를 수반하지 않고, 대신 다른 표기법을 사용한다.

을 위해 (인트로 i : 인트라어) {     어떻게 좀 해봐.(i); } 

점프 문

레이블

라벨은 코드에서 다음과 같이 지정된다. break 그리고 continue 진술들 참고: Java goto 키워드를 사용하여 코드의 특정 지점으로 이동할 수 없음.

출발하다: 모스메토드(); 

break 성명서

그 break 문장이 가장 가까운 루프를 벗어나거나 switch 성명서 종료된 명령문이 있는 경우 명령문에서 실행은 계속된다.

을 위해 (인트로 i = 0; i < 10; i++) {     하는 동안에 (진실의) {         부숴뜨리다;     }     // 이 지점으로 꺾일 것이다. } 

라벨을 사용하여 외부 루프에서 이탈할 수 있다.

바깥의: 을 위해 (인트로 i = 0; i < 10; i++) {     하는 동안에 (진실의) {         부숴뜨리다 바깥의;     } } // 이 지점으로 꺾일 것이다. 

continue 성명서

그 continue 문장은 현재 통제 문장의 반복을 중단하고 다음 반복을 시작한다. 다음 while 아래 코드의 루프는 전화를 걸어 문자를 읽는다. getChar(), 문자가 공백인 경우 루프 본문의 문을 건너뛰십시오.

인트로 ch; 하는 동안에 (ch == 차르를 얻다()) {     만일 (ch == ' ') {         계속하다; // 나머지 슬립은 건너뛰십시오.     }      // 나머지 loop은 ch == '에 도달하지 않는다.     어떻게 좀 해봐.(); } 

라벨 지정 가능 continue 진술서 및 break 문장:

바깥의: 을 위해 (끈 발을 동동 구르다 : 현악기) {     마를 뜨다[] 스트라차스 = 발을 동동 구르다.토샤어레이();     을 위해 (마를 뜨다 ch : 스트라차스) {         만일 (ch == ' ') {             /* 외부 사이클과 다음 사이클의 지속             문자열 Arr */에서 문자열 검색             계속하다 바깥의;         }         어떻게 좀 해봐.(ch);     } } 

return 성명서

그 return 명령문은 메서드 실행을 종료하고 값을 반환하는 데 사용된다. 메소드에 의해 반환된 값은 다음 뒤에 기록된다. return 키워드 이 방법이 다음을 반환하는 경우 void, 그것은 반드시 사용해야만 한다. return 얼마간의 가치를 반환하라는 성명

공허하게 하다 어떻게 좀 해봐.(부울 스트림 닫힘) {     // streamClosed가 true이면 실행이 중지됨     만일 (스트림 닫힘) {         돌아오다;     }     readFromStream(); }  인트로 합계를 계산하다(인트로 a, 인트로 b) {     인트로 결과 = a + b;     돌아오다 결과; } 

return 명령문은 하나의 경우를 제외하고 즉시 실행이 종료된다: 명령문이 a 내에서 발견되는 경우 try block으로 보완하다. finally, 제어는 에 전달된다. finally 막다

공허하게 하다 어떻게 좀 해봐.(부울 스트림 닫힘) {     해보다 {         만일 (스트림 닫힘) {             돌아오다;         }         readFromStream();     } 종국에는 {         /* 다음과 같은 경우에도 마지막이라고 함          readFromStream()을 */라고 부르지 않음         freeResources();     } } 

예외처리명세서

try-catch-finally 진술들

예외 관리 기간: try ... catch 블록들

해보다 {     // 예외를 발생시킬 수 있는 진술     메서드던싱Exceptions(); } 잡히다 (예외 이외의) {     // 여기에서 예외를 발견하여 처리     reportException(이외의); } 종국에는 {     // 시도/캐치 블록 후에 항상 실행되는 문장     freeResources(); } 

다음 항목 내의 진술: try 블록이 실행되며, 이들 중 하나라도 예외를 던지면 블록의 실행이 중단되고 예외는 다음이 처리한다. catch 블럭. 여러 개가 있을 수 있다. catch 블록. 이 경우 던져진 예외 유형과 일치하는 유형의 예외 변수를 가진 첫 번째 블록이 실행된다.

자바 SE 7도 유니캐치 조항 외에 멀티캐치 조항을 도입했다. 이러한 유형의 어획 조항은 서로 하위 클래스가 아닌 경우 자바에게 단일 블록에서 서로 다른 유형의 예외를 처리할 수 있도록 한다.

해보다 {     메서드던싱Exceptions(); } 잡히다 (IOException   언페러그먼트예외 이외의) {     //IOException과 TrafficArgument 모두여기서 예외를 포착하여 처리한다.     reportException(이외의); } 

아닐 경우 catch 블록은 던져진 예외의 유형, 또는 를 포함하는 외부 블록(또는 방법)의 실행과 일치한다. try ... catch 문장이 중단되고, 예외는 포함된 블록(또는 방법)을 위/밖으로 전달된다. 예외가 콜 스택을 통해 일치될 때까지 위쪽으로 전파됨 catch 현재 활성화된 방법 중 하나에서 블록을 찾을 수 있다. 예외가 맨 위까지 전파되는 경우 main 일치되지 않는 방법 catch 발견되는 블록, 예외에 대한 텍스트 설명이 표준 출력 스트림에 기록된다.

다음 항목 내의 진술: finally 블록은 항상 다음에 실행된다. try 그리고 catch 블록(예외가 던져졌는지 여부 return 성명서에 도달했다. 이러한 블록은 항상 실행이 보장되는 정리 코드를 제공하는 데 유용하다.

그 catch 그리고 finally 블록은 선택 사항이지만, 다음 중 하나 이상이 있어야 한다. try 막다

try-이유성명세서

try-with-with-with 진술은 특별한 유형이다. try-catch-finally Java SE 7에서 폐기 패턴의 구현으로 도입된 문장. try-명백한 성명서 try 키워드에 이어 자동으로 릴리스되는 하나 이상의 리소스 초기화: try 블록 실행이 완료됨 리소스는 구현해야 함 java.lang.AutoCloseable. try-이러한 진술은 반드시 다음과 같은 것이 필요하지 않다. catch 또는 finally 보통 때와 달리 막다 try-catch-finally 진술들

해보다 (FileOutputStream fos = 새로운 FileOutputStream("filename");     XMLEncoder xEnc = 새로운 XMLEncoder(fos)) {     xEnc.writeObject(이의를 제기하다); } 잡히다 (IOException 이외의) {     로거.겟로거(시리얼라이저.계급.getName()).통나무를 하다(레벨.심각하다, 무효의, 이외의); } 

Java 9는 이미 선언된 변수를 사용할 수 있다.

FileOutputStream fos = 새로운 FileOutputStream("filename"); XMLEncoder xEnc = 새로운 XMLEncoder(fos); 해보다 (fos; xEnc) {     xEnc.writeObject(이의를 제기하다); } 잡히다 (IOException 이외의) {     로거.겟로거(시리얼라이저.계급.getName()).통나무를 하다(레벨.심각하다, 무효의, 이외의); } 

throw 성명서

그 throw 문장은 예외를 던지고 블록이나 방법의 실행을 끝내는 데 사용된다. 던져진 예외 인스턴스는 다음 뒤에 기록된다. throw 성명서

공허하게 하다 메서드던싱Exceptions(오브젝트 오비지) {     만일 (오비지 == 무효의) {         // NullPointer 예외 발생예외형         던지다 새로운 널포인터예외();     }     // 객체가 null인 경우 호출되지 않음     doSomethingWithObject(오비지); } 

스레드 동시성 제어

자바에는 멀티스레드 프로그래밍을 위한 도구가 내장되어 있다. 스레드 동기화를 위해 synchronized 문장은 자바 언어에 포함되어 있다.

코드 블록을 동기화하려면 다음이 선행되어야 한다. synchronized 키워드 뒤에 괄호 안에 자물쇠 물체가 있다. 실행 스레드가 동기화된 블록에 도달하면 상호 제외 잠금을 획득하여 블록을 실행한 다음 잠금을 해제한다. 잠금을 해제하기 전에는 이 블록에 스레드가 들어갈 수 없다. Null이 아닌 참조 유형은 잠금으로 사용할 수 있다.

/* 일부 객체에 대한 잠금을 획득한다. 의 것이 틀림없다. 기준 형식이며 비기준 형식이어야 함 */ 동기화된 (some Object) {     // 동기화된 문 } 

assert 성명서

assert J2SE 1.4 이후 진술서를 이용할 수 있다. 이러한 유형의 진술은 소스코드에서 주장을 펴는데 사용되는데, 이는 특정 클래스나 패키지에 대해 실행 중에 켜거나 끌 수 있다. 주장을 다음과 같이 선언하다 assert 키워드 뒤에 조건부 식을 사용한다. 평가 대상인 경우 false 진술이 실행되면 예외가 발생한다. 이 문장은 콜론 뒤에 다른 표현식을 포함할 수 있으며, 예외의 세부 메시지 역할을 할 것이다.

// n이 0이면 AssertionError가 발생함 주장하다 n != 0; /* n이 0이면 AssertionError가 발생함 콜론 뒤의 메세지와 함께 */ 주장하다 n != 0 : "n은 0과 같음"; 

원시형

자바의 원시 유형에는 정수형, 부동 소수점 번호, UTF-16 코드 단위, 부울형이 있다. Java에 서명되지 않은 유형이 있는 경우를 제외하고 char UTF-16 코드 단위를 나타내는 데 사용되는 형식. 서명되지 않은 유형의 부족은 서명되지 않은 우측 시프트 작동을 도입함으로써 상쇄된다.>>>))은 C++에 존재하지 않는다. 그럼에도 불구하고 C, C++ 이런 원인에 대한 호환성 부족에 대한 비판은 평준화돼 왔다.^[3]

char 반드시 하나의 문자와 일치하는 것은 아니다. 그것은 대리모 쌍의 일부를 나타낼 수 있으며, 이 경우 유니코드 코드 포인트가 2의 시퀀스로 표현된다. char 가치

복싱 및 언박스

이 언어 기능은 J2SE 5.0에서 도입되었다. 복싱은 원시 유형의 값을 해당 참조 유형의 값으로 변환하는 작업으로, 이 특정 원시 유형의 포장지 역할을 한다. Unboxing은 기준 유형(이전 박스화)의 값을 해당 원시 유형의 값으로 변환하는 역작동이다. 어느 작전도 명시적 변환을 필요로 하지 않는다.

예:

인트로 foo = 42; // 원시 유형 정수 술집을 내다 = foo; /* foo는 bar에 박스를 맞추고 bar는 정수형이며,                       int */의 포장지 역할을 하는 것 인트로 foo2 = 술집을 내다; // 원시 유형으로 다시 상자 해제됨 

참조 유형

참조 유형에는 클래스 유형, 인터페이스 유형 및 배열 유형이 포함된다. 생성자를 호출하면 힙에 객체가 생성되고 변수에 참조가 할당된다. 물체의 변수가 범위를 벗어나면 참조가 깨지고 참조가 남아 있지 않으면 쓰레기로 표시된다. 그리고 나서 쓰레기 수집가는 그것을 수집하여 얼마 후에 파괴한다.

기준 변수는 null 어떤 물체도 참조하지 않을 때

배열

Java의 어레이는 클래스 인스턴스와 마찬가지로 런타임에 생성된다. 배열 길이는 생성 시 정의되며 변경할 수 없다.

인트로[] 숫자 = 새로운 인트로[5]; 숫자[0] = 2; 숫자[1] = 5; 인트로 x = 숫자[0]; 

이니셜라이저

// 긴 구문 인트로[] 숫자 = 새로운 인트로[] {20, 1, 42, 15, 34}; // 짧은 구문 인트로[] 숫자2 = {20, 1, 42, 15, 34}; 

다차원 배열

자바에서 다차원 배열은 배열의 배열로 표현된다. 기술적으로 그것들은 다른 배열들에 대한 참조 배열로 표현된다.

인트로[][] 숫자 = 새로운 인트로[3][3]; 숫자[1][2] = 2;  인트로[][] 숫자2 = {{2, 3, 2}, {1, 2, 6}, {2, 4, 5}}; 

다차원 배열의 특성상 하위 배열의 길이가 다를 수 있으므로 C:와 달리 다차원 배열은 직사각형이 될 수 없다.

인트로[][] 숫자 = 새로운 인트로[2][]; //첫 번째 차원만 초기화  숫자[0] = 새로운 인트로[3]; 숫자[1] = 새로운 인트로[2]; 

반

클래스는 자바와 같은 객체 지향 언어의 기본이다. 그들은 데이터를 저장하고 조작하는 구성원을 포함하고 있다. 클래스는 최상위 레벨과 중첩으로 나뉜다. 중첩된 클래스는 둘러싸는 클래스의 개인 구성원에 접근할 수 있는 다른 클래스 내에 위치한 클래스다. 중첩 클래스는 멤버 클래스(단순 중첩을 위한 정적 수식어 또는 내부 클래스를 위한 정적 수식어로 정의할 수 있음), 로컬 클래스 및 익명 클래스를 포함한다.

선언

계급 푸 {     // 반원 } 

계급 푸 { // 최상위 클래스     계급 바 { // 이너 클래스     } } 

계급 푸 { // 최상위 클래스     정태의 계급 바 { // 중첩 클래스     } } 

계급 푸 {     공허하게 하다 술집을 내다() {         계급 푸바 {// 메서드 내의 로컬 클래스         }     } } 

계급 푸 {     공허하게 하다 술집을 내다() {         새로운 오브젝트() {// 개체를 확장하는 새 익명 클래스 만들기         };     } } 

인스턴스화

클래스의 비정적 멤버는 해당 클래스에서 생성된 객체와 관련된 인스턴스(instance) 변수와 메서드의 유형을 정의한다. 이러한 객체를 만들려면 를 사용하여 클래스를 인스턴스화해야 한다. new 운영자와 클래스 생성자를 호출하십시오.

푸 foo = 새로운 푸(); 

구성원 액세스

인스턴스 및 정적 클래스의 구성원은 다음 작업을 통해 액세스된다. . (점) 연산자.

인스턴스 멤버 액세스
인스턴스 멤버는 변수 이름을 통해 액세스할 수 있다.

끈 foo = "여보세요"; 끈 술집을 내다 = foo.토퍼케이스(); 

정적 클래스 멤버 액세스
정적 멤버는 클래스 이름이나 다른 유형을 사용하여 액세스한다. 이것은 클래스 인스턴스를 만들 필요가 없다. 정적 멤버는 다음을 사용하여 선언됨 static 수식어

공중의 계급 푸 {     공중의 정태의 공허하게 하다 어떻게 좀 해봐.() {     } }  // 정적 메서드 호출 푸.어떻게 좀 해봐.(); 

수식어

수식어는 유형 및 유형 구성원의 선언을 수정하는 데 사용되는 키워드다. 가장 주목할 만한 것은 액세스 한정자를 포함하는 하위 그룹이 있다는 것이다.

• abstract - 클래스는 기본 클래스 역할만 하며 인스턴스화할 수 없음을 지정한다.
• static - 멤버 클래스에만 사용되며, 멤버 클래스가 포함된 클래스의 특정 인스턴스에 속하지 않도록 지정한다.
• final - 로 표시된 클래스 final 하위 클래스에서 확장할 수 없으며 하위 클래스를 가질 수 없다.
• strictfp - IEEE 754에 따라 모든 부동소수점 작업을 수행해야 하며, 중간 결과를 저장하기 위해 강화된 정밀도를 사용하는 것을 금지한다.

액세스 한정자

액세스 한정자 또는 상속 한정자는 클래스, 메서드 및 기타 구성원의 접근성을 설정한다. 로 표시된 구성원 public 어디서든 닿을 수 있다. 클래스 또는 해당 멤버에 수식어가 없는 경우, 기본 액세스가 가정된다.

공중의 계급 푸 {     인트로 가다() {         돌아오다 0;     }      사유의 계급 바 {     } } 

다음 표는 클래스의 코드가 액세스 클래스 위치와 액세스 클래스 또는 클래스 멤버의 수식어에 따라 클래스 또는 메서드에 액세스할 수 있는지 여부를 보여준다.

이 이미지는 클래스 및 패키지 내의 클래스 멤버 범위를 설명한다.

생성자 및 이니셜라이저

생성자는 객체가 초기화될 때 호출되는 특별한 방법이다. 그것의 목적은 물체의 구성원을 초기화하는 것이다. 시공자와 통상적인 방법의 주요한 차이점은 클래스의 인스턴스가 만들어졌을 때만 시공자가 호출되고 아무것도 반환하지 않는다는 것이다. 생성자는 일반적인 방법으로 선언되지만, 클래스 이름을 따서 명명되고 반환 유형은 지정되지 않는다.

계급 푸 {     끈 발을 동동 구르다;      푸() { // 인수 없이 생성자          // 초기화     }      푸(끈 발을 동동 구르다) { // 인수가 하나 있는 생성자         이.발을 동동 구르다 = 발을 동동 구르다;     } } 

이니셜라이저는 클래스 또는 클래스의 인스턴스가 생성될 때 실행되는 코드 블록이다. 이니셜라이저에는 정적 이니셜라이저와 인스턴스 이니셜라이저 두 종류가 있다.

정적 이니셜라이저는 클래스가 생성될 때 정적 필드를 초기화한다. 그들은 다음을 사용하여 선언된다. static 키워드:

계급 푸 {     정태의 {         // 초기화     } } 

클래스는 한 번만 만들어진다. 따라서 정적 이니셜라이저를 두 번 이상 부르지 않는다. 반대로, 인스턴스 이니셜라이저는 클래스의 인스턴스가 생성될 때마다 생성자에 대한 호출 전에 자동으로 호출된다. 생성자 인스턴스(instance)와 달리 인스턴스 이니셜라이저는 어떠한 인수도 취할 수 없으며 일반적으로 점검된 예외를 발생시킬 수 없다(몇 가지 특별한 경우를 제외한다). 인스턴스 이니셜라이저는 키워드 없이 블록으로 선언됨:

계급 푸 {     {         // 초기화     } } 

자바에는 쓰레기 수거 메커니즘이 있기 때문에 파괴자가 없다. 그러나, 모든 물체는 finalize() 가비지 수집 전에 호출되는 방법. 이 방법은 최종화를 구현하기 위해 재정의할 수 있다.

방법들

자바에 있는 모든 문장은 메소드 내에 있어야 한다. 방법은 클래스에 속한다는 점을 제외하면 기능과 비슷하다. 메서드는 반환 값, 이름 및 일반적으로 일부 인수로 호출될 때 초기화되는 일부 매개 변수를 가지고 있다. C++와 마찬가지로 아무것도 반환하지 않는 방법에는 반환 유형이 다음과 같이 선언되어 있다. void. C++와 달리 자바에서는 기본 인수 값을 가질 수 없고 대신 메서드가 과부하된다.

계급 푸 {     인트로 술집을 내다(인트로 a, 인트로 b) {         돌아오다 (a*2) + b;     }      /* 이름이 같지만 인수 집합이 다른 과부하 메서드 */     인트로 술집을 내다(인트로 a) {         돌아오다 a*2;     } } 

방법은 다음과 같이 부른다. . 물체에 대한 표기법 또는 정적 방법의 경우, 클래스 이름에도 표기법.

푸 foo = 새로운 푸(); 인트로 결과 = foo.술집을 내다(7, 2); // foo에서 정전기 이외의 방법을 호출함  인트로 최종 결과 = 수학.복근(결과); // 정적 메서드 호출 

그 throws 키워드는 메서드가 예외를 발생시킨다는 것을 나타낸다. 선택한 모든 예외는 쉼표로 구분된 목록에 나열되어야 한다.

공허하게 하다 openStream() 던지다 IOException, myException { // IOException이 던져질 수 있음을 나타냄 } 

수식어

• abstract - 추상적인 방법은 추상적인 계층에서만 존재할 수 있으며, 추상적인 그 자체가 아닌 한 하위 클래스에서 오버라이드되어야 한다.
• static - 클래스 인스턴스를 만들지 않고도 메소드를 정적으로 만들고 액세스할 수 있게 한다. 그러나 정적 방법은 동일한 클래스의 비정적 구성원에 접근할 수 없다.
• final - 하위 클래스에서 메서드를 오버라이드할 수 없음을 선언한다.
• native - 플랫폼 종속 코드에서 JNI를 통해 이 방법이 구현됨을 나타낸다. 실제 구현은 자바 코드 밖에서 이루어지며, 그러한 방법에는 본체가 없다.
• strictfp - 부동 소수점 운영 수행 시 IEEE 754에 대한 엄격한 준수를 선언한다.
• synchronized - 이 메서드를 실행하는 스레드가 모니터를 획득해야 함을 선언함. 을 위해 synchronized 모니터가 클래스 인스턴스인 방법 java.lang.Class 방법이 정적이면
• 액세스 한정자 - 클래스와 함께 사용되는 한정자와 동일함.

바라그스

이 언어 기능은 J2SE 5.0에서 도입되었다. 방법의 마지막 주장은 가변 아리티 파라미터로 선언할 수 있으며, 이 경우 방법은 가변 아리티 방법(고정 아리티 방법과는 반대로)이 되거나 단순 바락스 방법이 된다. 이를 통해 선언된 유형의 가변 값 수를 매개 변수로서 방법(매개변수 없음 포함)으로 전달할 수 있다. 이러한 값은 배열로 방법 내부에서 사용할 수 있다.

공허하게 하다 printReport(끈 머리글, 인트로... 숫자) { //messages는 vargs를 나타낸다.     시스템.밖으로.인쇄하다(머리글);     을 위해 (인트로 숫자 : 숫자) {         시스템.밖으로.인쇄하다(숫자);     } }  // vargs 메서드 호출 printReport("보고서 데이터", 74, 83, 25, 96); 

필드

필드 또는 클래스 변수는 데이터를 저장하기 위해 클래스 본문 내부에 선언될 수 있다.

계급 푸 {     곱절로 하다 술집을 내다; } 

선언할 때 필드를 직접 초기화할 수 있다.

계급 푸 {     곱절로 하다 술집을 내다 = 2.3; } 

수식어

• static - 필드를 정적 멤버로 만든다.
• final - 생성자 또는 내부 초기화 블록에서 또는 선언 중 이른 시간에 한 번만 필드를 초기화할 수 있음.
• transient - 직렬화 중에 이 필드가 저장되지 않음을 표시한다.
• volatile - 필드가 선언된 경우 volatile모든 스레드는 변수에 대해 일관된 값을 볼 수 있다.

상속

Java의 클래스는 한 클래스에서만 상속할 수 있다. 클래스는 로 표시되지 않은 클래스에서 파생될 수 있다. final. 를 사용하여 상속이 선언된다. extends 키워드 클래스는 다음을 사용하여 자신을 참조할 수 있다. this 키워드 및 를 사용한 직접 수퍼클래스 super 키워드

계급 푸 {  }  계급 푸바 연장하다 푸 {  } 

클래스가 수퍼 클래스를 지정하지 않으면 다음에서 암시적으로 상속된다. java.lang.Object class. 따라서 자바에 있는 모든 class는 subclass이다. Object 계급

수퍼클래스에 매개변수가 없는 생성자가 없는 경우 하위 클래스는 어떤 수퍼클래스의 생성자를 사용할지 생성자에 지정해야 한다. 예를 들면 다음과 같다.

계급 푸 {     공중의 푸(인트로 n) {         // n으로 뭔가를 해라.     } }  계급 푸바 연장하다 푸 {     사유의 인트로 번호를 붙이다;     // Superclass에 매개 변수가 없는 생성자가 없음     // 그래서 우리는 우리의 슈퍼클래스의 어떤 시공자와 어떻게 사용할지 명시해야 한다.      공중의 푸바(인트로 번호를 붙이다) {         잘 하는 군요(번호를 붙이다);         이.번호를 붙이다 = 번호를 붙이다;     } } 

재지정 방법

C++와 달리 모든 비-비-비-비-final Java의 메서드는 가상이며 상속 클래스에 의해 재정의될 수 있다.

계급 작전 {     공중의 인트로 어떻게 좀 해봐.() {         돌아오다 0;     } }  계급 뉴오퍼레이션 연장하다 작전 {     @오버라이드     공중의 인트로 어떻게 좀 해봐.() {         돌아오다 1;     } } 

추상 클래스

추상 수업은 불완전하거나 불완전하다고 간주되는 수업이다. 정상계급은 추상계급인 경우에만 선언되었지만 아직 실행되지 않은 추상적인 방법, 즉 추상계급을 가질 수 있다. 클래스 C는 다음 중 하나라도 참일 경우 추상적인 방법을 가진다.

• C에는 추상적인 방법의 선언이 명시적으로 포함되어 있다.
• C의 슈퍼클래스 중 어느 것도 추상적인 방법을 가지고 있고 C는 그것을 실행하는 방법을 선언하지도 계승하지도 않는다.
• C의 직접 초인터페이스는 어떤 방법(따라서 필연적으로 추상적)을 선언하거나 계승하고, C는 그것을 실행하는 방법을 선언하거나 계승하지도 않는다.
• 그 자체가 추상적이지 않은 추상 클래스의 하위 클래스가 인스턴스화될 수 있으며, 따라서 추상 클래스에 대한 생성자를 실행하고, 따라서 해당 클래스의 인스턴스 변수에 대한 필드 이니셜라이저를 실행할 수 있다.

꾸러미 org.vocwp.test;  /**  * @author jcrypto  */ 공중의 계급 추상 클래스 {     사유의 정태의 최종의 끈 안녕;      정태의 {         시스템.밖으로.인쇄하다(추상 클래스.계급.getName() + ": 정적 블록 런타임");         안녕 = "안녕하십니까" + 추상 클래스.계급.getName();     }      {         시스템.밖으로.인쇄하다(추상 클래스.계급.getName() + ": 인스턴스 블록 런타임");     }      공중의 추상 클래스() {         시스템.밖으로.인쇄하다(추상 클래스.계급.getName() + ": 생성자 런타임");     }      공중의 정태의 공허하게 하다 안녕() {         시스템.밖으로.인쇄하다(안녕);     } } 

꾸러미 org.vocwp.test;  /**  * @author jcrypto  */ 공중의 계급 커스텀클래스 연장하다 추상 클래스 {      정태의 {         시스템.밖으로.인쇄하다(커스텀클래스.계급.getName() + ": 정적 블록 런타임");     }      {         시스템.밖으로.인쇄하다(커스텀클래스.계급.getName() + ": 인스턴스 블록 런타임");     }      공중의 커스텀클래스() {         시스템.밖으로.인쇄하다(커스텀클래스.계급.getName() + ": 생성자 런타임");     }      공중의 정태의 공허하게 하다 본래의(끈[] 아그) {         커스텀클래스 엔씨 = 새로운 커스텀클래스();         안녕();         //AxstractClass.hello():///또한 유효함     } } 

출력:

org.vocwp.test.추상 클래스: 정적 블록 런타임 조직.dwwp.test.CustomClass: 정적 블록 런타임 org.dwwp.test.추상 클래스: 인스턴스 블록 런타임 org.dwwp.test.추상 클래스: 생성자 런타임 org.dwwp.test.CustomClass: 인스턴스 블록 런타임 org.dwwp.test.CustomClass: org.dwwp.test의 생성자 런타임 hello.추상 클래스 

열거형

이 언어 기능은 J2SE 5.0에서 도입되었다. 기술적으로 열거하면 그 체내에 열거 상수가 들어 있는 클래스의 일종이다. 각 열거형 상수는 열거형 유형의 인스턴스를 정의한다. 열거 클래스는 열거 클래스 자체를 제외하고 어느 곳에서도 인스턴스화할 수 없다.

열거하다 계절 {     윈터, 봄, 여름, 가을 } 

열거형 상수는 생성자를 가질 수 있으며, 이 생성자는 클래스가 로드될 때 호출된다.

공중의 열거하다 계절 {     윈터("콜드"), 봄("워머"), 여름("핫"), 가을("쿨러");      계절(끈 설명) {         이.설명 = 설명;     }      사유의 최종의 끈 설명;      공중의 끈 getDescription() {         돌아오다 설명;     } } 

열거형에는 클래스 본체가 있을 수 있으며, 이 경우 열거형 클래스를 확장하는 익명 클래스처럼 처리된다.

공중의 열거하다 계절 {     윈터 {         끈 getDescription() {돌아오다 "냉정";}     },     봄 {         끈 getDescription() {돌아오다 "warmer";}     },     여름 {         끈 getDescription() {돌아오다 "핫";}     },     가을 {         끈 getDescription() {돌아오다 "cooler";}     }; } 

인터페이스

인터페이스는 필드를 포함하지 않는 유형이며, 일반적으로 실제 구현 없이 여러 가지 방법을 정의한다. 그들은 많은 수의 서로 다른 구현으로 계약을 정의하는 데 유용하다. 모든 인터페이스는 암묵적으로 추상적이다. 인터페이스 메소드는 언어 버전에 따라 액세스 한정자의 하위 집합을 가질 수 있다. strictfp, 그것은 수업과 같은 효과를 가지고 있고, 또한 static Java SE 8 이후.

접점 ActionListener {     인트로 조치_추가 = 0;     인트로 조치_제거 = 1;       공허하게 하다 액션선택됨(인트로 액션); } 

인터페이스 구현

클래스에 의해 구현되는 인터페이스는 implements 키워드 2개 이상의 인터페이스를 구현할 수 있으며, 이 경우 다음에 작성된다. implements 쉼표로 구분된 목록의 키워드 인터페이스를 구현하는 클래스는 모든 방법을 재정의해야 하며, 그렇지 않으면 추상적인 것으로 선언해야 한다.

접점 RequestListener {     인트로 요청 수신됨(); }  계급 액션핸들러 기구들 ActionListener, RequestListener {     공중의 공허하게 하다 액션선택됨(인트로 액션) {     }      공중의 인트로 요청 수신됨() {     } }  //인터페이스로 정의된 호출 방식 RequestListener 듣는 사람 = 새로운 액션핸들러(); /*ActionHandler는 다음과 같을 수 있다.                                    RequestListener로 표시됨...*/ 듣는 사람.요청 수신됨(); /*... 따라서 구현되는 것으로 알려져 있음                             request Received() 메서드*/ 

기능 인터페이스 및 람다 식

이러한 기능들은 Java SE 8의 출시와 함께 도입되었다. 인터페이스는 오직 하나의 방법만을 정의하면 자동적으로 기능 인터페이스가 된다. 이 경우 구현은 새로운 클래스에서 구현하는 대신 람다 표현으로 표현될 수 있으므로 기능적 스타일의 코드 작성을 크게 단순화할 수 있다. 기능 인터페이스는 선택적으로 로 주석을 달 수 있다. @FunctionalInterface 주석: 인터페이스가 실제로 기능 인터페이스의 정의에 부합하는지 여부를 컴파일러에게 알려준다.

// 기능 인터페이스 @기능적인터페이스 접점 계산 {     인트로 계산하다(인트로 일부 번호, 인트로 someOtherNumber); }  // 이 인터페이스를 매개 변수로 받아들이는 방법 인트로 런계산(계산 계산) {     돌아오다 계산.계산하다(1, 2); }  // 람다를 사용하여 메소드를 호출 런계산((번호를 붙이다, otherNumber) -> 번호를 붙이다 + otherNumber);  // 익명 클래스를 대신 사용하는 동등한 코드 런계산(새로운 계산() {     @오버라이드     공중의 인트로 계산하다(인트로 일부 번호, 인트로 someOtherNumber) {         돌아오다 일부 번호 + someOtherNumber;     } }) 

람다의 매개변수 유형은 완전히 명시될 필요가 없으며 구현하는 인터페이스에서 유추할 수 있다. 람다의 몸은 몸통과 글씨가 없어도 글씨를 쓸 수 있다. return 표현일 뿐이라면 진술. 또한 방법에서 단일 매개변수만 갖는 인터페이스의 경우 원형 대괄호는 생략할 수 있다.^[5]

// 위와 같은 통화지만 완전히 지정된 유형과 차체 블록 런계산((인트로 번호를 붙이다, 인트로 otherNumber) -> {     돌아오다 번호를 붙이다 + otherNumber; });  // 단일 매개 변수만 있는 메서드의 기능 인터페이스 접점 스트링 익스텐더 {     끈 extendString(끈 입력하다); }  // 람다를 사용하여 이 유형의 변수 초기화 스트링 익스텐더 연장하다 = 입력하다 -> 입력하다 + "확장"; 

방법 참조

인터페이스와 호환되는 명명된 방법이 이미 있는 경우에는 람다스를 사용할 필요가 없다. 이 방법은 방법 참조를 사용하여 람다 대신 통과시킬 수 있다. 방법 참조에는 다음과 같은 몇 가지 유형이 있다.

위 코드에서 호출 코드 runCalculation 방법 참조를 사용하여 다음과 같이 대체할 수 있다.

런계산(정수::합계를 내다); 

상속

인터페이스는 클래스처럼 다른 인터페이스로부터 상속받을 수 있다. 클래스와 달리 여러 인터페이스에서 상속이 허용된다. 그러나 여러 인터페이스가 같은 이름의 필드를 가질 수 있으며, 이 경우 단일 모호한 구성원이 되어 접속할 수 없게 된다.

/* 이 인터페이스를 구현하는 클래스는 두 가지 방법을 모두 구현해야 한다. ActionListener 및 RequestListener */ 접점 EventListener 연장하다 ActionListener, RequestListener {     } 

기본 방법

자바 SE 8은 개발자가 인터페이스를 이미 구현한 클래스와의 호환성을 깨지 않고 기존 인터페이스에 새로운 방법을 추가할 수 있는 인터페이스에 디폴트 메소드를 도입했다. 일반적인 인터페이스 방법과 달리, 기본 방법은 구현 클래스가 이를 무시하지 않을 경우 호출될 본문을 가지고 있다.

접점 StringManipulator {     끈 extendString(끈 입력하다);          // 구현하기 위해 선택적인 방법     체납 끈 단축 문자열(끈 입력하다) {         돌아오다 입력하다.하위 문자열(1);     } }  // 모든 방법을 구현하지 않았음에도 불구하고 유효한 클래스임 계급 부분스트링매니폴레이터 기구들 StringManipulator {     @오버라이드     공중의 끈 extendString(끈 입력하다) {         돌아오다 입력하다 + "확장";     } } 

정적 방법

정적 방법은 Java SE 8에서 도입된 또 다른 언어 기능이다. 그들은 수업과 정확히 같은 방식으로 행동한다.

접점 StringUtils {     정태의 끈 단축 기준원심볼(끈 입력하다) {         돌아오다 입력하다.하위 문자열(1);     } }  StringUtils.단축 기준원심볼("테스트"); 

개인 방법

Java 9 릴리스에는 개인 방법이 추가되었다. 인터페이스는 개인으로 표시된 본체를 가진 방법을 가질 수 있으며, 이 경우 클래스를 상속하는 것은 보이지 않을 것이다. 코드 재사용을 목적으로 디폴트 방식에서 호출할 수 있다.

접점 로거 {     체납 공허하게 하다 로그오류() {         통나무를 하다(레벨.오류);     }      체납 공허하게 하다 로그인포() {         통나무를 하다(레벨.정보);     }      사유의 공허하게 하다 통나무를 하다(레벨 수평을 이루다) {         시스템 로거.통나무를 하다(수평을 이루다.id);     } } 

주석

Java의 주석은 메타데이터를 코드에 내장하는 방법이다. 이 언어 기능은 J2SE 5.0에서 도입되었다.

주석 유형

Java는 일련의 미리 정의된 주석 유형을 가지고 있지만 새로운 주석 유형을 정의할 수 있다. 주석 유형 선언은 인터페이스 선언의 특별한 유형이다. 그것들은 인터페이스를 제외한 인터페이스와 같은 방법으로 선언된다. interface 키워드는 다음이 선행한다. @ 서명. 모든 주석은 다음에서 암시적으로 확장된다. java.lang.annotation.Annotation 다른 어떤 것에서도 연장될 수 없다.

@interface 차단작동작 { } 

주석은 본문에서 공통 인터페이스와 동일한 선언을 가질 수 있으며, 추가적으로 열거 및 주석을 포함할 수 있다. 가장 큰 차이점은 추상적 방법 선언에는 어떤 매개 변수가 없어야 하고 어떤 예외도 있어서는 안 된다는 것이다. 또한 기본값을 가질 수 있으며, 기본값은 를 사용하여 선언된다. default 메서드 이름 뒤의 키워드:

@interface 차단작동작 {     부울 fileSystemOperations();     부울 네트워크운영() 체납 거짓의; } 

주석 사용

주석은 패키지, 클래스(에누스 포함), 인터페이스(주석 포함), 필드, 방법, 매개변수, 생성자 또는 로컬 변수 등 모든 종류의 선언에서 사용될 수 있다. 또한 그것들은 열거형 상수와 함께 사용될 수 있다. 주석을 사용하여 선언한다. @ 앞의 기호 주석 유형 이름 뒤에 요소-값 쌍이 대괄호 안에 기록된다. 기본값이 없는 모든 요소에는 값을 할당해야 한다.

@BlockingOperations(/*message*/ fileSystemOperations, /*선택사항*/ 네트워크운영 = 진실의) 공허하게 하다 openOutputStream() { //공지 방법 } 

주석을 선언하는 형식은 일반 형식 외에 두 가지 형태가 있는데, 이 형식은 속기형이다. 마커 주석은 짧은 형식이며, 요소에 값을 할당하지 않을 때 사용된다.

@Unused // @Unused()에 대한 속기 공허하게 하다 travelToJupiter() { } 

다른 짧은 형태는 단일 요소 주석이라고 불린다. 하나의 요소만을 포함하는 주석형이나 복수의 요소가 존재하는 경우, 하나의 요소에만 기본값이 결여되어 있는 경우에 사용한다. 단일 요소 주석 양식에서는 요소 이름이 생략되고 대신 값만 기록된다.

/* @BlockingOperations(fileSystemOperations = true). networkOperations에는 기본값이 있으며 값을 할당할 필요가 없음 */  @BlockingOperations(진실의) 공허하게 하다 openOutputStream() { } 

제네릭스

제네릭 또는 파라미터화된 유형 또는 파라메트릭 다형성은 J2SE 5.0에서 도입된 주요 특징 중 하나이다. 제네릭이 도입되기 전에는 모든 종류를 명시적으로 선언하도록 요구되었다. 제네릭을 사용하면 정확한 유형을 선언하지 않고도 다른 유형과 유사한 방식으로 작업할 수 있게 되었다. 제네릭의 주요 목적은 형식 안전을 보장하고 컴파일 중에 런타임 오류를 감지하는 것이다. C#과 달리, 사용된 파라미터에 대한 정보는 유형 삭제로 인해 런타임에 이용할 수 없다.^[6]

일반 클래스

각괄호 안에 형식 변수를 추가하여 클래스를 매개변수로 지정할 수 있다.< 그리고 >) 클래스 이름 뒤에 있음. 실제 유형 대신 클래스 멤버에서 이 유형 변수를 사용할 수 있도록 한다. 두 개 이상의 유형 변수가 있을 수 있으며, 이 경우 쉼표로 구분된 리스트로 선언된다.

형식 변수를 특정 클래스의 하위 유형으로 제한하거나 형식에 의해 구현되어야 하는 인터페이스를 선언할 수 있다. 이 경우 형식 변수는 다음과 같이 추가된다. extends 키워드 뒤에 클래스 또는 인터페이스 이름이 표시됨. 변수가 클래스 및 인터페이스 모두에 의해 제약되거나 인터페이스가 여러 개 있는 경우 클래스 이름이 먼저 작성되고 다음으로 인터페이스 이름이 & 구분 기호로 사용되는 기호

/* 이 클래스는 T와 V의 두 가지 유형 변수를 가지고 있다. T는 반드시  ArrayList의 하위 유형 및 Formattable 인터페이스 구현 */ 공중의 계급 매퍼<T 연장하다 배열 목록 & 서식할 수 있는, V> {     공중의 공허하게 하다 덧셈을(T 배열하다, V 항목) {         // 어레이에 ArrayList 하위 클래스이기 때문에 추가 메서드가 있음         배열하다.덧셈을(항목);     } } 

매개변수화된 유형의 변수가 선언되거나 인스턴스가 생성될 때, 실제 유형이 유형 변수 선언의 위치에 기록되는 것을 제외하고, 그 유형은 클래스 헤더에서와 정확히 동일한 형식으로 작성된다.

/* Mapper는 CustomList를 T로, 정수(Instant)를 V로 하여 생성된다. CustomList는 ArrayList의 하위 클래스여야 하며 Formattable */ 구현 매퍼<CustomList, 정수> 매퍼 = 새로운 매퍼<CustomList, 정수>(); 

자바 SE 7부터는 다이아몬드(Diamond)를 사용할 수 있다.<>) 형식 인수 대신, 이 경우 후자를 유추한다. Java SE 7의 다음 코드는 앞의 예와 동일하다.

매퍼<CustomList, 정수> 매퍼 = 새로운 매퍼<>(); 

매개변수화된 유형에 대한 변수를 선언할 때 명시적 형식 이름 대신 와일드카드를 사용할 수 있다. 와일드카드는 글로 표현된다. ? 실형 대신 서명하다 일부 특정 클래스의 하위 클래스 또는 슈퍼 클래스로 가능한 유형을 한정할 수 있다. extends 키워드 또는 더 super 해당 키워드 뒤에 클래스 이름이 표시됨

/* CustomList를 첫 번째 매개 변수로 사용하는 모든 매퍼 인스턴스 두 번째 것과 상관없이 사용할 수 있다.*/ 매퍼<CustomList, ?> 매퍼; 매퍼 = 새로운 매퍼<CustomList, 부울>(); 매퍼 = 새로운 매퍼<CustomList, 정수>();  /* 다음을 제외한 어떤 유형도 사용하지 않음 두 번째 파라미터로 Number의 하위 클래스 */ 공허하게 하다 애드매퍼(매퍼<?, ? 연장하다 숫자> 매퍼) { } 

일반 방법 및 생성자

제네릭의 사용은 일부 특정 방법으로 제한될 수 있으며, 이 개념은 생성자에게도 적용된다. 매개 변수화된 방법을 선언하려면 일반 클래스와 동일한 형식으로 메서드의 반환 형식 앞에 입력 변수를 기록하십시오. 생성자의 경우 유형 변수는 생성자 이름 앞에 선언된다.

계급 매퍼 {     // 클래스 자체가 일반적이지 않고 생성자가     <T, V> 매퍼(T 배열하다, V 항목) {     } }  /* 이 방법은 다음과 같은 유형의 배열만 허용함 검색 항목 유형 또는 하위 유형*/ 정태의 <T, V 연장하다 T> 부울 포함하다(T 항목, V[] arr) {     을 위해 (T currentItem : arr) {         만일 (항목.대등하다(currentItem)) {             돌아오다 진실의;         }     }     돌아오다 거짓의; } 

일반 인터페이스

인터페이스는 클래스와 유사한 방식으로 매개변수를 지정할 수 있다.

접점 확장 가능<T 연장하다 숫자> {     공허하게 하다 애디템(T 항목); }  // 이 클래스는 매개 변수 지정됨 계급 배열<T 연장하다 숫자> 기구들 확장 가능<T> {     공허하게 하다 애디템(T 항목) {     } }  // 그리고 이것은 아니며 대신 명시적 유형을 사용한다. 계급 정수 배열 기구들 확장 가능<정수> {     공허하게 하다 애디템(정수 항목) {     } } 

참고 항목

• Java 플랫폼, Standard Edition

참조

외부 링크

위키북스는 Java Programming/Syntax를 주제로 한 책을 가지고 있다.

• Java 언어 규격, 제3판 Java 언어에 대한 권위 있는 설명
• Java SE 10 API Javadocs