• We can read java file using buffered reader class in java
• We need to import java.io.BufferedReader in order to read java text file.
• Create object of java.io.BufferedReader class by passing new FileReader("C:\\Sample.txt") object to the constructor.
• In order to read line by line call readLine() method of BufferedReader class which returns current line. Initially first line of java text file

• Yes we can define a constructor in abstract class in java.


• Then next question will come like when we can not create object of abstract class then why to define constructor for abstract class.
• It is not possible to create object of abstract class directly but we can create object of abstract class from sub class which is actually extending abstract class.
• When we define a abstract class a class must extend that abstract class then only there will be use of that class
• Then when we create object of class which extends abstract class constructor of sub class will be called from that abstract class constructor will be called and memory will be created for all non static members.
• If we are not defining any constructor default constructor will be executed.
• So we can define any number of constructor in abstract class.
• And it is recommended to define constructor as protected. Because there is only one scenario which we can create object is from subclass so define abstract class constructor as protected always.

•  When we  create object of  class which is extending abstract class then it will call abstract class constructor through sub class constructor.
• Lest see a java example program on abstract class constructor in java

• Yes we can define parameterized constructor in abstract class.
• But we need to make sure that the class which is extending abstract class have a constructor and it should call super class parameterized constructor
• We can call super class parameterized constructor in sub class by using super() call
• For example: Super(2) ;
• What will happen if we are not placing super call in sub class constructor?
• Compiler time error will come.

• In java we can generate random number in two ways 
• By using Random class
• By using Math.random

• First we need to create object of java.util.Random class.
• After creating object of java.util.Random class then we need call nextInt() method by passing range
• int range = maximum - minimum + 1;
• int randomNum =  rn.nextInt(range) + minimum;

• By using Math.random() method also we can generate random number in java
• int randomNum = minimum + (int)(Math.random() * maximum);

• lets see how to generate unique random numbers in java
• By using Collections.shuffle();

• In HTML if we want to apply any styles to any elements we will use cascading style sheets.
• By using CSS we can apply styles to an element in HTML
• If some style is needed for more than one type of element then we cant make a style and name it and where ever that style is required we can place that style for that element.


• So like this it is always possible to apply multiple styles or multiple classes to HTML elements.
• We can specify more than one CSS class to an element.
• By using class attribute we can specify multiple  CSS classes to a single element and all classes must be separated by a space.
• For example if we are applying multiple classes to a div tag.
• <div class="class1 class2"></div>
• Here class is the attribute and class1 and class2 are the two different CSS classes.
• Lets take an example of one paragraph element and two css classes 
• Fist we define a <p> element with no styles.
• Second one more <p> element with one style
• Third one more <p> element with two styles.  
• HTML multiple classes

#1: Html example file to show how to assign multiple CSS classes to an HTML element :

• Design patterns are solutions to software design problems.
• Design patterns classified into three types.
• Creational, Structural and behavioral design patterns.


• Creational patterns helps us to create objects in a manner suitable to the given situation.
• Builder design pattern is one of the creational  design pattern in java.
• Builder  design pattern helps us to create complex class object.
• Builder design pattern helps us to separate the construction process of a complex object from its representation so that same object construction process can be created in different representations.
• Means it will separate complex construction into two parts  initialization of class instance and return  class instance.
• When a class having more number of fields and constructor of that class take care of assigning initial values. 
• And when we want to create object of the class we need to pass all  parameters and should be in same order which constructor is accepting.
• Builder design pattern helps us to create same class object by passing required number of fields by using separate builder class object.
• Builder design pattern is useful when object creation is very complex.

• Builder design pattern simplifies complex object creation.
• Builder design pattern provides separation between instance creation and representation
• Re usability

• To create object of employee class  we need to provide all the fields values to the constructor.
• So it is somewhat difficult to pass all values all times.
• Employee builder class taken all variables of Employee and in setter methods accepts a value and returns EmployeBuilder object.
• And EmployeBuilder class has build method which will  assign all values to employee and returns Employee object.
• Employee empobj= new EmployeeBuilder().setName("Saidesh").setId(1234).build();
• Now we create object of Employee class by creating EmployeBuilder class object and caling calling setter methods whatever we have.
• Is is very easy to set the values because we have corresponding setter method name is same as variable name.
• After setting the values we need  to call build method so that it will return employee object with values.

• Static methods are class level so there are not part of object.
• So we can not override static methods but we can call super class static method using subclass name or instance also.
• If we are trying to override static methods in sub class from super class then it will be method hiding not method overriding.


• Means whenever we call the static method on super class will call super class static method and if we are calling method using sub class it will call sub class method.
• So it is clear that static methods are hidden not overridden and they are part of class means class level not object level.
• Now the question is can a method be static and final together?
• For non static methods if we declare it as final then we are preventing that method from overriding so it can not be overridden in sub class.
• When we declare static method as final its prevents from method hiding.
• When we declare final static method and override in sub class then compiler shows an error
• Compile time error: Cannot override the final method from Super
• Lets see an example program to understand this better.

• When we override static methods its not overriding it is method hiding and whenever we call method on class name it will call corresponding class method.
• If we call methods using objects it will call same methods.

• We can call super class static methods using sub class object or sub class name also.
• Now lets see what will happen in final static methods

• Can a method be static and final together in java?
• When we declare a method as final we can not override that method in sub class.
• In the same way when we declare a static method as final we can not hide it in sub class means we can not create same method in sub class. 
• If we try to create same static method in sub class compiler will throw an error.
• Lets see a java example program on final static methods in inheritance.