Thread: JPanel new FlowLayout

You use new to create a new instance of a class. Using FlowLayout() without new looks like a call to a method not a call to make a new instance of a class.

How does a method take a class and know what to do with it?

That would be what the programmer that wrote the method would define and take care of. By class I assume you mean an instance of a class.

would the method setLayout look something like this?

public void setLayout(object layout)

That defines a method named setLayout that takes a parameter of type object named layout. Somewhere the class named object would have to be defined.

The next line is confusing because it has a classname the same as the parameter's name:

layout newlayout = new layout();

The syntax of that line says: Define a variable of type layout with a name of newlayout and assign it the value of a new layout object.

using a new for classes, even when I'm not making a new object.

You use new to create an instance of a class. What you just said does not make sense.

I'm sorry if I didn't make sense. What I meant is I am use to doing stuff like

MyClass newClass = new MyClass();

not doing a new inside a parenthesis like this

newClass.getSomething(new Whatever());

I just can't figure out what to do with the (new Whatever()), or how to write a method in MyClass, that knows how to take another class(Whatever()) and actually tell
1: What class it is.
2:What to do with the class now that is knows what it is.

I guess Ill just copy and paste some of my code.

public class Test
{


public static void main(String[] args)
{
TestSubject subjective = new TestSubject();
subjective.setTestSubject(new Subject());
}

}
public class TestSubject
{
public void setTestSubject(Object newClass)
{
System.out.println(newClass.toString());
Object newSubject;
newSubject = new Subject();
System.out.println(newSubject.toString());
if (newClass.equals( new Subject()));
{
System.out.print("didnt work");

}
}
}

Have another class called subject that's just for test. It actually contains no code.

The first way assigns a reference to a variable that can be used elsewhere. The second way does not. They both create an instance of the class.
newClass.getSomething(new Whatever()); // Added needed ()s