http://www.hadoopexam.com/Oracle/Java1z0808/Oracle_java_1z0_808_programmer_8_developer_certification_exam_dumps.html

http://www.hadoopexam.com/Oracle/Java1z0808/Oracle_java_1z0_808_programmer_8_developer_certification_exam_dumps.html


PDF Link for this Training Module Download Here


-       JDK: Java Development Kit


-       JRE : Java Runtime Environment


-       Creating WorkSpace in eclipse.


-       Creating Projects in eclipse


-       Class: It is a building block of Java Programming


In class you describe all the parts and characteristics of one of those building blocks.


 


Sample Welcome Class


 


public class Welcome {

 

      public static void main(String[] args) {

            System.out.println("Welcome to HadoopExam Learning Resources : Core Java Training");

      }

}


 


 


Object: Most of the time, you will be creating objects from the class. An object is a runtime instance of a class in memory.


 


Fields and Methods: You will be having these two components in a Java class


 


-       Methods also known as functions e.g. totalProducts , operate on that state


-       Fields also known as variables. e.g. webSiteName , it shows the state of the program.


-       Keywords : public, class


 


public class Company {

 

      String webSiteName="www.HadoopExam.com";

 

      public int totalProducts() {

            System.out.println("We have 30 Products in total");

            return 30;

      }

}


 


 


-       Discuss return type.


-       Shows behaviors of public statement, using below class


 


public class Welcome {

 

      public static void main(String[] args) {

            System.out.println("Welcome to HadoopExam Learning Resources : Core Java Training");

           

            Company myCompany = new Company();

           

            System.out.println(myCompany.webSiteName + " has total " + myCompany.totalProducts() + " Products ");

           

      }

}

 


 


 


-       Create getter and setter methods in eclipse and use it in Welcome class.


public class Company {

 

   String webSiteName="www.HadoopExam.com";

 

   public String getWebSiteName() {

         return webSiteName;

   }

 

   public void setWebSiteName(String webSiteName) {

         this.webSiteName = webSiteName;

   }

 

   public int totalProducts() {

         return 30;

   }

  

   public void printInfo(){

         System.out.println("We have 30 Products in total");

   }

}


 


Method Signature:


public void setWebSiteName(String webSiteName)


 


Discuss about comments: (Watch Video)


Relation between Class and File: If you keen below code in a single file named Welcome.java then it is Ok.


Some Rule


-       At most one of the classes in the file is allowed to be public


-       If you do have a public class, it needs to match the file name


public class Welcome {

 

      public static void main(String[] args) {

            System.out.println("Welcome to HadoopExam Learning Resources : Core Java Training");

            Company myCompany = new Company();

            System.out.println(myCompany.webSiteName + " has total " + myCompany.totalProducts() + " Products ");

           

      }

}

 

class InnerCompany {

 

      String webSiteName="www.HadoopExam.com";

 

      public String getWebSiteName() {

            return webSiteName;

      }

 

}


 


About main() method : Entry Point for a Java Process


-       A Java program begins execution with its main() method


-       A main() method is the gateway between the startup of a Java process, which is managed by the Java Virtual Machine (JVM), and the beginning of the programmer’s code.


 


 


Run Code using Command Line


 


javac Welcome.java (Which will generate bytecode in file named Welcome.class)

java Welcome


 


-       Bytecode consists of instructions that the JVM knows how to execute.


 


Supply Arguments to Class and use it.


 


public class Welcome {

 

      public static void main(String[] args) {

            System.out.println("Welcome " + args[0] );

            System.out.println("Welcome " + args[1] );

            System.out.println("Welcome " + args[2] );

      }

}


 


 


 


 


 


-       Java comes with thousands of built-in classes


-       Packages: Java puts classes in packages. These are logical groupings for classes


-       Visit Random class source code in eclipse (Watch Video)


-       Import statements tell Java which packages to look in for classes


 


//import java.util.Random;

 

public class Welcome {

 

      public static void main(String[] args) {

            System.out.println(Integer.MAX_VALUE); //Imported by default

            Random randomValue = new Random(); //Require explicit import of package

            System.out.println(randomValue.nextInt(100));

      }

}

 


 


-       Put Company class in a package and use it in Welcome class.


import com.hadoopexam.Company;

public class Welcome {

   public static void main(String[] args) {

               System.out.println("Welcome to HadoopExam Learning Resources : Core Java Training");

               Company myCompany = new Company();

               System.out.println(myCompany.webSiteName + " has total " + myCompany.totalProducts() + " Products ");

   }

}


 


-       Wildcards: Classes in the same package are often imported together.


import com.hadoopexam.*;


 


-       Default package , which will be always imported


Import java.lang.*;


 


-       Redundant Imports : (Watch Video)


-       Wrong imports


import java.*;

NO GOOD – a wildcard only matches class names, not "lang.*Files"

import java.*.*;

NO GOOD – you can only have one wildcard and it must be at the end

import com.hadoopexam.Company.*;

NO GOOD – you cannot import methods only class names


 


-       Because of the package, class name should not be unique across all packages.


-       There are two classes with same name in different packages.


java.sql.Date

java.util.Date


 


-       Following code will give error.


   import com.hadoopexam.Company;

   import java.sql.Date;

   import java.util.Date;

 

   public class Welcome {

         public static void main(String[] args) {

                     System.out.println(new Date());

         }

   }


Valid Example


 


      import com.hadoopexam.Company;

      import java.sql.Date;

 

      public class Welcome {

            public static void main(String[] args) {

                        System.out.println(new Date(10000000));

                        System.out.println(new java.util.Date(10000000));

            }

      }


 


 


 Constructor:  It is a special type of Method.


-       Creating an instance of a Class


Company myCompany = new Comapny();


 


-       new Company is creating actual instance of a class


-       myCompany is a reference to newly created object.


package com.hadoopexam;

public class Company {

 

   public String webSiteName="www.HadoopExam.com";

 

   Company(){}       //Default Constructor

        

   public int totalProducts() {

         return 30;

   }

  

   public void printInfo(){

         System.out.println("We have 30 Products in total");

   }

}


 


-       Invalid definition of constructor


public void Company(){} //it is a another method.


 


-       Do nothing constructor is defined by a compiler itself.


-       The purpose of a constructor is to initialize fields, although you can put any code in there.


   import com.hadoopexam.Company;

  

   public class Welcome {

         public static void main(String[] args) {

         System.out.println("Welcome to HadoopExam Learning Resources : Core Java Training");

         Company myCompany = new Company();

         System.out.println(myCompany.webSiteName + " has total " + myCompany.totalProducts() + " Products ");

 

         Company anotherCompany = new Company("QuickTechie.com" , 19);

         System.out.println(anotherCompany.webSiteName + " has " + anotherCompany.totalProducts() + " Products ");

 

         }

   }

package com.hadoopexam;

public class Company {

      public String webSiteName;

      public int totalProducts;

 

      public Company(){

            webSiteName="www.HadoopExam.com";

            totalProducts=30;

      }    

     

      public Company(String name, int productCount){

            webSiteName=name;

            totalProducts=productCount;

      }

           

      public int totalProducts() {

            return totalProducts;

      }

     

      public void printInfo(){

            System.out.println("We have "+ totalProducts +" Products in total");

      }

}


Basic Rule of initialization.


-       Fields and instance initializer blocks are run in the order in which they appear in the file.


-       The constructor runs after all fields and instance initializer blocks have run.


-       Order matters for the fields and blocks of code. You can’t refer to a variable before it has been initialized


-        


 


public class Welcome {

      private String name = "HadoopExam.com";

      {

            System.out.println("It is the block 1 " + name);

      }

      {

            System.out.println("It is the block 2 " + (name = "Training4Exam.com"));

      }

      Welcome() {

            name = "QuickTechie.com";

      }

      public static void main(String[] args) {

            Welcome welcome = new Welcome();

            System.out.println(welcome.name);

      }

}


 


Module 5: Java applications contain two types of data: primitive types and reference types.


Primitive Types: Java has eight built-in data types, referred to as the Java primitive types.


Keyword

Type

 

Example

boolean

TRUE or FALSE

 

TRUE

byte

8-bit

integer

123

short

16-bit

integer

123

int

32-bit

integer

123

long

64-bit

integer

123

float

32-bit

floating-point

123.45f

double

64-bit

floating-point

123.456

char

16-bit

Unicode

'a'


-       A float requires the letter f following the number so Java knows it is a float.


-       byte, short, int, and long are used for numbers without decimal points.


-       Java allocates 32 bits if you write this: int value;


-       long max = 3333333333; // DOES NOT COMPILE


-       long max = 3333333333L; // DOES COMPILE


-       When a number is present in the code, it is called a literal


-       By default, Java assumes you are defining an int value with a literal


-       primitive types that hold their values in the memory where the variable is allocated


 


One more thing you need to know about numeric literals is a feature added in Java 7. You can have underscores in numbers to make them easier to read:


 


double notAtStart = _1000.00; // DOES NOT COMPILE

double notAtEnd = 1000.00_; // DOES NOT COMPILE

double notByDecimal = 1000_.00; // DOES NOT COMPILE

double annoyingButLegal = 1_00_0.0_0; // this one compiles


 


 


Reference Types:


 


-       A reference type refers to an object (an instance of a class).


-       References do not hold the value of the object they refer to.


-       Instead, a reference “points” to an object by storing the memory address where the object is located, a concept referred to as a pointer.


-       You can only use the reference to refer to the object.


 


Some important points


-       A reference can be assigned to another object of the same type.


-       A reference can be assigned to a new object using the new keyword.


 


public class Welcome {

      String name;

      Welcome(String siteName) {

            name = siteName;

      }

      public static void main(String[] args) {

            Welcome welcome = new Welcome("HadoopExam.com");

            welcome = new Welcome("QuickTechie.com");

            System.out.println(welcome.name);

      }

}


 


 


 


Please remember:


-       Reference types can be assigned null, which means they do not currently refer to an object.


int value = null; // DOES NOT COMPILE


String s = null;


-       Reference types can be used to call methods when they do not point to null.


-       Primitives do not have methods declared on them.


-       All the primitive types have lowercase type names.


-       All classes that come with Java begin with uppercase.


 


About Variables:


 


-       A variable is a name for a piece of memory that stores data. When you declare a variable, you need to state the variable type along with giving it a name.


 


public String webSiteName;

public int totalProducts;


 


-       Initializing variables


webSiteName="www.HadoopExam.com";

totalProducts=30;


 


-       Another way of declaring variables


String s1, s2;

String s3 = "Hadoop", s4 = "Exam";

String i1, i2, i3 = "HadoopExam.com";

int num, String name; // DOES NOT COMPILE


 


About identifiers: There are only three rules to remember for legal identifiers


 


-       The name must begin with a letter or the symbol $ or _.


-       Subsequent characters may also be numbers.


-       You cannot use the same name as a Java reserved word.


-       Some example of illegal identifiers


§  1Exam // identifiers cannot begin with a number


§  hadoop@exam // @ is not a letter, digit, $ or _


§  *$hadoop // * is not a letter, digit, $ or _


§  public // public is a reserved word


 


 


 


 


 


abstract

assert

boolean

break

byte

case

catch

char

class

const

continue

default

do

double

else

enum

extends

FALSE

final

finally

float

for

goto

if

implements

import

instanceof

int

interface

long

native

new

null

package

private

protected

public

return

short

static

strictfp

super

switch

synchronized

this

throw

throws

transient

TRUE

try

void

volatile

while

 

 


 


 


Variables Initialization: Before you can use a variable, it needs a value.


 


Local Variables:


 


-       A local variable is a variable defined within a method.


-       Local variables must be initialized before use.


-       The compiler will not let you read an uninitialized value.


-       Below code will not compile.


 


      public void doCalculation(){

            int i;

            int j;

           

            System.out.println( "Final Calculation": i + j);

      }


 


-       The compiler is smart enough to recognize variables that have been initialized after their declaration but before they are used.


 


Instance and Class Variables:


 


-       Variables that are not local variables are known as instance variables or class variables.


-       Instance variables are also called fields.


-       Class variables are shared across multiple objects.


-       You can tell a variable is a class variable because it has the keyword static before it.


-       Instance and class variables do not require you to initialize them.


-       As soon as you declare these variables, they are given a default value.


public class Welcome {

   String name;

   char ch;

   boolean b;

   byte by;

   short sh;

   int i;

   long ln;

   float fl;

   double db;

   {

         System.out.println("String value " + name);

         System.out.println("Char value " + ch); //'\u0000' (NUL)

         System.out.println("boolean value " + b);

         System.out.println("byte value " + by);

         System.out.println("short value " + sh);

         System.out.println("int value " + i);

         System.out.println("long value " + ln);

         System.out.println("float value " + fl);

         System.out.println("double value " + db);

   }

  

   Welcome(String siteName) {

         name = siteName;

   }

  

   public static void main(String[] args) {

         Welcome welcome = new Welcome("HadoopExam.com");

   }

}


 


 


Variable Scope:


 


    


public void greetMe(String name){ //method parameter

            String str= "Welcome";

      }


 


-       Both of these variables are said to have a scope local to the method.


-       This means they cannot be used outside the method.


-       Local variables can never have a scope larger than the method they are defined in. However, they can have a smaller scope.


 


      public void greetMe(String name){

            if(name!=null){

                  String str= "Welcome";

            }

            System.out.println(str + name); //str not available

      }


 


-       More about different types of variable


public class Welcome {

   static int HEIGHT = 130;  //Class Variable

   String name; //instance variable

  

   //local variable : name, myHeight, str,profstr

   public void greetMe(String name, int myHeight){

         if(myHeight < HEIGHT){

               String str= "Welcome Student " + name;

               System.out.println(str);

         }

         else{

               String profstr= "Welcome Professor " + name;

               System.out.println(profstr);

         }

   }

}


 


-       Local variables- in scope from declaration to end of block


-       Instance variables - in scope from declaration until object garbage collected


-       Class variables - in scope from declaration until program ends


 


Various statements order in a Java Class


 


Element

Example

Required?

Where does it go?

Package declaration

package com.hadoopexam;

No

First line in the file

Import statements

import java.util.*;

No

Immediately after the package
(Empty lines allowed before that)

Class declaration

public class Welcome

Yes

Immediately after the import
(Empty lines allowed before that)

Field declarations

String name="HadoopExam";

No

Anywhere inside a class

Method declarations

public void doCalculate()

No

Anywhere inside a class


 


-       A file is also allowed to have neither class be public. As long as there isn’t more than one public class in a file, it is okay.


 


 


Garbage Collection: Destroying Object (Cleaning memory area)


 


-       All java objects are stored in Java heap.


-       The heap may be quite large, depending on your environment, but there is always a limit to its size. If your program keeps instantiating objects and leaving them on the heap, eventually it will run out of memory.


-       Garbage collection refers to the process of automatically freeing memory on the heap by deleting objects that are no longer reachable in your program.


-       Sytem.gc() : (Just a suggestion to JVM) it is not guaranteed to run, and you should be able to recognize when objects become eligible for garbage collection.


-       An object is no longer reachable when one of two situations occurs:


o    The object no longer has any references pointing to it.


o    All references to the object have gone out of scope


 


-       Reference: A reference may or may not be created on the heap. All references are the same size, no matter what their data type is, and are accessed by their variable name.


-       Object: Objects are always on the heap. They have no name and can only be accessed via a reference. Objects vary in size depending on their class definition.


-       Draw object reference diagram for below code.


   public static void main(String[] args) {

         String first, second;

         first = new String("HadoopExam");

         second = new String("QuickTechie");

         first = second;

         String three = first;

         first = null;

   }


 


finalize() method :


 


-       finalize() is only run when the object is eligible for garbage collection.


-       Java allows objects to implement a method called finalize() that might get called.


-       This method gets called if the garbage collector tries to collect the object.


-       If the garbage collector doesn’t run, the method doesn’t get called.


-       If the garbage collector fails to collect the object and tries to run it again later, the method doesn’t get called a second time.


-       you are highly unlikely to use it in real projects.


-       finalize() call could run zero or one time.


 


Java is Secure :


-       Java code runs inside the JVM. This creates a sandbox that makes it hard for Java code to do evil things to the computer it is running on.

http://www.hadoopexam.com/Oracle/Java1z0808/Oracle_java_1z0_808_programmer_8_developer_certification_exam_dumps.html




Ċ
Module3_CoreJavaTraining_1z0_808.pdf
(756k)
Training4Exam Info,
Nov 17, 2016, 11:25 AM
v.1