Develop Reference

Passing variable from another file and then use variable within to another method within same class

I am trying to call a variable from another class in another to the second java file
public class selectFile {
public void hdrFile(){
String hdrName = "directory";
readImage sendVari = new readImage();
sendVari.setprintHDR(hdrName);
}
}
public class readImage {
private String hdr_dir;
public static void main(String[] args){
selectFile call_vari = new selectFile();
call_vari.hdrFile();
}
public void setprintHDR(String hdr_dir){
this.hdr_dir = hdr_dir;
}
public String getprintHDR(){
return hdr_dir;
}
public void anotherMethod(){
System.out.println(getprintHDR());
}
}
I am doing this because I want to use "anotherMethod" Method in second in the third file, but when I am testing in the second java file by printing it to the terminal "anotherMethod" cannot print any hdr_dir even I return hdr_dir. But if I check "setprintHDR" by printing it to the command everything seem fine, it returns "directory"
public class Main {
public static void main(String[] args){
readImage call_vari = new readImage();
call_vari.anotherMethod();
}
}

Since you want to use the updated value in another object( basically trying to share the value between multiple objects), you should keep your variable hdr_dir as static. Static vs Instance Variables: Difference?
You were currently using the variable as instance one due to which if one object updates the value, it will remain specific to that object only.
For your main class,
public class Main {
// private String hdr_dir;
public static void main(String[] args){
int res = 0;
selectFile call_var = new selectFile();
call_var.hdrFile();
readImage call_vari = new readImage();
// call_var.anotherMethod();
// call_vari.setprintHDR("printHDR");
call_vari.anotherMethod();
}
}
and the output is
value of hdr_dir is passed is -------directory // doing some console logging
value of hdr_dir assigned is -------directory
directory

Convert array to string using an object from a different class

Hello I'm very new to Java and currently I'm trying to convert an array, that is a playfield, into a string through using a method(object) I created in a different class . This is what I have tried:
public class Testing
{
public static void main(String[] args) {
//create an empty playfield that is 10x10
Board emptyBoard = new Board(10,10);
//convert playfield to string and save it in new variable
String newBoard = convertToString(emptyBoard); // this throws an error saying "cannot resolve method 'convertToString(...)'
//now show the playfield as a string
System.out.println(newBoard);
}
}
The method convertToString lies in another class called ArrayToString, if that matters for any reason and "convertToString" should take in a Board and return a String. Any ideas on how to solve this kind of problem? :)

package foo;
// add static import to not write it before method name
import static foo.ArrayToString;
public class Testing {
public static void main(String[] args) {
// method should be static, because you don't use new ArrayToString().convertToString(emptyBoard)
String newBoard = convertToString(emptyBoard);
}
}
package foo;
public class ArrayToString {
// should be static method
public static String convertToString(Board board) {}
}

Calling Methods in Main Class and Other Class Differences in Java

I have 3 classes, Mainn, ReadFile, and Entry.
ReadFile is basically my class that does all file i/o stuff.
How come I am able to access ReadFile in my Mainn class just fine, but
when I try to access it in Entry "e.openFile()" i get an error that says identifier expected.
I know this can be fixed by making an overloaded method openFile() in Entry but why is this needed in Entry, but not in the main class Mainn?
package homework6;
public class mainn {
public static void main(String[] args){
ReadFile r = new ReadFile();
r.openFile();
//r.readFile();
r.skipFirst();
String x[] = r.getData();
String y[] = r.getData();
String z[] = r.getData();
System.out.println(x[0] + "," + x[1]);
System.out.println(y[0] + "," + y[1]);
System.out.println(z[0] + "," + z[1]);
r.closeFile();
}
}
ReadFile:
package homework6;
import java.util.*;
import java.io.*;
public class ReadFile {
Scanner x = null;
public void openFile(){
try{
x = new Scanner(new FileInputStream(
"C:\\Users\\Rohan Vidyarthi\\workspace\\Data.csv"));
}
catch(FileNotFoundException e){
System.out.println("File not found error");
}
}
public void readFile(){
while (x.hasNextLine())
System.out.println(x.nextLine());
}
public void skipFirst(){
x.nextLine();
}
public String[] getData(){ //returns String[] with Date and ADJ Close
String[] temp;
String[] out = new String[2];
temp = (x.nextLine()).split(",");
out[0] = temp[0];
out[1] = temp[6];
return out;
}
public boolean checker(){
return x.hasNextLine();
}
public void closeFile(){
x.close();
}
}
class Entry:
package homework6;
public class Entry extends ReadFile{
ReadFile e = new ReadFile();
e.openFile();
double minn = Double.MAX_VALUE;
double maxx = Double.MIN_VALUE;
/*public String[] rMax(){
String[] temp1;
String[] temp2;
}
*/
}

I suggest you move your openFile() logic to the ReadFile class constructor as shown below and this approach will give you two advantages:
(1)scanner (which is a mandatory variable of ReadFile class) gets initialized inside the class constructor which makes more sense and avoids all NullPointerException i.e., someone accidentally calling other methods first before openFile() (Always ensure that all mandatory instance variables i.e., data is being initialized by the constructors, I strongly suggest make it as a practice and never allow any object being created freely without being the mandatory variables initialized through constructors which will avoid most of the issues).
(2) It will fix your problem automatically as you don't need a call to openFile() method (well, you don't have that method itself, ReadFile constructor has initialized the scanner).
public class ReadFile {
Scanner x = null;
public ReadFile() {
try{
x = new Scanner(new FileInputStream(
"C:\\Users\\Rohan Vidyarthi\\workspace\\Data.csv"));
}
catch(FileNotFoundException e){
System.out.println("File not found error");
}
}
public void readFile(){
//add code
}
public void skipFirst(){
//add code
}
public String[] getData(){
//add code
}
public boolean checker(){
return x.hasNextLine();
}
public void closeFile(){
x.close();
}
}
Just ensure that you don't need to call openFile() anymore as shown below:
public class Entry extends ReadFile{
ReadFile e = new ReadFile();//initializes scanner as well
public String[] readFile() {//add any methods you like here in this like
return e.readFile();
}
double minn = Double.MAX_VALUE;
double maxx = Double.MIN_VALUE;
}
How come I am able to access ReadFile in my Mainn class just fine, but
when I try to access it in Entry "e.openFile()" I get an error that
says identifier expected.
In Java, invocation of any method call (like your r.openFile()) should be done from another method or from constructor or from initializers (static or instance initializer), so the answer is in your Mainn class, you are calling the openFile() inside from main(String[] args) method whereas in your Entry class your openFile() method call is not wrapped inside any of the above-mentioned code blocks (i.e., methods, constructors, initializers).
One more important point is that in general when you say A extends B in Object Oriented Languages, it means that A IS-A type of B, but in your code Entry extends ReadFile does not make much sense, so you should avoid that.

put e.openFile(); in a method or constructor. You cannot place floating codes outside methods. Any statement can only be used inside the block of codes (i.e. methods, constructors, static initializers)

If you do
public class mainn {
ReadFile r = new ReadFile();
r.openFile();
//r.readFile();
r.skipFirst();
String x[] = r.getData();
...
you will receive the same error in mainn

ArrayList class separate from Java main file

I have two separate files, one named WonderfulArrayList, and the other named ArrayListMain (I'm experimenting with ArrayLists, and I'm not quite sure what to do) and so I have a method in the WonderfulArrayList file, but the main file cannot see the method, which I have named booladdData, which would return true once the data is added to the array list. My WonderfulArrayList file is the following:
import java.util.*;
import java.io.*;
public class WonderfulArrayList{ //implement WonderfulArrayList
public static int ADDNums;
public static int index;
public static int HEADNums;
public static ArrayList<Integer> arr = new ArrayList<Integer>(15);
public static boolean booladdData(ArrayList<Integer>arr){
arr.add(ADDNums);
return true;
}
}
As you can see, I have booladdData instantiated with the ArrayList, named arr. Now, if you look at my main file:
public class ArrayListMain{
//public ArrayList<Integer> arr = new ArrayList<Integer>(15);
public static void main(String[]args){
ArrayList<Integer> arr = new ArrayList<Integer>(15);
int MenuNum = 0;
int ADDNums = 0;
Object Obj = new Object();
Scanner scanner1 = new Scanner(System.in); //set up scanner for user input
while(MenuNum != 7){ //menu loop
Menu(MenuNum);
MenuNum = scanner1.nextInt();
if(MenuNum == 1){
arr.booladdData();
}
For some reason, even though I know that booladdData is created as public and they're both in the same folder, the main file doesn't have the scope to be able to see booladdData in the separate file.
Any idea what I'm doing wrong?

You should be calling WonderfulArrayList.booladdData(arr) instead of arr.booladdData(). The method booladdData() is defined as a class method of your WonderfulArrayList class. It's not an instance method of Java's ArrayList.
You also might want to read into object-oriented programming. Everything in your code is static.

You need to create your type instead of ArrayList
package com.jbirdvegas.test;
import java.util.ArrayList;
public class MainClazz {
public static void main(String[] args) {
// notice I'm creating my type `MyArrayList` instead of `ArrayList` type
MyArrayList myArrayList = new MyArrayList();
myArrayList.add("blah");
System.out.println("My message:" + myArrayList.getSomething());
}
}
class MyArrayList extends ArrayList {
public String getSomething() {
return "something";
}
}
Prints:
My message: something

Get String From Another Method?

I have two methods, the first one creates a string, then I want to use that string in the second method.
When I researched this, I came across the option of creating the string outside of the methods, however, this will not work in my case as the first method changes the string in a couple of ways and I need the final product in the second method.
Code:
import java.util.Random;
import java.util.Scanner;
public class yaya {
public static void main(String[] args) {
System.out.println("Enter a word:");
Scanner sc = new Scanner(System.in);
String input = sc.nextLine();
Random ran = new Random();
int ranNum = ran.nextInt(10);
input = input + ranNum;
}
public void change(String[] args) {
//more string things here
}
}

Create an instance variable:
public class MyClass {
private String str;
public void method1() {
// change str by assigning a new value to it
}
public void method2() {
// the changed value of str is available here
}
}

You need to return the modified string from the first method and pass it into the second. Suppose the first method replaces all instances or 'r' with 't' in the string (for example):
public class Program
{
public static String FirstMethod(String input)
{
String newString = input.replace('r', 't');
return newString;
}
public static String SecondMethod(String input)
{
// Do something
}
public static void main(String args[])
{
String test = "Replace some characters!";
test = FirstMethod(test);
test = SecondMethod(test);
}
}
Here, we pass the string into the first method, which gives us back (returns) the modified string. We update the value of the initial string with this new value and then pass that into the second method.
If the string is strongly tied to the object in question and needs to be passed around and updated a lot within the context of a given object, it makes more sense to make it an instance variable as Bohemian describes.

Pass the modified string in the second method as an argument.

create a static variable used the same variable in both the method.

public class MyClass {
public string method1(String inputStr) {
inputStr += " AND I am sooo cool";
return inputStr;
}
public void method2(String inputStr) {
System.out.println(inputStr);
}
public static void main(String[] args){
String firstStr = "I love return";
String manipulatedStr = method1(firstStr);
method2(manipulatedStr);
}
}

Since you mentioned that both methods should be able to be called independently, you should try something like this:
public class Strings {
public static String firstMethod() {
String myString = ""; //Manipulate the string however you want
return myString;
}
public static String secondMethod() {
String myStringWhichImGettingFromMyFirstMethod = firstMethod();
//Run whatever operations you want here and afterwards...
return myStringWhichImGettingFromMyFirstMethod;
}
}
Because both of these methods are static, you can call them in main() by their names without creating an object. Btw, can you be more specific about what you're trying to do?