ผู้ประกอบการมากไปใน Java

คุณช่วยบอกฉันหน่อยได้ไหมว่ามันเป็นไปได้ที่จะโอเวอร์โหลดโอเปอเรเตอร์ใน Java หรือไม่? หากมีการใช้ที่ใดก็ได้ใน Java คุณสามารถบอกฉันเกี่ยวกับมันได้

ไม่จาวาไม่รองรับการบรรทุกเกินพิกัดที่ผู้ใช้กำหนด แง่มุมเดียวของ Java ที่มาใกล้กับการโอเวอร์โหลดของตัวดำเนินการ "กำหนดเอง" คือการจัดการกับ + สำหรับสตริงซึ่งอาจส่งผลให้การรวมเวลาคงที่ของค่าคงที่หรือการต่อข้อมูลเวลาดำเนินการโดยใช้ StringBuilder / StringBuffer คุณไม่สามารถกำหนดโอเปอเรเตอร์ของคุณเองซึ่งกระทำในลักษณะเดียวกัน

สำหรับ Java เหมือน (และ JVM-based) ภาษาที่ไม่มากไปประกอบการการสนับสนุนคุณสามารถดูKotlinหรือGroovy หรือคุณอาจพบโชคมีวิธีการแก้ปัญหา Java ปลั๊กอินคอมไพเลอร์

ตัวดำเนินการโอเวอร์โหลดถูกใช้ใน Java สำหรับการต่อข้อมูลประเภท String:

String concat = "one" + "two";

อย่างไรก็ตามคุณไม่สามารถกำหนดโอเปอเรเตอร์ของคุณเองได้

นอกจากนี้ทุกคนชี้ให้เห็นว่า+มีมากเกินไปสตริง-ยังมากเกินไปสำหรับทั้งจุดลอยและจำนวนเต็มการดำเนินงานเช่นเดียวกับและ*/

[แก้ไข] %มีการโหลดมากเกินไปสำหรับจุดลอยซึ่งอาจเป็นเรื่องน่าประหลาดใจสำหรับผู้ที่มีพื้นหลัง C หรือ C ++

Java ไม่อนุญาตให้มีการบรรทุกเกินพิกัด วิธีที่แนะนำคือการกำหนดวิธีการในชั้นเรียนของคุณในการดำเนินการนี้แทนa.add(b) a + bคุณสามารถดูข้อมูลสรุปของบิตอื่น ๆ Java ที่เหลือจาก C เช่นภาษาที่นี่: คุณลักษณะถูกลบออกจาก C และ C ++

คุณไม่สามารถทำสิ่งนี้ได้ด้วยตนเองเนื่องจาก Java ไม่อนุญาตให้ผู้ให้บริการโหลดมากเกินไป

ด้วยข้อยกเว้นหนึ่งอย่างไรก็ตาม +และ+ =มีการโอเวอร์โหลดสำหรับวัตถุสตริง

ตามที่คนอื่น ๆ ตอบ: Java ไม่รองรับการบรรทุกเกินพิกัดที่ผู้ใช้กำหนด

อาจจะเป็นนอกหัวข้อ แต่ฉันต้องการแสดงความคิดเห็นในสิ่งที่ฉันอ่านในคำตอบบางอย่าง

เกี่ยวกับการอ่าน
เปรียบเทียบ:

1. c = a + b
2. c = a.add (b)

ดูอีกครั้ง!
อันไหนที่อ่านได้มากกว่า?

ภาษาการเขียนโปรแกรมที่อนุญาตให้สร้างประเภทที่ผู้ใช้กำหนดควรอนุญาตให้พวกเขาดำเนินการในลักษณะเดียวกับประเภทในตัว (หรือประเภทดั้งเดิม)

ดังนั้น Java จึงแบ่งหลักการพื้นฐานของการเขียนโปรแกรมทั่วไป:
เราควรจะสามารถแลกเปลี่ยนออบเจ็กต์ประเภทที่มีอยู่แล้วภายในกับออบเจ็กต์ที่ผู้ใช้กำหนดเอง
(คุณอาจสงสัยว่า: "เขาพูดว่า 'วัตถุในตัว' หรือไม่" ใช่ดูที่นี่ )

เกี่ยวกับการต่อสตริง:

นักคณิตศาสตร์ใช้สัญลักษณ์ + สำหรับการดำเนินการสลับชุด
ดังนั้นเราจึงมั่นใจได้ว่า a + b = b + a
การต่อสตริง (ในภาษาการเขียนโปรแกรมส่วนใหญ่) ไม่เคารพเครื่องหมายทางคณิตศาสตร์ทั่วไปนี้

a := "hello";
b := "world";
c := (a + b = b + a);

หรือใน Java:

String a = "hello";
String b = "world";
boolean c = (a + b).equals(b + a);

พิเศษ:
สังเกตว่าสับสนในความเท่าเทียมและเอกลักษณ์ของ Java อย่างไร == (ความเสมอภาค) หมายถึงสัญลักษณ์:
ความเท่าเทียมกันสำหรับประเภทดั้งเดิม
ข Identity-check สำหรับประเภทที่ผู้ใช้กำหนดดังนั้นเราถูกบังคับให้ใช้function equals () เพื่อความเท่าเทียมกัน
แต่ ... สิ่งนี้เกี่ยวข้องกับการบรรทุกเกินพิกัดหรือไม่
หากภาษาอนุญาตให้โอเปอเรเตอร์บรรทุกเกินพิกัดผู้ใช้สามารถให้ความหมายที่เหมาะสมกับโอเปอร์เรเตอร์ที่เท่าเทียมกัน

สามารถลองใช้Java Operator Overloadingได้ มันมีข้อ จำกัด ของตัวเอง แต่มันก็คุ้มค่าที่จะลองถ้าคุณต้องการใช้ตัวดำเนินการมากไป

เพียงใช้ Xtend พร้อมกับรหัส Java ของคุณ รองรับ Operator Overloading:

    package com.example;

@SuppressWarnings("all")
public class Test {
  protected int wrapped;

  public Test(final int value) {
    this.wrapped = value;
  }

  public int operator_plus(final Test e2) {
    return (this.wrapped + e2.wrapped);
  }
}

package com.example

class Test2 {

    new() {
        val t1 = new Test(3)
        val t2 = new Test(5)
        val t3 = t1 + t2
    }

}

บนเว็บไซต์อย่างเป็นทางการมีรายการวิธีการใช้งานสำหรับผู้ให้บริการแต่ละราย!

หรือคุณสามารถสร้าง Java Groovyและเพียงแค่โอเวอร์โหลดฟังก์ชันเหล่านี้เพื่อให้ได้สิ่งที่คุณต้องการ

//plus() => for the + operator
//multiply() => for the * operator
//leftShift() = for the << operator
// ... and so on ...

class Fish {
    def leftShift(Fish fish) {
        print "You just << (left shifted) some fish "
    }
}


def fish = new Fish()
def fish2 = new Fish()

fish << fish2

ใครไม่อยากเป็น / ใช้งาน groovy? : D

ไม่คุณไม่สามารถใช้ JARs ที่รวบรวมได้ใน Java ด้วยวิธีเดียวกัน มันยังคงเป็นข้อผิดพลาดของคอมไพเลอร์สำหรับ Java

ซึ่งแตกต่างจาก C ++, Java ไม่รองรับการบรรทุกเกินพิกัดของผู้ใช้ การโหลดมากเกินไปทำได้ภายใน Java

เราสามารถใช้+(บวก) ตัวอย่างเช่น:

int a = 2 + 4;
string = "hello" + "world";

ที่นี่บวกเพิ่มจำนวนเต็มสองจำนวนและเชื่อมสองสายเข้าด้วยกัน ดังนั้นเราจึงสามารถพูดได้ว่า Java รองรับการบรรทุกเกินพิกัด แต่ไม่ได้กำหนดโดยผู้ใช้