Equivalent of void myRoutine in Java?

Equivalent of void myRoutine in Java?

I know that in order to pass something byreference, you pass an already-created objectand let the subroutine modify the contents ofthat object. Unfortunately, the Integer, String,etc. objects don’t allow their internal values tobe changed. How can I do the equivalent ofvoid myRoutine (int *x, int *y, int *z) in Java?

First a little background for Java newcomers:

Java methods can manipulate two types of parameters: scalars (numbers,booleans and characters) and pointers to objects (objects = arrays orclass instances). A method receives private copies of all its parameters.In the case of a pointer, this amounts to a private or local copy of apointer to a non-local object, which means modifications made inside amethod to instance variables or components of an object pointer parameterare modifications made to the corresponding non-local object. Thesemodifications can be intentional or unintentional.

The Java parameter passing mechanism can be compared to the pass-by-valueand pass-by-reference mechanisms in C++:

   void foo(Object x, scalar y) { … }   // Java method   void foo(Object &x, scalar y) { … }  // corresponding C++ function
It’s also similar to passing pointers in C (or C++) except pointer parametersmust be explicitly dereferenced in the function body, and addresses must beexplicitly passed as inputs:
 void foo(Object *x, scalar y){ … }  // bind x to &a, use *x in … 
When would a programmer intentionally modify instance variables of a non-localobject? This would be the case if the object models a mutable “real world”object, i.e. an object with internal state that can change without changingthe identity of the object. The classical example is a bank account. In thiscase its mutable internal state is its balance:
   class Account {      // …      public double balance; // should be private, see note at bottom   } 
Here’s a fragment of code that manipulates bank accountbalances:
   class Bank {      private Account[] accts = new Account[500]; // the bank’s accounts      // …      public void deposit(double amount, Account acct) {         acct.balance += amount; // will modify non-local accts[i]      }      // …   } 
A method that intentionally modifies an instance variable of a non-localobject is called a mutator.

Enough background, back to the original question. For every Java scalartype there is a corresponding Java class called the wrapper for that type.For example, the wrapper for the type int is the classInteger. Thus, everyscalar has a corresponding class instance. This gives us a choice when wedesign a method that expects a scalar input.

Should the input be a scalaror a pointer to the corresponding object wrapper? For example:

   void foo(int x) { … }  or  void foo(Integer x) { … }? 
In the first case, foo will get private copies of itsint parameters; inthe second case, foo receives pointers to its Integerparameters.

Is there a danger in the second case that the non-local Integerobject willbe unintentionally modified inside foo()? This might be aconcern, except Java regards scalars as non-mutable (i.e. stateless)objects. Indeed,this is the view most mathematicians have of scalars. (C-isms like”x = x + 1” drive mathematicians crazy!) Since scalars areregarded asnon-mutable, Java does not provide any way for programmers to modify theinternal state, i.e. the value, of an Integer object since this would beequivalent to trying to reassign the value of a constant: 5 = 5 + 1.

Nevertheless, C and C++ programmers often pass scalar pointers andscalar references to functions that modify theirparameters:

void inc(int *x) { *x = *x + 1;}  or  voidinc(int &x) { x = x + 1; }
How would this be done in Java?

First, notice that neither function makes sense if called with a constant:

(This is handled by passing a temporary variable containing 5.)

The input must be a variable or a pointer to one. That being thecase, we should think of the true input to inc as a mutablecontainer. With this in mind, we should avoid passing non-mutable Integerwrappers to mutators, and instead pass custom made mutable integercontainers:

   class IntContainer {      // …      public int value;   }
Here’s inc:
void inc(IntContainer x) { x.value = x.value + 1; }
One last note: It’s bad form to have public instance variables. Instead,provide member function mutators and accessors:
   class IntContainer {      // …      // accessor (aka selector)      public int getValue() { return value; }      // mutator      public void setValue(int val) {         value = val;      }      // …      private int value;   } 
and then:
   void inc(IntContainer x) { x.setValue(x.getValue() + 1); } 

Share the Post:
Heading photo, Metadata.

What is Metadata?

What is metadata? Well, It’s an odd concept to wrap your head around. Metadata is essentially the secondary layer of data that tracks details about the “regular” data. The regular

XDR solutions

The Benefits of Using XDR Solutions

Cybercriminals constantly adapt their strategies, developing newer, more powerful, and intelligent ways to attack your network. Since security professionals must innovate as well, more conventional endpoint detection solutions have evolved

AI is revolutionizing fraud detection

How AI is Revolutionizing Fraud Detection

Artificial intelligence – commonly known as AI – means a form of technology with multiple uses. As a result, it has become extremely valuable to a number of businesses across

AI innovation

Companies Leading AI Innovation in 2023

Artificial intelligence (AI) has been transforming industries and revolutionizing business operations. AI’s potential to enhance efficiency and productivity has become crucial to many businesses. As we move into 2023, several

data fivetran pricing

Fivetran Pricing Explained

One of the biggest trends of the 21st century is the massive surge in analytics. Analytics is the process of utilizing data to drive future decision-making. With so much of

kubernetes logging

Kubernetes Logging: What You Need to Know

Kubernetes from Google is one of the most popular open-source and free container management solutions made to make managing and deploying applications easier. It has a solid architecture that makes

ransomware cyber attack

Why Is Ransomware Such a Major Threat?

One of the most significant cyber threats faced by modern organizations is a ransomware attack. Ransomware attacks have grown in both sophistication and frequency over the past few years, forcing