Java 8 Features

• Lambda Expression 
• Functional interfaces
• Method references
• Stream API 

Java Programming Language

1. Lambda Expressions, a new language feature, has been introduced in this release. They enable you to treat functionality as a method argument, or code as data. Lambda expressions let you express instances of single-method interfaces (referred to as functional interfaces) more compactly.
2. Method references provide easy-to-read lambda expressions for methods that already have a name.
3. Default methods enable new functionality to be added to the interfaces of libraries and ensure binary compatibility with code written for older versions of those interfaces.
4. Repeating Annotations provide the ability to apply the same annotation type more than once to the same declaration or type use.
5. Type Annotations provide the ability to apply an annotation anywhere a type is used, not just on a declaration. Used with a pluggable type system, this feature enables improved type checking of your code.
6. Improved type inference.
7. Method parameter reflection.
8. Collections

Classes in the new java.util.stream package provide a Stream API to support functional-style operations on streams of elements. The Stream API is integrated into the Collections API, which enables bulk operations on collections, such as sequential or parallel map-reduce transformations.

Performance Improvement for HashMaps with Key Collisions

Concurrency

1. Classes and interfaces have been added to the java.util.concurrent package.
2. Methods have been added to the java.util.concurrent.ConcurrentHashMap class to support aggregate operations based on the newly added streams facility and lambda expressions.
3. Classes have been added to the java.util.concurrent.atomic package to support scalable updatable variables.
4. Methods have been added to the java.util.concurrent.ForkJoinPool class to support a common pool.
5. The java.util.concurrent.locks.StampedLock class has been added to provide a capability-based lock with three modes for controlling read/write access.

JDBC

1. The JDBC-ODBC Bridge has been removed.
2. JDBC 4.2 introduces new features.

java.lang and java.util Packages

1. Parallel Array Sorting
2. Standard Encoding and Decoding Base64
3. Unsigned Arithmetic Support

------------------------------------------------------------------------------------------------------------------------------

Inner Class

·         Inner classes let you define one class within another

·         Inner class is a part of the outer class

·         Inner class instance has access to all members of the outer class, even those marked private

·         Lambda expressions, which are often used as an alternative syntax (shorthand) for inner classes

1.      Inner classes (“nested class” in the objective)
2.      Method-local inner classes (“local class” in the objective)
3.      Anonymous inner classeses
4.      Static nested classes (“static inner class” in the objective)
 

·         Event handlers are perhaps the best example of inner class

 

public class MyClass extends Applet {

    ...

        someObject.addMouseListener(new MyAdapter());

    ...

    class MyAdapter extends MouseAdapter {

        public void mouseClicked(MouseEvent e) {

            ...//Event listener implementation goes here...

        }

    }

}

One of the key benefits of an inner class is the

“Special relationship” an inner class instance shares with an instance of the outer class. That “special relationship” gives code in the inner class access to members of the enclosing (outer) class, as if the inner class were part of the outer class 

1.       Inner classes: 

class Outer
{

class Inner

{

}

}

Javac Outer.java	Outer.class
	Outer$Inner.class
Java Outer.java	Outer$Inner.java  is wrong not going to work as there is no main method

 

public static void main(String args[])
{

Outer.Inner in= new Outer.new Inner();

Inn.innerMethod(); 

System.out.println(x);

System.out.println(this.x);

System.out.println(Outer.x);
}

 

Member Modifiers Applied to Inner Classes

 A regular inner class is a member of the outer class just as instance variables and methods are, so the following modifiers can be applied to an inner class:

1.       final

2.       abstract

3.       public

4.       private

5.       protected

6.       static—but static turns it into a static nested class, not an inner class

7.       strictfp

2.      Method-local inner classes

 

class Outer
{
 

void outerMethod()

{

class Inner

{

}

}

}

 

What a Method-Local Inner Object Can and Can’t Do

 

A method-local inner class can be instantiated only within the method where the inner class is defined.

 In other words, no other code running in any other method—inside or outside the outer class—can ever instantiate the method-local inner class.

 Like regular inner class objects, the method-local inner class object shares a special relationship with the enclosing (outer) class object and can access its private (or any other) members. However, the inner class object cannot use the local variables of the method the inner class is in. Why not?

Think about it. 

The local variables of the method live on the stack and exist only for the lifetime of the method. You already know that the scope of a local variable is limited to the method the variable is declared in. When the method ends, the stack frame is blown away and the variable is history. But even after the method completes, the inner class object created within it might still be alive on the heap if, for example, a reference to it was passed into some other code and then stored in an instance variable. Because the local variables aren’t guaranteed to be alive as long as the method-local inner class object is, the inner class object can’t use them. Unless the local variables are marked final or are ef ectively final! The following code attempts to access a local variable from within a method-local inner class:

Removing the line that changes z fixes the problem, and marking the local variable z as final, although option

Just a reminder about modifiers within a method: The same rules apply to method-local inner classes as to local variable declarations. 

You can’t, for example, mark a method-local inner class public, private, protected, static, transient, and the like. For the purpose of the exam, the only modifiers you can apply to a method-local inner class are abstract and final, but, as always, never both at the same time.

Remember that a local class declared in a static method has access to only static members of the enclosing class, since there is no associated instance of the enclosing class. If you’re in a static method, there is no this, so an inner class in a static method is subject to the same restrictions as the static method. In other words, no access to instance variables

Anonymous inner classeses

1. In Java: inner classes declared without any class name at all (hence, the word anonymous)
2. We can define these classes, not just within a method, but even within an argument to a method

there are two flavour of anonymous inner class

class Base

{

payment()
{

System.out.println("--------Base")
}

}

class  Child extends Base

{

payment()
{

System.out.println("--------Child ")
}

}

public class Main
{

public static void main(String args)
{

Base b = new Base(0;

b.payment();

Child c = new Child ();

c.payment();

Base c1 = new Child (0;

c1.payment();

Child c2 = (Child) new Base(0;

c2.payment();

}
}

package normalClass;

public class Card {

int a=10;

public void payment()

{

System.out.println("Payment inside  card");

}

public void cash()

{

System.out.println("Payment inside  cash pay");

}

}

package normalClass;

public class CreditCard extends Card {

int a=20;

public void payment()

{

System.out.println("Payment inside Credit card");

}

public void localpayment()

{

System.out.println("Payment inside localpayment card");

}

}

package normalClass;

public class PayMoney {

public static void main(String[] args) {

Card c = new Card();

c.payment();

System.out.println("--------------both are Card");

CreditCard cc = new CreditCard();

cc.payment();

System.out.println("--------------both are CreditCard");

Card ccc = new CreditCard();

ccc.payment();

System.out.println("----Ref Crad----------Obect are CreditCard");

// CreditCard cccd =  (CreditCard) new Card();

// ccc.payment();

//System.out.println("----Ref CreditCard----------Obect are Crad");

System.out.println(c.a);

System.out.println(cc.a);

System.out.println(ccc.a);

}

}

package innerClass;

import normalClass.Card;

public class PayMoney {

public static void main(String args[]) {

Card c = new Card() {

public void payment() {

System.out.println("I am inside payment method in annonymous inner class");

}

};

c.payment();

c.cash();

}

}