Một cái gì đó như sau:

ví dụ ref:

void changeString(ref String str) {
    str = "def";
}

void main() {
    String abc = "abc";
    changeString(ref abc);
    System.out.println(abc); //prints "def"
}

ra ví dụ:

void changeString(out String str) {
    str = "def";
}

void main() {
    String abc;
    changeString(out abc);
    System.out.println(abc); //prints "def"
}

Không, Java không có thứ gì đó giống như C # refvà outcác từ khóa để chuyển qua tham chiếu.

Bạn chỉ có thể chuyển theo giá trị trong Java. Ngay cả các tham chiếu cũng được truyền theo giá trị. Xem trang của Jon Skeet về truyền tham số trong Java để biết thêm chi tiết.

Để làm điều gì đó tương tự refhoặc outbạn sẽ phải bọc các tham số của mình bên trong một đối tượng khác và chuyển tham chiếu đối tượng đó vào dưới dạng một tham số.

Câu trả lời trực tiếp: Không

Nhưng bạn có thể mô phỏng tham chiếu với trình bao bọc .

Và làm như sau:

void changeString( _<String> str ) {
    str.s("def");
}

void testRef() {
     _<String> abc = new _<String>("abc");
     changeString( abc );
     out.println( abc ); // prints def
}

Ngoài

void setString( _<String> ref ) {
    str.s( "def" );
}
void testOut(){
    _<String> abc = _<String>();
    setString( abc );
    out.println(abc); // prints def
}

Và về cơ bản bất kỳ loại nào khác như:

_<Integer> one = new <Integer>(1);
addOneTo( one );

out.println( one ); // May print 2

Trên thực tế, không có từ khóa ref và out nào tương đương trong ngôn ngữ Java theo như tôi biết. Tuy nhiên tôi đã chỉ cần chuyển một C # mã vào Java mà sử dụng ra tham số và sẽ tư vấn những gì tôi vừa thực hiện. Bạn nên bọc bất kỳ đối tượng nào vào một lớp trình bao bọc và chuyển các giá trị được bao bọc trong thể hiện đối tượng trình bao bọc như sau;

Một ví dụ đơn giản để sử dụng Wrapper

Đây là Lớp Wrapper ;

public class Wrapper {
    public Object ref1; // use this as ref
    public Object ref2; // use this as out

    public Wrapper(Object ref1) {
        this.ref1 = ref1;
    }
}

Và đây là mã kiểm tra;

public class Test {

    public static void main(String[] args) {
        String abc = "abc";
        changeString(abc);
        System.out.println("Initial object: " + abc); //wont print "def"

        Wrapper w = new Wrapper(abc);
        changeStringWithWrapper(w);
        System.out.println("Updated object: " + w.ref1);
        System.out.println("Out     object: " + w.ref2);
    }

    // This won't work
    public static void changeString(String str) {
        str = "def";
    }

    // This will work
    public static void changeStringWithWrapper(Wrapper w) {
        w.ref1 = "def";
        w.ref2 = "And this should be used as out!";
    }

}

Một ví dụ về thế giới thực

Phương thức AC # .NET sử dụng tham số out

Đây là một phương thức C # .NET đang sử dụng từ khóa out ;

public bool Contains(T value)
{
    BinaryTreeNode<T> parent;
    return FindWithParent(value, out parent) != null;
}

private BinaryTreeNode<T> FindWithParent(T value, out BinaryTreeNode<T> parent)
{
    BinaryTreeNode<T> current = _head;
    parent = null;

    while(current != null)
    {
        int result = current.CompareTo(value);

        if (result > 0)
        {
            parent = current;
            current = current.Left;
        }
        else if (result < 0)
        {
            parent = current;
            current = current.Right;
        }
        else
        {
            break;
        }
    }

    return current;
}

Java Tương đương với mã C # đang sử dụng tham số out

Và tương đương với Java của phương thức này với sự trợ giúp của lớp wrapper như sau;

public boolean contains(T value) {
    BinaryTreeNodeGeneration<T> result = findWithParent(value);

    return (result != null);
}

private BinaryTreeNodeGeneration<T> findWithParent(T value) {
    BinaryTreeNode<T> current = head;
    BinaryTreeNode<T> parent = null;
    BinaryTreeNodeGeneration<T> resultGeneration = new BinaryTreeNodeGeneration<T>();
    resultGeneration.setParentNode(null);

    while(current != null) {
        int result = current.compareTo(value);

        if(result >0) {
            parent = current;
            current = current.left;
        } else if(result < 0) {
            parent = current;
            current = current.right;
        } else {
            break;
        }
    }

    resultGeneration.setChildNode(current);
    resultGeneration.setParentNode(parent);

    return resultGeneration;
}

Lớp bọc

Và lớp trình bao bọc được sử dụng trong mã Java này như bên dưới;

public class BinaryTreeNodeGeneration<TNode extends Comparable<TNode>>  {

    private BinaryTreeNode<TNode>   parentNode;
    private BinaryTreeNode<TNode>   childNode;

    public BinaryTreeNodeGeneration() {
        this.parentNode = null;
        this.childNode = null;
    }

    public BinaryTreeNode<TNode> getParentNode() {
        return parentNode;
    }

    public void setParentNode(BinaryTreeNode<TNode> parentNode) {
        this.parentNode = parentNode;
    }

    public BinaryTreeNode<TNode> getChildNode() {
        return childNode;
    }

    public void setChildNode(BinaryTreeNode<TNode> childNode) {
        this.childNode = childNode;
    }

}

Java chuyển các tham số theo giá trị và không có bất kỳ cơ chế nào để cho phép chuyển theo tham chiếu. Điều đó có nghĩa là bất cứ khi nào một tham số được truyền, giá trị của nó được sao chép vào khung ngăn xếp xử lý lệnh gọi.

Giá trị thuật ngữ mà tôi sử dụng ở đây cần được làm rõ một chút. Trong Java, chúng ta có hai loại biến - nguyên thủy và đối tượng. Giá trị của một nguyên thủy là chính nguyên thủy và giá trị của một đối tượng là tham chiếu của nó (chứ không phải trạng thái của đối tượng được tham chiếu). Do đó, bất kỳ thay đổi nào đối với giá trị bên trong phương thức sẽ chỉ thay đổi bản sao của giá trị trong ngăn xếp và người gọi sẽ không nhìn thấy. Ví dụ: không có bất kỳ cách nào để triển khai phương thức hoán đổi thực, phương thức này nhận hai tham chiếu và hoán đổi chúng (không phải nội dung của chúng!).

Giống như nhiều người khác, tôi cần chuyển đổi một dự án C # sang Java. Tôi đã không tìm thấy một giải pháp hoàn chỉnh trên web về công cụ sửa đổi out và ref . Nhưng, tôi có thể lấy thông tin tôi tìm thấy và mở rộng thông tin đó để tạo các lớp của riêng tôi để đáp ứng các yêu cầu. Tôi muốn phân biệt giữa các tham số ref và out để làm rõ mã. Với các lớp dưới đây, điều đó là hoàn toàn có thể. Mong thông tin này tiết kiệm thời gian và công sức cho người khác.

Một ví dụ được bao gồm trong đoạn mã dưới đây.

//*******************************************************************************************
//XOUT CLASS
//*******************************************************************************************
public class XOUT<T>
{
    public XOBJ<T> Obj = null;

    public XOUT(T value)
    {
        Obj = new XOBJ<T>(value);
    }

    public XOUT()
    {
      Obj = new XOBJ<T>();
    }

    public XOUT<T> Out()
    {
        return(this);
    }

    public XREF<T> Ref()
    {
        return(Obj.Ref());
    }
};

//*******************************************************************************************
//XREF CLASS
//*******************************************************************************************

public class XREF<T>
{
    public XOBJ<T> Obj = null;

    public XREF(T value)
    {
        Obj = new XOBJ<T>(value);
    }

    public XREF()
    {
      Obj = new XOBJ<T>();
    }

    public XOUT<T> Out()
    {
        return(Obj.Out());
    }

    public XREF<T> Ref()
    {
        return(this);
    }
};

//*******************************************************************************************
//XOBJ CLASS
//*******************************************************************************************
/**
 *
 * @author jsimms
 */
/*
    XOBJ is the base object that houses the value. XREF and XOUT are classes that
    internally use XOBJ. The classes XOBJ, XREF, and XOUT have methods that allow
    the object to be used as XREF or XOUT parameter; This is important, because
    objects of these types are interchangeable.

    See Method:
       XXX.Ref()
       XXX.Out()

    The below example shows how to use XOBJ, XREF, and XOUT;
    //
    // Reference parameter example
    //
    void AddToTotal(int a, XREF<Integer> Total)
    {
       Total.Obj.Value += a;
    }

    //
    // out parameter example
    //
    void Add(int a, int b, XOUT<Integer> ParmOut)
    {
       ParmOut.Obj.Value = a+b;
    }

    //
    // XOBJ example
    //
    int XObjTest()
    {
       XOBJ<Integer> Total = new XOBJ<>(0);
       Add(1, 2, Total.Out());    // Example of using out parameter
       AddToTotal(1,Total.Ref()); // Example of using ref parameter
       return(Total.Value);
    }
*/


public class XOBJ<T> {

    public T Value;

    public  XOBJ() {

    }

    public XOBJ(T value) {
        this.Value = value;
    }

    //
    // Method: Ref()
    // Purpose: returns a Reference Parameter object using the XOBJ value
    //
    public XREF<T> Ref()
    {
        XREF<T> ref = new XREF<T>();
        ref.Obj = this;
        return(ref);
    }

    //
    // Method: Out()
    // Purpose: returns an Out Parameter Object using the XOBJ value
    //
    public XOUT<T> Out()
    {
        XOUT<T> out = new XOUT<T>();
        out.Obj = this;
        return(out);
    }

    //
    // Method get()
    // Purpose: returns the value
    // Note: Because this is combersome to edit in the code,
    // the Value object has been made public
    //
    public T get() {
        return Value;
    }

    //
    // Method get()
    // Purpose: sets the value
    // Note: Because this is combersome to edit in the code,
    // the Value object has been made public
    //
    public void set(T anotherValue) {
        Value = anotherValue;
    }

    @Override
    public String toString() {
        return Value.toString();
    }

    @Override
    public boolean equals(Object obj) {
        return Value.equals(obj);
    }

    @Override
    public int hashCode() {
        return Value.hashCode();
    }
}

Ba giải pháp không được đề cập chính thức, rõ ràng:

ArrayList<String> doThings() {
  //
}

void doThings(ArrayList<String> list) {
  //
}

Pair<String, String> doThings() {
  //
}

Đối với Pair, tôi muốn giới thiệu: https://commons.apache.org/proper/commons-lang/apidocs/org/apache/commons/lang3/tuple/Pair.html

java không có cách làm tiêu chuẩn. Hầu hết các hoán đổi sẽ được thực hiện trên danh sách được đóng gói trong lớp. nhưng có một cách không chính thức để làm điều đó:

package Example;

import java.lang.reflect.Field;
import java.util.logging.Level;
import java.util.logging.Logger;



 public class Test{


private static <T> void SetValue(T obj,T value){
    try {
        Field f = obj.getClass().getDeclaredField("value");
        f.setAccessible(true);
        f.set(obj,value);
        } catch (IllegalAccessException | IllegalArgumentException | 
            NoSuchFieldException | SecurityException ex) {
            Logger.getLogger(CautrucjavaCanBan.class.getName()).log(Level.SEVERE, 
       null, ex);
        }
}
private  static  void permutation(Integer a,Integer b){
    Integer tmp = new Integer(a);
    SetValue(a, b);
    SetValue(b, tmp);
}
 private  static  void permutation(String a,String b){
    char[] tmp = a.toCharArray();
    SetValue(a, b.toCharArray());
    SetValue(b, tmp);
}
public static void main(String[] args) {
    {
        Integer d = 9;
        Integer e = 8;
        HoanVi(d, e);
        System.out.println(d+" "+ e);
    }
    {
        String d = "tai nguyen";
        String e = "Thai nguyen";
        permutation(d, e);
        System.out.println(d+" "+ e);
    }
}

}