Java가 연산자 오버로딩을 제공하지 않는 이유는 무엇입니까?
https://stackoverflow.com/questions/77718
-
09-06-2019 - |
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
Russian문제
C++에서 Java로 넘어오면서 분명한 대답이 없는 질문은 Java에 연산자 오버로딩이 포함되지 않은 이유는 무엇입니까?
아닌가? Complex a, b, c; a = b + c; 보다 훨씬 간단하다 Complex a, b, c; a = b.add(c);?
이에 대해 알려진 이유가 있고 유효한 주장이 있습니까? ~ 아니다 연산자 과부하를 허용합니까?그 이유는 임의적인 것입니까, 아니면 시간이 지나서 잊혀진 것입니까?
해결책
다음에서 참조하는 개체의 이전 값을 덮어쓰려고 한다고 가정합니다. a, 그러면 멤버 함수를 호출해야 합니다.
Complex a, b, c;
// ...
a = b.add(c);
C++에서 이 표현식은 컴파일러에게 스택에 세(3) 개의 객체를 생성하고 추가를 수행하고 다음을 수행하도록 지시합니다. 복사 임시 개체에서 기존 개체로의 결과 값 a.
그러나 자바에서는 operator= 참조 유형에 대한 값 복사를 수행하지 않으며 사용자는 값 유형이 아닌 새 참조 유형만 생성할 수 있습니다.따라서 이름이 지정된 사용자 정의 유형의 경우 Complex, 할당은 기존 값에 대한 참조를 복사하는 것을 의미합니다.
대신 다음을 고려하십시오.
b.set(1, 0); // initialize to real number '1'
a = b;
b.set(2, 0);
assert( !a.equals(b) ); // this assertion will fail
C++에서는 값이 복사되므로 비교 결과가 같지 않습니다.자바에서는 operator= 참조 복사를 수행하므로 a 그리고 b 이제 동일한 값을 참조하고 있습니다.결과적으로 객체가 자신과 동일하다고 비교되므로 비교 결과 '같음'이 생성됩니다.
복사본과 참조의 차이는 연산자 오버로드의 혼란을 가중시킬 뿐입니다.@Sebastian이 언급했듯이 Java와 C#은 모두 값과 참조 동등성을 별도로 처리해야 합니다. operator+ 아마도 가치와 객체를 다룰 것이지만, operator= 참조를 처리하기 위해 이미 구현되었습니다.
C++에서는 한 번에 한 종류의 비교만 처리해야 하므로 덜 혼란스러울 수 있습니다.예를 들어, Complex, operator= 그리고 operator== 둘 다 값에 대해 작업하고 있습니다. 즉, 값을 복사하고 값을 비교하고 있습니다.
다른 팁
운영자 과부하에 대해 불평하는 게시물이 많이 있습니다.
나는 "연산자 오버로딩" 개념을 명확히 하고 이 개념에 대한 대안적인 관점을 제시해야 한다고 느꼈습니다.
코드 난독화?
이 주장은 오류입니다.
난독화는 모든 언어에서 가능합니다.
C++에서 연산자 오버로드를 통해 코드를 난독화하는 것처럼 함수/메서드를 통해 C 또는 Java에서 코드를 난독화하는 것은 쉽습니다.
// C++
T operator + (const T & a, const T & b) // add ?
{
T c ;
c.value = a.value - b.value ; // subtract !!!
return c ;
}
// Java
static T add (T a, T b) // add ?
{
T c = new T() ;
c.value = a.value - b.value ; // subtract !!!
return c ;
}
/* C */
T add (T a, T b) /* add ? */
{
T c ;
c.value = a.value - b.value ; /* subtract !!! */
return c ;
}
...Java의 표준 인터페이스에서도
또 다른 예를 들어 보겠습니다. Cloneable 상호 작용 자바에서:
이 인터페이스를 구현하는 개체를 복제해야 합니다.하지만 거짓말을 할 수도 있습니다.그리고 다른 개체를 만듭니다.사실 이 인터페이스는 너무 약해서 재미삼아 다른 유형의 객체를 모두 반환할 수도 있습니다.
class MySincereHandShake implements Cloneable
{
public Object clone()
{
return new MyVengefulKickInYourHead() ;
}
}
다음과 같이 Cloneable 인터페이스는 남용되거나 난독화될 수 있습니다. C++ 연산자 오버로딩과 동일한 근거로 인터페이스를 금지해야 합니까?
우리는 toString() 의 방법 MyComplexNumber 클래스를 사용하여 문자열화된 시간을 반환하도록 합니다.해야 toString() 과적도 금지되나요?우린 방해할 수도 있어 MyComplexNumber.equals 임의의 값을 반환하도록 하려면 피연산자를 수정하세요.등.등.등..
C++에서와 마찬가지로 Java나 어떤 언어에서든 프로그래머는 코드를 작성할 때 최소한의 의미론을 존중해야 합니다.이는 다음을 구현하는 것을 의미합니다. add 추가하는 함수, 그리고 Cloneable 복제하는 구현 방법 및 ++ 증분보다 연산자.
어쨌든 난독화하는 것은 무엇입니까?
이제 우리는 순수한 Java 메서드를 통해서도 코드가 방해받을 수 있다는 것을 알았으므로 C++에서 연산자 오버로딩의 실제 사용에 대해 스스로에게 질문할 수 있습니다.
명확하고 자연스러운 표기법:방법 대연산자 과부하?
어떤 종류의 코딩 스타일이 더 명확한지에 대한 아이디어를 얻기 위해 아래에서 다양한 경우에 대해 Java와 C++의 "동일한" 코드를 비교해 보겠습니다.
자연스러운 비교:
// C++ comparison for built-ins and user-defined types
bool isEqual = A == B ;
bool isNotEqual = A != B ;
bool isLesser = A < B ;
bool isLesserOrEqual = A <= B ;
// Java comparison for user-defined types
boolean isEqual = A.equals(B) ;
boolean isNotEqual = ! A.equals(B) ;
boolean isLesser = A.comparesTo(B) < 0 ;
boolean isLesserOrEqual = A.comparesTo(B) <= 0 ;
A와 B는 연산자 오버로드가 제공되는 한 C++에서 모든 유형이 될 수 있습니다.Java에서 A와 B가 원시형이 아닌 경우 원시형 객체(BigInteger 등)의 경우에도 코드가 매우 혼란스러워질 수 있습니다.
자연 배열/컨테이너 접근자 및 첨자:
// C++ container accessors, more natural
value = myArray[25] ; // subscript operator
value = myVector[25] ; // subscript operator
value = myString[25] ; // subscript operator
value = myMap["25"] ; // subscript operator
myArray[25] = value ; // subscript operator
myVector[25] = value ; // subscript operator
myString[25] = value ; // subscript operator
myMap["25"] = value ; // subscript operator
// Java container accessors, each one has its special notation
value = myArray[25] ; // subscript operator
value = myVector.get(25) ; // method get
value = myString.charAt(25) ; // method charAt
value = myMap.get("25") ; // method get
myArray[25] = value ; // subscript operator
myVector.set(25, value) ; // method set
myMap.put("25", value) ; // method put
Java에서는 각 컨테이너가 동일한 작업(인덱스 또는 식별자를 통해 콘텐츠에 액세스)을 수행하는 경우 이를 수행하는 방법이 다르기 때문에 혼란스럽습니다.
C++에서는 연산자 오버로딩 덕분에 각 컨테이너가 동일한 방법을 사용하여 콘텐츠에 액세스합니다.
자연스러운 고급 유형 조작
아래 예에서는 Matrix 개체, Google에서 '에 대해 찾은 첫 번째 링크를 사용하여 찾았습니다.Java 매트릭스 객체" 그리고 "C++ 매트릭스 객체":
// C++ YMatrix matrix implementation on CodeProject
// http://www.codeproject.com/KB/architecture/ymatrix.aspx
// A, B, C, D, E, F are Matrix objects;
E = A * (B / 2) ;
E += (A - B) * (C + D) ;
F = E ; // deep copy of the matrix
// Java JAMA matrix implementation (seriously...)
// http://math.nist.gov/javanumerics/jama/doc/
// A, B, C, D, E, F are Matrix objects;
E = A.times(B.times(0.5)) ;
E.plusEquals(A.minus(B).times(C.plus(D))) ;
F = E.copy() ; // deep copy of the matrix
그리고 이것은 행렬에만 국한되지 않습니다.그만큼 BigInteger 그리고 BigDecimal Java의 클래스는 동일한 혼란스러운 장황함으로 인해 어려움을 겪는 반면, C++의 해당 클래스는 내장 유형만큼 명확합니다.
자연 반복자:
// C++ Random Access iterators
++it ; // move to the next item
--it ; // move to the previous item
it += 5 ; // move to the next 5th item (random access)
value = *it ; // gets the value of the current item
*it = 3.1415 ; // sets the value 3.1415 to the current item
(*it).foo() ; // call method foo() of the current item
// Java ListIterator<E> "bi-directional" iterators
value = it.next() ; // move to the next item & return the value
value = it.previous() ; // move to the previous item & return the value
it.set(3.1415) ; // sets the value 3.1415 to the current item
자연 펑터:
// C++ Functors
myFunctorObject("Hello World", 42) ;
// Java Functors ???
myFunctorObject.execute("Hello World", 42) ;
텍스트 연결:
// C++ stream handling (with the << operator)
stringStream << "Hello " << 25 << " World" ;
fileStream << "Hello " << 25 << " World" ;
outputStream << "Hello " << 25 << " World" ;
networkStream << "Hello " << 25 << " World" ;
anythingThatOverloadsShiftOperator << "Hello " << 25 << " World" ;
// Java concatenation
myStringBuffer.append("Hello ").append(25).append(" World") ;
좋아, Java에서는 다음을 사용할 수 있습니다. MyString = "Hello " + 25 + " World" ; 도...하지만 잠시만 기다려주세요.이것은 연산자 오버로딩입니다. 그렇죠?사기 아닌가요???
:-디
일반 코드?
피연산자를 수정하는 동일한 일반 코드는 내장/기본 객체(Java에 인터페이스가 없음), 표준 객체(올바른 인터페이스를 가질 수 없음) 및 사용자 정의 객체 모두에 사용할 수 있어야 합니다.
예를 들어, 임의 유형의 두 값의 평균 값을 계산합니다.
// C++ primitive/advanced types
template<typename T>
T getAverage(const T & p_lhs, const T & p_rhs)
{
return (p_lhs + p_rhs) / 2 ;
}
int intValue = getAverage(25, 42) ;
double doubleValue = getAverage(25.25, 42.42) ;
complex complexValue = getAverage(cA, cB) ; // cA, cB are complex
Matrix matrixValue = getAverage(mA, mB) ; // mA, mB are Matrix
// Java primitive/advanced types
// It won't really work in Java, even with generics. Sorry.
연산자 오버로딩에 대해 논의
이제 연산자 오버로딩을 사용하는 C++ 코드와 Java의 동일한 코드를 공정하게 비교했으므로 이제 "연산자 오버로딩"을 개념으로 논의할 수 있습니다.
연산자 과부하는 컴퓨터 이전부터 존재했습니다.
컴퓨터 과학 외부에도 연산자 과부하가 있습니다.예를 들어, 수학에서 다음과 같은 연산자는 +, -, *, 등.과부하가 걸렸습니다.
실제로, 의 의미는 +, -, *, 등.피연산자의 유형(숫자, 벡터, 양자파동함수, 행렬 등)에 따라 변경됩니다.
우리 대부분은 과학 과정의 일환으로 피연산자의 유형에 따라 연산자에 대한 다양한 의미를 배웠습니다.우리는 그들이 혼란스럽다고 생각했나요?
연산자 오버로딩은 피연산자에 따라 달라집니다.
이는 연산자 오버로딩에서 가장 중요한 부분입니다.수학이나 물리학과 마찬가지로 연산은 피연산자의 유형에 따라 달라집니다.
따라서 피연산자의 유형을 알면 연산의 효과를 알 수 있습니다.
C와 Java에도 (하드 코딩된) 연산자 오버로드가 있습니다.
C에서는 연산자의 실제 동작이 피연산자에 따라 변경됩니다.예를 들어, 두 개의 정수를 추가하는 것은 두 개의 double을 추가하거나 하나의 정수와 하나의 double을 추가하는 것과 다릅니다.전체 포인터 산술 도메인도 있습니다(캐스팅 없이 포인터에 정수를 추가할 수 있지만 두 개의 포인터를 추가할 수는 없습니다...).
Java에는 포인터 연산이 없지만 누군가 여전히 문자열 연결을 발견했습니다. + 연산자는 "연산자 오버로드는 악하다"는 신조에서 예외를 정당화할 만큼 충분히 터무니없을 것입니다.
단지 C(역사적인 이유로) 또는 Java(예: 개인적인 사유, 아래 참조) 코더를 직접 제공할 수는 없습니다.
C++에서는 연산자 오버로딩이 선택 사항이 아닙니다.
C++에서는 내장 유형에 대한 연산자 오버로딩이 불가능하지만(이것은 좋은 일입니다) 사용자 정의 유형은 가질 수 있습니다 사용자 정의 연산자 과부하.
앞서 이미 말했듯이, C++에서는 Java와 반대로 사용자 유형은 내장 유형과 비교할 때 언어의 2급 시민으로 간주되지 않습니다.따라서 내장 유형에 연산자가 있으면 사용자 유형도 이를 가질 수 있어야 합니다.
진실은 다음과 같습니다. toString(), clone(), equals() 메소드는 Java(즉.준표준형), C++ 연산자 오버로딩은 C++의 많은 부분을 차지하므로 원래 C 연산자나 앞서 언급한 Java 메서드만큼 자연스러워집니다.
템플릿 프로그래밍과 결합하여 연산자 오버로딩은 잘 알려진 디자인 패턴이 됩니다.실제로 오버로드된 연산자를 사용하지 않고, 자신의 클래스에 대해 오버로드된 연산자를 사용하지 않고는 STL에서 멀리 갈 수 없습니다.
...하지만 남용해서는 안 됩니다
연산자 오버로딩은 연산자의 의미를 존중하도록 노력해야 합니다.에서 빼지 마세요. + 연산자("에서 빼지 마십시오. add 함수" 또는 "쓰레기를 반환합니다. clone 방법").
캐스트 오버로드는 모호성을 유발할 수 있으므로 매우 위험할 수 있습니다.따라서 잘 정의된 경우를 위해 예약되어야 합니다.에 관해서는 && 그리고 ||, 자신이 하고 있는 일을 실제로 알지 않는 한 절대 과부하하지 마십시오. 기본 연산자가 제공하는 단락 회로 평가를 잃게 되기 때문입니다. && 그리고 || 즐기다.
그래서...좋아요...그렇다면 왜 Java에서는 불가능합니까?
제임스 고슬링이 이렇게 말했기 때문입니다.
나는 연산자 오버로딩을 생략했습니다. 상당히 개인적인 선택 너무 많은 사람들이 C++에서 그것을 남용하는 것을 보았기 때문입니다.
제임스 고슬링.원천: http://www.gotw.ca/publications/c_family_interview.htm
위의 Gosling의 텍스트를 아래 Stroustrup의 텍스트와 비교해 보세요.
많은 C++ 디자인 결정은 사람들에게 특정 방식으로 작업을 수행하도록 강요하는 것을 싫어하는 데 뿌리를 두고 있습니다. [...] 종종 저는 개인적으로 싫어하는 기능을 금지하려는 유혹을 받았지만 그렇게 하지 않았습니다. 나는 내 의견을 다른 사람에게 강요할 권리가 없다고 생각했습니다..
비얀 스트로스트럽.원천:C++의 설계와 진화(1.3 일반 배경)
연산자 오버로딩이 Java에 도움이 될까요?
일부 객체는 연산자 오버로드(BigDecimal, 복소수, 행렬, 컨테이너, 반복자, 비교기, 파서 등과 같은 구체적인 유형 또는 숫자 유형)로 인해 큰 이점을 얻을 수 있습니다.
C++에서는 Stroustrup의 겸손 덕분에 이러한 이점을 누릴 수 있습니다.Java에서는 Gosling 때문에 망가졌습니다. 개인적인 선택.
Java에 추가할 수 있나요?
현재 Java에 연산자 오버로드를 추가하지 않는 이유는 내부 정치, 기능에 대한 알레르기, 개발자에 대한 불신(Java 팀을 괴롭히는 방해 행위자...), 이전 JVM과의 호환성 등이 혼합되어 있을 수 있습니다. 올바른 사양을 작성하는 데 필요한 시간 등
그러니 이 기능을 기다리면서 숨을 멈추지 마세요...
하지만 그들은 C#으로 그것을 합니다!!!
응...
이것이 두 언어의 유일한 차이점은 아니지만, 이것은 결코 나를 즐겁게 하지 못합니다.
분명히 C# 사람들은 그들의 "모든 기본 요소는 struct, 그리고 struct 개체에서 파생됩니다.", 첫 시도에 바로 성공했습니다.
그리고 그들은 그것을 해냅니다 다른 언어!!!
사용된 정의 연산자 오버로드에 대한 모든 FUD에도 불구하고 다음 언어가 이를 지원합니다. 스칼라, 다트, 파이썬, 에프#, 씨#, 디, 알골 68, 잡담, 그루비, 펄 6, C++, 루비, 하스켈, MATLAB, 에펠, 루아, 클로저, 포트란 90, 빠른, 에이다, 델파이 2005...
너무나 많은 언어와 매우 다양한(때로는 반대되는) 철학을 가지고 있지만, 그들은 모두 그 점에 동의합니다.
생각할 거리...
James Gosling은 Java 설계를 다음과 같이 비유했습니다.
"이사할 때 한 아파트에서 다른 아파트로 이사할 때 이런 원칙이 있어요.흥미로운 실험은 아파트를 포장하고 모든 것을 상자에 넣은 다음 다음 아파트로 이사하고 필요할 때까지 아무것도 포장하지 않는 것입니다.그래서 당신은 첫 번째 식사를 만들고 상자에서 무언가를 꺼내고 있습니다.그런 다음 한 달 정도 지나면 그것을 사용하여 인생에서 실제로 필요한 것이 무엇인지 거의 파악하고 나머지 항목을 가져갑니다. 얼마나 좋아하는지, 얼마나 멋진지는 잊어버리세요. 그냥 버리시면 됩니다.이것이 여러분의 삶을 얼마나 단순화하는지 놀랍습니다. 그리고 여러분은 모든 종류의 디자인 문제에 이 원칙을 사용할 수 있습니다.단지 멋지거나 흥미롭기 때문에 일을 하지 마세요."
당신은 읽을 수 있습니다 여기 인용문의 맥락
기본적으로 연산자 오버로딩은 일종의 점, 통화 또는 복소수를 모델링하는 클래스에 적합합니다.하지만 그 후에는 예제가 빨리 부족해지기 시작합니다.
또 다른 요인은 개발자가 '&&', '||', 캐스트 연산자 및 물론 'new'와 같은 연산자를 오버로드하여 C++ 기능을 남용한 것입니다.이를 값별 전달 및 예외와 결합하여 발생하는 복잡성은 다음에서 잘 설명됩니다. 뛰어난 C++ 책.
Boost.Units를 확인하세요: 링크 텍스트
연산자 오버로딩을 통해 오버헤드가 없는 차원 분석을 제공합니다.얼마나 더 명확해질 수 있습니까?
quantity<force> F = 2.0*newton;
quantity<length> dx = 2.0*meter;
quantity<energy> E = F * dx;
std::cout << "Energy = " << E << endl;
실제로는 "Energy = 4 J"가 출력되는데 이는 정확합니다.
Java 설계자는 연산자 오버로드가 가치 있는 것보다 더 큰 문제라고 결정했습니다.그렇게 간단합니다.
모든 객체 변수가 실제로 참조인 언어에서 연산자 오버로딩은 적어도 C++ 프로그래머에게는 매우 비논리적이라는 추가적인 위험을 가져옵니다.C#의 == 연산자 오버로딩과 상황을 비교해 보세요. Object.Equals 그리고 Object.ReferenceEquals (또는 무엇이라고 부르든).
그루비 연산자 오버로드가 있으며 JVM에서 실행됩니다.성능 저하(매일 점점 작아짐)에 신경 쓰지 않는다면.메소드 이름에 따라 자동으로 수행됩니다.예를 들어 '+'는 'plus(argument)' 메서드를 호출합니다.
나는 이것이 개발자가 자신의 의도를 명확하게 전달하는 이름을 가진 기능을 만들도록 강요하는 의식적인 디자인 선택이었을 것이라고 생각합니다.C++에서 개발자는 주어진 연산자의 일반적으로 허용되는 특성과 관련이 없는 기능으로 연산자를 오버로드하므로 연산자 정의를 살펴보지 않고 코드 조각이 수행하는 작업을 결정하는 것이 거의 불가능합니다.
글쎄요, 오퍼레이터의 과부하로 인해 발에 총을 쏠 수도 있습니다.사람들이 포인터를 사용할 때 어리석은 실수를 저지르는 것과 같아서 가위를 없애기로 결정했습니다.
적어도 나는 그것이 이유라고 생각한다.어쨌든 나는 당신 편입니다.:)
연산자 오버로드로 인해 연산자가 연산 논리와 일치하지 않는 유형의 논리적 오류가 발생한다고 말하는 것은 아무 말도 하지 않는 것과 같습니다.함수 이름이 작업 논리에 적합하지 않은 경우 동일한 유형의 오류가 발생합니다. 해결 방법은 무엇입니까?기능 활용 능력을 떨어뜨린다!?이것은 우스꽝스러운 대답입니다. "작업 논리에 부적절합니다.", 모든 매개변수 이름, 모든 클래스, 함수 또는 모든 것이 논리적으로 부적절할 수 있습니다.나는 이 옵션이 존경할만한 프로그래밍 언어로 제공되어야 한다고 생각하며, 이것이 안전하지 않다고 생각하는 사람들은 이 옵션을 사용해야 한다고 말합니다.C#을 살펴보겠습니다.그들은 포인터를 떨어뜨렸지만 '안전하지 않은 코드' 진술이 있습니다. 당신이 원하는 대로 프로그램하십시오.
어떤 사람들은 Java에서 연산자 오버로드가 난독화로 이어질 것이라고 말합니다.그 사람들이 BigDecimal을 사용하여 재정적 가치를 백분율로 높이는 것과 같은 몇 가지 기본 수학을 수행하는 일부 Java 코드를 살펴보기 위해 멈춰 본 적이 있습니까?....그러한 연습의 장황함은 그 자체로 난독화를 보여주는 것이 됩니다.아이러니하게도 Java에 연산자 오버로딩을 추가하면 이러한 수학적 코드를 우아하고 단순하게 만드는(덜 난독화되는) 자체 통화 클래스를 만들 수 있습니다.
기술적으로 다양한 유형의 숫자를 처리할 수 있는 모든 프로그래밍 언어에는 연산자 오버로딩이 있습니다.정수와 실수.설명:오버로딩이라는 용어는 하나의 함수에 대해 단순히 여러 구현이 있다는 것을 의미합니다.대부분의 프로그래밍 언어에서는 연산자 +, 정수, 실수에 대해 서로 다른 구현이 제공됩니다. 이를 연산자 오버로딩이라고 합니다.
이제 많은 사람들은 문자열을 함께 추가하기 위해 Java에 연산자 +에 대한 연산자 오버로딩이 있다는 사실을 이상하게 생각합니다. 수학적 관점에서는 이것이 실제로 이상할 수 있지만 프로그래밍 언어 개발자의 관점에서 보면 내장 연산자 오버로딩을 추가하는 데 아무런 문제가 없습니다. 연산자 +의 경우 다른 클래스의 경우끈.그러나 대부분의 사람들은 일단 문자열에 대해 +에 내장 오버로딩을 추가하면 개발자에게도 이 기능을 제공하는 것이 일반적으로 좋은 생각이라는 데 동의합니다.
A는 연산자 오버로딩이 코드를 난독화한다는 오류에 전적으로 동의하지 않습니다. 이는 개발자가 결정하도록 남겨져 있기 때문입니다.이것은 순진한 생각이며, 솔직히 말하면 점점 늙어가고 있습니다.
Java 8에 연산자 오버로딩을 추가하는 경우 +1
Java를 구현 언어로 가정하면 a, b 및 c는 모두 초기 값이 null인 Complex 유형에 대한 참조가 됩니다.또한 언급한 대로 Complex가 불변이라고 가정합니다. 빅정수 그리고 유사한 불변 BigDecimal, 제 생각에는 b와 c를 추가하여 반환된 Complex에 참조를 할당하고 이 참조를 a와 비교하지 않기 때문에 다음을 의미한다고 생각합니다.
그렇지 않습니까?
Complex a, b, c; a = b + c;많이 다음보다 간단합니다:
Complex a, b, c; a = b.add(c);
때로는 연산자 오버로딩, 친구 클래스 및 다중 상속을 사용하는 것이 좋을 수도 있습니다.
그러나 나는 아직도 그것이 좋은 결정이었다고 생각한다.Java에 연산자 오버로딩이 있었다면 소스 코드를 살펴보지 않고는 연산자 의미를 확신할 수 없습니다.현재로서는 그럴 필요가 없습니다.그리고 연산자 오버로딩 대신 메소드를 사용하는 예도 꽤 읽기 쉽다고 생각합니다.상황을 더 명확하게 하고 싶다면 언제든지 털이 많은 진술 위에 주석을 추가할 수 있습니다.
// a = b + c
Complex a, b, c; a = b.add(c);
이는 이를 허용하지 않는 타당한 이유는 아니지만 실용적인 이유입니다.
사람들은 항상 그것을 책임감 있게 사용하지는 않습니다.Python 라이브러리 scapy의 다음 예를 살펴보세요.
>>> IP()
<IP |>
>>> IP()/TCP()
<IP frag=0 proto=TCP |<TCP |>>
>>> Ether()/IP()/TCP()
<Ether type=0x800 |<IP frag=0 proto=TCP |<TCP |>>>
>>> IP()/TCP()/"GET / HTTP/1.0\r\n\r\n"
<IP frag=0 proto=TCP |<TCP |<Raw load='GET / HTTP/1.0\r\n\r\n' |>>>
>>> Ether()/IP()/IP()/UDP()
<Ether type=0x800 |<IP frag=0 proto=IP |<IP frag=0 proto=UDP |<UDP |>>>>
>>> IP(proto=55)/TCP()
<IP frag=0 proto=55 |<TCP |>>
설명은 다음과 같습니다.
/ 연산자는 두 층 사이의 구성 연산자로 사용되었습니다.그렇게 할 때, 하부 층은 상단 층에 따라 하나 이상의 기본값 필드를 과부하 할 수 있습니다.(여전히 원하는 가치를 줄 수 있습니다).문자열을 원시 레이어로 사용할 수 있습니다.
Java 연산자 오버로딩의 기본 지원에 대한 대안
Java에는 연산자 오버로딩이 없으므로 다음과 같은 몇 가지 대안을 살펴볼 수 있습니다.
- 다른 언어를 사용하세요.둘 다 그루비 그리고 스칼라 연산자 오버로딩이 있으며 Java를 기반으로 합니다.
- 사용 자바-우, Java에서 연산자 오버로딩을 가능하게 하는 플러그인입니다.플랫폼 독립적이지 않다는 점에 유의하세요.또한 많은 문제가 있으며 최신 Java 릴리스(예:자바 10).(원본 StackOverflow 소스)
- 사용 JNI, Java 기본 인터페이스 또는 대안.이를 통해 Java에서 사용할 C 또는 C++(다른 것일 수도 있음) 메서드를 작성할 수 있습니다.물론 이것은 플랫폼 독립적이지도 않습니다.
혹시 아시는 분 계시면 댓글 달아주시면 목록에 추가하겠습니다.
