Modifier

     MODIFIER

    · Modifier

    · private/ default/ protected/ public

    · Non modifier

    · final/ static/ abstract

    · transient/ volatile/ native/ synchronized



    I. Class Modifier

    •  A class (A) can access to other class (B) :
    • Create a new object of class B
    •  Extend class B
    • Access to method/ property in class B

    Default Access

    • Do not use public keyword when create a new class.
    • Can be accessed by other classes in same package
    • Can not be accessed by other class if not in same package

    · 

    Public Access

    •  Use public keyword when create a new class
    •  Allow all class from other packages access and create new object


    Final Class

    • Can not be extended
    •  Other class can access via create new object

    Abstract Class

    • Do not allow initialize an object if it's abstract class
    • Can be used via extend

    II. Method/ Property Modifier




    Data Types in Java

       

          Data Types in Java

      There are 2 different types in java. They are shown below. You don't need to remember detail, just simplify know that. Then code as much as you can ^_^

      I. Primitive data types



      II. Non-primitive data types







      Variables in Java

         

        Variables in Java




        I. What is variable in Java?

        A variable is nothing but a name given to a storage area that our programs can manipulate..Each variable has a specific type. Data type determines size and layout of the variable's memory

        II. Declaring a variable

        type variable_name = value;
        Ex: 
        int a, b, c;
        int d = 35, e, f = 55;
        byte z = 22; // initializes z.
        double pi = 3.14159; // declares an approximation of pi.
        char x = 'x'; // the variable x has the value 'x'.
        String name = "Your name";\

        III. Type of variables

        1. Local Variables
        .A variable declared inside the body of the method is called local variable. You can use this variable only within that method and the other methods in the class do not know that the variable exists.

        A local variable cannot be defined with "static" keyword.




        public class LocalVariableExample {
            public int sum(int n) {
                int sum = 0;
                for (int i = 0; i < n; i++) {
                    sum = sum + i;
                }
                return sum;
            }
        
            public static void main(String[] args) {
                LocalVariableExample localVariableExample = new LocalVariableExample();
                int sum = localVariableExample.sum(10);
                System.out.println("Sum of first 10 numbers -> " + sum);
            }
        }

        Output:
        Sum of first 10 numbers -> 45
         2. Instance Variables (Non-Static Fields)
        - Declared in class but outside methods, constructor or block code

        - Be created when an object is created. Then this variable is destroyed when that object is destroyed

        – có thể được khai báo trong lớp trước hoặc sau khi sử dụng nó.

        –  Use access modifier for instance variables. If we do not specify any access specifier, then the default access modifier will be used.

        – thông thường thì local variable sẽ visible với tất cả các method, constructor và block trong class.

        – Have Initialization  value . number is 0, boolean is false, object is null.

        public class InstanceVariableExample {
            public static void main(String[] args) {
                Employee employee = new Employee();
        
                // Before assigning values to employee object
                System.out.println(employee.empName);
                System.out.println(employee.id);
                System.out.println(employee.age);
        
                employee.empName = "Ramesh";
                employee.id = 100;
                employee.age = 28;
        
                // After assigning values to employee object
                System.out.println(employee.empName);
                System.out.println(employee.id);
                System.out.println(employee.age);
            }
        
        }
        
        class Employee {
        
            // instance variable employee id
            public int id;
        
            // instance variable employee name
            public String empName;
        
            // instance variable employee age
            public int age;
        }
        Output:
        null
        0
        0
        Ramesh
        100
        28

        3. Static variable
        A variable that is declared as static is called a static variable

        class Student {
            private int rollNo;
            private String name;
            private static String college = "ABC"; // static variable
            public Student(int rollNo, String name) {
                super();
                this.rollNo = rollNo;
                this.name = name;
            }
            @Override
            public String toString() {
                return "Student [rollNo=" + rollNo + ", name=" + name + ", college=" + college + "]";
            }
        }


        JAVA FOR BEGINNER

                 JAVA FOR BEGINNER


          I. GETTING STARTED

          1. Variable in java

          2. Data type in Java

          3. Modifiers

          4. Arithmetic Operators

          5. If Statement

          6. Switch case statement




          TEST CASES FOR SEARCH FIELD

           

          TEST CASES FOR SEARCH FIELD

            A search field is the common field of any website. Hope below some test cases are helpful for you !

          1.   Check the name of search field is correct

          2.   Check whether the the search field can be clicked or not.

          3.   Check whether it is able to type or enter in the search field or not.

          4.   Check placeholder is added to the search field.

          5.   Check the cursor appears after clicking the search icon.

          6.   Check that when the user pastes or copy in the search field.

          7.   Check that when the user can type any alphanumeric, special characters in the search field.

          8.   Check the search function return correct results for the valid keywords.

          9.   Enter any one character in the search field and click on the Search button/press Enter key.

          10.   Enter string more than the max length in search field.

          11.   Enter a string in the search field with spaces (before the string, after the string, and in between) and verify the results.

          12.   Without entering character in the search field then click on the Search button.

          13.   Click in the search field and press Enter key.

          14.   Check the time systems return search results.

          15.   Check the search results are in the correct order as requirement.

          16.   Check if suggestions are shown when adding keywords to the search field.

          17.   Try to drag and drop images, videos or another file in the search field and check the result

          Keyword in Java


          Java Keywords

          Java keywords are also known as reserved words. Keywords are particular words that act as a key to a code. These are predefined words by Java so they cannot be used as a variable or object name or class name.

          List of Java Keywords

          A list of Java keywords or reserved words are given below:

          1. abstract: Java abstract keyword is used to declare an abstract class. An abstract class can provide the implementation of the interface. It can have abstract and non-abstract methods.
            public abstract class Helloworld

            You can use it to defining a method to make it abstract.

            public abstract void doStuff();
          2. boolean: Java boolean keyword is used to declare a variable as a boolean type. It can hold True and False values only.
            boolean flag = true
          3. break: Java break keyword is used to break the loop or switch statement. It breaks the current flow of the program at specified conditions.
          4. byte: Java byte keyword is used to declare a variable that can hold 8-bit data values.
            byte no = 3;
          5. case: Java case keyword is used with the switch statements to mark blocks of text.
            switch (key) {
                case value:
                    break;
                default:
                    break;
            }
          6. catch: Java catch keyword is used to catch the exceptions generated by try statements. It must be used after the try block only.
            try {
                    // Do some stuff
                } catch (Exception e) {
                    // handle exception
                }
          7. char: Java char keyword is used to declare a variable that can hold unsigned 16-bit Unicode characters
            char x = 'x';
          8. class: Java class keyword is used to declare a class.
            class Helloworld
          9. continue: Java continue keyword is used to continue the loop. It continues the current flow of the program and skips the remaining code at the specified condition.
            public void doStuff() {
                for (int i = 1; i < 10; i++) {
                    if (i == 2) {
                        continue;
                        // The control will go back and never reach this line.
                        // a = i;
                    }
                }
            }
          10. default: Java default keyword is used to specify the default block of code in a switch statement.
            switch (key) {
                case value:
                    break;
                default:
                    break;
            }
          11. do: Java do keyword is used in the control statement to declare a loop. It can iterate a part of the program several times.
            do {
                    // do stuffs
                } while (condition);
          12. double: Java double keyword is used to declare a variable that can hold 64-bit floating-point number.
            double price = 5.67;
          13. else: Java else keyword is used to indicate the alternative branches in an if statement.
            if(condition){
                   // Do some stuff
               }else{
                   // else throw some exception
                   throw new Exception();
               }
          14. enum: Java enum keyword is used to define a fixed set of constants. Enum constructors are always private or default.
            public enum Helloworld
          15. extends: Java extends keyword is used to indicate that a class is derived from another class or interface.
            public class Helloworld extends SuperHelloworld
          16. final: Java final keyword is used to indicate that a variable holds a constant value. It is used with a variable. It is used to restrict the user from updating the value of the variable.
            final String name = "RAM";
            
                public final class HelloWorld
            
                public final void doStuff()
          17. finally: Java finally keyword indicates a block of code in a try-catch structure. This block is always executed whether an exception is handled or not.
            try {
                    // Do some stuff
                } catch (Exception e) {
                    // handle exception
                }finally{
                    // So the stuff that has to be executed at any conditions
                }
          18. float: Java float keyword is used to declare a variable that can hold a 32-bit floating-point number.
            float price = 5;
          19. for: Java for keyword is used to start a for loop. It is used to execute a set of instructions/functions repeatedly when some condition becomes true. If the number of iteration is fixed, it is recommended to use for loop.
            for (int i = 0; i < array.length; i++) {
                    // do some stuff
                }
          20. if: Java if keyword tests the condition. It executes the if block if the condition is true.
            if(condition){
                   // Do some stuff
               }else{
                   // else throw some exception
                   throw new Exception();
               }
          21. implements: Java implements keyword is used to implement an interface.
            public abstract class Helloworld implements IHelloworld
          22. import: Java import keyword makes classes and interfaces available and accessible to the current source code.
            import java.util.*;
          23. instanceof: Java instanceof keyword is used to test whether the object is an instance of the specified class or implements an interface.
            Integer value;
                protected void doStuff() {
                    if(value instanceof Integer){
                        // do some stuff
                    }
                }
          24. int: Java int keyword is used to declare a variable that can hold a 32-bit signed integer.
            private int age = 25;
          25. interface: Java interface keyword is used to declare an interface. It can have only abstract methods.
            public interface IHelloworld
          26. long: Java long keyword is used to declare a variable that can hold a 64-bit integer.
            long price = 5;
          27. native: Java native keyword is used to specify that a method is implemented in native code using JNI (Java Native Interface).
          28. new: Java new keyword is used to create new objects.
            Helloworld obj = new Helloworld();
          29. null: Java null keyword is used to indicate that a reference does not refer to anything. It removes the garbage value.
            private String name = null;
          30. package: Java package keyword is used to declare a Java package that includes the classes.
            package com.java.connect;
          31. private: Java private keyword is an access modifier. It is used to indicate that a method or variable may be accessed only in the class in which it is declared.
            private void doStuff()
          32. protected: Java protected keyword is an access modifier. It can be accessible within the package and outside the package but through inheritance only. It can't be applied with the class.
            protected void doStuff()
          33. public: Java public keyword is an access modifier. It is used to indicate that an item is accessible anywhere. It has the widest scope among all other modifiers.
            public int add(){	return 5 + 4;}
          34. return: Java return keyword is used to return from a method when its execution is complete.
            public int add(){	return 5 + 4;}
          35. short: Java short keyword is used to declare a variable that can hold a 16-bit integer.
            short price = 5;
          36. static: Java static keyword is used to indicate that a variable or method is a class method. The static keyword in Java is mainly used for memory management.
            private static int age = 25;
            
            static{
                // do some stuff which will be loaded when class loaded in memory
            }
            
            public static int add(){
                return 5 + 4;
            }
          37. super: Java super keyword is a reference variable that is used to refer to parent class objects. It can be used to invoke the immediate parent class method.
            super.doStuff();
          38. switch: The Java switch keyword contains a switch statement that executes code based on test value. The switch statement tests the equality of a variable against multiple values.
            switch (key) {
                case value:
                    break;
                default:
                    break;
            }
          39. synchronized: Java synchronized keyword is used to specify the critical sections or methods in multithreaded code.
            synchronized (value) {
                   // do some stuff
               }
          40. this: Java this keyword can be used to refer the current object in a method or constructor.
            this.doStuff();
          41. throw: The Java throw keyword is used to explicitly throw an exception. The throw keyword is mainly used to throw custom exceptions. It is followed by an instance.
            if(condition){
                   // Do some stuff
               }else{
                   // else throw some exception
                   throw new Exception();
               }
          42. throws: The Java throws keyword is used to declare an exception. Checked exceptions can be propagated with throws.
            public void doStuff() throws Exception{
                    // Do some stuff
                }
          43. transient: Java transient keyword is used in serialization. If you define any data member as transient, it will not be serialized.
            transient int value;
          44. try: Java try keyword is used to start a block of code that will be tested for exceptions. The try block must be followed by either catch or finally block.
            try {
                    // Do some stuff
                } catch (Exception e) {
                    // handle exception
                }finally{
                    // So the stuff that has to be executed at any conditions
                }
          45. void: Java void keyword is used to specify that a method does not have a return value.
            public void doStuff() throws Exception{
                    // Do some stuff
                }
          46. volatile: Java volatile keyword is used to indicate that a variable may change asynchronously.
            volatile int value;
          47. while: Java while keyword is used to start a while loop. This loop iterates a part of the program several times. If the number of iteration is not fixed, it is recommended to use the while loop.
            while (condition) {
                    // do stuffs
                    }