First, lets talk about the contents of the files {{Cat.java}}.
* _Fields_: The class {{Cat}} has three fields, {{name}}, {{age}} and {{friend}}. Each field has a _type_, which ensures that we can only store a {{String}} in {{name}}, an {{int}} in {{age}} and another {{Cat}} in {{friend}}. The word {{private}} before each field indicates that the field can only be accessed from within the class {{Cat}}.
* _Constructors_: The class {{Cat}} has one constructor {{public Cat(String name, int age){...\}}}. In the constructor, the fields {{name}} and {{age}} are initialized with the values given in the arguments, while {{friend}} is simply set to {{null}}. Because the constructor is public, it can be invoked from other classes. An example of the invoking the constructor can be seen in {{CatsTheMusical.java}}.
* _Methods_: The class {{Cat}} has four methods, {{getName(){...\}}}, {{getFriend(){...\}}}, {{setFriend(...){...\}}} and {{sayHello(...){..\}}}. The keyword{{public}} indicates that the methods can be called outside of the class {{Cat}}. The second word in each method is the _return type_, or the _type_ of the result of the method. Notice that {{setFriend(...)}} has a return type of {{void}}, indicating that nothing is returned. The first two methods are examples of _getter_ methods, as they simply retrieve the value of a private field. The third method is a _setter_ method, which allows the field {{friend}} to be changed from outside the class {{Cat}}.
Now lets talk about the other file {{CatsTheMusical.java}}.
* _Static Methods_: Methods that are {{static}}, while associated with the class they are written in, are not associated with any particular instance. They can be invoked by using{{[class-name].[method]}}. For example, see the invocation of {{areFriends(...)}} within {main(...)}.
* _main(...)_: All Java program must start with the code {{public static void main(String[] args){...\}}}. From here, we will follow the methods and constructors into other class files. The arguments, {{String[] args}} can be accessed by calling {{args[0]}} etc. and can be set by going to the top menu bar and then selecting _Run → Run Configurations..._, then selecting the _Arguments_ tab in the center and filling out the _Program Arguments_ box.
Now that we have the basic terminology down, lets examine some of the finer points which may be confusing to non-Java programmers:
* Given an instance of a class (e.g. for {{Cat c = new Cat(...)}}, {{c}} is an instance), non-static methods from the class can be called by \[instance name\].\[method name\] (e.g. {{c.getName()}}). Similarly, non-static fields can be accessed by calling \[instance name\].\[field name\], (e.g. {{c.name}}). However, methods or fields labeled {{private}} can only be called/accessed from code written within their own class file.
* Within a constructor, we can directly access the fields of a class by name without reference to any particular instance, as it is implied that the instance is the one that is being built. For example, in the {{Cat}} constructor, we make the assignment {{friend = null}}. However, when there are argument variables with the same name as the field variables, they take precedence and _shadow_ the fields variables. To reference the fields once they have been shadowed, you need to use the keyword {{this}}. In fact, you can use the keyword {{this}} whenever you want to refer to a field or method of the instance of the class being built by the constructor, regardless of whether there is shadowing. Analogous rules apply for fields and methods inside other non-static methods.
* In static methods, we cannot refer to any non-static fields or non static methods of the class without also providing an instance, as static methods are not associated with any instance. Similarly, the keyword this cannot be applied.
|