Java Constructor don't have return type:

Constructor never return in Java and if you see the constructor have return type, so it's not a constructor it's a method with the same name of class...
class Bird {
public String Bird() {
return ("I am bird");
}
public static void main (String args[]){
Bird b - new Bird(); // object creation and assign the Reference to variable
b.Bird(); // now the function call
}

Good use of static, constructor and init blocks

class Bird {
{
System.out.print("b1 ");
}

public Bird() {
System.out.print("b2 ");
}
}

class Raptor extends Bird {
static {
System.out.print("r1 ");
}

public Raptor() {
System.out.print("r2 ");
}

{
System.out.print("r3 ");
}
static {
System.out.print("r4 ");
}
}

class Hawk extends Raptor {
public static void main(String[] args) {
System.out.print("pre ");
new Hawk();

System.out.println("hawk ");
/*Raptor rap = new Raptor();
if (rap instanceof Raptor){
System.out.println("i m working");
}*/
}
}


Guess what is the answer: r1 r4 pre b1 b2 r3 r2 hawk
static always related with class not with instance so they run when the class initialized, next turn for constructor but here we have init blocks so first the init blocks have run then the constructor come in picture from top to bottom, super class init => constructor => child class init => constructor...

Serialization (Store the Objects) and Deserialization (Restore the objects) in Java

Serialization:
Objects have a state and behavior.
Behavior (methods) lives Class (in memory term Stack), state (instance variable) lives with in each objects (Heap), serialization is the way to save the state of object.
If you are writing a game, you're gonna need a Save/Restore Game Feature.

Deserialization: the whole point of serializing an object is so that you can restore it back to the original state at some later date, in a different run of JVM (which might not even be the same JVM that was running at the time the object was serialized).
Deserialization is lot like serialization in reverse.


import java.io.*;
import java.lang.*;

class Model implements Serializable {//mandatory to implement serializable interface(contains not any method).
int id;

String name;

public Integer getId() {
return id;
}

public void setId(int id) {
this.id = id;
}

public String getName() {
return name;
}

public void setName(String name) {
this.name = name;

}
}

public class SampleProgram {

public static void main(String args[]) {
Model model = new Model();
model.setId(10);
model.setName("aayush");

System.out.println("the out put before serialize " + model.getId()
+ " " + model.getName() + " i am going to finish");
try {

System.out.println("Serialize start");
//create a file or use a existing file.
FileOutputStream file = new FileOutputStream("inpu.ser");
//connect the file like from source to destination
ObjectOutputStream obj = new ObjectOutputStream(file);
//writing object
obj.writeObject(model);
//closing
obj.close();

}
catch (Exception ex) {

ex.printStackTrace();

}
//declare reference value null
model = null;

try {
System.out.println("i am going to restore");
//restoring start
ObjectInputStream restore = new ObjectInputStream(
new FileInputStream("inpu.ser"));
//reading object with type cast
Model model_restore = (Model) restore.readObject();
//closing
restore.close();
//output
System.out.println(model_restore.getName());

}
catch (Exception exe) {
exe.printStackTrace();
}

}
}

Is OuterClass able to access the InnerClass Methods and Variables (Vice-Versa)?

In Main method both classes are unable to access the variables and methods but outside the Main method InnerClass has a right to access the OuterClass variables and Methods (even private also), but what about the OuterClass?
OuterClass has also right to access the InnerClass Variables and Methods...

How : innerclass_object and outerclass_obect
These two objects on the heap have a special bond, The inner can use the outer's variable (and vice-versa).

See the example:


public class OuterClass {
private String str;

// create the instance of innerclass...
InnerClass obj = new InnerClass();

private class InnerClass {
int i;

public int getI() {

// intialize the outerclass private variable
str = "aayushjain";
System.out.println(str);
return i;
}

public void setI(int i) {
this.i = i;

}

}

public void trial() {
System.out.println("hello i from outerclass");

// call the Inner Class methods
obj.setI(100);
System.out.println(obj.getI());
}

public static void main(String args[]) {
OuterClass obj_out = new OuterClass();

// unbale to access the innerclass methods.....
/* obj_out.getI(); */

OuterClass.InnerClass obj_inner = obj_out.new InnerClass();

obj_inner.setI(10);
System.out.println(obj_inner.getI());

// unable to access the outerclass methods..
/* obj_inner.trial(); */
obj_out.trial();

}
}

How to Bulk file Rename in Linux

How to Bulk Rename Files in Linux (Terminal or GUI)

If you have a directory of files that you would like to bulk rename, you can use the rename command from the terminal.

The syntax for the rename command is:

rename [ -v ] [ -n ] [ -f ] perlexpr [ files ]

-v means "verbose" and it will output the names of the files when it renames them. It is a good idea to use this feature so you can keep track of what is being renamed. It is also a good idea to do a test run with -n which will do a test run where it won't rename any files, but will show you a list of files that would be renamed.

Here is an example of the rename command:

rename -n ’s/\.htm$/\.html/’ *.htm

The -n means that it's a test run and will not actually change any files. It will show you a list of files that would be renamed if you removed the -n. In the case above, it will convert all files in the current directory from a file extension of .htm to .html.

If the output of the above test run looked ok then you could run the final version:

rename -v ’s/\.htm$/\.html/’ *.htm

The -v is optional, but it's a good idea to include it because it is the only record you will have of changes that were made by the rename command as shown in the sample output below:

$ rename -v 's/\.htm$/\.html/' *.htm
3.htm renamed as 3.html
4.htm renamed as 4.html
5.htm renamed as 5.html

The tricky part in the middle is a Perl substitution with regular expressions, highlighted below:

rename -v ’s/\.htm$/\.html/’ *.htm

Tip: There is an intro to Perl regular expression here

Basically the "s" means substitute. The syntax is s/old/new/ — substitute the old with the new.

A . (period) has a special meaning in a regular expression — it means "match any character". We don't want to match any character in the example above. It should match only a period. The backslash is a way to "escape" the regular expression meaning of "any character" and just read it as a normal period.

The $ means the end of the string. \.htm$ means that it will match .htm but not .html.

It's fairly basic — substitute .htm with .html:

's/\.htm$/\.html/'

The last part of the command, highlighted below, means to apply the rename command to every file that ends with .htm (the * is a wildcard).

rename -v ’s/\.htm$/\.html/’ *.htm

Other Example
Maybe you have a digital camera that takes photos with filenames something like 00001234.JPG, 00001235.JPG, 00001236.JPG. You could make the .JPG extension lowercase with the following command executed from the same directory as the images:

rename -v 's/\.JPG$/\.jpg/' *.JPG

Here is the output of the above command:

$ rename -v 's/\.JPG$/\.jpg/' *.JPG
00001111.JPG renamed as 00001111.jpg
00001112.JPG renamed as 00001112.jpg
00001113.JPG renamed as 00001113.jpg

That is simple enough, as it is similar to the .html example earlier. You could also bulk rename them with something descriptive at the beginning like this:

Tip: Before trying more complicated renaming like in the example below, do a test run with the -n option as described at the beginning of this tutorial.

rename -v 's/(\d{8})\.JPG$/BeachPics_$1\.jpg/' *.JPG

or you can combine the two commands like below example

find -name '*.JPG' | rename -v 's/(\d{8})\.JPG$/BeachPics_$1\.jpg/' *.JPG

Java Static Function

Q. Can we override the Static function in Java ?
A. Yes we can override the Static function in Java see the sample recipe

class Sample implements Over {

public static int simple(int a, int b) {
int c = a + b;
return c;
}
}
class Overloading extends Sample {

public static int simple(int a, int b) {
int c = a * b;
return c;

}
public static void main(String[] args) {
        Sample sam = new Sample(22, 90);
        Overloading obj = new Overloading();
          obj.simple(10,20); // here the sub class function call
         sam..simple(10,20); // here the super class function call
}
}

Type Hint in PHP

Type Hint in PHP.

Day by day PHP introduces new strong OOPS concepts earlier i used the Type Hinting (earlier it's available in Hot cup of Java) in type hint we restrict the input type parameter like this:

class DAO{function add(Model $model){}}

here we restrict the input parameter is object type & also object of Model class.

but yet it's have some limitation, available for object and array not for integer, float etc