C Sharp와 Java의 비교
Comparison of C Sharp and Java![]() |
비교 프로그래밍 언어 |
---|
|
이 문서에서는 다음 두 가지 프로그래밍 언어를 비교합니다.C# (Java 사용)이 기사의 초점은 주로 언어와 그 기능에 맞춰져 있지만, 이러한 비교에서는 플랫폼과 라이브러리의 몇 가지 특징도 고려해야 합니다.플랫폼의 상세한 비교에 대해서는, 「Java 와의 비교」를 참조해 주세요.NET 플랫폼
C#과 Java는 정적으로, 강하게, 명확하게 입력되는 유사한 언어입니다.둘 다 객체 지향으로 세미 인터프리테이션 또는 런타임 저스트 인 타임 컴파일로 설계되었으며 둘 다 C 및 C++와 같은 곱슬곱슬한 괄호 언어입니다.
종류들
![]() | 이 섹션은 너무 길어서 쉽게 읽고 탐색할 수 없습니다.. (2014년 10월) 이 문제를 |
데이터형 | 자바 | C# |
---|---|---|
임의의 크기의 소수점 | 참조 유형, 연산자 없음[1] | 서드파티 라이브러리[2] |
임의의 크기의 정수 | 참조 유형, 연산자 없음 | 네, 그렇습니다[3]. |
어레이 | 네, 그렇습니다[4]. | 네. |
부울형 | 네. | 네. |
성격 | 네, 그렇습니다[5]. | 네. |
복소수 | 서드파티 라이브러리[6] | 네. |
날짜/시간 | 있음, 참조[7] 유형 | 있음; 값 유형 |
열거형 | 있음, 참조 유형 | 있음, 스칼라 |
고정밀 10진수 | 아니요. 하지만 위의 '임의 크기 소수점'을 참조하십시오. | 128비트(28자리) 10진수형[8] |
IEEE 754 바이너리 32 부동 소수점 번호 | 네. | 네. |
IEEE 754 바이너리64 부동 소수점 번호 | 네. | 네. |
리프팅(Nullable) 유형 | 아니요. 하지만 래퍼 유형 | 네. |
포인터 | 아니요.[9] 메서드 참조만[10] 가능합니다. | 네, 그렇습니다[11]. |
참조 유형 | 네. | 네. |
부호 있는 정수 | 있음, 8, 16, 32, 64비트 | 있음, 8, 16, 32, 64비트 |
줄들 | 불변의 참조 타입, 유니코드 | 불변의 참조 타입, 유니코드 |
주석 입력 | 네. | 네. |
싱글 루트(통합) 타입 시스템 | 아니요. 하지만 래퍼 유형 | 네, 그렇습니다[12]. |
튜플 | 아니요. 서드파티가 한정되어 있습니다.[13] | 네, 그렇습니다[14]. |
부호 없는 정수 | 아니요. 하지만 몇 가지 방법이 지원됩니다.[15] | 있음, 8, 16, 32, 64비트 |
value | 만. 프리미티브 유형만 | 네, □□입니다. |
두 언어 모두 클래스 기반 객체 방향으로 정적으로 입력됩니다.Java에서 원시 유형은 객체 지향적이지 않고 언어 자체를 사용하여 정의할 수 없다는 점에서 특별합니다.또한 참조 유형과 공통 조상을 공유하지 않습니다.Java 참조 유형은 모두 공통 루트 유형에서 파생됩니다.C#에는 최종적으로 모든 타입(불안전한[16] 포인터 제외)이 공통 루트타입에서 파생되는 통합형 시스템이 있습니다.따라서 모든 유형이 이 루트 유형의 메서드를 구현하고 유형에 정의된 확장 메서드는 모든 유형, 심지어 원시 리터럴 및 위임에도 적용됩니다.이를 통해 Java와 달리 C#은 참조 유형이 아닌 캡슐화를 사용하는 개체를 지원할 수 있습니다.
Java에서 복합 유형은 참조 유형과 동의어입니다. 클래스 참조 유형이 아니면 메서드를 정의할 수 없습니다.C#에서는 캡슐화 및 메서드의 개념이 참조 요건에서 분리되어 있기 때문에 타입이 참조 타입이 아닌 메서드와 캡슐화를 지원할 수 있습니다.그러나 가상 메서드와 전문화를 지원하는 것은 참조 유형뿐입니다.
두 언어 모두 참조가 아닌 값으로 복사 및 전달되는 많은 기본 제공 유형을 지원합니다.Java는 이러한 유형을 원시 유형이라고 부르지만 C#에서는 단순 유형이라고 부릅니다.일반적으로 원시/심플 타입은 기본 프로세서 아키텍처에서 기본적으로 지원됩니다.
C# 심플 타입은 여러 인터페이스를 구현하기 때문에 리터럴에서도 많은 메서드를 해당 유형의 인스턴스에 직접 제공합니다.C# 타입명도 Common Language Runtime(CLR; 공통언어 런타임) 타입의 에일리어스일 뿐입니다.C# 타입은 타입과 완전히 같은 타입입니다.단, 전자가 canonical이라는 점만 다릅니다.NET 이름, 후자는 그 C# 에일리어스입니다.
Java는 원시 유형에서 직접 메서드를 제공하지 않습니다.대신 원시 값에 대해 작동하는 메서드는 동반 원시 래퍼 클래스를 통해 제공됩니다.이러한 래퍼 클래스의 고정 집합이 존재하며, 각 클래스는 원시 유형의 고정 집합 중 하나를 래핑합니다.예를 들어 Java 유형은 원시 유형을 래핑하는 참조 유형입니다.그러나 그들은 같은 타입이 아니다.
(「」)
)
있는
Java와 C#은 모두 8, 16, 32 및 64비트의 부호 있는 정수를 지원합니다.Java에서는 8비트 정수를, C#에서는 (서명 바이트)를 제외하고, 같은 이름 또는 에일리어스를 타입에 사용합니다.
없는
C#은 부호 있는 정수 타입 외에 부호 없는 정수 타입도 지원합니다.부호 없는 타입은 8, 16, 32 및 64비트 폭의 경우, 및 입니다.형식에서 부호 없는 산술 연산도 지원됩니다.예를 들어, 부호 없는 uint정수를 2개 더해도 긴 정수나 부호 있는 정수가 아닌 가 생성됩니다.
Java는 부호 없는 정수 유형을 지원하지 않습니다.특히 Java에는 부호 없는 바이트에 대한 원시 유형이 없습니다.대신, Java의 유형은 부호 확장이며, 이는 [17]버그와 혼란의 일반적인 원인입니다.
James Gosling은 프로그래머가 부호 없는 산술이 어떻게 작동하는지 이해하지 못할 것이라고 믿었기 때문에 부호 없는 정수는 의도적으로 Java에서 제외되었다.
프로그래밍 언어 설계에서, 표준 문제 중 하나는 언어가 너무 복잡해서 아무도 이해할 수 없다는 것이다.제가 시도했던 작은 실험 중 하나는 사람들에게 C의 부호 없는 산술 규칙에 대해 물어보는 것이었습니다.C의 부호 없는 산술이 어떻게 작용하는지 아무도 모르는 것으로 밝혀졌습니다.사람들이 이해할 수 있는 몇 가지 분명한 것들이 있지만,[9][18] 많은 사람들은 이해하지 못한다.
('10')
C#에는 고정밀(10진수 28자리) 10진수 산술용 타입과 리터럴 표기가 있어 재무 [19][20][21]및 화폐 계산에 적합합니다.및 데이터 타입과는 달리 0.1과 같은 10진수 소수는 정확하게 10진수 표현으로 나타낼 수 있습니다.부동표현 및 이중표현에서 이러한 숫자는 종종 비종단 이진수 확장을 가지므로 이러한 표현은 반올림 오류가 [20]발생하기 쉽습니다.
Java에는 이러한 빌트인 타입이 없지만 Java 라이브러리는 임의의 정밀도 10진수 타입을 갖추고 있습니다.이는 언어 유형으로 간주되지 않으며 일반적인 산술 연산자를 지원하지 않습니다. 오히려 형식 방법을 사용하여 조작해야 하는 참조 유형입니다.아래 임의 크기/정밀 숫자에 대한 자세한 내용은 참조하십시오.
수치 급급 advanced 。
두 언어 모두 임의 크기 정수 및 소수점 계산을 위한 라이브러리 정의 임의 정밀도 산술 유형을 제공합니다.
임의의 정밀도 소수점 계산을 위한 데이터 유형을 가진 것은 Java뿐입니다.복소수 처리 타입은 C#뿐입니다.
어느 언어에서도, 고도의 수치 타입으로 실행할 수 있는 조작의 수는, 짜넣기 IEEE 754 부동 소수점 타입에 비해 제한됩니다.예를 들어, 임의의 크기 유형은 제곱근이나 로그를 지원하지 않습니다.
C#에서는 커스텀 암묵적/명시적 변환과 연산자 오버로드를 사용하여 라이브러리 정의 유형을 기존 유형 및 연산자와 통합할 수 있습니다.라이브러리 정의 유형 통합 섹션의 예를 참조하십시오.
( )
두 언어 모두 네이티브(문자) 데이터형을 단순 유형으로 제공합니다.이 유형은 비트 연산자와 함께 사용할 수 있지만 이 작업은 작업 전에 값을 정수 값으로 승격함으로써 수행됩니다.따라서 비트 연산 결과는 두 언어 모두 문자가 아닌 숫자 유형입니다.
데이터
두 언어 모두 문자열을 참조 유형의 개체로 취급합니다.두 언어 모두 이 유형에는 문자열, 구문 분석, 형식 등을 조작하는 여러 가지 방법이 포함되어 있습니다.양쪽 언어에서 정규 표현은 외부 기능으로 간주되며 별도의 클래스로 구현됩니다.
두 언어의 라이브러리는 서로 다른 문화권의 날짜 및 달력으로 작업하기 위한 클래스를 정의합니다.Java는 가변 참조 유형이며 C#은 구조 값 유형입니다.C# 에서는, 기간을 사용하는 타입도 정의합니다.두 언어 모두 다른 문화에 따른 날짜와 시간 계산을 지원합니다.
★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★
C#을 사용하면 프로그래머는 키워드를 사용하여 사용자 정의 값 유형을 만들 수 있습니다.클래스와는 달리 표준 프리미티브와 마찬가지로 이러한 값 유형은 참조가 아닌 값으로 전달되고 할당됩니다.또한 오브젝트의 일부(필드 또는 박스형)가 될 수도 있고 클래스 유형에 대해 일반적으로 존재하는 메모리 간접 없이 배열에 저장할 수도 있습니다.
값 유형은 값에 대한 개념이 없고 초기화 없이 배열에서 사용할 수 있으므로 기본적으로 구조 메모리 공간을 0으로 채우는 암묵적인 기본 생성자가 항상 제공됩니다.프로그래머는 하나 이상의 인수가 있는 추가 생성자만 정의할 수 있습니다.값 유형에는 가상 메서드 테이블이 없습니다.이러한 테이블(및 고정 메모리 사용 공간)은 암묵적으로 씰링됩니다.다만, 값 타입은, 인터페이스를 실장할 수 있습니다(및 실장하는 경우가 있습니다.예를 들어 임베디드 정수형은 여러 인터페이스를 구현합니다.
기본 제공 프리미티브 유형 외에 Java는 값 유형의 개념을 포함하지 않습니다.
열거
두 언어 모두 열거를 정의하지만 기본적으로 다른 방식으로 구현됩니다.따라서 열거는 두 언어 간의 코드를 자동으로 변환하도록 설계된 도구(Java에서 C# 변환기 등)에서 장애가 발생하는 영역입니다.
C#은 C와 유사한 방법으로 열거를 구현하고 있습니다.즉, 기본 적분형(int, 바이트, short 등)으로 구현된 비트플래그 주변에 래퍼로서 구현되어 있습니다.이로 인해 퍼포먼스가 향상되어 C/C++ 컴파일된 코드와의 상호작용이 개선됩니다.단, C# 언어에서 허용된 바와 같이 낮은 수준의 값 유형을 열거형으로 직접 캐스트하면 버그가 발생할 수 있습니다.그러므로, 그것은 통사적인 [22]설탕으로 보여진다.이와는 대조적으로 Java는 완전한 기능의 인스턴스 모음으로 열거를 구현하여 더 많은 메모리를 필요로 하며 C/C++ 코드와의 상호작용을 지원하지 않지만 리플렉션과 본질적인 동작에서 추가 기능을 제공합니다.각 언어의 실장은 다음 표에 설명되어 있습니다.
바 | C# | |
---|---|---|
★★★ | Java에서 열거형은 클래스이며 값은 해당 클래스의 개체(인스턴스)입니다.유효한 값은 열거에 나열된 값뿐입니다.열거 유형은 필드를 선언하여 각 열거된 값이 해당 특정 값과 고유하게 연관된 추가 데이터를 참조할 수 있도록 합니다.열거형은 메서드를 선언 또는 덮어쓰거나 인터페이스를 [23]구현할 수도 있습니다. | C#의 열거는 암묵적으로 값 유형 파생 유형에서 파생됩니다.C# 열거값 세트는 8, 16, 32 또는 64비트의 부호 있는 정수 타입 또는 부호 없는 정수 타입으로 정의할 수 있습니다.열거 정의는 선택한 정수 [23][24]값의 이름을 정의합니다.기본적으로는 이름에는 값 0(제로)이 할당되며 다음 이름은 1씩 증가합니다.기본 프리미티브 유형의 값은 열거 유형의 유효한 값이지만 할당하려면 명시적 캐스트가 필요할 수 있습니다. |
★★의 | Java 열거 세트 및 맵 컬렉션은 여러 열거 값을 결합된 값으로 결합하는 기능을 제공합니다.이러한 특별한 컬렉션을 통해 컴파일러 최적화를 통해 컬렉션을 조합 메커니즘으로 사용함으로써 발생하는 오버헤드를 최소화할 수 있습니다. | C#은 실제 값이 비트 단위로 열거된 값의 조합이거나 함께 사용될 수 있는 비트 매핑 열거를 지원합니다.유형에 의해 암묵적으로 정의된 포맷 및 구문 분석 메서드는 이러한 값을 사용하려고 합니다. |
C#과 Java 모두에서 프로그래머는 문자열 또는 원시 정수 타입으로 변환하지 않고 스위치스테이트먼트 내의 열거를 사용할 수 있습니다.단, C#에서는 case 스테이트먼트에 코드가 포함되지 않는 한 암묵적인 폴 스루는 허용되지 않습니다.이는 찾기 어려운 [25]버그의 일반적인 원인이기 때문입니다.폴스루는 goto [26]문을 사용하여 명시적으로 선언해야 합니다.
, 메서드 , " " " "
C#은 위임 형식으로 객체 지향 메서드 포인터를 구현합니다.대리자는 메서드에 대한 참조를 캡처할 수 있는 특수 유형입니다.이 참조는 위임 유형 변수에 저장하거나 위임 매개 변수를 통해 메서드에 전달하여 나중에 호출할 수 있습니다.C# 대리인은 공분산 및 위반을 지원하며 시그니처 호환 정적 메서드, 인스턴스 메서드, 익명 메서드 또는 람다 표현에 대한 참조를 유지할 수 있습니다.
딜러는 폐쇄 및 인라인 기능과 혼동해서는 안 됩니다.폐색/인라인 함수에 대한 참조를 딜러 참조에 캡처해야 유용하기 때문에 이러한 개념은 관련이 있습니다.단, 위임자가 항상 인라인 함수를 참조하는 것은 아닙니다.기존 스태틱 또는 인스턴스 메서드를 참조할 수도 있습니다.딜러는 C# 이벤트의 기초를 형성하지만 이것들과 혼동해서는 안 됩니다.
대리인은 불필요하고 언어에 유해하다고 간주되어 퍼포먼스상의 [27]문제가 발생할 가능성이 있기 때문에 의도적으로 Java에서 제외되었습니다.대신 대체 메커니즘이 사용됩니다.클라이언트가 기존의 인터페이스를 통해1개 이상의 클라이언트 정의 메서드에 액세스 할 수 있다는 점에서 C#의 위임자와 유사한 래퍼 패턴도 그러한 [citation needed]메커니즘의 하나입니다.다른 하나는 내부 클래스를 사용한 어댑터 오브젝트의 사용으로, Java의 설계자들은 바인딩된 메서드 [27]참조보다 더 나은 솔루션이라고 주장했습니다.
C# 위임자 및 동등한 Java 구성 예도 참조하십시오.
리프팅(Nullable) 유형
C#에서는 값/프라이머리/단순 유형을 "리프트"하여 유형의 네이티브 값 외에 특별한 값을 사용할 수 있습니다.타입명에 서픽스를 추가하면 타입이 해제됩니다.이는 범용 타입을 사용하는 것과 동일합니다.여기서 는 리프팅할 타입입니다.변환은 기본 유형과 리프팅 유형의 값을 변환하도록 암묵적으로 정의됩니다.리프팅된 타입은 비교하거나 테스트할 수 있습니다.또한 리프팅되지 않은 베이스에 따라 암묵적으로 자동으로 정의되며, 일부 부울 연산자를 제외하고 null 인수가 결과에 전파됩니다.
Java는 타입 리프팅을 개념으로 지원하지 않지만 모든 기본형은 대응하는 래퍼 타입을 가지고 있으며 참조 타입(클래스)이기 때문에 값을 지원합니다.클래스)이기 때문에 값을 지원합니다.
Java 사양에 따르면 참조를 해제하려고 하면 런타임에 예외가 발생해야 합니다(정의상 메모리 내의 오브젝트를 가리키지 않기 때문에 참조를 해제하는 것은 의미가 없습니다).이것은 래퍼 타입의 변수를 언박스로 하려고 할 때도 적용됩니다.이 경우 프로그램은 예외를 발생시킵니다.이는 박스 해제할 객체가 없기 때문입니다.따라서 후속 계산에 참여할 박스 값이 없기 때문입니다.
다음으로 다른 동작을 나타내는 예를 나타냅니다.C#에서는 lifted*operator가 오퍼랜드의 값을 전파합니다.Java에서는 늘 참조를 언박스로 하면 예외가 발생합니다.
모든 C# 리프팅 연산자가 피연산자 중 하나가 인 경우 무조건 전파되도록 정의된 것은 아닙니다. 구체적으로는 부울 연산자가 3진 로직을 지원하도록 리프팅되어 SQL에서 임피던스를 유지합니다.
Java 부울 연산자는 3진 로직을 지원하지 않으며 기본 클래스 라이브러리에도 구현되지 않습니다.
C#에는 리플렉션 없는 동적 호출, 동적 언어와의 상호 운용성 및 문서 객체 모델에 대한 애드혹바인딩을 지원하는 레이트바운드의 다이내믹타입을 갖추고 있습니다.이 유형은 컴파일 시 정적/가상적 접근이 아닌 런타임에 동적으로 구성원 액세스를 해결합니다.멤버 룩업메커니즘은 폴백메커니즘으로서 기존의 리플렉션을 사용하여 확장할 수 있습니다.
C# 의 타입에는, 다음의 몇개의 사용 사례가 있습니다.
- 반사의 장황한 사용 감소:인스턴스를 유형에 캐스팅함으로써 Reflection API를 직접 사용하지 않고도 속성, 메서드, 이벤트 등의 멤버를 인스턴스에서 직접 호출할 수 있습니다.
- 동적 언어와의 상호 운용성:다이내믹 타입에는 동적 타입의 오브젝트 및 효율적인 멤버룩업을 위한 공통 런타임인프라스트럭처를 구현하기 위한 허브 앤 스포크 지원이 포함되어 있습니다.
- 동적 추상화 작성: 예를 들어 동적 객체를 사용하면 XML 또는 XHTML 문서와 같은 문서 객체 모델에 쉽게 액세스할 수 있습니다.
자바어의 사용 Java 에서는하는 구조가 다릅니다.C# c 、 에 、 Java 、 릅 、 릅릅 。
- 기존 유형의 동적 레이트바인드 바이네임 호출의 경우 리플렉션을 사용해야 합니다.
- 동적 언어와의 상호 운용성을 위해서는 해당 언어에 고유한 상호 운용성 API를 사용해야 합니다.Java 가상 시스템 플랫폼에는 여러 동적 언어가 구현되어 있지만 언어 간에 개체를 전달하는 방법에 대한 공통 표준은 없습니다.일반적으로 여기에는 어떤 형태의 반사 또는 반사 API가 포함됩니다.Java에서 [28]JavaFX 개체를 사용하는 방법의 예시로 사용합니다.
- 예를 들어 문서 객체 모델 추상화와의 상호작용과 같이 실행 시 객체 전체를 생성하고 상호 작용하려면 특정 추상화 API를 사용해야 합니다.
예: #다이나믹 언어와의 상호 운용성도 참조해 주세요.
Java는 Java 런타임 환경 내에서 포인터 및 포인터 산술을 허용하지 않습니다.자바 언어 설계자들은 포인터가 프로그래머들이 그들의 코드에 버그를 넣을 수 있게 해주는 주요 기능들 중 하나이며 그것들을 지원하지 않기로 [9]결정했다.Java는 기본 운영 체제와 객체/구조를 직접 주고받는 것을 허용하지 않기 때문에 객체/구조를 이러한 특정 메모리 레이아웃으로 모델링할 필요가 없습니다.Java와 기본 운영 체제의 통신은 대신 Java Native Interface(JNI; Java 네이티브 인터페이스)를 기반으로 하며, 기본 운영 체제와의 통신은 외부 글루 레이어를 통해 처리됩니다.
C#에서는 포인터와 대응하는 포인터 산술의 사용이 허가되어 있습니다만, C# 언어 설계자는 포인터가 오브젝트액세스의 엄격한 규칙을 바이패스하기 위해서 사용될 가능성이 있는 것과 같은 문제를 안고 있었습니다.따라서 디폴트로는 C#에서는 [29]포인터도 사용할 수 없습니다.그러나 많은 네이티브 함수를 호출할 때는 포인터가 필요하기 때문에 포인터는 명시적으로 안전하지 않은 모드에서 허용됩니다.포인터를 사용하는 코드 블록 또는 메서드는 포인터를 사용할 수 있도록 키워드로 마킹해야 하며 컴파일러는 스위치가 이러한 코드를 컴파일할 수 있도록 해야 합니다.스위치를 사용하여 컴파일된 어셈블리는 마크가 붙어 명시적으로 신뢰할 수 있는 경우에만 실행할 수 있습니다.이를 통해 포인터 및 포인터 산수를 사용하여 운영체제 또는 기타 네이티브 API와 오브젝트를 직접 주고받을 수 있습니다.또, 이러한 오브젝트의 네이티브 메모리 레이아웃을 사용하고, 그러한 잠재적인 안전하지 않은 코드를, 특별히 신뢰할 수 있는 어셈블리에서 격리할 수도 있습니다.
참조 。
두 언어 모두 참조가 중심 개념입니다.클래스의 모든 인스턴스는 참조에 의한 것입니다.
언어 구문 자체로는 직접 명확하지 않지만 두 언어 모두 약한 참조 개념을 지원합니다.취약한 참조에서만 참조되는 인스턴스는 참조가 전혀 없는 것처럼 가비지 수집에 적합합니다.양쪽 언어에서 이 기능은 실제로 핵심 런타임 기능임에도 불구하고 관련 라이브러리를 통해 공개됩니다.
Java는 약한 참조와 함께 소프트 참조를 가지고 있습니다.이들은 약한 참조와 비슷하지만 메모리가 필요할 때까지 JVM은 부드럽게 참조된 개체의 할당을 해제하지 않습니다.
참조 。 | C# | |
---|---|---|
. | 네, □□입니다. | |
한 레퍼런스 ★★★★★ | . | 네, □□입니다. |
큐컬렉션과의 ) | . | 네, □□입니다. |
. | . | |
. | . | |
;; 생성 | ○, "" " " " " " |
및
어레이와 컬렉션은 두 언어 모두에서 특징적인 개념입니다.
어레이 및 컬렉션 | C# | |
---|---|---|
데이터 | . | 네, □□입니다. |
인덱스 은 1차원 인덱스 어레이입니다. | . | 네, □□입니다. |
차다 | . | 네, □□입니다. |
츠키 | . | 네, □□입니다. |
베이스가 아닌 | 아니요. | ★★★ |
및 | 아니요. | 네, □□입니다. |
(/사/전 maps | . | 네, □□입니다. |
된 사전 | . | 네, 그렇습니다[30]. |
. | 네, □□입니다. | |
된 세트 | . | 네, 그렇습니다[31]. |
('/') | . | 네, □□입니다. |
/스택 | . | 네, □□입니다. |
queue priority » | . | 네, 그렇습니다[32][33]. |
/멀티세트 | 네, □□입니다. | |
최적화 | . | 네, 그렇습니다[34]. |
C#에 다차원 배열을 선언 및 조작하기 위한 구문이 추가된 것을 제외하고 배열을 선언 및 액세스하기 위해 사용되는 구문은 동일합니다.
C# | |
---|---|
어레이는 암묵적으로의 직접 특성화입니다.이들은 컬렉션 유형과 통합되지 않습니다. | C#의 배열은 여러 수집 인터페이스를 구현하는 클래스의 암묵적인 전문화입니다. |
어레이와 컬렉션은 통합 없이 완전히 분리되어 있습니다.배열은 시퀀스 또는 컬렉션이 예상되는 곳에 전달할 수 없습니다(다만, 를 사용하여 래핑할 수 있습니다). | 배열은 시퀀스 IEnumerable또는 컬렉션/리스트 인터페이스가 예상되는 곳으로 전달할 수 있습니다.그러나 요소 수(삽입/추가/제거)를 변경하는 수집 작업은 어레이에서 지원되지 않으므로 예외가 발생합니다. |
이 문에는 배열 또는 를 사용할 수 있습니다.모든 컬렉션이 구현됩니다.즉, 같은 짧은 구문을 for-loops에서도 사용할 수 있습니다. | 이 문은 보통 또는 인터페이스를 [35]통해 구현되는 메서드의 특정 구현을 사용하여 시퀀스를 반복합니다.어레이는 항상 이러한 인터페이스를 암묵적으로 구현하기 때문에 루프는 어레이에서도 반복됩니다. |
두 언어 모두에서 기준 유형의 배열은 공변량입니다.즉, 배열을 (에 할당 가능)의 특수화와 마찬가지로의 변수에 할당할 수 있습니다.두 언어 모두에서 어레이는 새로운 값을 삽입할 때 유형 검사를 수행합니다. 그렇지 않으면 유형 안전성이 저하될 수 있습니다.이는 일반 컬렉션이 두 언어로 구현된 방식과 대조적입니다. | |
다차원 배열(직사각형 배열)은 없지만 어레이에 대한 참조 배열(잡지 배열)입니다. | 다차원 어레이(직사각형 어레이) 및 어레이에 대한 참조 어레이(잡지형 어레이) |
어레이 크기를 조정할 수 없습니다(다만, 이 방법을 사용하면 어레이 크기를 조정할 수 있습니다). | 정적 배열 방식을 사용하여 기존 값을 유지하면서 배열 크기를 조정할 수 있습니다(단, 새 배열이 반환될 수 있음). |
그java.util 도서관 추가 기능을 세트, 연결 집합 같은 데이터 구조, 그리고 몇몇 알고리즘, 가장 큰 성분을 Comparator<에 기초한 흔적을 찾은 것과 같은 컬렉션의 요소들을 조작할 수 있는 같은 공간,; 구현합니다.T>개체는 목록 내에서 sublists는 목록의 내용 뒤집은 카드의 내용이 작은 요소를 찾겠죠목록의 s, 컬렉션의 불변 버전을 만들고, 정렬을 수행하고, 이진 [36]검색을 수행합니다. | C# 컬렉션 프레임워크는 및 네임스페이스의 클래스와 몇 가지 유용한 인터페이스, 추상 클래스 및 데이터 [37]구조로 구성됩니다.NET 3.5에는 , , , , , , 등 컬렉션을 쿼리하기 위한 다양한 확장 메서드가 포함된 네임스페이스가 추가되었습니다.이러한 방법을 사용하는 쿼리를 Language Integrated Query(LINQ; 언어 통합 쿼리)라고 합니다. |
다차원 어레이는 로컬리티가 증가하기 때문에 퍼포먼스가 향상될 수 있습니다(예: 들쭉날쭉한 어레이의 경우처럼 어레이의 모든 차원에 대해 포인터 디레퍼런스가1개가 아닌1개의 포인터 디레퍼런스가 있기 때문에).단, 다차원 어레이 내의 모든 어레이 요소 액세스에는 2차원 이상의 차원에 대한 곱셈/시프트가 필요하기 때문에 이는 매우 랜덤한 액세스 시나리오에서만 유효합니다.
또 다른 차이점은 operator의 단일 어플리케이션으로 다차원 어레이 전체를 할당할 수 있는 반면 들쭉날쭉한 어레이에는 모든 차원에 대한 루프와 할당이 필요하다는 것입니다.그러나 Java는 정규 길이로 들쭉날쭉한 어레이를 할당하기 위한 구문 구조를 제공합니다. 그러면 가상 머신에 의해 루프와 여러 할당이 수행되므로 소스 수준에서 명시적일 필요는 없습니다.
모두 목록, 및 있습니다.
Java는 C/C++[38] 구문도 지원합니다.
과
과 | C# | |
---|---|---|
. | 네, □□입니다. | |
. | 네, □□입니다. | |
. | 네, □□입니다. | |
. | 네, □□입니다. | |
. | 네, □□입니다. | |
. | 네, □□입니다. | |
★★ | , 암묵적 | 암묵적, 암묵적 |
★★★★★ | , 암묵적 | 명시적, 명시적 |
연산자 | 'java.java.'입니다. | 네, □□입니다. |
아니요. | 네, □□입니다. | |
한 부동소수점 | , opt-in/out, opt-in/out | 네, 옵트인[39] |
그대로의 | 네, 그렇습니다[40]. | 네, 그렇습니다[41]. |
앤
두 언어 모두 자동 박스와 언박스를 허용합니다. 즉, 모든 원시 유형과 해당 참조 유형 간에 암묵적인 캐스팅을 허용합니다.
C#에서 원시 유형은 개체 유형의 하위 유형입니다.Java에서는 이는 사실이 아닙니다. 주어진 원시 유형과 대응하는 래퍼 유형은 서로 특별한 관계가 없습니다. 단, 자동 박스와 언박스는 서로 교환하기 위한 통사적인 설탕 역할을 합니다.이것은 자동 캐스팅이 허용되지 않은 이전 버전의 Java와의 하위 호환성을 유지하기 위해 의도적으로 이루어졌으며 프로그래머는 두 가지 유형의 집합, 즉 원시 유형과 래퍼(참조) 유형 [42]계층을 사용하여 작업했습니다.
이 차이는 다음과 같은 결과를 초래합니다.우선 C#에서는 오브젝트의 메서드 오버라이드 등의 메서드를 정의할 수 있습니다.Java에서 이 작업은 원시 래퍼 클래스에 의해 수행됩니다.
둘째, Java에서는 자동으로 박스가 설정되지 않기 때문에 원시 값을 직접 참조하려고 할 때마다 추가 캐스트가 필요합니다.이 표현식은 C#에서 동일한 작업을 수행하는 동안 정수 리터럴을 Java에서 문자열로 변환합니다.이는 후자가 원시값 인스턴스 콜인 반면 전자는 유형의 오브젝트 인스턴스 콜이기 때문입니다.
마지막으로, Java는 범용에서 박스형을 많이 사용한다는 점도 다릅니다(아래 참조).
C# | ||
---|---|---|
★★★ | . | 네, □□입니다. |
★★★ | . | 네, □□입니다. |
. | 네, □□입니다. | |
★★★ | . | 네, □□입니다. |
. | 네, □□입니다. | |
. | 네, □□입니다. | |
네, 그렇습니다[43]. | 네, □□입니다. | |
(ARM) | . | 네, □□입니다. |
문문
두 언어 모두 C/C++ 어족에서 "curly brace" 언어로 간주됩니다.전체적으로 언어의 구문은 매우 유사하다.문장과 식 수준의 구문은 C/C++의 전통에서 영감을 얻은 것과 거의 동일합니다.유형 정의 수준(클래스 및 인터페이스)에서는 몇 가지 사소한 차이가 있습니다.Java는 클래스 확장 및 인터페이스 구현에 대해 명시적인 반면 C#은 새로운 클래스/인터페이스가 파생된 유형에서 이를 추론합니다.
C# Java 보 c c c c c c c c c c 。이것은 Java보다 더 많은 키워드와 문법 규칙을 지정하는 구문에서도 어느 정도 나타납니다.
및
언어가 진화함에 따라 두 언어의 언어 디자이너는 새로운 키워드 또는 구문을 사용하여 언어를 확장하고 싶은 상황에 직면하게 되었습니다.특히 새로운 키워드는 소스 레벨에서 기존 코드를 파괴할 수 있습니다.즉, 오래된 코드가 컴파일러에 제시되어 새로운 버전의 언어를 사용할 경우 컴파일러가 더 이상 컴파일되지 않을 수 있습니다.언어 디자이너들은 그러한 퇴행을 피하고 싶어 한다.두 언어의 설계자는 이 문제에 대처할 때 서로 다른 경로를 따라 왔습니다.
Java 언어 디자이너는 가능한 한 새로운 키워드를 피하고 대신 이전에는 합법적이지 않았던 새로운 구문 구조를 도입하거나 기존 키워드를 새로운 컨텍스트에서 재사용하는 것을 선호합니다.이렇게 하면 하위 호환성을 위태롭게 하지 않습니다.전자의 예는 루프가 반복 가능한 유형으로 확장되는 방식에서 찾을 수 있습니다.후자의 예는 Java 1.5에서 제네릭이 도입되었을 때 및 (특히) 키워드가 타입 경계를 지정하기 위해 어떻게 재사용되었는지에서 확인할 수 있습니다.이전에는 키워드로 예약되지 않았던 새로운 키워드가 한 때(Java 1.4) 도입되었습니다.예를 들어 식별자로 사용되는 코드일 경우 이전에 유효한 코드가 비활성화될 수 있습니다.그 설계자들은 4기분율 해결책을 이 문제를 해결하려고:1), 2)만이 자바 1.4와 후, 3)가 1.3∼이전(비 1.4을 잘 알고 코드), 현재 무효 4)을 발행하다. 경고 렌더링을 피하기 위해 Defaulting하고 마치 그 키워드 u. 때 종합한 키워드로 잘라 말하는 만약 자바 1.4또는 나중에 사용되어야 할지 여부를 나타내는 컴파일러 스위치 도입을 선택했다sed 나는n Java 1.3 모드.개발자가 코드를 변경할 수 있도록 합니다.
C# 언어 디자이너는 첫 번째 버전부터 몇 가지 새로운 키워드를 도입했습니다.다만, 이러한 키워드를 글로벌키워드로 정의하는 것이 아니라, 컨텍스트 의존 키워드로 정의합니다.즉, C# 2.0에 키워드와 키워드를 도입했을 때에도 컨텍스트에 따라 키워드를 as로 사용하는 것과 식별자로 사용하는 것 사이에 모순이 발생하지 않기 때문에 이들 단어를 식별자로 사용하는 것은 여전히 유효합니다.따라서 현재 C# 구문은 사용하는 언어 버전을 지정하지 않고 이전 버전에 대해 작성된 소스 코드와 완전히 하위 호환됩니다.
(키워드) | , 예 「」, 「」 |
---|---|
checked, unchecked | C#에서는 문 블록 또는 식을 사용하여 산술 [44]오버플로를 런타임 체크할 수 있습니다. |
get, set | C#은 언어 구문의 일부로서 속성을 구현합니다.이러한 속성은 Java에서 사용되는 접근 방식 대신 언어 기능이 아닌 메서드 이름 규칙에 기초한 코딩 패턴입니다. |
goto | C# 는 키워드를 서포트하고 있습니다.이것은, 예를 들면 유한 상태 머신의 실장이나 생성된 코드에 도움이 되는 경우가 있습니다만, 통상은 보다 구조화된 제어 플로우의 방법을 사용하는 것을 추천합니다(goto 스테이트먼트에 대한 비판 참조).Java는 문을 지원하지 않습니다(단, 예약된 단어임).단, Java는 라벨 부착 및 스테이트먼트를 지원하며, 특정 상황에서는 스테이트먼트를 사용할 수 있습니다. )의 변화) 를 구별하다 ★.★★★★★★★★★★★★★★★★★★▼: ★★★. Line ) '색상' ; 를 구별하다 ★. 블루: ★★★. Line ) 를 구별하다 ★.★★★★★★★★★★★★★★★★★★▼; } |
lock | C#에서 키워드는 여러 스레드(를 사용)에서 코드 블록에 대한 액세스를 동기화하기 위한 줄임말로, ... 블록으로 둘러싸여 있습니다. |
out, ref | C#에는 출력 파라미터와 참조 파라미터가 지원됩니다.이를 통해 메서드에서 여러 출력 값을 반환하거나 참조로 값을 전달할 수 있습니다. |
strictfp | Java는 부동소수점 연산 결과를 플랫폼 전체에서 동일하게 유지하기 위해 사용합니다. |
switch | C#에서는 string과 long에서도 switch 문이 동작합니다.빈 문장에 대해서는 폴스루가 허용되며 코드가 포함된 문장에 대해서는 'goto case'를 통해 가능합니다.Java의 스위치 문은 기본 유형이 아닌 문자열로 작동하며 모든 문('break[45]가 있는 문 제외)에 대해 사용됩니다. |
synchronized | Java에서 키워드는 여러 스레드(를 사용)에서 코드 블록에 대한 액세스를 동기화하기 위한 줄임말로, ... 블록으로 둘러싸여 있습니다. |
throws | Java에서는 체크된 예외 또는 체크된 예외의 슈퍼클래스를 선언하기 위해 모든 메서드가 필요합니다.임의의 방법으로 발생하는 체크되지 않은 예외를 선언할 수도 있습니다.C# c c c c c c c c c c c c c c c 。 Item (읽기 항목) ) 프로세서..IOException(IOException) } |
using | C#에서는 코드 블록이 실행된 후 또는 코드 블록 내에서 예외가 발생했을 때 실행이 선언된 객체의 메서드(인터페이스를 통해 구현됨)를 발생시킵니다. // 를 만들고 .// "test.txt"는 "test.txt"로 를 종료합니다(에도).//...를 종료합니다(예외가 발생한 경우에도). . )StreamWriter: = StreamWriter: ) "test.txt" . ) (테스트) } Java SE 7에서는 리소스 사용이라는 유사한 구조가 추가되었습니다[46]. ) Reader(버퍼 리더) br = Reader(버퍼 리더) ) file file file ) 스루프 ) ) ) br.readLine read 。 );( ); } |
프로그래밍
C#과 Java는 모두 동적 디스패치를 사용하여 객체 지향 언어로 처음부터 설계되었으며 구문은 C++와 유사합니다(C++는 C에서 파생됩니다).단, 어느 언어도 C와 C++의 슈퍼셋은 아닙니다.
C# | ||
---|---|---|
» | '필수' | |
. | 네, □□입니다. | |
. | 네, □□입니다. | |
, , public, private, ", " | private, internal, private, protected internal, private, private, protected internal, private | |
클래스 레벨의 내부 클래스 | . | 네, □□입니다. |
의 내부 | . | . |
스테이트먼트 레벨(로컬) 어나니머스 클래스 | . | 없이, 방법론으로는요. |
아니요. 서드파티 라이브러리[47] | 네, □□입니다. | |
" " ( " ) " | ; 필요 없습니다. | 네, 그렇습니다[48]. |
폐지/폐지 | . | 네, □□입니다. |
버전 | 네, □□입니다. | |
Enums는 인터페이스를 구현할 수 있습니다. | . | . |
아니요. | 네, □□입니다. | |
기능 " " " " | ||
아니요. | 네, □□입니다. | |
아니요. | 네, □□입니다. | |
아니요. 단, "자동 상자 설정" 참조 | 네, □□입니다. | |
변환 | . | 네, □□입니다. |
C#에서는 partial class라는 기능을 사용하여 클래스 정의를 여러 소스 파일로 분할할 수 있습니다.각 부품에는 키워드를 붙여야 합니다.모든 부품은 컴파일러에 단일 컴파일의 일부로 제시되어야 합니다.부품은 다른 부품의 부재를 참조할 수 있습니다.부품은 인터페이스를 구현할 수 있으며 부품은 기본 클래스를 정의할 수 있습니다.이 기능은 코드 생성 시나리오(사용자 인터페이스(UI) 설계 등)에서 코드 생성기가 한 부분과 다른 부분을 함께 컴파일할 수 있는 경우에 유용합니다.따라서 개발자는 나중에 코드 생성기가 해당 코드를 덮어쓸 위험 없이 부품을 편집할 수 있습니다.클래스 확장 메커니즘과 달리 부분 클래스는 컴파일 시 해결이 보장되므로 부분 간의 순환 종속성을 허용합니다.Java에는 대응하는 개념이 없습니다.
및
두 언어 모두 내부 클래스를 허용합니다. 여기서 클래스는 다른 클래스 내에서 사전적으로 정의됩니다.그러나 각 언어에서 이러한 내부 클래스는 다소 다른 의미론을 가지고 있습니다.
Java에서는 inner 클래스가 선언되지 않는 한 inner 클래스의 인스턴스에 대한 참조는 외부 클래스에 대한 참조를 수반합니다.그 결과 inner 클래스의 코드는 outer 클래스의 static 멤버와 non-static 멤버 모두에 액세스 할 수 있습니다.스태틱하지 않은 내부 클래스의 인스턴스를 만들려면 포섭 외부 클래스의 인스턴스에 [49]이름을 지정해야 합니다.이는 JDK 1.3에서 도입된 새로운 오퍼레이터를 통해 이루어집니다.이것은 외부 클래스의 인스턴스에 대한 참조가 있는 모든 클래스에서 수행할 수 있습니다.
C#에서 내부 클래스는 개념적으로 일반 클래스와 동일합니다.어떤 의미에서 외부 클래스는 네임스페이스 역할만 합니다.따라서 내부 클래스의 코드는 외부 클래스의 인스턴스에 대한 명시적 참조를 통해 액세스하지 않는 한 외부 클래스의 비정적 멤버에 액세스할 수 없습니다.프로그래머는 내부 클래스를 개인 클래스로 선언하여 외부 클래스만 액세스할 수 있도록 할 수 있습니다.
Java는 메서드 본문 내에서 정의할 수 있는 로컬 클래스 또는 익명 클래스라는 다른 기능을 제공합니다.이들은 보통 1~2개의 메서드(일반적으로 이벤트핸들러)만으로 인터페이스를 실장하기 위해서 사용됩니다.그러나 슈퍼 클래스의 가상 메서드를 재정의하는 데도 사용할 수 있습니다.이러한 로컬 클래스의 메서드는 선언된 외부 메서드의 로컬 변수에 액세스할 수 있습니다. C#은 익명 위임자를 제공하여 이러한 사용 사례를 충족합니다. 자세한 내용은 이벤트 처리를 참조하십시오.
C#은 어나니머스 타입/클래스라는 기능도 제공하지만 같은 이름의 Java의 개념과는 다소 다릅니다.이를 통해 프로그래머는 클래스가 가져야 할 속성의 이름 집합과 각각을 초기화하기 위한 식만 제공함으로써 클래스를 인스턴스화할 수 있습니다.속성 유형은 해당 식 유형에서 유추됩니다.암묵적으로 선언된 이러한 클래스는 개체에서 직접 파생됩니다.
C# multicast-delegates 는 이벤트와 함께 사용됩니다.이벤트는 이벤트 구동 프로그래밍을 지원하며 옵서버 패턴을 구현합니다.이를 지원하기 위해 클래스에서 이벤트를 정의하는 특정 구문과 이벤트 핸들러를 등록, 등록 취소 또는 결합하는 연산자가 있습니다.
Java에서 이벤트를 구현하는 방법에 대한 자세한 내용은 여기를 참조하십시오.
및
연산자 오버로드와 사용자 정의 캐스트는 모두 새로운 유형이 유형 시스템에서 퍼스트 클래스 시민이 되는 것을 목표로 하는 별개의 기능입니다.C#에서 이러한 기능을 사용함으로써 덧셈이나 곱셈과 같은 일반 연산자가 새로운 유형으로 동작하도록 및 등의 유형이 통합되었습니다.C++ 와 달리 C# 에서는 연산자 오버로드 사용이 제한되고 연산자, , , , , 및 와 같은 복합문의 변형은 금지됩니다.단, 복합 연산자는 호출 및 [50]등 오버로드된 단순 연산자를 호출합니다.
자바에는 연산자 오버로드나 커스텀 변환은 포함되어 있지 않습니다.기능의 남용을 방지하고 언어를 [51]단순하게 유지하기 위해서입니다.
또한 C#에는 연산자 오버로드의 특수한 경우(C++ 등) 또는 파라미터화된 set/ 속성으로 간주할 수 있는 인덱서도 포함되어 있습니다.인덱서는 하나 이상의 매개 변수(인덱스)를 사용하는 속성입니다. 인덱스는 모든 유형의 개체일 수 있습니다.
myList4 = 5; 표시 = Nodexml 노 xml. attrib "filename" (이름)]; = Map 객 customer];
Java ★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★」일반적인 Java 패턴에는 C# 프로그래머가 인덱서를 사용할 수 있는 명시적인 getter 및 setter가 포함됩니다.
[ and Initialization ](와 )
[ and Initialization ](와 ) | C# | |
---|---|---|
★★★ | . | 네, □□입니다. |
★★★ | . | 있음. 단, 계속 전달된[52] 파라미터는 지원되지 않습니다. |
정적(클래스) 컨스트럭터 | . | 네, □□입니다. |
. | 네, □□입니다. | |
(Finalizers/Destructors) | . | 네, □□입니다. |
. | 컨스트럭터 ''를 수 . 인스턴스 생성자를 사용하여 시뮬레이션할 수 있습니다. | |
오브젝트 초기화 | ★★★ 필드와 컨스트럭터) | 상향식(컨스트럭터) |
. | 네, □□입니다. | |
(컬렉션 이니셜라이저) | 메서드 'varargs' | 네, □□입니다. |
. | 네, □□입니다. |
C#과 Java 모두에서 객체의 필드는 변수 이니셜라이저(변수가 정의되어 있는 변수에 할당할 수 있는 표현식) 또는 컨스트럭터(개체가 생성될 때 실행되는 특수 서브루틴)에 의해 초기화할 수 있습니다.또한 Java에는 인스턴스 이니셜라이저가 포함되어 있습니다.인스턴스 이니셜라이저는 슈퍼클래스의 생성자에 대한 명시적(또는 암묵적) 호출 후 생성자가 실행되기 전에 실행되는 인수가 없는 익명의 코드 블록입니다.
C# c c c c c c c c음 c c c c 음 c c c 。
- 된
- 인스턴스
- static " " "
- instance " "
- 컨스트럭터
- 컨스트럭터
위의 필드 중 일부는 적용되지 않을 수 있습니다(예를 들어 객체에 정적 필드가 없는 경우).파생 필드는 객체의 직접 클래스에 정의된 필드이고 기본 필드는 객체의 슈퍼 클래스 중 하나에 정의된 필드를 나타내는 용어입니다.메모리 내의 객체 표현에는 슈퍼클래스의 일부 필드가 프라이빗으로 정의되어 있는 경우에도 클래스 또는 슈퍼클래스에 정의되어 있는 모든 필드가 포함됩니다.
오브젝트 클래스의 인스턴스 생성자와 슈퍼클래스가 모두 필드 이니셜라이저를 호출한 후에 호출되기 때문에 필드 이니셜라이저가 호출되기 전에 반드시 유효하게 됩니다.단, 기본 컨스트럭터에서 가상 메서드를 호출할 경우 오브젝트 초기화에는 잠재적인 트랩이 있습니다.하위 클래스의 재정의된 메서드는 하위 클래스에 정의된 필드를 참조할 수 있지만 필드 초기화를 포함하는 하위 클래스의 생성자가 기본 클래스의 생성자 뒤에 호출되기 때문에 이 필드가 초기화되지 않았을 수 있습니다.
- 다른 생성자 호출(개체의 클래스 또는 개체의 슈퍼 클래스 중 하나)
- 인스턴스 변수 이니셜라이저 및 인스턴스 이니셜라이저(소스 코드에 표시되는 순서대로)
C#과 마찬가지로 새로운 오브젝트는 특정 컨스트럭터를 호출하여 작성됩니다.생성자 내에서 첫 번째 문장은 다른 생성자의 호출일 수 있습니다.이를 생략하면 슈퍼클래스의 인수 없는 컨스트럭터에 대한 콜이 컴파일러에 의해 암묵적으로 추가됩니다.그렇지 않으면 오브젝트 클래스의 오버로드된 다른 생성자를 명시적으로 호출하거나 슈퍼 클래스 생성자를 호출할 수 있습니다.전자의 경우, 호출된 생성자는 다시 다른 생성자(개체의 클래스 또는 그 하위 클래스 중 하나)를 호출하고 체인은 조만간 슈퍼 클래스의 생성자 중 하나에 호출됩니다.
다른 생성자를 호출한 후(슈퍼 클래스 생성자를 직접 호출하는 등 개체 클래스로 이동) 개체의 클래스에 정의된 인스턴스 변수가 초기화됩니다.일부 변수에 대해 명시적으로 정의된 변수 이니셜라이저가 없는 경우에도 이러한 변수는 기본값으로 초기화됩니다.슈퍼클래스에 정의되어 있는 인스턴스 변수는 이 시점에서 이미 초기화되어 있습니다.이는 슈퍼클래스 컨스트럭터가 호출되었을 때(컨스트럭터의 코드 또는 컨스트럭터의 코드 앞에서 실행되는 변수 이니셜라이저에 의해 또는 디폴트치에 암묵적으로 실행됨)에 의해 초기화되었기 때문입니다.Java에서는 변수 이니셜라이저가 소스 파일 내의 텍스트 순서에 따라 실행됩니다.
마지막으로 컨스트럭터 본체가 실행된다.이것에 의해, 오브젝트 클래스의 필드의 초기화가 개시되기 전에, 베이스 클래스의 필드의 초기화가 완료되는 등, 적절한 초기화 순서가 보증됩니다.
Java 객체 초기화에는 주로 두 가지 잠재적인 트랩이 있습니다.첫 번째로 변수 이니셜라이저는 메서드콜을 포함할 수 있는 식입니다.메서드는 클래스에서 정의된 모든 변수를 참조할 수 있으므로 변수 이니셜라이저에서 호출된 메서드는 초기화할 변수 아래에 정의된 변수를 참조할 수 있습니다.초기화 순서는 변수 정의의 텍스트 순서에 대응하므로 이러한 변수는 이니셜라이저에 의해 지정된 값으로 초기화되지 않고 기본값을 포함합니다.또 다른 잠재적 트랩은 파생 클래스에서 오버라이드된 메서드가 기본 클래스 생성자에서 호출되는 경우로, 파생 클래스의 오브젝트가 생성되었을 때 프로그래머가 예상하지 못한 동작을 초래할 수 있습니다.초기화 순서에 따라 가변 이니셜라이저가 평가되기 전 및 파생 클래스 컨스트럭터의 본문이 실행되기 전에 베이스 클래스 컨스트럭터의 본문이 실행된다.그러나 기본 클래스 생성자에서 호출된 재정의된 메서드는 파생 클래스에 정의된 참조 변수를 사용할 수 있지만, 이러한 변수는 아직 이니셜라이저에 의해 지정된 값으로 초기화되지 않았거나 파생 클래스 생성자에 설정되지 않았습니다.후자의 문제는 C#에도 적용되지만 C#의 메서드는 기본적으로 덮어쓸 수 없기 때문에 덜 중요한 형식입니다.
두 언어 모두 메모리의 명시적 할당 해제가 아닌 메모리 리소스를 회수하는 수단으로 가비지 컬렉션을 주로 사용합니다.두 경우 모두 객체가 파일 핸들, 그래픽 리소스 등 메모리 이외의 다른 종류의 리소스를 보유하고 있는 경우 애플리케이션이 더 이상 사용하지 않을 때 명시적으로 통지해야 합니다.C#과 Java는 모두 이러한 결정론적 폐기를 위한 인터페이스를 제공하며 C#과 Java(Java 7 이후)는 모두 이러한 인터페이스에서 폐기/폐쇄 방식을 자동으로 호출하는 자동 자원 관리 문을 갖추고 있습니다.
및 | C# | |
---|---|---|
(Import) | . | 네, 그렇습니다[53]. |
default () | 입니다. | |
. | 네, □□입니다. | |
. | 네, □□입니다. | |
인터페이스 | 네, 그렇습니다[54]. | |
( 「」) | . | 네, □□입니다. |
) 파라미터 '('/')' | 아니요. | 네, □□입니다. |
) 파라미터 '(')' | 아니요. | 네, □□입니다. |
있음, 최종 파라미터 | 네, 그렇습니다[55]. | |
. | 네, □□입니다. | |
" " " | 아니요.[56] 대신 메서드 오버로드 또는 varargs | 네, □□입니다. |
된 ''' | ,, " " " | 네, □□입니다. |
아니요. | 네, □□입니다. | |
/default methods (확장/디폴트 ) / " " " | . | 네, □□입니다. |
아니요. | 네, □□입니다. | |
인 방법 | 아니요. | 네, □□입니다. |
및
C#은 메서드의 첫 번째 파라미터에 대해 특별한 이 지정자를 사용하여 메서드가 첫 번째 파라미터 유형의 멤버 메서드인 것처럼 동작할 수 있도록 합니다.외국인 클래스의 이러한 확장은 순전히 구문론적이다.확장 메서드는 순수 정적 클래스 내에서 선언 및 정의해야 합니다.메서드는 클래스 외부의 다른 메서드와 마찬가지로 멤버접근 제한에 따라야 합니다.따라서 스태틱메서드는 오브젝트의 [57][58]캡슐화를 해제할 수 없습니다."확장"은 정적 호스트 클래스의 네임스페이스를 가져온 범위 내에서만 활성화됩니다.
Java 8 이후 Java에는 기본 메서드라고 불리는 유사한 기능이 있습니다.이것은 인터페이스에서 선언된 바디를 가진 메서드입니다.C# 확장 방식과 달리 Java 기본 방식은 이를 선언하는 인터페이스 상의 인스턴스 방식입니다.인터페이스를 실장하는 클래스의 디폴트 메서드의 정의는 임의입니다.클래스에서 메서드를 정의하지 않으면 기본 정의가 대신 사용됩니다.
C# 확장 메서드와 Java 기본 메서드에서는 각각 클래스가 확장/기본 메서드의 기본 구현을 덮어쓸 수 있습니다.양쪽 언어에서 이 덮어쓰기는 메서드의 대체 구현을 사용해야 하는 클래스에 메서드를 정의함으로써 이루어집니다.
C# 스코프 규칙에서는 클래스에서 일치하는 메서드가 발견되면 일치하는 확장 메서드보다 우선함을 정의합니다.Java에서는 기본 메서드를 사용하여 인터페이스를 구현하도록 선언된 클래스는 클래스 자체가 메서드를 구현하지 않는 한 기본 메서드 구현으로 간주됩니다.
인 방법
부분 클래스와 관련된 C#에서는 부분 클래스 내에서 부분 메서드를 지정할 수 있습니다.부분 메서드는 시그니처에 몇 가지 제한이 있는 메서드의 의도적인 선언입니다.이 제한에 의해 정의가 클래스 부품에 의해 제공되지 않는 경우 메서드와 그에 대한 모든 콜을 안전하게 [59]삭제할 수 있습니다.이 기능을 사용하면 컴파일 시에 다른 클래스 부품에 의해 이러한 확장 포인트가 사용되지 않는 경우 런타임 오버헤드를 지불하지 않고 다수의 대행 수신 포인트(템플릿 메서드의 GoF 설계 패턴 등)를 코드로부터 제공할 수 있습니다.Java에는 대응하는 개념이 없습니다.
C#의 메서드는 기본적으로는 비가상이며 필요에 따라 명시적으로 virtual로 선언해야 합니다.Java에서는 모든 비정적 비개인 메서드가 가상입니다.가상화에 의해 메서드의 최신 오버라이드가 항상 호출되지만 호출 시 특정 런타임 비용이 발생합니다.이러한 호출은 통상은 인라인화할 수 없고 가상 메서드테이블을 통한 간접 콜이 필요하기 때문입니다.그러나 Oracle 참조 구현을 비롯한 일부 JVM 구현에서는 가장 일반적으로 불리는 가상 방법을 인라인 방식으로 구현합니다.
Java 메서드는 기본적으로 가상입니다(단, 오버라이드를 허용하지 않는 수식자를 사용하여 밀봉할 수 있습니다).파생 클래스에서 동일한 이름으로 관련 없는 새 메서드를 정의할 수 없습니다.
즉, Java에서는 디폴트이며 C#에서 명시적으로 이니블로 되어 있는 경우에만 새로운 메서드를 기본 클래스와 동일한 이름과 시그니처를 사용하여 파생 클래스에서 정의할 수 있습니다.메서드가 이러한 객체의 슈퍼 클래스 참조에서 호출되면 참조되는 객체의 특정 하위 클래스에 따라 기본 클래스의 "가장 깊은" 재정의된 구현이 호출됩니다.
경우에 따라서는 서브클래스가 기본클래스에 이미 존재하는 메서드와 동일한 이름과 시그니처를 가진 메서드를 도입하면 문제가 발생할 수 있습니다.Java에서 이는 파생 클래스의 메서드가 기본 클래스의 메서드를 암묵적으로 덮어쓰는 것을 의미합니다. 단, 어느 클래스의 설계자의 의도는 아닐 수도 있습니다.
이를 완화하기 위해 C#에서는 상속된 메서드를 덮어쓰려는 메서드의 경우 키워드를 지정해야 합니다.그렇지 않으면 상속된 메서드가 "숨김"됩니다.키워드가 없는 경우 이 취지의 컴파일러 경고가 발행되며 키워드를 지정하여 무음화할 수 있습니다.이렇게 하면 시그니처가 이미 파생 클래스에서 사용되고 있는 비프라이빗 메서드(즉, 네임스페이스의 상속된 부분)로 확장되는 기본 클래스에서 발생할 수 있는 문제를 방지할 수 있습니다.Java는 메서드 주석의 형태로 유사한 컴파일러 체크를 가지고 있지만 강제적인 것은 아니며, 이것이 없으면 대부분의 컴파일러는 코멘트를 제공하지 않습니다(그러나 메서드는 덮어쓰게 됩니다).
상수/불변 파라미터
Java에서는 로컬 변수 또는 메서드 파라미터의 재할당을 방지할 수 있습니다.final
키워드를 지정합니다.이 키워드를 프리미티브타입 변수에 적용하면 변수는 불변하게 됩니다.단, 신청final
참조 유형 변수에 다른 개체가 할당되는 것만 방지합니다.개체에 포함된 데이터가 변환되는 것을 방지하지는 않습니다.C#7에서는 키워드를 사용하여 메서드 파라미터의 재할당을 방지할 수 있지만 로컬 변수에서는 이 키워드를 사용할 수 없습니다.Java와 마찬가지로 파라미터에 적용하면 파라미터가 다른 값으로 재할당되지 않습니다.개체에 [60]포함된 데이터를 계속 변환할 수 있습니다.
자바 | C# |
---|---|
일반의 인트 add One(원 추가)(최종 인트 x) { x++; // 오류: 최종 변수를 재할당할 수 없습니다. 돌아가다 x; } 일반의 목록. add One(원 추가)(최종 목록.< >정수> 목록.) { 목록..더하다(1); // OK: 아직 수정이 가능합니다. // 최종(기준 유형) 변수 돌아가다 목록.; } | 일반의 인트 애드원(에 인트 x) { x++; // 오류: 읽기 전용 매개 변수를 재할당할 수 없습니다. 돌아가다 x; } 일반의 목록.< >인트> 애드원(에 목록.< >인트> 목록.) { 목록..더하다(1); // OK: 아직 수정이 가능합니다. // 읽기 전용(기준 유형) 파라미터 돌아가다 목록.; } |
두 언어 모두 C/C++에 존재하는 const-correctness의 기본 기능을 지원하지 않으므로 메서드가 일정해집니다.
Java는 "상수"라는 단어를 임의로 정의한다.static final
이러한 변수 이름은 원칙상 대문자로만 구분되며 밑줄로 구분되지만 Java 언어에서는 이를 고집하지 않습니다.이 파라미터는final
는 상수로 간주되지 않습니다.단, 원시 데이터형 또는 불변의 클래스의 경우일 수 있습니다.String
.
제너레이터 방식
returning으로 선언된 임의의 C# 메서드 또는 이러한 인터페이스의 범용 버전은 구문을 사용하여 구현할 수 있습니다.이는 제한된 컴파일러 생성 연속의 한 형태로, 트래버스 또는 시퀀스 생성에 필요한 코드를 대폭 줄일 수 있습니다.단, 이 코드는 컴파일러에 의해 생성된 것입니다.이 기능은 피보나치 번호의 시퀀스 등 무한 시퀀스를 구현하기 위해서도 사용할 수 있습니다.
Java에는 동등한 기능이 없습니다.대신에, 발전기는 일반적으로 잘 알려진 집합이나 반복 가능한 인터페이스의 특별한 구현을 제공함으로써 정의되며, 이것은 요구에 따라 각 요소를 계산할 것이다.이러한 제너레이터를 각 스테이트먼트의 에서 사용하려면 , 인터페이스를 실장할 필요가 있습니다.
아래의 피보나치 시퀀스의 예를 참조해 주세요.
명시적 인터페이스 구현
또한 C#에는 명시적인 인터페이스 구현이 있습니다.이것에 의해, 클래스는 독자적인 클래스 메서드와 별도로 인터페이스의 메서드를 실장하거나, 2개의 베이스 인터페이스로부터 같은 이름과 시그니처를 가지는 2개의 메서드에 다른 실장을 제공할 수 있습니다.
어느 언어에서도 메서드(또는 C#의 속성)가 여러 인터페이스에서 같은 이름과 시그니처로 지정되어 있는 경우, 이러한 인터페이스를 실장하는 클래스가 설계되면 멤버가 충돌합니다.실장에서는 디폴트로 모든 인터페이스에 공통 방식이 실장됩니다.개별 실장이 필요한 경우(메서드가 다른 목적에 대응하거나 인터페이스 간에 반환값이 다르기 때문에), C#의 명시적인 인터페이스 실장은 오브젝트의 현재 캐스트에 따라 같은 메서드에 대해 다른 결과를 허용하지만 문제를 해결합니다.Java에서는 이름 [54]충돌을 피하기 위해 하나 이상의 인터페이스를 리팩터링하는 것 외에 이 문제를 해결할 방법이 없습니다.
참조(in/out) 파라미터
메서드에 대한 원시 유형의 인수(예: int, double)는 Java에서 값으로 전달되는 반면 개체는 참조로 전달됩니다.즉, 메서드는 실제 변수가 아닌 전달된 원시 요소의 복사본에서 작동합니다.반대로 실제 오브젝트는 변경될 수 있습니다.다음 예에서는 오브젝트 String은 변경되지 않습니다.클래스 'a'의 객체가 변경되었습니다.
C# 에서는, C++ 와 비슷하고, C 와 같은 키워드를 사용해 참조를 강제할 수 있습니다.C#의 이 기능은 여러 개체를 반환하는 메서드를 작성할 때 특히 유용합니다.Java에서는 래퍼(이 경우 "Ref"[61]라는 이름)를 사용하지 않는 한 메서드에서 여러 값을 반환하는 시도는 지원되지 않습니다.
자바 | C# |
---|---|
학급 PassByRef테스트 { 정적인 학급 참조< >T> { T 값; 참조(T 값) { 이것..값 = 값; } } 정적인 무효 체인지미(참조< >스트링> s) { s.값 = "변경"; } 정적인 무효 바꾸다(참조< >정수> x, 참조< >정수> y) { 인트 임시직 = x.값; x.값 = y.값; y.값 = 임시직; } 일반의 정적인 무효 주된(스트링[] args) { 변화하다 a = 신규 참조(5); 변화하다 b = 신규 참조(10); 변화하다 s = 신규 참조("아직 변경되지 않음"); 바꾸다(a, b); 체인지미(s); 시스템..나가..인쇄( "a =" + a.값 + ", " + "b = " + b.값 + ", " + "s =" + s.값 ); } } | 학급 PassByRef테스트 { 일반의 정적인 무효 Change Me(Change Me)(나가. 스트링 s) { s = "변경"; } 일반의 정적인 무효 바꾸다(레퍼런스 인트 x, 레퍼런스 인트 y) { 인트 임시직 = x; x = y; y = 임시직; } 일반의 정적인 무효 주된(스트링[] args) { 인트 a = 5; 인트 b = 10; 스트링 s = "아직 변경되지 않음"; 바꾸다(레퍼런스 a, 레퍼런스 b); Change Me(Change Me)(나가. s); 시스템..콘솔.기입선("a =" + a + ", " + "b = " + b + ", " + "s =" + s); } } |
a = 10, b = 5, s = Changed | a = 10, b = 5, s = Changed |
예외
예외 | 자바 | C# |
---|---|---|
체크된 예외 | 네. | 아니요. |
트라이캐치-드 | 네. | 네. |
예외 필터 | 아니요. | 네, 그렇습니다[62]. |
체크된 예외
Java는 선택된 예외(선택되지 않은 예외도 포함)를 지원합니다.C#은 체크되지 않은 예외만 지원합니다.체크된 예외는 프로그래머가 메서드에 던져진 예외를 선언하거나 절을 사용하여 던져진 예외를 검출하도록 강제합니다.
체크된 예외는 모든 오류를 확실하게 처리할 수 있도록 양호한 프로그래밍 관행을 장려할 수 있습니다.그러나 수석 C# 언어 설계자인 Anders Hejlsberg는 그것들이 자바에서 어느 정도 실험이었고 작은 예제 [63][64]프로그램 외에는 가치가 없다는 것을 보여주지 못했다고 주장한다.
체크된 예외는 프로그래머가 예외를 더 높은 수준의 예외 처리 루틴으로 전파하지 않고 예외를 묵살하는 빈 캐치 블록()catch (Exception e) {}[65]을 사용하도록 권장한다는 비판도 있습니다.단, 예외 체인을 래퍼 예외로 재투입함으로써 예외 체인을 대신 적용할 수 있습니다.예를 들어 파일이 아닌 데이터베이스에 액세스하도록 개체를 변경하면SQLException
잡히고 재검출될 수 있다IOException
발신자가 오브젝트의 내부 동작을 알 필요가 없을 수 있기 때문입니다.
그러나 모든 프로그래머가 이 입장에 동의하는 것은 아니다.James Gosling과 다른 사람들은 체크된 예외가 유용하며, 이러한 예외를 잘못 사용한 것이 문제를 일으켰다고 주장한다.예외를 사일런트하게 캐치하는 것은 가능하지만 기본적으로 아무것도 할 수 없는 선택되지 않은 예외와 비교하여 예외에 대해 수행할 작업을 명시적으로 명시해야 합니다.무시할 수 있지만 [66][67]무시하려면 코드를 명시적으로 작성해야 합니다.
트라이캐치-드
이 발언을 다루는 데 있어서도 두 언어 사이에 차이가 있다.블록에 또는 와 같은 제어 전달 문이 포함되어 있어도 항상 블록이 실행됩니다.Java에서는 블록에 값이 있는 스테이트먼트가 남아 있으면 예기치 않은 동작이 발생할 수 있으며 이후 실행되는 블록도 값이 다른 스테이트먼트가 남아 있을 수 있습니다.C#은 블록 내에서 또는 같은 제어 전달 문을 금지함으로써 이 문제를 해결합니다.
블록을 사용하는 일반적인 이유는 자원 관리 코드를 보호하고 최종 블록에서 귀중한 자원의 해방을 보증하기 위해서입니다.C# 에는, 이 일반적인 시나리오의 구문적인 단축형으로서 스테이트먼트가 기능하고 있습니다.이 시나리오에서는 오브젝트의 메서드가 항상 호출됩니다.
다소 미묘한 차이는 예외가 느려질 때 스택트레이스가 작성되는 순간입니다Java에서는 예외가 생성되는 순간에 스택트레이스가 생성됩니다.
학급 푸우 { 예외. 업. = 신규 예외.(); 인트 후우() 던지다 예외. { 던지다 업.; } }
위 문장의 예외에는 foo가 호출되는 빈도에 관계없이 항상 컨스트럭터의 스택트레이스가 포함됩니다.한편 C#에서는 "throw"가 실행되는 순간 스택트레이스가 생성됩니다.
학급 푸우 { 예외. e = 신규 예외.(); 인트 후우() { 해라 { 던지다 e; } 또 만나 (예외. e) { 던지다; } } }
위의 코드에서는 예외에 첫 번째 슬로우 라인의 스택트레이스가 포함됩니다예외를 검출할 때는 예외를 리스루닝할 필요가 있는 경우의 두 가지 옵션이 있습니다.원래의 예외를 원래 스택으로 재투입하기만 하면 새로운 스택트레이스가 생성됩니다.
최종적으로 블록
Java를 사용하면 입력 방식에 관계없이 제어 흐름이 스테이트먼트의 블록을 벗어날 수 있습니다.이로 인해 실행 중 다른 제어 흐름문( 등)이 종료될 수 있습니다.예를 들어 다음과 같습니다.
인트 후우() { 해라 { 돌아가다 0; } 마침내. { 돌아가다 1; } }
상기의 코드에서는, 블록내의 스테이트먼트에 의해서 제어가 이탈하기 때문에, 실제의 리턴이 발생하기 전에 블록이 실행된다.그러나 블록 자체도 반환을 수행합니다.따라서 입력의 원인이 된 원래 반환은 실행되지 않으며 위의 메서드는 0이 아닌 1을 반환합니다.비공식적으로 말하면 0을 반환하려고 하지만 최종적으로 1을 반환합니다.
C#에서는 컨트롤 플로우가 블록을 너무 빨리 빠져나가는 것을 제외한 모든 스테이트먼트가 허용되지 않습니다.특히 타깃라벨이 블록 외부에 있는 경우에는 허용되지 않으며 가장 가까운 엔클로징루프가 블록 외부에 있는 경우에는 허용되지 않습니다.
범용
제네릭스 분야에서는 두 언어가 겉으로는 구문론적 유사성을 보이지만 근본적인 차이가 심하다.
범용 | 자바 | C# |
---|---|---|
실행 | 활자 삭제 | 리플리케이션 |
런타임 실현 | 아니요. | 네. |
유형차이 | 사용 사이트 | 선언 사이트(인터페이스 상에서만) |
참조 유형 제약 조건 | 있음, 암묵적 | 네. |
값/프라이머리 타입의 제약 조건 | 아니요. | 네. |
생성자 제약 조건 | 아니요. | 예(파라미터가 없는 생성자에 한함) |
서브타입 제약조건 | 네. | 네. |
슈퍼타입 제약 | 네. | 아니요. |
이행 호환성 | 네. | 아니요. |
유형 삭제와 재작성된 제네릭
Java의 제네릭은 언어만의 구성이며 컴파일러에서만 구현됩니다.생성된 클래스 파일에는 메타데이터 형식으로만 범용 시그니처가 포함되어 있습니다(컴파일러가 새로운 클래스를 컴파일 할 수 있습니다).런타임에는 범용 유형 시스템이 인식되지 않습니다. 제네릭은 JVM의 일부가 아닙니다.대신 제네릭 클래스와 메서드는 유형 삭제라는 프로세스를 통해 컴파일 중에 변환됩니다.이 동안 컴파일러는 모든 범용 유형을 raw 버전으로 대체하고 유형과 메서드가 사용되는 클라이언트 코드에 캐스트/체크를 적절히 삽입합니다.생성된 바이트 코드에는 범용 유형이나 파라미터에 대한 참조가 포함되지 않습니다(Java의 제네릭 참조).
Java 언어 사양에서는 제네릭의 특정 사용을 의도적으로 금지하고 있습니다.이는 타입 삭제를 통한 제네릭 구현과 이행 [68]호환성을 확보하기 위해 필요합니다.Project Valhalla의 일환으로 Java 플랫폼에 인증된 제네릭을 추가하는 연구가 진행 중입니다.
C#은 가상 실행 시스템에서의 범용 지원을 기반으로 구축되어 있습니다.즉, 단순한 언어 기능이 아닙니다.이 언어는 CLR에서 크로스 언어 범용 지원을 위한 프런트 엔드일 뿐입니다.컴파일 중에 제네릭이 올바른지 검증되지만 제네릭을 구현하기 위한 코드 생성은 클래스 로드 시간으로 연기됩니다.클라이언트 코드(일반 메서드/속성을 호출하는 코드)는 완전히 컴파일되어 제네릭이 타입 세이프하다고 안전하게 간주할 수 있습니다.이것을 리플리케이션이라고 부릅니다.런타임에 범용 클래스/메서드/대리자에 대한 고유한 유형 파라미터 세트가 처음 발견되면 클래스 로더/검증기는 구체적인 클래스 기술자를 합성하고 메서드 구현을 생성합니다.기준 유형이 안전하게 동일한 구현을 공유할 수 있기 때문에 방법 구현 생성 중에 모든 기준 유형은 하나의 유형으로 간주된다.이것은 단지 코드를 구현하기 위한 목적일 뿐입니다.참조 타입의 다른 세트에는, 고유의 타입 기술자가 있습니다.메서드 테이블은 같은 코드를 가리킬 뿐입니다.
다음 목록은 범용 관리 시 Java와 C#의 몇 가지 차이점을 보여 줍니다.모든 것을 [69]망라한 것은 아닙니다.
자바 | C# |
---|---|
유형 검사 및 다운캐스트가 클라이언트 코드(제너릭을 참조하는 코드)에 주입됩니다.수동 캐스트를 사용하는 일반적이지 않은 코드와 비교하면 이러한 캐스트는 [70]동일하지만 런타임 캐스트 및 검사가 필요하지 않은 컴파일 시간 검증된 코드와 비교하면 이러한 작업은 성능 오버헤드를 나타냅니다. | C#/.NET 제네릭은 타입의 안전성을 보증하고 컴파일 시에 검증되므로 런타임에 추가 체크/캐스트를 할 필요가 없습니다.따라서 일반 코드는 일반적이지 않은 개체 또는 유형 삭제 개체를 처리할 때 캐스트를 필요로 하는 일반(또는 유형 삭제) 코드보다 빠르게 실행됩니다. |
기본 형식을 형식 매개 변수로 사용할 수 없습니다. 대신 개발자는 기본 형식에 해당하는 래퍼 형식을 사용해야 합니다.이로 인해 포장지가 스택 할당이 아닌 힙 할당이 되기 때문에 박스와 언박싱 변환과 메모리 및 가비지 수집 압력이 요구되므로 퍼포먼스 오버헤드가 증가합니다. | 일반 현실화의 유형 매개 변수로 원시 유형 및 값 유형이 허용됩니다.런타임 시 코드는 최초 사용 시 유형 파라미터의 고유한 조합별로 합성 및 컴파일됩니다.원시/값 유형을 사용하여 실현되는 제네릭은 박스/언박스를 변환할 필요가 없습니다. |
일반 예외가 허용되지[71] 않으며 catch[72] 절에서 형식 매개 변수를 사용할 수 없습니다. | 일반 예외를 정의하고 catch 절에 사용할 수 있습니다. |
스태틱 멤버는 모든 범용[73] 리얼라이제이션 간에 공유됩니다(타입 삭제 중에는 모든 리얼라이제이션이1개의 클래스로 접힙니다). | 스태틱 멤버는 일반적인 실현마다 다릅니다.범용 실현은 하나의 클래스입니다. |
형식 매개 변수는 정적 필드/메서드의 선언 또는 정적 내부 클래스의 정의에서 사용할 수 없습니다. | 유형 매개 변수 사용에 대한 제한 없음 |
구성 요소 유형이 일반 현실화(구체 매개 변수화된 유형)인 경우 배열을 생성할 수 없습니다.짝< >스트링 , [ ] > [ ] 10† = 10; /OK | 범용 실현은 1등급 시민이며 다른 모든 클래스로 사용할 수 있으며 어레이 컴포넌트로도 사용할 수 있습니다.물건 10쌍 = 신규 짝< >인트, 스트링>[10]; // OK(확인) |
구성 요소 유형이 유형 매개 변수인 경우 어레이를 생성할 수 없습니다. 그러나 구성 요소 유형이 유형 매개 변수인 경우 어레이를 생성할 수 있습니다.Object 어레이 및 새로운 어레이에 대해 같은 효과를 얻기 위해 타입캐스트를 수행합니다. 일반의 학급 찾다< >K, V> { 일반의 V[] get Empty Values(빈 값)(K 열쇠) { 돌아가다 (V[]) 신규 물건[0]; // OK(확인) } } 일반 유형 매개 변수가 상속 제약 조건인 경우 제약 조건 유형을 다음과 같이 사용할 수 있습니다. 일반의 학급 찾다< >K, V 확장 동등한< >V>> { 일반의 V[] get Empty Values(빈 값)(K 열쇠) { 돌아가다 (V[]) 신규 동등한[0]; } } | 유형 매개 변수는 실제 이산 클래스를 나타내며 일반 정의 내의 다른 유형과 마찬가지로 사용할 수 있습니다. 일반의 학급 찾다< >K, V> { 일반의 V[] 빈 값 가져오기(K 열쇠) { 돌아가다 신규 V[0]; // OK(확인) } } |
일반 유형의 구체적인 실현을 위한 클래스 리터럴이 없습니다. | 일반적인 인식은 실제 클래스입니다. |
instanceof 유형 매개 변수 또는 구체적인 일반 실현에는 허용되지 않습니다. | 및 연산자는 유형 파라미터에 대해 다른 유형과 동일하게 동작합니다. |
유형 매개 변수를 유형으로 사용하여 새 인스턴스를 생성할 수 없습니다. | 생성자 제약 조건을 사용하여 일반 메서드 또는 일반 클래스의 메서드는 기본 생성자를 가진 클래스의 인스턴스를 만들 수 있습니다. |
컴파일 중에 유형 정보가 지워집니다.원래 유형을 검색하려면 반사에 대한 특수 확장을 사용해야 합니다. | C# 일반 유형에 대한 유형 정보는 런타임에 완전히 보존되며, 일반 유형의 전체 반영 지원과 인스턴스화를 허용합니다. |
반사를 사용하여 새 일반 현실화를 구성할 수 없습니다.컴파일 중에 제네릭스의 클라이언트코드에 추가 코드(타입캐스트)가 삽입됩니다.따라서 나중에 새로운 실현을 만들 수 없습니다. | 반사를 사용하여 유형 매개변수의 새 조합에 대한 새 실현을 만들 수 있습니다. |
C# 에서는, 원시 타입의 제네릭을 직접 사용할 수 있습니다.대신 Java에서는 박스형 타입을 타입 파라미터로 사용할 수 있습니다(대신).이러한 값은 모두 사용할 때 박스화/해제해야 하며 모두 힙 할당이 필요하기 때문에 비용이 발생합니다.단, 범용 타입은 Java에서 기본 타입의 배열 타입으로 특화할 수 있습니다.예를 들어 [74]허용됩니다.몇몇 서드파티 라이브러리는 기본 컬렉션을 Java에 구현하여 기본 유형이 [75]제공하는 런타임 및 메모리 최적화를 보존하기 위해 기본 어레이를 지원했습니다.
이행 호환성
Java의 유형 삭제 설계는 이전 버전의 호환성과 혼동하지 않고 마이그레이션 호환성을 달성하기 위한 설계 요건에 따라 설계되었습니다.특히 원래 요건은 "Java 2 플랫폼에 도입된 Collections API에 대해 깨끗하고 입증 가능한 마이그레이션 경로가 있어야 합니다."[42]였습니다.이는 기존의 컬렉션 클래스 [76]중 하나를 필요로 하는 메서드에 새로운 범용 컬렉션을 전달할 수 있도록 설계되었습니다.
C# generic은 완전한 하위 호환성을 유지하면서 이 언어에 도입되었지만 완전한 마이그레이션 호환성은 유지되지 않았습니다.오래된 코드(C# 2.0 이전)는 재컴파일 없이 새로운 제네릭 인식 런타임에서 변경되지 않고 실행됩니다.이행 호환성에 대해서는 비범위를 보완하는 새로운 범용 컬렉션클래스와 인터페이스가 개발되었습니다.NET 1.x 컬렉션을 교체하는 대신새로운 범용 컬렉션클래스는 범용 컬렉션인터페이스에 가세해 가능한 한 범용 이외의 컬렉션인터페이스를 실장합니다.따라서 기존(일반적이지 않은) 메서드가 컬렉션 클래스를 사용하도록 코딩된 경우 이러한 메서드를 사용하여 새로운 범용 컬렉션을 사용할 수 없습니다.
공분산 및 반차이
공분산 및 반분산은 두 언어 모두에서 지원됩니다.Java에는 단일 범용 클래스가 공존 및 위반 모두를 사용하여 멤버를 선언할 수 있는 use-site variance가 있습니다.C#에는 범용 인터페이스 및 위임에 대한 정의 사이트 분산이 있습니다.Variance는 클래스에서 직접 지원되지 않지만 Variant 인터페이스를 구현함으로써 지원됩니다.C#은 또한 방법과 위임에 대한 사용 사이트 공분산 지원을 가지고 있다.
기능 프로그래밍
기능 프로그래밍 | 자바 | C# |
---|---|---|
메서드 레퍼런스 | 네, 그렇습니다[10]. | 네. |
폐쇄 | 모든 람다가 새로운 수준의 스코프를 도입하는 것은 아닙니다.참조되는 모든 변수는 사실상 최종 변수여야 합니다. | 네. |
람다 식 | 네, 그렇습니다[77]. | 네. |
식목 | 아니요. | 네. |
범용 쿼리 언어/API | 있음, Java Stream API(Monad)[78] | 네. |
테일 재귀 컴파일러 최적화 | 아니요[citation needed]. | x64에서만[79] |
폐쇄
닫힘은 어휘 범위에서 변수를 캡처하는 인라인 함수입니다.
C#은 어나니머스 메서드 또는 완전한 기능의 클로저 [80][81]시멘틱스를 가진 람다 식으로서 클로저를 지원합니다.
Java에서는 Java 8이 새로운 표준이 될 때까지 익명의 내부 클래스가 폐쇄를 에뮬레이트하기 위해 선호되는 방법으로 남을 것입니다.이것은 좀 더 장황한 구성이다.이 접근방식은 실제 폐쇄와 비교하여 몇 가지 차이점이 있으며, 특히 주변 범위의 변수에 대한 보다 제어된 접근은 최종 멤버만 참조할 수 있다.그러나 Java 8은 현재 범위를 완전히 상속하는 람다를 도입하여 새로운 범위를 도입하지 않습니다.
메서드에 대한 참조가 나중에 실행되도록 전달될 수 있는 경우, 메서드의 어휘 범위에 변수/파라미터에 대한 참조가 있을 때 수행할 작업에 대한 문제가 발생합니다.C# 닫힘은 어휘적 범위에서 모든 변수/파라미터에 액세스할 수 있습니다.Java의 익명 내부 클래스에서는 어휘 범위의 최종 멤버에 대한 참조만 허용되므로 개발자는 어떤 변수를 사용할 수 있는지, 어떤 상태(아마도 박스가 필요함)에 표시를 해야 합니다.
람다와 표현 나무
C#과 Java는 람다라고 불리는 특별한 유형의 인라인 클로저를 특징으로 합니다.이것들은 익명 메서드입니다.서명과 본문은 있지만 이름은 없습니다.이들은 주로 함수 프로그래밍과 관련된 기술인 다른 메서드에 대한 호출에서 로컬 함수 값 인수를 지정하기 위해 사용됩니다.
Java와 달리 C#에서는 식 트리라고 불리는 특수한 데이터 구조를 정의하는 방법으로 람다 함수를 사용할 수 있습니다.실행 가능한 함수인지 데이터 구조인지 여부는 컴파일러 유형 추론과 어떤 유형의 변수 또는 파라미터에 할당되거나 캐스트되는지에 따라 달라집니다.Lambdas 및 표현 트리는 Language Integrated Query(LINQ; 언어 통합 쿼리)에서 중요한 역할을 합니다.
메타데이터
![]() | 이 섹션은 확장해야 합니다.추가하시면 됩니다. (2015년 2월) |
메타데이터 | 자바 | C# |
---|---|---|
메타데이터 주석/속성 | 인터페이스 기반, 사용자 정의 주석 생성[82] 가능 | 클래스 베이스 |
위치 인수 | 아니요. 단일 인수가 아닌 한 | 네. |
명명된 인수 | 네. | 네. |
디폴트값 | 정의 시 | 초기화를 통해 |
중첩된 유형 | 네. | 네. |
전문화 | 아니요. | 네. |
조건부 메타데이터 | 아니요. | 네. |
전처리, 컴파일 및 패키징
전처리, 컴파일 및 패키징 | 자바 | C# |
---|---|---|
네임스페이스 | 패키지 | 네임스페이스 |
파일 내용 | 제한된 | 공짜 |
패키징 | 패키지 | 네임스페이스 멤버의 퍼블릭/내부 가시성(CLR 수준의 모듈 및 어셈블리로 변환) |
클래스/어셈블리 검색 경로 | 클래스 패스 | 컴파일 시간과 런타임[83][84] 모두 |
조건부 컴파일 | 아니요. 단 Apache[85] Ant 참조 | 네. |
커스텀 에러/경고 | 있음; 주석 프로세서 | 네. |
명시적 영역 | 아니요. | 네. |
네임스페이스 및 파일 내용
C#의 네임스페이스는 C++의 네임스페이스와 비슷합니다.Java의 패키지 이름과 달리 네임스페이스는 소스 파일의 위치에 어떤 식으로도 연결되어 있지 않습니다.Java 소스 파일 위치가 패키지 디렉토리 구조를 미러링할 필요는 없지만 일반적인 조직입니다.
두 언어 모두 클래스를 가져올 수 있으므로(예: Java) 이름만 사용하여 클래스를 참조할 수 있습니다.같은 이름의 클래스가 여러 네임스페이스 또는 패키지에 존재하는 경우가 있습니다.이러한 클래스는 정규화된 이름을 사용하거나 이름이 다른 선택된 클래스만 가져와 참조할 수 있습니다.이를 위해 Java에서는 단일 클래스(예: )를 Import할 수 있습니다.C#에서는 다음 구문을 사용하여 새 로컬 이름으로 클래스를 Import할 수 있습니다.또한 의 형식으로 클래스의 전문화를 Import할 수도 있습니다.
두 언어 모두 클래스의 정적 메서드/필드의 일부 또는 전부를 사용할 수 있는 정적 Import 구문을 가지고 있습니다(예를 들어 다른 클래스에서 를 스태틱하게 Import할 수 있습니다).C#에는 정적 클래스 구문(Java의 정적 내부 클래스와 혼동하지 않음)이 있습니다.이 구문에서는 클래스는 정적 메서드만 포함하도록 제한됩니다.C# 3.0 에는 확장 방식이 도입되어 사용자가 타입에 메서드를 스태틱하게 추가할 수 있습니다(예를 들어, 에서는 타입으로 동작하는 Import된 확장 방식을 사용할 수 있습니다).
Sun Microsystems Java 컴파일러에서는 소스 파일 이름이 내부 퍼블릭클래스에만 일치해야 합니다.한편, C# 에서는, 같은 파일에 복수의 퍼블릭클래스가 허가되어 파일명에 제한이 없습니다.C# 2.0 이후에는 소스 코드에서 키워드를 사용하여 클래스 정의를 여러 파일로 분할할 수 있습니다.Java에서는 퍼블릭클래스는 항상 자체 소스 파일에 있습니다.C#에서는 소스 코드 파일과 논리 유닛의 분리는 밀접하게 관련되어 있지 않습니다.
조건부 컴파일
Java와 달리 C#는 프리프로세서 디렉티브를 사용하여 조건부 컴파일을 구현합니다.또한 특정 컴파일 상수가 정의되었을 때만 호출되는 메서드를 정의하는 속성도 제공합니다.이렇게 하면 상수가 정의되었을 때만 평가되는 메서드를 사용하여 어사션을 프레임워크 기능으로 제공할 수 있습니다.버전 1.4 이후 Java에서는 어설션 언어 기능이 제공되고 있습니다.어설은 기본적으로 실행 시 꺼지지만 JVM을 호출할 때 또는 스위치를 사용하여 활성화할 수 있습니다.
스레드 기능 및 비동기 기능
두 언어 모두 언어 구문의 일부로 스레드 동기화 메커니즘을 포함합니다.
스레드화 및 동기화 | 자바 | C# |
---|---|---|
스레드 | 네. | 네. |
스레드 풀 | 네. | 네. |
태스크 기반 병렬 처리 | 네, 그렇습니다[86]. | 네, 그렇습니다[87]. |
세마포어 | 네. | 네. |
모니터 | 네. | 네. |
스레드 로컬 변수 | 네. | 있음, ThreadStaticAttribute 및 ThreadLocal <T> 클래스 |
C#의 태스크 기반 병렬 처리
.NET Framework 4.0에서는 기존의 이벤트 기반 비동기 모델을 대체하는 새로운 태스크 기반 프로그래밍 모델이 도입되었습니다.API는 및 클래스를 기반으로 합니다.작업을 구성하고 연결할 수 있습니다.
관례상 을 반환하는 모든 메서드는 이름에 Async를 붙여야 합니다.
일반의 정적인 학급 Some Async 코드 { 일반의 정적인 작업< >X-Document(X-Document(XDocument)> Get Content Async() { Http Client http Client = 신규 Http Client(); 돌아가다 http Client.GetStringAsync("www.contoso.com").계속하다.와 함께((작업) => { 스트링 responseBodyAs본문 = 작업.결과; 돌아가다 X-Document(X-Document(XDocument).해석(responseBodyAs본문); }); } } 변화하다 t = Some Async 코드.Get Content Async().계속하다.와 함께((작업) => { 변화하다 xml 문서 = 작업.결과; }); t.시작();
C# 5에서는 태스크모델을 사용하기 쉽게 하기 위해 일련의 언어와 컴파일러 확장기능이 도입되었습니다.이러한 언어 확장에는 메서드의 개념과 프로그램 흐름을 동기화하는 문장이 포함되어 있습니다.
일반의 정적인 학급 Some Async 코드 { 일반의 정적인 비동기 작업< >X-Document(X-Document(XDocument)> Get Content Async() { Http Client http Client = 신규 Http Client(); 스트링 responseBodyAs본문 = 기다리다 http Client.GetStringAsync("www.contoso.com"); 돌아가다 X-Document(X-Document(XDocument).해석(responseBodyAs본문); } } 변화하다 xml 문서 = 기다리다 Some Async 코드.Get Content Async(); // 작업은 호출 시 wait와 함께 시작됩니다.
이 구문설탕으로부터 C# 컴파일러는 개발자가 생각할 필요 없이 필요한 연속을 처리하는 상태 머신을 생성합니다.
Java용 태스크 기반 병렬 처리
Java는 JDK 1.0 이후 스레드를 지원합니다. Java는 종종 태스크라고 불리는 스레드를 실행할 수 있는 높은 범용성을 제공합니다.이것은, 다음의 예에 나타내듯이, 단일의 보이드 no-args 방식을 정의하는 기능 인터페이스(인터페이스)를 실장하는 것으로 실현됩니다.
변화하다 mythread(마이스스레드) = 신규 실(() -> { 변화하다 스레드명 = 실.current Thread(쓰레드)().getName(); 시스템..나가..인쇄("안녕하세요" + 스레드명); }); mythread(마이스스레드).개시하다();
C#과 마찬가지로 Java는 스레드 조작을 위한 보다 높은 수준의 메커니즘을 갖추고 있습니다.는 비동기 태스크를 실행할 수 있으며 서브프로세스 그룹도 관리할 수 있습니다.인스턴스의 모든 스레드는 풀에서 처리됩니다.이 인스턴스는 복수 태스크에 대해 후드 아래에서 재사용되므로 단일 실행자 서비스 인스턴스를 사용하여 응용 프로그램의 라이프 사이클 전체에 걸쳐 프로그래머가 원하는 만큼의 동시 태스크를 실행할 수 있습니다.
첫 번째 스레드 예는 다음과 같습니다.
실행자 서비스 실행자 = 실행자.new Single Thread Executor(); 실행자.제출하다(() -> { 변화하다 스레드명 = 실.current Thread(쓰레드)().getName(); 시스템..나가..인쇄("안녕하세요" + 스레드명); });
이 인스턴스는 인터페이스도 지원하지만 포함된 메서드의 시그니처는 값을 반환합니다.이렇게 하면 람다 식도 값을 반환해야 합니다.
일반의 정적인 학급 Some Async 코드 { 실행자 서비스 실행자 = 실행자.new Single Thread Executor(); 일반의 정적인 미래.< >스트링> get Content Async(){ 돌아가다 실행자.제출하다(() -> { HttpRequest(HttpRequest) httpReq = HttpRequest(HttpRequest).new Builder() .uri(신규 URI("https://www.graalvm.org")) .구축하다(); 돌아가다 Http Client.newHttp Client() .보내세요(httpReq, 바디 핸들러.문자열의()) .몸(); }); } } 변화하다 web Page Result(웹 페이지 결과) = Some Async 코드.get Content Async().얻다();
메서드를 호출하면 현재 스레드가 차단되고 콜 가능이 완료될 때까지 기다렸다가 값을 반환합니다(예에서는 웹 페이지콘텐츠).
기타 기능
수치 어플리케이션
수학 및 재무 계산 분야에서 응용 프로그램을 적절히 지원하기 위해 몇 가지 언어 특징이 있습니다.[88]
Java의 strictfp 키워드는 코드 영역에 대해 엄격한 부동소수점 계산을 가능하게 합니다.엄격한 부동 소수점 계산에서는 플랫폼이 계산 중에 더 높은 정밀도를 제공하더라도 중간 결과를 단일/이중으로 변환해야 합니다.이것에 의해, 엄밀한 부동 소수점 계산이 모든 플랫폼에서 완전히 같은 결과를 반환합니다.엄밀한 부동 소수점 없이 플랫폼 구현은 계산 중 중간 결과에 더 높은 정밀도를 자유롭게 사용할 수 있습니다.C#에서는, 소정의 하드웨어 아키텍처의 실장에서는, 가능한 경우, 중간 결과에 대해서 항상 높은 정밀도를 사용할 수 있습니다.즉, C#에서는 프로그래머가 중간 결과에 싱글/[89]더블의 잠재적인 낮은 정밀도를 사용하도록 강제할 수 없습니다.
Java의 부동소수점 산술은 주로 IEEE 754(Standard for Binary Floating)에 기반하지만 IEEE 표준 754에 의해 요구되는 예외 플래그 및 Directed Rounding과 같은 엄밀한 fp 수식자를 사용하더라도 일부 기능은 지원되지 않습니다(자바의 비판, 부동소수점 산술 참조).
C#은 Java/C#의 2배보다 정밀도가 높은(단, 범위가 작음) 10진수 [90]타입을 내장하고 있습니다.10진수 유형은 재무 및 금전 계산에 적합한 128비트 데이터 유형입니다.소수점 유형은 유효 자릿수가 28–[91]29인 1.0 × 10부터−28 약 7.9 × 10까지의28 값을 나타낼 수 있습니다.이 구조체는 C# 연산자 오버로드를 사용하여 다른 원시 데이터 유형처럼 +, -, *, / 등의 연산자를 사용하여 소수점을 조작할 수 있습니다.
BigDecimal
★★★★★★★★★★★★★★★★★」BigInteger
Java 에 부속되어 있는 타입에서는, 10 진수와 정수 번호를 각각 임의의 정밀도로 표시할 수 있습니다.Java 표준 라이브러리에는 복잡한 번호를 처리하는 클래스가 없습니다.
C# 에 부속되어 있는및 타입을 사용하면,[3] 각각 임의의 정밀도의 정수 및 복소수를 표현 및 조작할 수 있습니다.구조체는 C# 연산자 오버로드를 사용하여 인스턴스를 다른 원시 데이터 유형과 마찬가지로 , , , , 등의 연산자를 사용하여 조작할 수 있습니다.C# 표준 라이브러리에는 임의의 정밀도의 부동 소수점 번호를 처리하는 클래스가 없습니다(임의의 정밀도의 산술에 대해서는, 소프트웨어를 참조해 주세요).
C#은 코드 영역의 산술 오버플로우를 확인하기 위한 런타임체크를 활성화 또는 비활성화할 수 있는 연산자를 사용하여 수학적 응용 프로그램에 도움이 됩니다.
Integrated Query( 언어 쿼리
C#s Language Integrated Query(LINQ; 언어 통합 쿼리)는 언어 내 쿼리 기능을 가능하게 하기 위해 연계하여 설계된 기능 세트로 C#과 Java를 구별하는 기능입니다.
과 같은 기능으로 됩니다.LINQ の 음음 。
- 확장 메서드를 사용하면 기존 인터페이스 또는 클래스를 새로운 메서드로 확장할 수 있습니다.실장은 공유하거나 전용 실장을 할 수 있습니다.
- 람다는 기준을 기능적으로 표현할 수 있게 해줍니다.
- 식 트리를 사용하면 특정 구현이 실행 가능한 블록이 아닌 추상 구문 트리로 람다를 캡처할 수 있습니다.이는 구현에서 다른 언어로 기준을 나타내기 위해 사용할 수 있습니다(예: SQL 형식). 예를 들어 다음과 같이 where 절이 있습니다.LINQ, LINQ에서 SQL로.
- 익명 유형 및 유형 추론은 쿼리의 결과 유형 캡처 및 작업을 지원합니다.쿼리는 조인 및 쿼리 원본 위에 투영될 수 있으며, 이로 인해 결과 유형을 지정할 수 없습니다.
- SQL 사용자에게 익숙한 구문을 지원하기 위해 식을 쿼리합니다.
- SQL과 같은 nullable 형식을 지원하는 쿼리 공급자와 더 잘 일치하도록 하려면 nullable(리프트됨) 형식을 사용합니다.
상호
상호 | C# | |
---|---|---|
언어 상호 | 있음(GraalVM, Nashorn, CORBA, JNI 또는 JNA [93]포함) | 네, C#은 이 기능을[93] 위해 설계되었습니다. |
('/'/'/' | . | 네, □□입니다. |
코드 ★★★★★★★★★★★★★★★★★★★★★★★★★★★★ | , " " " | |
포인터와 산술 | 아니요, 하지만 sun.misc를 보세요.안전하지 않다 | 네, □□입니다. |
네, 그렇습니다[94]. | 네, □□입니다. | |
크기 | 아니요. | 네, □□입니다. |
스택 | 아니요. | 네, □□입니다. |
(주소) | 아니요. | 네, □□입니다. |
오오주주 ( 주주주주주주주주주주주 ) | 아니요. | 네, □□입니다. |
아니요. | 네, 그렇습니다[95]. | |
아니요. | 네, 그렇습니다[96]. |
Java Native Interface(JNI; Java 네이티브인터페이스) 기능을 사용하면 Java 프로그램이 Java 이외의 코드를 호출할 수 있습니다.다만, JNI 에서는, 몇개의 규약을 따르도록 코드를 호출할 필요가 있어, 사용하는 타입과 이름에 제한을 가합니다.즉, 레거시 코드와 Java 사이에 추가 적응 계층이 필요한 경우가 많습니다.이 어댑테이션 코드는 비 Java 언어(대부분 C 또는 C++)로 코딩해야 합니다.Java Native Access(JNA; Java 네이티브 액세스)를 사용하면 Java 코드만 작성하면 되는 네이티브 코드를 쉽게 호출할 수 있습니다.단, 퍼포먼스 비용이 많이 듭니다.
또한 서드파티 라이브러리는 Java-Component Object Model(COM) 브리징(예: JACOB(무료) 및 J-Integra for COM(독자 사양)을 제공합니다.
.NET Platform Invoke(P/Invoke)는 C#에서 Microsoft가 비관리 코드라고 부르는 콜을 허용함으로써 동일한 기능을 제공합니다.메타데이터 속성을 통해 프로그래머는 파라미터와 결과의 마샬링 방법을 정확하게 제어할 수 있으므로 Java에서 동등한 JNI에 필요한 외부 글루 코드를 피할 수 있습니다.P/Invoke는 프로시저 API(Win32나 POSIX 등)에 대한 거의 완전한 접근을 허용하지만 C++ 클래스 라이브러리에는 제한적으로 접근합니다.
외에 Framework는.NET Framework를 합니다.NET-COM 릿 net netCOM 컴포넌트가 퍼스트 클래스인 경우 COM 컴포넌트에 액세스할 수 있습니다.NET ★★★★★★★★★★★★★★★★」
C#은 또한 프로그래머가 CLR의 일반 유형 검사 및 기타 안전 기능을 비활성화할 수 있도록 하며, 이를 통해 포인터 변수를 사용할 수 있습니다.이 기능을 사용하는 경우 프로그래머는 키워드를 사용하여 코드를 표시해야 합니다.JNI, P/Invoke 및 "unsafe" 코드도 마찬가지로 위험한 기능으로, 잠재적인 보안 구멍과 애플리케이션 불안정성을 노출합니다.P/Invoke 또는 JNI보다 안전하지 않은 관리 대상 코드의 장점은 프로그래머가 익숙한 C# 환경에서 작업을 계속하여 관리 대상 코드를 호출해야 하는 작업을 수행할 수 있다는 것입니다.안전하지 않은 코드를 사용하는 어셈블리(프로그램 또는 라이브러리)는 특수 스위치를 사용하여 컴파일해야 하며 이렇게 표시됩니다.이를 통해 런타임 환경은 잠재적으로 유해한 코드를 실행하기 전에 특별한 예방 조치를 취할 수 있습니다.
Java(프로그래밍 언어)는 Java Runtime Environment(JRE)를 통해 Java 플랫폼에서 실행되도록 설계되었습니다.Java 플랫폼에는 Java Virtual Machine(JVM; Java 가상 머신)과 공통 라이브러리 세트가 포함됩니다.JRE는 원래 최종 컴파일을 옵션으로 하여 해석 실행을 지원하도록 설계되었습니다.대부분의 JRE 환경은 적응형 최적화를 통해 전체 또는 부분적으로 컴파일된 프로그램을 실행합니다.Java 컴파일러는 Java 바이트 코드를 생성합니다.실행 시 바이트 코드는 Java 런타임에 의해 로드되며 직접 해석되거나 기계 명령으로 컴파일된 후 실행됩니다.
C#은 Common Language Runtime(CLR; 공통언어 런타임)에 실행되도록 설계되어 있습니다.CLR은 완전히 컴파일된 코드를 실행하도록 설계되어 있습니다.C# 컴파일러는 공통 중간 언어 명령을 생성합니다.실행 시 런타임은 이 코드를 로드하고 대상 아키텍처의 기계 명령에 컴파일합니다.
»
★★★★★★
두 언어를 사용하여 한 번에 한 줄씩 한 파일에서 다른 파일로 텍스트를 복사하는 예를 보여 줍니다.
바 | C# |
---|---|
param.nio.file.*; 표시 ★★★IO )[ [ ] args) 입니다. 하지 않다 표시 = ★★★. 든 read 、 )★★★. ) input.txt" ) ; ) ; ★★★.을 쓰다 )★★★. )".txt " txt 표시 } } | . IOSystem.입출력; 표시 ★★★IO )[ [ ] args) 하지 않다 표시 = ★★★.ReadLines 。 ) input.txt" ★★★.WriteAllLines write 、 )".txt " txt , 표시 } } |
실장에 : Java 실장:
| C#은 다음과 같습니다.
|
정의
C#에서는 다음 예시와 같이 커스텀 암묵적/명시적 변환과 연산자 오버로드를 사용하여 라이브러리 정의 유형을 기존 유형 및 연산자와 통합할 수 있습니다.
C# | |
---|---|
하지 않다 Number big버 big = Integer )12345678901234567890" 하지 않다 = Number big버 big. ) Integer ) ) ; ) ; 하지 않다 = Number big버 big. ) Number big버 big 하지 않다 = Number big버 big. ) Number big버 big | 하지 않다 Number big버 big = Integer. ★★★ )12345678901234567890" 하지 않다 = Number big버 big*42; 하지 않다 = Number big버 big* Number big버 big; 하지 않다 = Number big버 big + Number big버 big; |
및 하는 Java 구성 C# Java
C# | |
---|---|
// " " " 표시 ★★★★ Method target 메서드(target Method method method) ) arg) 을 해라// 하다 ; } } // // "사용방법 하다. ) // method를 을 구축합니다 "타깃 메서드" 하지 않다 표시 = ★★★★ );( ); reference// "" .< > , ★★★> ivk = 표시 Method target 메서드(target Method method method); 된 메서드를 합니다.// 참조된 메서드를 호출합니다. = ivk. ) "httring" "httring" } | // " " " 표시 ★★★★ Method target target target ) arg) 을 해라// 하다 ; } } // // "사용방법 Something do do do do do 。 ) // method를 을 구축합니다 "타깃 메서드" 하지 않다 표시 = ★★★★ );( ); // 나중에 호출하기 위해 // 캡처합니다. < > , > dlg = 표시. Method target target target; // // 를 = dlg ) "httring" "httring" } |
C# | |
---|---|
Java에는 이 기능이 없지만 클래스에서 비슷한 효과를 볼 수 있습니다. 하지 않다 a = 입니다.. )42 하지 않다 b = 입니다.. 있다 );( ); // 는 b 이 null// b "null" 또는 "Else(0)" 0"이면 하지 않다 c = a. ) * b. )0 | intint?? a = 42; intint?? b = ; // 값을 받습니다// c는 null 값을 // 중 가 null// "*" "null" 입니다 intint?? c = a * b; |
다음 예시는 Java 및 C#을 사용하여 다른 프로그래밍 언어로 구현된 클래스의 인스턴스를 만들고 호출하는 방법을 보여 줍니다."Deepthink" 클래스는 Ruby 프로그래밍 언어를 사용하여 구현되며 메서드가 호출될 때 두 개의 입력 값(a 및 )을 곱하는 단순한 계산기를 나타냅니다.Java에는 기존의 방법 외에도 구현된 프로그래밍 언어를 실행할 수 있는 가상 머신인 GraalVM이 있습니다.
바 | C# | |
---|---|---|
VM 사용 ★★★ = ★★★. Builder 새 빌더 ). ( ). All Access All 액세스 허용 )를 참조해 주세요. );( ); // 루비 ★★★ Array = . ) , 1,2,42,4" Result 비 ruby ruby 。 = Array. Array Element는 다음과 같습니다. )2를 참조해 주세요.asInt );( ); // ★★★ ★★★ Array python 어레이 = 표시. ) , 1,2,42,4" Resultpython 결과(「」) = Array python 어레이. Array Element는 다음과 같습니다. )2를 참조해 주세요.asInt );( ); //JavaScript ★★★ jsArray = . ) , 1,2,42,4" 과과 = jsArray. Array Element는 다음과 같습니다. )2를 참조해 주세요.asInt );( ); //R ★★★ = . )'R' , , c(1, 2, 42, 4)" 과 r = . Array Element는 다음과 같습니다. )2를 참조해 주세요.asInt );( ); // C,단 등LLVM('C'+', Go, Basic') ★★★ 의 표시하다 = ★★★. Builder 새 빌더 ) "llvm" , ★★★ ) "C_Program.bc" ) ) 。 );( ); ★★★ = . )의 표시하다 . Memberget Member(「」 ) "메인"를 참조해 주세요. );( ); 의 // 엔진 초기화 하지 않다 할 수 없다 = Engine Manager Script Engine Manager ). ( ). Engine By Name 이름으로 엔진 가져오기(이름으로 엔진 가져오기) ) "jruby" 하지 않다 File 일일 ruby ruby = file file file ) thinked "Deep thinked.rb" 구동. ) | // 엔진 초기화 하지 않다 에 표시되다 = Script (스크립트 실행 시간). From Configuration Create From 구 create );( ); = 에 표시되다.; 에 표시되다. 파일 ) thinked "Deep thinked.rb" // "새 .// "Deepthink" 계산기. 하지 않다 = . 생각.@new );( ); // 설정// 계산기 입력값 설정 계산기 입력값 설정 .a = 6; .b = 7; // 결과 계산 하지 않다 = .하다. );( ); // "새 .// "Deepthink" 계산기. 하지 않다 Classcalc 래 calc calc = 구동. ) 생각한★★★★★★★★★★★★★★★★★★★」 하지 않다 = 할 수 없다. Method invoke invoke ) Classcalc 래 calc calc , " "신규" // 설정// 계산기 입력값 설정 계산기 입력값 설정 할 수 없다. Method invoke invoke ) , "a=" , 6 할 수 없다. Method invoke invoke ) , "b=" , 7 // 결과 계산 하지 않다 = 할 수 없다. Method invoke invoke ) , "계산" | |
: Java 실장:
| C#은 다음과 같습니다.
|
피보나치 수열
다음으로 2개의 언어를 사용하여 피보나치 시퀀스를 구현하는 예를 나타냅니다.C# 버전에서는 C# 제너레이터 방식을 사용합니다.Java 버전은 인터페이스 및 메서드 참조를 활용합니다.Java 및 C# 예제 모두 클래스, 메서드 및 문의 코드 포맷에 K&R 스타일을 사용합니다.
자바 | C# |
---|---|
// 피보나치 시퀀스 개울..생성하다(신규 공급자.< >정수>() { 인트 a = 0; 인트 b = 1; 일반의 정수 얻다() { 인트 임시직 = a; a = b; b = a + 임시직; 돌아가다 임시직; } }).제한.(10).각각(시스템..나가.::인쇄); | // 피보나치 시퀀스 일반의 IENumerable< >인트> 피보나치() { 인트 a = 0; 인트 b = 1; 하는 동안에 (진실의) { 산출하다 돌아가다 a; (a, b) = (b, a + b); } } |
// 첫 번째 피보나치 숫자 10개를 인쇄합니다. 앞지르다 (변화하다 그것 에 피보나치().가지고 가다(10)) { 콘솔.기입선(그것); } | |
Java 버전에 대한 참고 사항:
스트림 API 스타일 기능상기의 알고리즘은, 를 사용해 보다 일관되게 기술할 수 있습니다.반복 메서드는 시드 매개 변수와 각 반복에 대해 수행할 작업을 지정하는 함수를 수신합니다.이 경우 시드는 알고리즘의 2개의 초기값과 각 반복에서의 각각의 변환을 가진 레코드 클래스가 될 수 있습니다. 기록. 짝(인트 a, 인트 b) {}; 개울..반복하다(신규 짝(0, 1), p -> 신규 짝(p.b, p.a + p.b)) .제한.(10) .지도(p -> p.a) .각각(시스템..나가.::인쇄); | C# 버전에 관한 주의사항:
|
「 」를 참조해 주세요.
레퍼런스
- ^ "BigDecimal (Java 2 Platform SE 5.0)". Docs.oracle.com. Retrieved 24 February 2015.
- ^ "Mpir.NET". Retrieved 17 July 2015.
- ^ a b "BigInteger Structure (System.Numerics)". Msdn.microsoft.com. 18 February 2015. Retrieved 24 February 2015.
- ^ "Collection (Java 2 Platform SE 5.0)". Docs.oracle.com. Retrieved 20 May 2015.
- ^ "String (Java 2 Platform SE 5.0)". Docs.oracle.com. Retrieved 20 May 2015.
- ^ "Math – The Commons Math User Guide – Complex Numbers". Retrieved 17 July 2015.
- ^ "Date (Java 2 Platform SE 5.0)". Docs.oracle.com. Retrieved 20 May 2015.
- ^ "decimal (C# Reference)". Microsoft. Retrieved 30 November 2015.
- ^ a b c "The Java Language Environment". Oracle.com. Retrieved 18 August 2013.
- ^ a b "Method References (The Java Tutorials > Learning the Java Language > Classes and Objects)". Docs.oracle.com. 28 February 2012. Retrieved 24 February 2015.
- ^ 안전하지 않은 모드 또는 IntPtr 관리 유형을 통해서만 사용 가능
- ^ 컴파일러가 데이터 유형으로 원시 포인터를 사용할 수 있는 안전하지 않은 모드로 전환되지 않는 한 유형 시스템은 기본적으로 통합됩니다.포인터는 객체에서 파생되지도 않고 객체 데이터 형식에서 암묵적으로 변환되지도 않습니다.
- ^ "org.apache.commons.lang3.tuple (Apache Commons Lang 3.4-SNAPSHOT API)". Commons.apache.org. 15 January 2014. Retrieved 24 February 2015.
- ^ Petrusha, Ron. "Programming Writer". Microsoft Developer Network. Microsoft Corporation. Retrieved 11 September 2015.
- ^ "Unsigned Integer Arithmetic API now in JDK 8 (Joseph D. Darcy's Oracle Weblog)". Blogs.oracle.com. Archived from the original on 25 February 2017. Retrieved 24 February 2015.
- ^ "Pointer types (C# Programming Guide)". Msdn.microsoft.com. 18 February 2015. Retrieved 24 February 2015.
- ^ Joshua Bloch; Neal Gafter (2005). Java puzzlers : traps, pitfalls, and corner cases (5. print. ed.). Upper Saddle River, NJ [u.a.]: Addison-Wesley. p. 36. ISBN 978-0-321-33678-1.
The lesson for language designers is that sign extension of byte values is a common source of bugs and confusion. The masking that is required in order to suppress sign extension clutters programs, making them less readable. Therefore, the byte type should be unsigned.
{{cite book}}
: CS1 maint: 여러 이름: 작성자 목록(링크) - ^ "James Gosling on Java, May 2001". Artima.com. 10 May 2001. Retrieved 24 February 2015.
- ^ "decimal". C# Reference. Microsoft.
- ^ a b Sestoft, Jon Jagger, Nigel Perry, Peter (2007). "11.1.7 The decimal type". C? annotated standard. Amsterdam: Elsevier/Morgan Kaufmann Publishers. ISBN 978-0-12-372511-0.
- ^ Mok, Heng Ngee (2003). "9.5. The decimal type". From Java to C? : a developer's guide. Harlow, England: Addison-Wesley. ISBN 978-0-321-13622-0.
- ^ "Enum". Internet: .NET Perls. Retrieved 14 November 2016.
Performance. Enums are fast. They are almost never a performance concern. They are just syntactic sugar on a type like int, which is also fast. […] Type. An enum has an underlying type. Each time we use the enum, we are using the underlying type. The enum has syntactic sugar on top.
- ^ a b Dare Obasanjo (2007). "A Comparison of Microsoft's C# Programming Language to Sun Microsystems' Java Programming Language". Dare Obasanjo. Archived from the original on 17 December 2001. Retrieved 6 September 2012.
In Java, enumerated types are a full-fledged class that means they are typesafe and can be extended by adding methods, fields or even implementing interfaces. Whereas in C#, an enumerated type is simply syntactic sugar around an integral type (typically an int) meaning they cannot be extended and are not typesafe.
- ^ Prof. Dr. Gruntz, Dominik (8 April 2005). "Java 5: Taming the Tiger: Syntactic Sugar" (in German). Fachhochschule Aargau, Nordwestschweiz. Archived from the original on 8 July 2012. Retrieved 10 September 2012.
Enumerationen sind die heimlichen Sieger von Java 1.5. Nach vielen Beteuerungen durch Sun, Enums seien in Java überflüssig und können einfach nachgebildet werden, wurden sie nun doch eingeführt. Die einfachste Möglichkeit einer Enumeration der Jahreszeiten sieht wie folgt aus … Das Schlüsselwort enum steht für eine spezielle Art von Klasse, die eine Enumeration definiert. … Im Gegensatz zu anderen Programmiersprachen wie C/C++ und C# kann man ihnen per Gleichheitszeichen keine ganzen Zahlen zuordnen.
- ^ Dare Obasanjo (2007). "A Comparison of Microsoft's C# Programming Language to Sun Microsystems' Java Programming Language: C. An Ever So Slight Feeling of Dèjà Vu: 4. Switch Statement". Dare Obasanjo. Archived from the original on 19 September 2012. Retrieved 10 September 2012.
- ^ "goto (C#)". Msdn.microsoft.com. Retrieved 18 August 2013.
- ^ a b "Oracle Technology Network for Java Developers Oracle Technology Network Oracle". Java.sun.com. Archived from the original on 27 June 2012. Retrieved 24 February 2015.
- ^ [1] 2009년 3월 4일 Wayback Machine에서 아카이브 완료
- ^ "Unsafe Code and Pointers (C# Programming Guide)". Microsoft. Retrieved 11 March 2013.
- ^ "SortedDictionary(TKey, TValue) Class (System.Collections.Generic)". Msdn.microsoft.com. Retrieved 18 August 2013.
- ^ "SortedSet(T) Class (System.Collections.Generic)". Msdn.microsoft.com. Retrieved 18 August 2013.
- ^ "Power Collections". Wintellect. 27 August 2008.
A Community Project to Develop the Best Public License type safe Collection Classes for .NET. Power Collections makes heavy use of .NET Generics. The goal of the project is to provide generic collection classes that are not available in the .NET framework. Some of the collections included are the Deque, MultiDictionary, Bag, OrderedBag, OrderedDictionary, Set, OrderedSet, and OrderedMultiDictionary.
The Power Collections for .NET contain priority queues within classes from OrderedBag and OrderedSet. - ^ "C5 Generic Collection Library". Archived from the original on 10 December 2015.
C5 provides functionality and data structures not provided by the standard .Net System.Collections.Generic namespace, such as persistent tree data structures, heap based priority queues, hash indexed array lists and linked lists, and events on collection changes. Also, it is more comprehensive than collection class libraries on other similar platforms, such as Java. Unlike many other collection class libraries, C5 is designed with a strict policy of supporting "code to interface not implementation".
Alt URL
Class IntervalHeap<T> implements interface IPriorityQueue<T> using an interval heap stored as an array of pairs. The FindMin and FindMax operations, and the indexer’s get-accessor, take time O(1). The DeleteMin, DeleteMax, Add and Update operations, and the indexer’s set-accessor, take time O(log n). In contrast to an ordinary priority queue, an interval heap offers both minimum and maximum operations with the same efficiency. - ^ "System.Collections.Concurrent Namespace". Microsoft. Retrieved 12 March 2013.
- ^ "foreach, in (C# reference)". Microsoft. 2018. Archived from the original on 12 January 2019. Retrieved 26 January 2019.
The foreach statement executes a statement or a block of statements for each element in an instance of the type that implements the System.Collections.IEnumerable or System.Collections.Generic.IEnumerable<T> interface.
- ^ Dare Obasanjo (2007). "A Comparison of Microsoft's C# Programming Language to Sun Microsystems' Java Programming Language: C. An Ever So Slight Feeling of Dèjà Vu: 6. Collections". Dare Obasanjo. Archived from the original on 19 September 2012. Retrieved 10 September 2012.
The Java collections framework not only has methods that enable one to access unsafe collections in a thread safe manner, but contains thread-safe versions of most of the data structures as well. The Java collections framework has a number of algorithms for manipulating the elements within the data structures including algorithms that can do the following; find the largest element based on some Comparator, find the smallest element, find sublists within a list, reverse the contents of a list, shuffle the contents of a list, creates immutable versions of a collection, performs sorts, and binary searches.
- ^ Dare Obasanjo (March 2007). "A Comparison of Microsoft's C# Programming Language to Sun Microsystems' Java Programming Language: C. An Ever So Slight Feeling of Dèjà Vu: 6. Collections". Dare Obasanjo. Archived from the original on 2 January 2013. Retrieved 10 September 2012.
The C# collections framework consists of the classes in the System. Collections and the System.Collections.Generic namespaces. The Systems.Collections namespace contains interfaces and abstract classes that represent abstract data types such as IList, IEnumerable, IDictionary, ICollection, and CollectionBase that enable developers to manipulate data structures independently of how they are actually implemented as long as the data structures inherit from the abstract data types. The System.Collections namespace also contains some concrete implementations of data structures such as ArrayList, Stack, Queue, HashTable and SortedList. All four of the concrete data structure implementations enable one to obtain synchronized wrappers to the collection that allows for access in a thread-safe manner. The System.Collections.Generic namespace has generic implementations of the key data structures in the System.Collections namespace including generic List<T>, Stack<T>,Queue<T>, Dictionary<K,T> and SortedDictionary<K,T> classes.
- ^ Dare Obasanjo (2007). "A Comparison of Microsoft's C# Programming Language to Sun Microsystems' Java Programming Language". Dare Obasanjo. Archived from the original on 19 September 2012. Retrieved 6 September 2012.
- ^ Eric Fleegal (2004). "Microsoft Visual C++ Floating-Point Optimization". MSDN. Retrieved 1 January 2016.
- ^ "JEP 378: Text Blocks". Retrieved 5 August 2020.
- ^ Dare Obasanjo (2007). "A Comparison of Microsoft's C# Programming Language to Sun Microsystems' Java Programming Language: D. Now for Something Completely Different: 13. Verbatim Strings". Dare Obasanjo. Archived from the original on 19 September 2012. Retrieved 11 September 2012.
- ^ a b "The Java Community Process(SM) Program – JSRs: Java Specification Requests – detail JSR# 14". Jcp.org. Retrieved 24 February 2015.
- ^ "JEP 286: Local-Variable Type Inference". Retrieved 25 April 2018.
- ^ Dare Obasanjo (2007). "A Comparison of Microsoft's C# Programming Language to Sun Microsystems' Java Programming Language: D. Now for Something Completely Different: 14. Overflow Detection". Dare Obasanjo. Archived from the original on 19 September 2012. Retrieved 11 September 2012.
- ^ Dare Obasanjo (2007). "A Comparison of Microsoft's C# Programming Language to Sun Microsystems' Java Programming Language: An Ever So Slight Feeling of Dèjà Vu: 4. switch Statment". Dare Obasanjo. Archived from the original on 19 September 2012. Retrieved 7 September 2012.
- ^ "The try-with-resources Statement (The Java Tutorials > Essential Classes > Exceptions)". Docs.oracle.com. 28 February 2012. Retrieved 24 February 2015.
- ^ Java 프로그래밍 언어용으로 작성된 확장자
- ^ "Anonymous Types (C# Programming Guide)". Msdn.microsoft.com. Retrieved 18 August 2013.
- ^ "Java SE Specifications". Java.sun.com. Retrieved 24 February 2015.
- ^ Dare Obasanjo (2007). "A Comparison of Microsoft's C# Programming Language to Sun Microsystems' Java Programming Language: Operator Overloading". Dare Obasanjo. Archived from the original on 19 September 2012. Retrieved 6 September 2012.
Note: Unlike C++, C# does not allow the overloading of the following operators; new, ( ), , &&, =, or any variations of compound assignments such as +=, -=, etc. However, compound assignment operators will call overloaded operators, for instance, += would call overloaded +.
- ^ "Java News from August, 1998". Cafeaulait.org. Retrieved 24 February 2015.
- ^ Sunwold, Corey (25 February 2010). "C# Equivalent to Java's "final"". Corey Sunwold. Archived from the original on 29 November 2012. Retrieved 13 September 2016.
There is than one use of the final keyword that C# does not have an equivalent for. When you pass a parameter to a method in Java, and you don't want that parameter's value to change within the scope of that method you can set it as final like this:
- ^ "C# – A C# 6.0 Language Preview". Msdn.microsoft.com. Retrieved 24 February 2015.
- ^ a b Dare Obasanjo (2007). "A Comparison of Microsoft's C# Programming Language to Sun Microsystems' Java Programming Language: D. Now for Something Completely Different: 15. Explicit Interface Implementation". Dare Obasanjo. Archived from the original on 22 September 2012. Retrieved 11 September 2012.
- ^ "in parameter modifier (C# Reference)". Microsoft. 5 March 2018. Archived from the original on 26 January 2019. Retrieved 26 January 2019.
- ^ Gosling, James. "The Java® Language Specification". Section 8.4.1. Formal Parameters. Retrieved 5 October 2014.
{{cite web}}
: CS1 유지보수: 위치(링크) - ^ Hanselman, Scott (4 April 2008). "How do Extension Methods work and why was a new CLR not required?". Retrieved 29 March 2014.
Extension methods are a really nice syntactic sugar. They're not really added to the class, as we can see, but the compiler makes it feel like they are
- ^ "Extension Methods (C# Programming Guide)". Microsoft. 2013. Retrieved 29 March 2014.
Extension methods are defined as static methods but are called by using instance method syntax
- ^ "C# Language Specification Version 4.0". Microsoft. p. 281. Retrieved 10 May 2012.
If no part of a partial type declaration contains an implementing declaration for a given partial method, any expression statement invoking it is simply removed from the combined type declaration. Thus the invocation expression, including any constituent expressions, has no effect at run-time. The partial method itself is also removed and will not be a member of the combined type declaration. If an implementing declaration exist for a given partial method, the invocations of the partial methods are retained. The partial method gives rise to a method declaration similar to the implementing partial method declaration except for the following: […]
- ^ "in parameter modifier (C# Reference)". Microsoft. 5 March 2018. Archived from the original on 26 January 2019. Retrieved 26 January 2019.
The in keyword causes arguments to be passed by reference. It is like the ref or out keywords, except that in arguments cannot be modified by the called method.
- ^ Dare Obasanjo (2007). "A Comparison of Microsoft's C# Programming Language to Sun Microsystems' Java Programming Language: D. Now for Something Completely Different: 12. Pass by Reference". Dare Obasanjo. Archived from the original on 19 September 2012. Retrieved 10 September 2012.
In Java the arguments to a method are passed by value meaning that a method operates on copies of the items passed to it instead of on the actual items. In C#, as in C++ and in a sense C, it is possible to specify that the arguments to a method actually be references to the items being passed to the method instead of copies. This feature is particularly useful when one wants to create a method that returns more than one object. In Java trying to return multiple values from a method is unsupported and leads to anomalies like: a method that swaps two numbers that have been the hallmark of freshman computer science classes for years, is impossible to do in Java without resorting to coding tricks.
- ^ "Exceptional Exception Filtering". Pluralsight®. Retrieved 24 June 2022.
- ^ "The Trouble with Checked Exceptions". Artima.com. Retrieved 24 February 2015.
- ^ "Msdn forums – Visual C# Language". Msdn2.microsoft.com. Archived from the original on 20 March 2007. Retrieved 24 February 2015.
- ^ Eckel, Bruce. "Does Java need Checked Exceptions?". Archived from the original on 5 April 2002. Retrieved 6 December 2012.
- ^ "Failure and Exceptions". Artima.com. 22 September 2003. Retrieved 18 August 2013.
- ^ "Checked Exceptions". Shaun Abram. Retrieved 18 August 2013.
- ^ "Java SE Specifications". Java.sun.com. Retrieved 24 February 2015.
- ^ Angelika Langer. "Java Generics FAQs – Frequently Asked Questions – Angelika Langer Training/Consulting". AngelikaLanger.com. Retrieved 24 February 2015.
- ^ Angelika Langer (16 April 2013). "Java Generics FAQs – Under The Hood of the Compiler – Angelika Langer Training/Consulting". AngelikaLanger.com. Retrieved 18 August 2013.
- ^ Angelika Langer (16 April 2013). "Java Generics FAQs – Under The Hood of the Compiler – Angelika Langer Training/Consulting". AngelikaLanger.com. Retrieved 18 August 2013.
- ^ Angelika Langer (16 April 2013). "Java Generics FAQs – Under The Hood of the Compiler – Angelika Langer Training/Consulting". AngelikaLanger.com. Retrieved 18 August 2013.
- ^ Angelika Langer (13 February 2014). "Java Generics FAQs – Type Parameters – Angelika Langer Training/Consulting". AngelikaLanger.com. Retrieved 24 February 2015.
- ^ "Generics in C#, Java, and C". Artima.com. Retrieved 24 February 2015.
- ^ "trove4j / Trove". Retrieved 30 June 2017.
- ^ Neal Gafter (23 September 2004). "Neal Gafter's blog: Puzzling Through Erasure: answer section". Gafter.blogspot.com. Retrieved 18 August 2013.
- ^ "Lambda Expressions (The Java Tutorials > Learning the Java Language > Classes and Objects)". Docs.oracle.com. 28 February 2012. Retrieved 24 February 2015.
- ^ "Lesson: Aggregate Operations (The Java Tutorials > Collections)". Docs.oracle.com. 28 February 2012. Retrieved 24 February 2015.
- ^ Grant Richins (11 May 2009). "Tail Call Improvements in .NET Framework 4". MSDN Blogs.
- ^ Richter, Jeffrey (April 2001). "An Introduction to Delegates". MSDN Magazine. Retrieved 23 December 2008.
- ^ Campbell, Dustin (9 February 2007). "What's in a Closure?". Did it with .NET. Archived from the original on 15 August 2014. Retrieved 23 December 2008.
- ^ Dare Obasanjo (2007). "A Comparison of Microsoft's C# Programming Language to Sun Microsystems' Java Programming Language: Metadata Annotations". Dare Obasanjo. Archived from the original on 19 September 2012. Retrieved 6 September 2012.
However a key difference between C# attributes and Java annotations is that one can create meta-annotations (i.e., annotations on annotations) in Java but can not do the same in C#. Developers can create their own custom annotations by creating an annotation type that is similar to an interface except that the keyword @interface is used to define it.
- ^ "Element". Msdn.microsoft.com. Retrieved 18 August 2013.
- ^ "C# Assembly – Custom Reference Path – Visual C# Kicks". Vcskicks.com. Retrieved 18 August 2013.
- ^ "How to do Conditional Compilation with Java". weblogs.java.net. Archived from the original on 5 January 2013. Retrieved 11 August 2015.
- ^ Java 버전 7에 포함된 포크 결합 프레임워크.
- ^ "Task Parallel Library (TPL)". Msdn.microsoft.com. 18 February 2015. Retrieved 24 February 2015.
- ^ "Java for Scientific Computation : Prospects and Problems" (PDF). Pds.ewi.tudelft.nl. Archived from the original (PDF) on 22 September 2007. Retrieved 24 February 2015.
- ^ "C# Language Specification Version 5.0". Microsoft. 4.1.6 Floating point types. Retrieved 28 October 2013.
Floating-point operations may be performed with higher precision than the result type of the operation. For example, some hardware architectures support an "extended" or "long double" floating-point type with greater range and precision than the double type, and implicitly perform all floating-point operations using this higher precision type. Only at excessive cost in performance can such hardware architectures be made to perform floating-point operations with less precision, and rather than require an implementation to forfeit both performance and precision, C# allows a higher precision type to be used for all floating-point operations. Other than delivering more precise results, this rarely has any measurable effects. However, in expressions of the form x*y/z, where the multiplication produces a result that is outside the double range, but the subsequent division brings the temporary result back into the double range, the fact that the expression is evaluated in a higher range format may cause a finite result to be produced instead of an infinity.
- ^ "decimal vs. 110". Retrieved 24 February 2015.[데드링크]
- ^ "C# Language Specification Version 5.0". Microsoft. 4.1.7 The decimal type.
- ^ "Complex". Retrieved 24 February 2015.[데드링크]
- ^ a b Dare Obasanjo (2007). "A Comparison of Microsoft's C# Programming Language to Sun Microsystems' Java Programming Language: C. An Ever So Slight Feeling of Dèjà Vu: 15. Cross Language Interoperability". Dare Obasanjo. Archived from the original on 19 September 2012. Retrieved 10 September 2012.
There are a number of ways cross language interoperability works in Java. First of all, there is the Java Native Interface (JNI) … Java also has the ability to interact with distributed objects that use the common object request broker architecture (CORBA) via Java IDL. … C# and the .NET runtime were created with seamless cross-language interoperability as a design goal.
- ^ "JNI Types and Data Structures". Docs.oracle.com. Retrieved 9 April 2020.
- ^ "Function pointers in C# 9". docs.microsoft.com. Retrieved 27 February 2021.
- ^ "Creating C/C++ unions in C#". docs.microsoft.com. Retrieved 27 February 2021.
외부 링크
- C# 및 으로 이동합니다.MSDN에서의 NET 프레임워크
- C#과 Java: MSDN에서의 프로그래밍 언어 비교
- 자바와C# – 코드 비교 코드
- 9개 언어 퍼포먼스 요약
- Microsoft 개발자 네트워크(MSDN): Java 개발자용 C# 프로그래밍 언어
- 표준 ECMA-334 C# 언어 사양
- 자바 언어 사양(일)
- C#의 상태: 아직 사용 가능한 언어입니까?