如何在Java中模拟指针类型操作，或者Java是按引用传递或按值传递？

Question

I'm modeling Mysql databases as en exercise in Java. Personal experiment. And I want to store the table collation as a string, since the columns can have different collation then the tables, I need to store that also for each column. It would be very helpful if the column's collation field could just point to the table's collation field. But I know that Java doesn't have pointers.

Do you have an idea on how I can point the field of one object, to he field of another object so the two will always match?

Answer 1

Java has references, which are the good parts of pointers without the ability to do pointer math.

public class Table {

  // name does not store a String, it stores a reference to a String
  private String name;

  // tableName is not passed in by copy, tableName's reference is passed in.
  public Table(String tableName) {
    // this is not a copy assignment, but a reference assignment
    name = tableName;
  }

}

As far as always pointing to a field in Java, you must keep in mind a few things. Objects are the basic element in an Object-Oriented programming language, not names. As such, you cannot build a reference to an object's internal names, as it is never clear if you are referencing the Object by its base type or by a super type. Since identical names can exist in both super classes and sub classes (which could then hide the super class type), field name references cannot be correctly resolved without knowledge of the actual class instance they are getting resolved upon.

This is by design, not by accident. In fact, external knowledge of a class's member fields is exactly what makes code maintenance so difficult, as there is no "shim" where one can insert code between the caller and the data. By encapsulating the data (putting in behind a method call) one sets the stage for future code maintenance; because, one can then insert code to generate the return values based on possibly changing internal data elements.

An example

public class Table {

  public Column[] columns;

  public String name;

  public Table() {
    name = ...;
    columns = ...;
  }

}

public class CreateTableDDL {

  public String statement(Table table) {
    StringBuilder buffer = new StringBuilder();
    buffer.append("CREATE TABLE ");
    buffer.append(table.name);
    buffer.append(" (");
    for (int i = 0; i < table.columns.length; i++) {
      Column column = table.columns[i];
      ...
    }
    ...
    return buffer.toString();
  }

}

exposes columns as an array of type Column , which isn't necessarily a bad thing, until we decide we want it to be a List of Column so we can dynamically add or remove Column s in a new nifty TableEditor .

Since we exposed the base data element, now we must search through the entire code base to find any use of the field, and rewrite all uses to now use a List interface. Actually, we need to do even more than that because we must also search through every external library that might have used the columns field directly, as multiple JARs unknown to us might have used this public class.

In addition, we will quickly notice that most of what we are doing with columns is really the Table 's business, but located in "helpers" and auxillary classes which detract from responsibilities best localized in Table.

Finally, we might even notice that external classes are modifying the columns of a table without the table's knowledge; because, they bypass any code that might alert the table to the change by grabbing the data directly.

If we had simply done

public class Table {

  private Column[] columns;

  private String name;

  public Table() {
    name = ...;
    columns = ...;
  }

  public Column[] getColumns() {
    Column[] copy = new Column[columns.length];
    for (int i = 0; i < columns.length; i++) {
      copy[i] = columns[i].clone();
    }
    return copy;
  }

}

Then we could have easily converted the base storage to a List and just constructed our "backwards compatible" array of columns from the list. The calling code now doesn't require a change, even if we decide that our previously existing columns field now needs to be a Map of String to DataType .

 public class CreateTableDDL {

  public String statement(Table table) {
    StringBuilder buffer = new StringBuilder();
    buffer.append("CREATE TABLE ");
    buffer.append(table.getName());
    buffer.append(" (");
    for (int i = 0; i < table.getColumns().length; i++) {
      Column column = table.getColumn(i);
      ...
    }
    ...
    return buffer.toString();
  }

}

Answer 2

First some definitions. And keep in mind that the pass by terminology does not refer to the underlying mechanism used to manage data. It refers to what result you can expect the manipulation of that data to give you.

All data is stored in memory locations. How this is defined varies between JVMs, and is not relevant to the discussion.

A pointer is a variable that stores the memory location of a data, instead of the actual data.

A reference is a generic term for any variable that stores some kind of index value that refers to some data. So a pointer is a type of reference. And in this discussion, the only type we care about.

Now in a pass by reference language, the actual data in memory is not being manipulated during assignment. The data is saved in memory. And the reference is assigned a value that tells the computer to go to the memory location to get the actual data. When you assign one variable to another, you assign the same value that tells the computer the data's memory location. So both references index the same data. If you change the actual data, then both references will index the newly changed data. One manipulation can change a number of variables only limited by the capabilities of the computer. A generic code example follows:

a = <valueof 1>; //"1" is now stored in memory, and a is a index to "1" in memory.
b = a; //b now indexes the same memory location as a. They both index the "1" in memory.

a = <value of 2>; //"2" now replaces "1" at the indexed memory location.
output a; //In this case would get the index value the language uses.
output b; //You'd get the same index value as a since they index the same memory location.
output <valueof a>; //Now you get "2", because however it's done in the language you have extracted the data in the memory location indexed by a.
output <valueof b>; //Same output as before as b indexes the same memory location as a.

In a pass by value language, b would still get you 1, and a would now get you 2. This is because b would not have been assigned the same reference as a. It would have been assigned the value as a new reference. The generic code would look the same, but give you different results.

a = <valueof 1>; //"1" is now stored in memory, and a is a index to "1" in memory.
b = a; //b now indexes a new memory location that now also stores "1".

a = <value of 2>; //"2" now replaces "1" at the indexed memory location.
output a; //You get "2" because a pass by value language will be designed to give you value, not the index.
output b; //You get "1" because when b was assigned to match a, a stored "1". But b is independent of a once assignment is complete.

The confusion comes from the fact that Java uses a pass by reference mechanism to achieve a pass by value design, in some cases. In the case of primitives Java acts as pass by value. In the case of Objects, it acts as a pass by reference. And if you wrap a primitive in an object, which is usually recommended, it will act as pas by reference. But while Strings are objects, they also act as pass by value. But Strings are weird.

Answer 3

Java variables are passed by reference. So if you have declared Object obj , then obj will always been a reference to that same object in your current scope. When you pass obj to a method, you're not passing a copy of the object, but a reference to it.

Furthermore, Java also has Iterators for collections that implement the Iterable interface, which you may want to look into. These act like pointers to specific positions within a List or similar.

Answer 4

您创建一个具有所有可能的排序规则类型的列表的枚举，然后将名为collat​​ionType的成员/属性添加到Table和Column类，然后将相同的Enum成员分配给相同的对象。