Using Built-in Java Classes

Expected duration: 120 minutes

Exercise 1: Create an object instance of a class using "new" keyword

In this exercise, you will exercise the concept object instance creation using "new" keyword.  You will learn how you are going to create your own classes and object instances later. 

1. Create String object instances using "new" keyword
2. Create Integer object instances using "new" keyword

(1.1) Create String object instances using "new" keyword

0. Start the NetBeans IDE if you have not done so.
1. Create a NetBeans project

• Select File from top-level menu and select New Project.
• Observe that the New Project dialog box appears.
• Select General under Categories section and Java Application under Projects section.
• Click Next.
• Under Name and Location pane, for the Project Name field, enter MyClassAndObjectProject.
• For the Create Main Class field, enter ClassAndObject.  (Figure-1.10 below)
• Click Finish.

Figure-1.10: Create a new project

• Observe that the MyClassAndObjectProject project node is created under Projects pane of the NetBeans IDE and IDE generated ClassAndObject.java is displayed in the editor window of the IDE.

2. Modify the IDE generated ClassAndObject.java as shown in Code-1.11. Study the code while paying special attention to the bold-fonted comments.

(1.2)  Create Integer object instances using "new" keyword

Summary

In this exercise, you have learned how to create an object instance of built-in classes such as String and Integer by using new keyword.
   
                                                                                                                                   Return to the top

Exercise 2: Static method and instance (non-static) methods

In this exercise, you will learn how to invoke static and non-static (instance) methods of a class.  Please note that a static method of a class is called in the following form:

(2.1) Use static and non-static (instance) methods

1. Create a NetBeans project

• Select File from top-level menu and select New Project.
• Observe that the New Project dialog box appears.
• Select General under Categories section and Java Application under Projects section.
• Click Next.
• Under Name and Location pane, for the Project Name field, enter MyStaticAndInstanceMethodsProject.
• For the Create Main Class field, enter StaticAndInstanceMethods.  (Figure-1.10 below)
• Click Finish.

• Observe that the MyStaticAndInstanceMethodsProject project node is created under Projects pane of the NetBeans IDE and IDE generated StaticAndInstanceMethods.java is displayed in the editor window of the IDE.

2. Modify the IDE generated StaticAndInstanceMethods.java as shown in Code-2.11. Study the code by special attention to the bold-fonted comments.

public class StaticAndInstanceMethods {         public static void main(String[] args) {         // Create two instances of String class         String strInstance1 = new String("I am object instance of a String class");         String strInstance2 = "Live your passion!";                 // Invoke an instance method charAt() through an object instance of String class         char x = strInstance1.charAt(2);         char y = strInstance2.charAt(1);         char z = strInstance2.charAt(0);                 System.out.println("The 3rd char of strInstance1 = " + x);         System.out.println("The 2nd char of strInstance2 = " + y);         System.out.println("The 1st char of strInstance2 = " + z);                 // Invoke an instance method equalsIgnoreCase(..) method         boolean b = strInstance1.equalsIgnoreCase(strInstance2);         String strInstance3 = b? "Yes":"No";         System.out.println("Do strInstance1 and strInstance2 have same string ignoring case?  " + strInstance3);                 // Invoke a static-method, valueOf (int i), of the String class         int i = 23;         String strInstance4 = String.valueOf(i);         System.out.println("value of strInstance4 = " + strInstance4);                 // You already have used parseInt() static method of the Integer class in         // previous exercises.         String strInstance5 = new String("34"); // Create an object instance of String class         int ii = Integer.parseInt(strInstance5);         System.out.println("value of ii = " + ii);     }     }

Code-2.11: StaticAndInstanceMethods.java

3. Build and run the program

• Right click MyStaticAndInstanceMethodsProject and select Run.
• Observe the result in the Output window of the NetBeans IDE. (Figure-2.12 below)

The 3rd char of strInstance1 = a The 2nd char of strInstance2 = i The 1st char of strInstance2 = L Do strInstance1 and strInstance2 have same string ignoring case?  No value of strInstance4 = 23 value of ii = 34

Figure-2.12: Result of running the application

4. Modify StaticAndInstanceMethods.java as shown in Code-2.13.  The code fragments that need to be added are highlighted in bold and blue-colored font. The new code added is expected to generate a compile error.

public class StaticAndInstanceMethods {         public static void main(String[] args) {                 // Create two instances of String class         String strInstance1 = new String("I am object instance of a String class");         String strInstance2 = "Live your passion!";                 // Invoke an instance method charAt() through an object instance of String class         char x = strInstance1.charAt(2);         char y = strInstance2.charAt(1);         char z = strInstance2.charAt(0);                 System.out.println("The 3rd char of strInstance1 = " + x);         System.out.println("The 2nd char of strInstance2 = " + y);         System.out.println("The 1st char of strInstance2 = " + z);                 // Invoke an instance method equalsIgnoreCase(..) method         boolean b = strInstance1.equalsIgnoreCase(strInstance2);         String strInstance3 = b? "Yes":"No";         System.out.println("Do strInstance1 and strInstance2 have same string ignoring case?  " + strInstance3);                 // Invoke a static-method, valueOf (int i), of the String class         int i = 23;         String strInstance4 = String.valueOf(i);         System.out.println("value of strInstance4 = " + strInstance4);                 // You already have used parseInt() static method of the Integer class in         // previous exercises.         String strInstance5 = new String("34"); // Create an object instance of String class         int ii = Integer.parseInt(strInstance5);         System.out.println("value of ii = " + ii);                 // The following code will generate a compile error since you are trying to         // invoke a instance method through a class.   Fix this compile error.         char f = String.charAt(2);             }     }

Code-2.13: Code that generates compile error.

5. Observe that the NetBeans shows the syntax error as shown in Figure-2.14 below.  Take note "non-static method charAt(int) cannot be referenced from a static context" hint message.


Figure-2.14: Compile error is detected.

6. Take a look at the Javadoc of the charAt() method of the String class to verify that charAt() method is indeed a non-static (instance) method.

• Move your cursor over the charAt() method and right click it and select Show Javadoc. (Figure-2.15 below)
  

Figure-2.15: Display JavaDoc of the String

• Observe that the Javadoc of the charAt() method of the String class gets displayed in the default browser. (Figure-2.16 below)
• Verify that it is not a static method.  (If it were, it should have a static modifier.)
  

Figure-2.16: Javadoc of the charAt() method.

7. (For your own exercise) Identify which bold-fonted methods of the Code-2.17 below are static methods and which ones are non-static methods.

// endsWith() method         String str = "Hello";            System.out.println( str.endsWith( "slo" ) );         // forDIgit() method         System.out.println( Character.forDigit(13, 16) );         // floor() method         System.out.println( Math.floor(3.14));         // isDigit() method         System.out.println( "0=" + Character.isDigit('0'));         System.out.println( "A=" +Character.isDigit('A'));

Code-2.17: Identify which methods are static methods and which methods are non-static methods

Solution: The solution to this exercise is provided as a ready-to-open-and-run NetBeans project as part of hands-on lab zip file. You can find it as <LAB_UNZIPPED_DIRECTORY>/javabuiltinclasses/samples/MyStaticAndInstanceMethodsProject.  You can just open it and run it.

                                                                                                                        return to top of the exercise

Summary

In this exercise,  you have built and run a Java application using NetBeans IDE.

                                                                                                                        return to the top

Exercise 3: Pass by value & Pass by reference parameter passing

In this exercise, you will exercise the concept of pass by value.  Please note that primitive type parameters are passed by value while reference type parameters are passed by reference.   An array is considered a reference type even though the entries it contains are primitive type.

1. Parameter passing via Pass by value
   
2. Parameter passing via Pass by reference
   

(3.1) Parameter passing via Pass by value

1. Create a NetBeans project

3. Build and run the program

(3.2) Parameter passing via Pass by reference

1. Create a NetBeans project

3. Build and run the program

Exercise 4: Scope of Variables

In this exercise, you will exercise the concept scope variable.  You will also learn how to declare three types of variables, static variable, instance variable, and local variable.

1. Build and run a Java program that excercises a scope of a variable
2. Write a Java program that uses all three types of variables
   

(4.1) Build and run a Java program that exercises a scope of a variable

1. Create a NetBeans project

public class ScopeOfVariable {         public static void main(String[] args) {                 int var1 = 10;                 if (var1 < 100){             int var2 = 20;         } else {             int var2 = 21;         }                 // Access to var1 is allowed so no compile error.         System.out.println("value of var1 = " + var1);                 // Access to var2 is not allowed so compile error will be generated         System.out.println("value of var2 = " + var2);     }     }

Code-4.11: Modified ScopeOfVariable.java

3. Observe that there is a compile error. (Figure-4.12 below)  This is expected because you are accessing the var2 variable scope is only within the closest { } and cannot be used outside of that scope.


Figure-4.12: Observe scope problem

4. Modify the ScopeOfVariable.java as shown in Code-5.13 below.  The code fragments that need to be removed (commented out here) are highlighted in bold and red-colored font while the code fragments that need to be added are highlighted in bold and red-colored font.

public class ScopeOfVariable {         public static void main(String[] args) {                 int var1 = 10;         // var2 is now defined in an outer scope         int var2 = 15;                 if (var1 < 100){             //int var2 = 20;             var2 = 20;         } else {             //int var2 = 21;             var2 = 21;         }                 // Access to var1 is allowed so no compile error.         System.out.println("value of var1 = " + var1);                 // Access to var2 is now allowed         System.out.println("value of var2 = " + var2);     }     }

Code-4.13: Modified ScopeOfVariable.java with correct scoping

5. Build and run the program

(4.2) Write a Java program that declares three types of variables

In this step, you are going to declare the three types of variables, static variable, instance variable, and local variable.  (I acknowlege that this is not probably the best example to show how these variables are used.  We will try different exercise when we learn how to create your own class and the concept of a package.)

1. Create a NetBeans project

2. Modify the IDE generated ThreeVariablesTypes.java as shown in Code-4.21 below. Study the code by special attention to the bold-fonted comments.

public class ThreeVariablesTypes {         // Example of static variable     static String myStaticVariable = "static variable";         // Example of instance variable     String myInstanceVariable = "instance variable";         /** Creates a new instance of ThreeVariablesTypes */     public ThreeVariablesTypes() {     }         /**      * @param args the command line arguments      */     public static void main(String[] args) {         String myLocalVariable = "local variable";         System.out.println("myStaticVariable = " + myStaticVariable);         System.out.println("myInstanceVariable = " + myInstanceVariable);         System.out.println("myLocalVariable = " + myLocalVariable);     }     }

Code-4.20: ThreeVariablesTypes.java

3. Observe that instance variable cannot be referenced from a static context - the main() method is a static method.  (Figure-4.21 below)


Figure-4.21: Three types of variables

4. Comment out the offending line and build and run the project.

Solution: The solution to this exercise is provided as  ready-to-open-and-run NetBeans project as part of hands-on lab zip file. You can find it as  <LAB_UNZIPPED_DIRECTORY>/javabuiltinclasses/samples/MyThreeVaraibleTypesProject.  You can just open it and run it.

                                                                                                                        return to top of the exercise

Exercise 5: Type casting of primitive types and Wrapper

In this exercise, you will exercise casting of primitive types and how to convert primitives to corresponding Wrapper classes and vice versa. Typeing of reference types will be exercises in other hands-on lab.

1. Casting primitive types
2. Converting primitives to Wrapper class objects and vice-versa
   

(5.1) Casting primitive types

1. Create a NetBeans project

3. Build and run the program

(5.2) Converting primitives to Wrapper class objects and vice-versa

1. Open a NetBeans project

3. Build and run the program

Exercise 6: Comparing objects

In this exercise, you will exercise the concept of comparing objects (object instances) using String class as an example. 

1. Build and run a Java program that compares objects
   

(6.1) Build and run a Java program that compares objects

1. Create a NetBeans project

3. Build and run the program

Exercise 7: getClass() method & instanceOf operator

In this exercise, you will use getClass() method of the Object class to find out the class of the an object instance.  You will also learn how to use instanceOf operator to find out if a particular object instance is a particular class type.

1. Use getClass() method
2. Use instanceof operator
   

(7.1) Build and run a Java program that compares objects

1. Create a NetBeans project

3. Build and run the program

(7.2) Use "instanceof" operator

1. Create a NetBeans project

public class instanceofOperator {         public static void main(String[] args) {                 // Create String object instance         String str1 = "Life is worth living... with Passion!";         Integer int1 = new Integer(40);                 // Check if str1 is String type using instanceof operator.         // Check also if it is Object type.         boolean b1 = str1 instanceof String;         System.out.println("str1 is String type: " + b1);         boolean b2 = str1 instanceof Object;         System.out.println("str1 is Object type: " + b2);                 // Check if int1 is Integer type using instanceof operator.         // Check also if it is Object type.         b1 = int1 instanceof Integer;         System.out.println("int1 is Integer type: " + b1);         b2 = int1 instanceof Object;         System.out.println("int1 is Object type: " + b2);         b2 = int1 instanceof Number;         System.out.println("int1 is Number type: " + b2);             } }

Code-7.21: instanceofOperator.java

3. Take a look the Javadoc of the Integer class.

• Move your cursor on the Integer (in the editor window of the NetBeans) and select Show Javadoc. (Figure-7.22 below)
  

Figure-7.22: Show Javadoc of the Integer class

• Observe that Integer class has parent class called java.lang.Number, which in turn has a parent class called java.lang.Object. (Figure-7.23 below)  This is why the testing of int1 instanceof Number returns true.
  

Figure-7.23: Javadoc of Integer class

3. Build and run the program

Homework exercise (for people who are taking Sang Shin's "Java Programming online course")

• Receive the first names of your family members (between 3 to 6 members of your family) as command line arguments and create an array of String.
  
• Write a static method called generateNewName() as following:
  
• It receives the array of String as a parameter.
• It creates a new first name by taking the 2nd character of each String from the array
• Display the names that were enetered and newly generated name
  

• Zip file of the the MyOwnBuiltinClassesProject NetBeans project.  (Someone else should be able to open and run it as a NetBeans project.)  You can use your favorite zip utility or you can use "jar" utility that comes with JDK as following.
  
• cd <parent directory that contains MyOwnBuiltinClassesProject directory> (assuming you named your project as MyOwnBuiltinClassesProject)
  
• jar cvf MyOwnBuiltinClassesProject.zip MyOwnBuiltinClassesProject (MyOwnBuiltinClassesProject should contain nbproject directory)
• Captured output screen  - name it as JavaIntro-javabuiltinclasses.gif orJavaIntro-javabuiltinclasses.jpg (or JavaIntro-javabuiltinclasses.<whatver graphics format>)
• Any screen capture that shows that your program is working is good enough.  No cosmetic polishment is required.
• If you decide to use different IDE other than NetBeans, the zip file should contain all the files that are needed for rebuilding the project.