We Keep Coding

How to print string method, idk how to phrase this sorry

package com.example.test1;
import java.util.Scanner;
public class class1{
public static String methodOne(String name){
String studentName = name + " is his name";
return (studentName);
}
public static void main(String[] args) {
methodOne("John");
}
}
How can I get this method to print out name + " is his name"? It shows nothing when I run this. I also can't add a System.out.println in the String studentName. I'm new to all of this sorry. EDIT: I want to somehow input the print function into the method and not type out System.out.println to print out methodOne, is it possible?

package com.example.test1;
import java.util.Scanner;
public class class1{
public static String methodOne(String name){
String studentName = name + " is his name";
return (studentName);
}
public static void main(String[] args) {
System.out.println(methodOne("John")); // Print string in this console
}
}

The function of returns a value that is string, so when you call her like that :
methodOne("John");
You didn't use the string value, you didn't say print it or anything.
You can use the returned value like this:
package com.example.test1;
import java.util.Scanner;
public class class1{
public static String methodOne(String name){
String studentName = name + " is his name";
return (studentName);
}
public static void main(String[] args) {
String nameStudent = methodOne("John"); // Saves the returned value in a variable
System.out.println(nameStudent ); // Prints the returned value stored in the variable
}
}
You can also print straight without storing a variable, as they say here already.

I want to somehow input the print function into the method.
There are two ways I could interpret it.
You could just mean that you want print within the methodOne method. That is easy:
public static String methodOne(String name){
String studentName = name + " is his name";
System.out.println(studentName);
return studentName;
}
Comments:
If you are going to do it this way, there isn't an obvious reason why methodOne needs to return anything. You could declare it as a void method.
Doing this is probably bad design. Generally speaking, a method should do one thing. (The design principle is Separation of Concerns (SoC).) But this modified method is doing two things. It is forming the string, and it is printing it. And since it is printing it to a specific place (standard output), it's utility is limited. (What if I wanted to create that string without printing it? What if I wanted to print it to a different stream?)
The second interpretation is that you literally want to pass the println method to the methodOne method ... so that it can call it. This is how you could do it:
public static String methodOne(String name,
java.util.function.Consumer<String> fn){
String studentName = name + " is his name";
fn(studentName);
return studentName;
}
and call it like this
methodOne("Fred", System.out::println);

toString() method using generics

I am new to using generics. I want to print out a pair of Integers and Strings. Here is my code:
public class Pair<T> {
private T first;
private T second;
public Pair(T first, T second) {
this.first = first;
this.second = second;
}
public T getFirst() {
return first;
}
public T getSecond() {
return second;
}
public void setFirst(T first) {
this.first = first;
}
public void setSecond(T second) {
this.second = second;
}
public <T> void toString(Pair<T> k) {
System.out.println(k.getFirst());
System.out.println(k.getSecond());
}
}
public class TestPair {
public static void main(String[] args) {
Pair<String> pS = new Pair<String>("yay", "it worked" );
Pair<Integer> pI = new Pair<Integer>(1, 2);
pS.toString();
pI.toString();
}
}
At the moment, it compiles but upon running TestPair class, I don't get anything printed out.

You need to be aware that now, your toString() method doesn't override Object.toString() method (as it is stated in official Java tutorial here: The overriding method has the same name, number and type of parameters, and return type as the method that it overrides). . If you want to call you implementation of toString() you need to pass argument of type Pair to it, as your toString() requires Pair instance as an argument. I rather suggest you to change your toString method to:
public void toString() {
System.out.println(this.getFirst());
System.out.println(this.getSecond());
}
In that case when you call:
pS.toString();
pI.toString();
, you get correct results as now your toString() doesn't require Pair argument.

The way you have it now, your "toString" takes a parameter so you have to pass it like so (note the parameters added to toString).
public static void main(String[] args) {
Pair<String> pS = new Pair<String>("yay", "it worked");
Pair<Integer> pI = new Pair<Integer>(1, 2);
pS.toString(pS);
pI.toString(pI);
}
Without the parameters - it calls the default toString() method of the object which returns a string representation like "test.Pair#33909752" which the class name followed by "#" followed by the address/pointer to the class. But since you are not printing the returned value from the default toString method of Object class - nothing prints.
The way toString typically should be coded is to return a String (you would override the toString method of the object). Something like:
#Override
public String toString() {
return "Pair [first=" + first + ", second=" + second + "]";
}
Then in your main program you should print it like:
System.out.println (pS.toString());
System.out.println (pI.toString());
or simply (because when printing "toString()" is implied)
System.out.println (pS);
System.out.println (pI);

There are two problems with your code:
In your main method you are calling toString() (with zero arguments) which the Pair class inherits from Object. This method returns a generic string like Pair#123. But as you don't do anything with this string, you don't get an output. You could create an output by writing System.out.println(pS.toString()); (or even System.out.println(pS);.
In your Pair-class, you have defined a toString method with one parameter. I suppose you wanted to overwrite the Object.toString(), so you should also use code like public String toString() {return first.toString() + " " + second.toString()} (plus null checks)

Java printing inherited objects with a println method

I'm taking those first steps from python to java and here is my first of many Java questions do doubt.
When printing via a shortened print method, I'm running into a problem with the return value from a inherited class. I'm sure it's something simple about Java I don't get yet. I'm also trying to convert any integers the println method receives to a string with .tostring(), but I'm not sure if that is correct.
class Inheritance {
private static void println (Object line){
System.out.println(line.toString());
}
static class A {
public int multiply(int a, int b){
int val = a*b;
return val;
}
}
static class B extends A {
public int multiply(int a, int b) {
int val = a * b * 5;
return val;
}
}
public static void main(String[] args) {
B b_class = new B();
b_class.multiply(3,4);
println(b_class);
println("Hello World");
}
}
The output is as follows:
Inheritance$B#74a14482
Hello World

You can just use the method inside println
public static void main(String[] args) {
B b_class = new B();
println(Integer.ToString(b_class.multiply(3,4)));
println("Hello World");
}

For Java toString method default it will
returns a string consisting of the name of the class of which the object is an instance, the at-sign character `#', and the unsigned hexadecimal representation of the hash code of the object. In other words, this method returns a string equal to the value of:
getClass().getName() + '#' + Integer.toHexString(hashCode())
https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html#toString()
so when you println b_class it will print: Inheritance$B#74a14482.
For your println (Object line) it's receiving Reference type(Object) to println, but as multiply method it's return a primitive type(int), it's not an object, you need to convert it to an Object for println method, as #StanteyS's answer, use Integer.toString can convert int to String.
What's the difference between primitive and reference types?

When you are executing println(b_class); implicitly it calls toString method of same class, which is inherited from Object class.
You need to override toString method to display correct output.
static class B extends A {
int val=0;
public int multiply(int a, int b) {
val = a * b * 5;
return val;
}
public String toString(){
return String.valueOf(val);
}
}
Now, println(b_class); will work as per your expectation.

Passing Argument in Java

New to Java here, please help. How arguments are passed in java? Why am I unable to change argument value in the calling method from within called method?
Code
public class PassTest {
public static void changeInt(int value)
{
value=55;
}
int val;
val=11;
changeInt(val);
System.out.println("Int value is:" + val);// calling modifier changeInt
}
Output
Int value is: 11
why it is not 55..?

Java passes by value, not by reference. In your method value contains a copy of the value from val. Modifying the copy does not change the original variable.
You could pass an int wrapped inside an object if you want your changes to be visible to the caller. You can for example use the class org.apache.commons.lang.mutable.MutableInt.
Java : Best way to pass int by reference

Java passes ByValue, meaning the value of the object you put as a parameter is passed, but not the object itself, therefore
val=11;
changeInt(val);
does the exact same thing as
int val=11;
int val2=val
changeInt(val2);
int is a primitive, primitives don't "wrap" a value, you could try to use an Integer class, or make your own class that stores an integer, and then change that classes integer value. Instances of an object are sometimes passed ByReference if setup right. here is an example
MyStringClass.java
public class MyStringClass{
private String string = null;
public MyStringClass(String s){
string = s;
}
public String getValue(){
return string;
}
public void setValue(String s){
string = s;
}
}
and then the workings
public static void addTo(String s){
s += " world";
}
public static void addTo(MyStringClass s){
s.setValue(s.getValue() + " world");
}
public static void main(String[] args){
String s = "hello";
MyStringClass s1 = new MyStringClass("hello");
addTo(s);
addTo(s1);
System.out.println(s);//hello
System.out.println(s1);//hello world
}
I would wonder why you need to change the value instead of just returning it? isn't it easier?

Java passes by Value, it makes a copy which is completely dis-associated with the original variable reference, which means it doesn't have access to change the original int. This is true for primitives as well as object references as well.
You can use AtomicInteger or something like it, to achieve what you are desiring to do.

Primitive variables are passed by value not reference as you are suggesting.

As others said, Java passes byValue by default which means that you are just getting a copy in the function. You can pass byReference, which will pass a pointer to the object and allow you to directly edit but this is not seen as best practice. I would suggest doing it like this:
public class PassTest {
public int changeInt(int value)
{
value = 55;
return value;
}
int val;
val=11;
val = changeInt(val);
System.out.println("Int value is:" + val);// calling modifier changeInt

Here is a Example to pass argument:
class Test {
int a,b;
public Test(int j, int k) {
a=j;
b=k;
}
void change(Test ko){
ko.a=ko.b+ko.a;
ko.a=ko.b-12;
}
}
class sdf {
public static void main(String[] args){
Test op=new Test(12,32);
System.out.println(op.a+" "+op.b);
op.change(op);
System.out.println(op.a+" "+op.b);
}
}
Take a look at this piece of code::
you can see , in this case the action inside change() have affected the object passed to the method
When an object reference is passed to the method ,the reference itself is passed to the method call-by-value . therefore , the parameter receives a copy of the reference used in this argument .As a result A change to the parameter (such as making it refers to the different object ) will not affect the reference used as the argument . however , since the parameter and the argument both refer to the same object , a change through the parameter will affect the object reffered by the argument.

How to use an output parameter in Java? [duplicate]

This question already has answers here:
Does Java have something like C#'s ref and out keywords?
(7 answers)
Closed 1 year ago.
Could someone please give me some sample code that uses an output parameter in function? I've tried to Google it but just found it just in functions. I'd like to use this output value in another function.
The code I am developing intended to be run in Android.

Java passes by value; there's no out parameter like in C#.
You can either use return, or mutate an object passed as a reference (by value).
Related questions
Does Java have something like C#'s ref and out keywords?
? (NO!)
Is Java pass by reference? (NO!)
Code sample
public class FunctionSample {
static String fReturn() {
return "Hello!";
}
static void fArgNoWorkie(String s) {
s = "What am I doing???"; // Doesn't "work"! Java passes by value!
}
static void fMutate(StringBuilder sb) {
sb.append("Here you go!");
}
public static void main(String[] args) {
String s = null;
s = fReturn();
System.out.println(s); // prints "Hello!"
fArgNoWorkie(s);
System.out.println(s); // prints "Hello!"
StringBuilder sb = new StringBuilder();
fMutate(sb);
s = sb.toString();
System.out.println(s); // prints "Here you go!"
}
}
See also
What is meant by immutable?
StringBuilder and StringBuffer in Java
As for the code that OP needs help with, here's a typical solution of using a special value (usually null for reference types) to indicate success/failure:
Instead of:
String oPerson= null;
if (CheckAddress("5556", oPerson)) {
print(oPerson); // DOESN'T "WORK"! Java passes by value; String is immutable!
}
private boolean CheckAddress(String iAddress, String oPerson) {
// on search succeeded:
oPerson = something; // DOESN'T "WORK"!
return true;
:
// on search failed:
return false;
}
Use a String return type instead, with null to indicate failure.
String person = checkAddress("5556");
if (person != null) {
print(person);
}
private String checkAddress(String address) {
// on search succeeded:
return something;
:
// on search failed:
return null;
}
This is how java.io.BufferedReader.readLine() works, for example: it returns instanceof String (perhaps an empty string!), until it returns null to indicate end of "search".
This is not limited to a reference type return value, of course. The key is that there has to be some special value(s) that is never a valid value, and you use that value for special purposes.
Another classic example is String.indexOf: it returns -1 to indicate search failure.
Note: because Java doesn't have a concept of "input" and "output" parameters, using the i- and o- prefix (e.g. iAddress, oPerson) is unnecessary and unidiomatic.
A more general solution
If you need to return several values, usually they're related in some way (e.g. x and y coordinates of a single Point). The best solution would be to encapsulate these values together. People have used an Object[] or a List<Object>, or a generic Pair<T1,T2>, but really, your own type would be best.
For this problem, I recommend an immutable SearchResult type like this to encapsulate the boolean and String search results:
public class SearchResult {
public final String name;
public final boolean isFound;
public SearchResult(String name, boolean isFound) {
this.name = name;
this.isFound = isFound;
}
}
Then in your search function, you do the following:
private SearchResult checkAddress(String address) {
// on address search succeed
return new SearchResult(foundName, true);
:
// on address search failed
return new SearchResult(null, false);
}
And then you use it like this:
SearchResult sr = checkAddress("5556");
if (sr.isFound) {
String name = sr.name;
//...
}
If you want, you can (and probably should) make the final immutable fields non-public, and use public getters instead.

Java does not support output parameters. You can use a return value, or pass in an object as a parameter and modify the object.

You can either use:
return X. this will return only one value.
return object. will return a full object. For example your object might include X, Y, and Z values.
pass array. arrays are passed by reference. i.e. if you pass array of integers, modified the array inside the method, then the original code will see the changes.
Example on passing Array.
void methodOne{
int [] arr = {1,2,3};
methodTwo(arr);
...//print arr here
}
void methodTwo(int [] arr){
for (int i=0; i<arr.length;i++){
arr[i]+=3;
}
}
This will print out: 4,5,6.

As a workaround a generic "ObjectHolder" can be used. See code example below.
The sample output is:
name: John Doe
dob:1953-12-17
name: Jim Miller
dob:1947-04-18
so the Person parameter has been modified since it's wrapped in the Holder which is passed by value - the generic param inside is a reference where the contents can be modified - so actually a different person is returned and the original stays as is.
/**
* show work around for missing call by reference in java
*/
public class OutparamTest {
/**
* a test class to be used as parameter
*/
public static class Person {
public String name;
public String dob;
public void show() {
System.out.println("name: "+name+"\ndob:"+dob);
}
}
/**
* ObjectHolder (Generic ParameterWrapper)
*/
public static class ObjectHolder<T> {
public ObjectHolder(T param) {
this.param=param;
}
public T param;
}
/**
* ObjectHolder is substitute for missing "out" parameter
*/
public static void setPersonData(ObjectHolder<Person> personHolder,String name,String dob) {
// Holder needs to be dereferenced to get access to content
personHolder.param=new Person();
personHolder.param.name=name;
personHolder.param.dob=dob;
}
/**
* show how it works
*/
public static void main(String args[]) {
Person jim=new Person();
jim.name="Jim Miller";
jim.dob="1947-04-18";
ObjectHolder<Person> testPersonHolder=new ObjectHolder(jim);
// modify the testPersonHolder person content by actually creating and returning
// a new Person in the "out parameter"
setPersonData(testPersonHolder,"John Doe","1953-12-17");
testPersonHolder.param.show();
jim.show();
}
}

Wrap the value passed in different classes that might be helpful doing the trick, check below for more real example:
class Ref<T>{
T s;
public void set(T value){
s = value;
}
public T get(){
return s;
}
public Ref(T value) {
s = value;
}
}
class Out<T>{
T s;
public void set(T value){
s = value;
}
public T get(){
return s;
}
public Out() {
}
}
public static void doAndChangeRefs (Ref<String> str, Ref<Integer> i, Out<String> str2){
//refs passed .. set value
str.set("def");
i.set(10);
//out param passed as null .. instantiate and set
str2 = new Out<String>();
str2.set("hello world");
}
public static void main(String args[]) {
Ref<Integer> iRef = new Ref<Integer>(11);
Out<String> strOut = null;
doAndChangeRefs(new Ref<String>("test"), iRef, strOut);
System.out.println(iRef.get());
System.out.println(strOut.get());
}

This is not accurate ---> "...* pass array. arrays are passed by reference. i.e. if you pass array of integers, modified the array inside the method.
Every parameter type is passed by value in Java. Arrays are object, its object reference is passed by value.
This includes an array of primitives (int, double,..) and objects. The integer value is changed by the methodTwo() but it is still the same arr object reference, the methodTwo() cannot add an array element or delete an array element. methodTwo() cannot also, create a new array then set this new array to arr. If you really can pass an array by reference, you can replace that arr with a brand new array of integers.
Every object passed as parameter in Java is passed by value, no exceptions.

Thank you. I use passing in an object as a parameter. My Android code is below
String oPerson= null;
if (CheckAddress("5556", oPerson))
{
Toast.makeText(this,
"It's Match! " + oPerson,
Toast.LENGTH_LONG).show();
}
private boolean CheckAddress(String iAddress, String oPerson)
{
Cursor cAddress = mDbHelper.getAllContacts();
String address = "";
if (cAddress.getCount() > 0) {
cAddress.moveToFirst();
while (cAddress.isAfterLast() == false) {
address = cAddress.getString(2).toString();
oPerson = cAddress.getString(1).toString();
if(iAddress.indexOf(address) != -1)
{
Toast.makeText(this,
"Person : " + oPerson,
Toast.LENGTH_LONG).show();
System.out.println(oPerson);
cAddress.close();
return true;
}
else cAddress.moveToNext();
}
}
cAddress.close();
return false;
}
The result is
Person : John
It's Match! null
Actually, "It's Match! John"
Please check my mistake.