C# vs Java programming comparison

 This guide is for those who like to learn Java and are from the C# background or vice - versa or similar who are pretty much versed in it. I have documented the aspects which needs to be grasped and is different from C#.

1. First line of code can be say a Pgm.java file like below.

```
class Pgm
{
    public static void main(String[] args)
    {
        System.out.println("Learning Java!);
    }
}
```
a. The name of the file should be the same as the class inside. Main method is `main` here and string is String here.

2. Inheritance -
a. Use `extends` for inheriting from another class. This can be from one class only.
b. No virtual or override, instead methods of the same signatures are overridden.
c. Use `implements` to implement from an Interface and for multiple inheritance.
d. If not implementing an interface, mark it as abstract. Only abstract classes can have abstract fields.

3. Classes -
a. Avoid modifiers to it, at least when learning. If using public it has to be in its own file.

4. Lambda methods -
Similar to C#, use -> instead, like `Predicate<String> pred = s -> s.length() == 3;` and do `pred.test("111")` which returns `true` if matching the predicate.

5. Compiling the source code.
`javac Pgm.java`

6. Running the program.
`java Pgm`

7. Packages -
Like namespaces, supposed to be the name of the folder but no compilation errors will be issued.
Use like `package abc.def.ghi;`
When compiling, one may have to do `javac -d . Pgm.java` and when running `java abc.def.ghi.Pgm`

8. Statements -
a. All if, else, while and for loops are similar.
b. Switch cases can have multiple with comma separtions like `case SATURDAY, SUNDAY -> "week end";`

9. Encapsulation - No properties here for classes. Create your own getter and setter individual methods.

10. Concurrent List - To make a list concurrent or thread safe, you can do `List newList = Collections.synchronizedList(eles);`

11. Generics seem similar

?? and ??= Null coalescence operators C#

 C# introduces the ?? and ??= operators which are known as the Null coalescence operators.

Purpose -
The ?? and ??= operators can help in cases where a comparison is made between two or more variable values and depending on the order in the statement, the variable valu is used.

Say for example there is variable either a and b to be returned by a method. Say if value is needed to be returned if it is not null and if yes, the value b is supposed to be returned.

```
public class NullCoal
{
public static int? Method(int? input)
{
    ....
    ....
    int? a;
    int? b;
    

    if(input > 10)
    {
        a = input * 6;
    }
    else
    {
        b = input * 7:;
    }

    return a ?? b;
}
}

```
In the above example, a is returned if it is not null or b is returned.

Similarly the ??= operator adds the assignment operation as well, which can be used like

```
    int? a = null;
    int? b = 1;

    a ??= b;
```
where if a is not null, value of b is assigned to it, otherwise nothing happens with the above statement.

The null coalescence operator is a short form for writing the below code.

```
if( a is null)
{
    a = 1;
}

```
instead it can be written as

```
a ??= 1;
```
What if there is more than two variables to check, in such cases say like below
```
return a ?? b ?? c;
```
the expression is evaluated from right to left like this
```
return a ?? ( b ?? c)
```