{"id":1425,"date":"2015-06-21T20:37:18","date_gmt":"2015-06-21T15:07:18","guid":{"rendered":"https:\/\/theoryofprogramming.wordpress.com\/?p=1425"},"modified":"2015-06-21T20:37:18","modified_gmt":"2015-06-21T15:07:18","slug":"java-tutorials-enum-and-methods-in-java","status":"publish","type":"post","link":"https:\/\/theoryofcoding.com\/index.php\/2015\/06\/21\/java-tutorials-enum-and-methods-in-java\/","title":{"rendered":"Java Tutorials – Enum and Methods in Java"},"content":{"rendered":"

Hello people..! This is a new post in Java Tutorials – Enum and Methods in Java. In this post I will talk about enum<\/span><\/b> and methods (that is, functions) in Java. The full potential and usage of these constructs will be seen when we start creating classes. But you’ve gotta start somewhere..! So this post is to get you started with these constructs.<\/p>\n

enum<\/span> in Java<\/h3>\n

“enum” is the short form for “enumeration”… Here, an enum<\/span><\/b> will be an enumeration of constants. In enum<\/span><\/b>, what we do is –<\/p>\n

    \n
  • Declare an enum<\/span><\/b>. Which involves declaring a set of constants.<\/li>\n
  • We create a variable of the enum<\/span><\/b> type, which can hold any one value among the declared constants for that enum<\/span><\/b>… Nothing else…!<\/li>\n<\/ul>\n

    Why would anyone use an enum<\/span><\/b>..? … Well, it can look insignificant at most times, but there is a wide scope where we can use them…!<\/p>\n

    Let’s take the men’s T-shirt sizes for example. We all know that the sizes have fixed letters associated with them. We don’t have to bother ourselves about all of them… Let’s just pick a few –<\/p>\n

      \n
    • S – Small<\/li>\n
    • M – Medium<\/li>\n
    • L – Large<\/li>\n
    • XL – Extra Large<\/li>\n<\/ul>\n

      Now, if you wanted to create a variable to store the T-shirt sizes… Which data types would you choose..? And moreover, how will you ensure that the variable will have exactly anyone of these predefined values..? That’s where an enum<\/span><\/b> comes into the picture.<\/p>\n

      Let’s look at a simple code which uses an enum<\/span><\/b> –<\/p>\n

      \nclass Enumerations\n{\n\t\/\/ Declaring an enum\n\t\/\/ Give the set of constants\n\tenum TShirtSizes {S, M, L, XL};\n\n\tpublic static void main (String[] args)\n\t{\n\t\t\/\/ Creating a variable of the enum\n\t\tTShirtSizes myShirt;\n\n\t\t\/\/ Assigning a value to the variable\n\t\t\/\/ Must assign a value among the\n\t\t\/\/ declared value\n\t\tmyShirt = TShirtSizes.L;\n\t\t\/\/ Access the declared value\n\t\t\/\/ using dot operator \n\n\t\tSystem.out.println(myShirt);\t\/\/ L\n\t}\n}\n<\/pre>\n
      This is how we use an enum<\/span><\/b>. As you can see, there are 3 steps involved in using an enum<\/span><\/b> in Java –<\/p>\n
        \n
      1. Declaring<\/strong> – Declare an enumeration using the enum<\/span><\/b> keyword. Provide the set of constants in curly braces. One important thing is that, enum<\/span><\/b> must be declared outside a method. They can be declared even outside a class, but not locally (inside a method)..!\n
        \nenum TShirtSizes {S, M, L, XL};\n<\/pre>\n<\/li>\n
      2. Creating a variable<\/strong> – We create the variable using the name of the enum<\/span><\/b> declared. It acts like a data type, similar to a struct<\/span><\/b>.\n
        \nTShirtSizes myShirt;\n<\/pre>\n<\/li>\n
      3. Assigning<\/strong> – Assign a value to the variable created. We must always assign a value among the constants declared before. We access these values by using the dot operator on the enum<\/span><\/b> name. Assignment of any other value gives a compilation error.\n
        \nmyShirt = TShirtSizes.L;\n<\/pre>\n<\/li>\n<\/ol>\n
        Those were about the legal declarations. Let’s look at some illegal declarations. The whole class is given as you could make a mistake at anyone of the steps –<\/p>\n
        \nclass EnumGoneWrong\n{\n\tenum TShirtSizes = {S, M, L, XL};\n\t\/\/ No '='. This is not an array!\n\n\tpublic static void main (String[] args)\n\t{\n\t\tTShirtSizes myShirt;\n\n\t\tmyShirt = TShirtSizes.L;\n\n\t\tSystem.out.println(myShirt);\n\t}\n}\n\n\/\/ Another\nclass EnumGoneWrong\n{\n\tenum TShirtSizes {S, M, L, XL};\n\n\tpublic static void main (String[] args)\n\t{\n\t\tTShirtSizes myShirt;\n\n\t\tmyShirt = TShirtSizes.XXL;\n\t\t\/\/ XXL wasn't declared..!\n\n\t\tSystem.out.println(myShirt);\n\t}\n}\n\n\/\/ Another\nclass EnumGoneWrong\n{\n\tenum TShirtSizes {S, M, L, XL};\n\n\tpublic static void main (String[] args)\n\t{\n\t\tTShirtSizes myShirt;\n\n\t\tmyShirt = M;\n\t\t\/\/ It is TShirtSizes.M !\n\n\t\tSystem.out.println(myShirt);\n\t}\n}\n\n\/\/ Another\nclass EnumGoneWrong\n{\n\tenum TShirtSizes {S, M, L, XL};\n\n\tpublic static void main (String[] args)\n\t{\n\t\tTShirtSizes myShirt;\n\n\t\tmyShirt = 'M';\n\t\t\/\/ It is TShirtSizes.M !\n\n\t\tSystem.out.println(myShirt);\n\t}\n}\n\n\/\/ Another\nclass EnumGoneWrong\n{\n\tenum TShirtSizes {S, M, L, XL};\n\n\tpublic static void main (String[] args)\n\t{\n\t\tTShirtSizes myShirt;\n\n\t\tmyShirt = 1;\n\t\t\/\/ Cannot take any value\n\t\t\/\/ other than those declared !\n\n\t\tSystem.out.println(myShirt);\n\t}\n}\n<\/pre>\n
        Methods in Java<\/h2>\n
        Functions in Java are actually called “methods”. That’s the terminology we are supposed to use here. In my previous posts, I have used the word “functions” more than “methods” so that you don’t feel too alien. But from now on, we use the term “methods”.<\/p>\n
        Methods as you know it, are subroutines that can be called from a method, where the control passes to the called method, and comes back to the caller method after execution of the subroutine, with or without a return type.<\/p>\n
        We will use a lot of methods when we start creating our own classes…. And by “a lot”, I mean really A LOT..! But for now, Let’s just learn how to call a method from the main() method.<\/p>\n
        \nclass Methods\n{\n\tpublic static void main (String[] args)\n\t{\n\t\tprintMessage("This was printed from a ");\n\t}\n\n\tstatic void printMessage(String msg)\n\t{\n\t\tSystem.out.println(msg + "method !");\n\t}\n}\n<\/pre>\n
        Now the VERY IMPORTANT thing here is that, if you want to call any method from the main() method, it must be marked static<\/span><\/b>, otherwise it is a compilation error..! Not just main() method, any static<\/span><\/b> method can only call another static<\/span><\/b> method..! So the following code gives a compilation error –<\/p>\n
        \nclass Methods\n{\n\tpublic static void main (String[] args)\n\t{\n\t\tprintMessage("This was printed from a ");\n\t}\n\n\tstatic void printMessage(String msg)\n\t{\n\t\tprintMessageToBob(msg + "method ");\n\t}\n\n\tvoid printMessageToBob(String msg)\n\t{\n\t\tSystem.out.println(msg + "Bob !");\n\t}\n}\n<\/pre>\n
        It is because we are calling a non-static method from a static method. This code gives compilation error which is pretty famous among the beginners –<\/p>\n
        Main.java:17: error: non-static method printMessageToBob(String) cannot be referenced from a static context\nprintMessageToBob(msg + \"method \");\n^\n1 error\n<\/pre>\n
        It is famous among the beginners because they don’t know what static really means. In Java, static means a lot. We will have a detailed discussion later. But you must remember this one rule.<\/p>\n
        Components in a Method’s Declaration<\/h3>\n
        Methods in Java have six components. They are –<\/p>\n
          \n
        1. Access Modifier<\/strong> – The access modifier define the scope of the method, that is, from where this method can\/cannot be accessed. Access modifiers is a separate topic that we will see later.<\/li>\n
        2. Return Type<\/strong> – This is the data type of the return value. It is void<\/span><\/b> if the method does not return anything.<\/li>\n
        3. Name<\/strong> – The name of the method.<\/li>\n
        4. List of Parameters<\/strong> – Then comes the list of parameters enclosed in parenthesis. The data type of the parameter should be mentioned first.<\/li>\n
        5. List of Exceptions<\/strong> – The method must declare unhandled exceptions using throws<\/span><\/b> keyword. We will discuss this later.<\/li>\n
        6. Body of the Method<\/strong> – The actual code of the method. Must be enclosed in curly braces.<\/li>\n<\/ol>\n
          I would like to introduce another important term –<\/p>\n
          Method Signature<\/strong> – It is the name of\u00a0 the method + the list of parameters. It does not include the return type.<\/p>\n
          Method Signature will be a very frequent term in the upcoming discussions. So, do remember this term well..! As I said before, we will confine ourselves only on calling methods from the main() method. So, you needn’t be bothered about Access Modifiers or List of Exceptions for now.
          \nSome examples of methods, their signatures, and whether they can be called from the main() method or not –<\/p>\n
          \n\/\/ Method\npublic static void main(String[] args) {\n    \/\/ main() method\n}\n\n\/\/ Signature -\n\/\/ main(String[] args)\n\n\/\/ Method\nvoid print() {\n    \/\/ Can't be called from main()\n}\n\n\/\/ Signature -\n\/\/ Print()\n\n\/\/ Method\nstatic String getMessage() {\n    \/\/ Can be called from main()\n    return "Hello";\n}\n\n\/\/ Signature -\n\/\/ getMessage()\n\n\/\/ Method\nstatic void sort(int[] arr) {\n    \/\/ Can be called from main()\n}\n\n\/\/ Signature -\n\/\/ sort(int[] arr)\n\n\/\/ Method\nint distance(int x1, int y1, int x2, int y2) {\n    \/\/ can't be called from main()\n    return 0;\n}\n\n\/\/ Signature -\n\/\/ distance(int x1, int y1, int x2, int y2)\n\n\/\/ Method\npublic static void main(String args) {\n    \/\/ Can be called from main()\n    \/\/ But this is not "the" main()..!\n}\n\n\/\/ Signature -\n\/\/ main(String args)\n<\/pre>\n
          The examples are self-explanatory. But do feel free to comment if you have any doubts..! \ud83d\ude42<\/p>\n
          Passing Variables of Primitive Data Types<\/h3>\n
          The primitive data types are always passed by value in Java. There are no pointers in Java. So… You cannot exactly create a swap function in Java..! I know you are a genius, but still, I want to remind you that this function does not swap the elements –<\/p>\n
          \npublic class SwapSwapSwap {\n\n    public static void main(String[] args) {\n        int x = 10;\n        int y = 20;\n        \n        swap(x, y);\n        \n        System.out.println("x = " + x);     \/\/ 10\n        System.out.println("y = " + y);     \/\/ 20\n    }\n    \n    static void swap(int x, int y) {\n        int temp = x;\n        x = y;\n        y = temp;\n    }\n    \n}\n<\/pre>\n
          Passing Objects<\/h3>\n
          The objects are passed by their object references, so “in-effect”, they are passed by reference. But passing an object doesn’t exactly mean that we can change them in the method called. That depends on whether the object passed is mutable or not. For example, we know that String<\/span> objects are immutable, whereas objects of StringBuilder<\/span> are mutable. So look at the following example –<\/p>\n
          \npublic class PassingAnObject {\n\n    public static void main(String[] args) {\n        String str = "String Object";\n        StringBuilder strb \n            = new StringBuilder("String Builder Object");\n        \n        changeString(str);\n        changeStringBuilder(strb);\n        \n        System.out.println(str);\n        \/\/ Gives - String Object\n        System.out.println(strb);\n        \/\/ Gives - String Builder Object Changed..!\n    }\n    \n    static void changeString(String str) {\n        str = str.concat(" Changed..!");\n    }\n    \n    static void changeStringBuilder(StringBuilder strb) {\n        strb.append(" Changed..!");\n    }\n    \n}\n<\/pre>\n
          Strings are real tricky in this aspect. When we pass a String<\/span> Object, initially, it does point to the object of the main() method, but once, we change it, we get a whole new object. This is not the case with objects of StringBuilder<\/span>…! Objects of StringBuilder<\/span> are mutable, so when we pass the object reference, the actual object can be modified by the called method, because inside the method, it’s just another reference pointing to the same StringBuilder<\/span> object created in the main() method.
          \nYou may not understand this… That’s ok..! \ud83d\ude42 … But remember this that whether the object can me modified depends on whether the object is immutable or not.<\/p>\n
          Naming Conventions<\/h3>\n
            \n
          • enum<\/span><\/strong>s – As discussed, enum<\/span><\/strong> is a set of constants. According to the Oracle Code Convention, constants must be named in all caps. Such as –\n
            \nenum TShirtSizes {SMALL, MEDIUM, LARGE, EXTRALARGE};\n<\/pre>\n<\/li>\n
          • Methods<\/strong> – Methods in Java follow the Camel Case Convention. Here, the first word is written in small letters and the rest of the words following are capitalized. Such as –\n
            \nint binarySearch(int[] arr, int key) {\n    \/\/ code\n}\n\nString toString(int[] arr) {\n    \/\/ code\n}\n\nchar charAt(int index) {\n    \/\/ code\n}\n\nint lastIndexOf(String str) {\n    \/\/ code\n}\n<\/pre>\n
            I don’t know each and every method in the Java Library, but all the methods I have seen so far strictly follow the naming convention. I think Java library is the best example for everything we study in Java.<\/li>\n<\/ul>\n
            More about an enum<\/span><\/h3>\n
            This is an advanced discussion… So beginners can feel free to skip this section… \ud83d\ude42 … There’s a lot more to an enum<\/span><\/b> in Java. enum<\/span><\/strong>s are like really special (or strange \ud83d\ude1b ) classes. As I told before, enum<\/span><\/b>s can be declared outside a class –<\/p>\n
            \nenum TShirtSizes {\n    S, M, L, XL;\n}\n\npublic class Enumerations {\n\n    public static void main(String[] args) {\n        \/\/ code\n    }\n\n}\n<\/pre>\n
            Being able to declare it outside a class doesn’t make it a special kind of class… Then what..? … We can have constructors, methods and variables inside an enum<\/span><\/b>..!
            \nTake our example of the enum TShirtSizes<\/span><\/b>… Well, saying S, M, L, is good… But wouldn’t it be nice if we had data about their actual measurements too..? I mean… What if we could store that size L meant 40 – 42 inches..? Now that would be great, wouldn’t it..? So, now, we bring the variables and constructors of an enum into picture. Go through the following code closely –<\/p>\n
            \nenum TShirtSizes {\n\n    \/\/ Constant(value associated)\n    S(36, 38), M(38, 40), L(40, 42), XL(42, 44);\n\n    \/\/ Values to be stored\n    final int START, END;\n    \n    \/\/ Constructor\n    private TShirtSizes(int START, int END) {\n        this.START = START;\n        this.END = END;\n    }\n\n}\n\npublic class Enumerations {\n\n    public static void main(String[] args) {\n        TShirtSizes shirt = TShirtSizes.L;\n        System.out.println(shirt);  \/\/ L\n        System.out.println(shirt.START + " - " \n                                       + shirt.END);\n        \/\/ Prints -> 40 - 42\n    }\n\n}\n<\/pre>\n
            This is an enum<\/span><\/b> with variables and a constructor. We cannot directly invoke the constructor. It is automatically called with the values specified at the time of declaring the constants. It is called when we try to create a variable of the enum<\/span><\/b> type. Have a look at the following program –<\/p>\n
            \nenum TShirtSizes {\n\n    \/\/ Constant(value associated)\n    S(36, 38), M(38, 40), L(40, 42), XL(42, 44);\n\n    \/\/ Values to be stored\n    final int START, END;\n    \n    \/\/ Constructor\n    private TShirtSizes(int START, int END) {\n        System.out.println("Enum's constructor");\n        this.START = START;\n        this.END = END;\n    }\n\n}\n\npublic class Enumerations {\n\n    public static void main(String[] args) {\n        System.out.println("main() begins...");\n        TShirtSizes shirt = TShirtSizes.L;\n        System.out.println(shirt);  \/\/ L\n        System.out.println(shirt.START + " - " \n                                       + shirt.END);\n        \/\/ Prints -> 40 - 42\n        \n        TShirtSizes shirt2 = TShirtSizes.M;\n        System.out.println(shirt2);  \/\/ M\n        System.out.println(shirt2.START + " - "\n                                        + shirt2.END);\n        \/\/ Prints -> 38 - 40\n        System.out.println("End of main()");\n    }\n\n}\n<\/pre>\n
            It gives the output –<\/p>\n
            main() begins...\nEnum's constructor\nEnum's constructor\nEnum's constructor\nEnum's constructor\nL\n40 - 42\nM\n38 - 40\nEnd of main()\n<\/pre>\n
            So the constructor is called as many times as the number of constants in the enum<\/span><\/b>, when we use it for the first time. If we don’t use it at all, then the constructor is never called.
            \nWe can also have non-static methods in a enum<\/span><\/b>, which can use this<\/span><\/b> reference to refer to the calling object.
            \nenum<\/span><\/b> has a static method called values() which returns an array of the enum<\/span><\/b> constants. This method can be called from the main method –<\/p>\n
            \npublic static void print() {\n    for (TShirtSizes shirt : TShirtSizes.values()) {\n        System.out.print(shirt);\n        System.out.print("(" + shirt.START);\n        System.out.print(" - " + shirt.END);\n        System.out.println(")");\n    }\n}\n<\/pre>\n
            So, we looked at enum<\/span><\/b> as a special class. Does this mean that we can extend an enum<\/span><\/b> to other classes..? No..! We cannot extend enum<\/span><\/b> to other classes..!<\/p>\n
            Summary<\/h3>\n
              \n
            • Syntax for declaring an enum<\/span><\/b> in Java –\n
              \nenum TShirtSizes {S, M, L, XL};\n<\/pre>\n<\/li>\n
            • We can’t declare an enum<\/span><\/b> locally, we must declare it outside the method.<\/li>\n
            • This is how we create a variable of enum<\/span><\/b> and assign a value to it –\n
              \nTShirtSizes myShirt = TShirtSizes.L;\n<\/pre>\n<\/li>\n
            • Functions are actually called “methods” in Java.<\/li>\n
            • Only static methods can be called from another static method. The main() method being static, can only call other static methods.<\/li>\n
            • Methods in Java have six components –\n
                \n
              1. Access Modifier<\/li>\n
              2. Return Type<\/li>\n
              3. Name<\/li>\n
              4. List of Parameters<\/li>\n
              5. List of Exceptions<\/li>\n
              6. Body of the Method<\/li>\n<\/ol>\n<\/li>\n
              7. Method signature is the name of the method + list of parameters. It does not include the return type.<\/li>\n
              8. Primitive Data Types are always passed by value.<\/li>\n
              9. Objects are passed through their object references, so, they produce a pass-by-reference effect.<\/li>\n
              10. What really decides if an object can be modified inside a method is whether the object is mutable or not.<\/li>\n
              11. enum<\/span><\/b>s are actually a special kind of classes in Java.<\/li>\n
              12. We can have constructors, non-static and static variables and methods in a enum<\/span><\/b>.<\/li>\n
              13. enum<\/span><\/b> has a static method which returns an array of enum<\/span><\/b> type variables which have all the enum’s declared constants.<\/li>\n
              14. We cannot extend an enum<\/span><\/b>.<\/li>\n<\/ul>\n
                This was what you needed to know about enum<\/span><\/b>s and methods in Java. I hope it helped you. If you have anything to ask about this topic, feel free to comment..! Keep practising..! Happy Coding..! \ud83d\ude00<\/p>\n","protected":false},"excerpt":{"rendered":"
                Hello people..! This is a new post in Java Tutorials – Enum and Methods in Java. In this post I will talk […]<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"jetpack_post_was_ever_published":false,"_jetpack_newsletter_access":"","_jetpack_dont_email_post_to_subs":false,"_jetpack_newsletter_tier_id":0,"_jetpack_memberships_contains_paywalled_content":false,"_jetpack_memberships_contains_paid_content":false,"footnotes":""},"categories":[9],"tags":[46,62,65,67,77,90,91],"class_list":["post-1425","post","type-post","status-publish","format-standard","hentry","category-java","tag-enums-in-java","tag-java","tag-java-programming-language","tag-java-tutorials","tag-methods-in-java","tag-passing-objects-in-java","tag-passing-variables-in-java"],"jetpack_sharing_enabled":true,"jetpack_featured_media_url":"","jetpack-related-posts":[],"_links":{"self":[{"href":"https:\/\/theoryofcoding.com\/index.php\/wp-json\/wp\/v2\/posts\/1425","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/theoryofcoding.com\/index.php\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/theoryofcoding.com\/index.php\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/theoryofcoding.com\/index.php\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/theoryofcoding.com\/index.php\/wp-json\/wp\/v2\/comments?post=1425"}],"version-history":[{"count":0,"href":"https:\/\/theoryofcoding.com\/index.php\/wp-json\/wp\/v2\/posts\/1425\/revisions"}],"wp:attachment":[{"href":"https:\/\/theoryofcoding.com\/index.php\/wp-json\/wp\/v2\/media?parent=1425"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/theoryofcoding.com\/index.php\/wp-json\/wp\/v2\/categories?post=1425"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/theoryofcoding.com\/index.php\/wp-json\/wp\/v2\/tags?post=1425"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}