In Java, all function definitions must be inside classes. We also call functions methods. Let’s look at an example method<\/p>\n
public<\/span> class<\/span> Main<\/span> {<\/span>\r\n public<\/span> static<\/span> void<\/span> foo<\/span>(<\/span>)<\/span> {<\/span>\r\n \/\/ Do something here<\/span>\r\n }<\/span>\r\n}<\/span>\r\n<\/code><\/pre>\nExecute Code<\/a><\/p>\nfoo<\/code>\u00a0is a method we defined in class Main. Notice a few things about\u00a0foo<\/code>.<\/p>\n\nstatic<\/span><\/code>\u00a0means this method belongs to the class Main and not to a specific instance of Main. Which means we can call the method from a different class like that\u00a0Main.<\/span>foo<\/span>(<\/span>)<\/span><\/code>.<\/li>\nvoid<\/span><\/code>\u00a0means this method doesn’t return a value. Methods can return a single value in Java and it has to be defined in the method declaration. However, you can use\u00a0return<\/span><\/code>\u00a0by itself to exit the method.<\/li>\n- This method doesn’t get any arguments, but of course Java methods can get arguments as we’ll see further on.<\/li>\n<\/ul>\n
Arguments<\/h3>\n
I always like to say that arguments to Java methods are passed by value, although some might disagree with my choice of words, I find it the best way to explain and understand how it works exactly.<\/p>\n
By value means that arguments are copied when the method runs. Let’s look at an example.<\/p>\n
public<\/span> void<\/span> bar<\/span>(<\/span>int<\/span> num1,<\/span> int<\/span> num2)<\/span> {<\/span>\r\n .<\/span>.<\/span>.<\/span>\r\n}<\/span>\r\n<\/code><\/pre>\nExecute Code<\/a><\/p>\nHere is a another place in the code, where bar is called<\/p>\n
int<\/span> a =<\/span> 3<\/span>;<\/span>\r\nint<\/span> b =<\/span> 5<\/span>;<\/span>\r\nbar<\/span>(<\/span>a,<\/span> b)<\/span>;<\/span>\r\n<\/code><\/pre>\nExecute Code<\/a><\/p>\nYou can picture in your head that when\u00a0bar<\/span>(<\/span>a,<\/span>\u00a0b)<\/span><\/code>\u00a0is run, it’s like in the beginning of\u00a0bar<\/code>\u00a0the following two lines are written:<\/p>\nint<\/span> num1 =<\/span> a;<\/span>\r\nint<\/span> num2 =<\/span> b;<\/span>\r\n<\/code><\/pre>\nExecute Code<\/a><\/p>\nAnd only then the rest of the method is run.<\/p>\n
This means that\u00a0a<\/code>\u00a0value get copied to\u00a0num1<\/code>\u00a0and\u00a0b<\/code>\u00a0value get copied to\u00a0num2<\/code>. Changing the values of\u00a0num1<\/code>\u00a0and\u00a0num2<\/code>\u00a0will not affect\u00a0a<\/code>\u00a0and\u00a0b<\/code>.<\/p>\nIf the arguments were objects, the rules remain the same, but it acts a bit differently. Here is a an example:<\/p>\n
public<\/span> void<\/span> bar2<\/span>(<\/span>Student s1,<\/span> Student s2)<\/span> {<\/span>\r\n .<\/span>.<\/span>.<\/span>\r\n}<\/span>\r\n<\/code><\/pre>\nExecute Code<\/a><\/p>\nAnd here is how we use it<\/p>\n
Student joe =<\/span> new<\/span> Student<\/span>(<\/span>\"joe\"<\/span>)<\/span>;<\/span>\r\nStudent jack =<\/span> new<\/span> Student<\/span>(<\/span>\"jack\"<\/span>)<\/span>;<\/span>\r\nbar2<\/span>(<\/span>joe,<\/span> jack)<\/span>;<\/span>\r\n<\/code><\/pre>\nExecute Code<\/a><\/p>\nAgain we can picture the same two lines in the beginning of\u00a0bar2<\/code><\/p>\nStudent s1 =<\/span> joe;<\/span>\r\nStudent s2 =<\/span> jack;<\/span>\r\n<\/code><\/pre>\nExecute Code<\/a><\/p>\nBut when we assign objects, it’s a bit different than assigning primitives.\u00a0s1<\/code>\u00a0and\u00a0joe<\/code>\u00a0are two different references to the same object.\u00a0s1\u00a0==<\/span>joe<\/code>\u00a0is true. This means that running methods on\u00a0s1<\/code>\u00a0will change the object\u00a0joe<\/code>. But if we’ll change the value of\u00a0s1<\/code>\u00a0as a reference, it will not affect the reference\u00a0joe<\/code>.<\/p>\ns1.<\/span>setName<\/span>(<\/span>\"Chuck\"<\/span>)<\/span>;<\/span> \/\/ joe name is now Chuck as well<\/span>\r\ns1 =<\/span> new<\/span> Student<\/span>(<\/span>\"Norris\"<\/span>)<\/span>;<\/span> \/\/ s1 is a new student, different than joe with the name of Norris<\/span>\r\n\/\/ s1 == joe is not true anymore<\/span>\r\n<\/code><\/pre>\nExecute Code<\/a><\/p>\nNon static methods<\/h3>\n
Non static methods in Java are used more than static methods. Those methods can only be run on objects and not on the whole class.<\/p>\n
Non static methods can access and alter the field of the object.<\/p>\n
public<\/span> class<\/span> Student<\/span> {<\/span>\r\n private<\/span> String name;<\/span>\r\n public<\/span> String getName<\/span>(<\/span>)<\/span> {<\/span>\r\n return<\/span> name;<\/span>\r\n }<\/span>\r\n public<\/span> void<\/span> setName<\/span>(<\/span>String name)<\/span> {<\/span>\r\n this<\/span>.<\/span>name =<\/span> name;<\/span>\r\n }<\/span>\r\n}<\/span>\r\n<\/code><\/pre>\n