Welcome to Java
public class Sample
{
public static void main(String args[])
{
System.out.println("Welcome Back to Java");
}
}
Assigning Variables
public class Sample
{
public String strName;
public static void main(String args[])
{
Sample1 objSample1 = new Sample1();
objSample1.strName = "MugilVannan";
System.out.println(objSample1.strName);
}
}
A Class with default access can be seen by class in same package.If classA and classB are in different package and classA has default access classA wont be visible to class B
Class Sample1.java has a class sample3 with default access applied to it.
Sample1.java
package pkgSampler;
public class Sample1
{
public static void main(String[] args)
{
SampleA objSampleA = new SampleA();
System.out.println(objSampleB.strName);
}
}
class SampleA
{
public String strName;
SampleA()
{
this.strName = "Mugil";
}
}
Some Other Class in Same Package Accessing Variable with in Class with Default Access
SampleB.java
package pkgSampler;
public class SampleB
{
public static void main(String[] args)
{
SampleA objSampleA = new SampleA();
System.out.println(objSampleA.strName);
}
}
The Methods in Class SampleA with default access in one package will only be visible to SampleB when it is Declared as Public.Otherwise it will compilation error.
Package1 with Class SampleA
package Package1;
class SampleA{}
Package2 with Class SampleB
package Package2;
import Package1.SampleA;
class SampleB extends SampleA{}
Classes Declared as Final cannot be inherited.Nor its methods and variable can be overridden or extended.
package Pack1;
public final class SampleA
{
public void Sampler(){}
}
Now ClassB tries to access classA
package Pack2;
import Pack1;
public class SamplerNew extends Sampler{}
The above code will result in error
Abstract Classes
1.Abstract classes cant be instantiated.It could be only extended.
2.Methods marked as abstract should end with semicolon at its end.
eg:
abstract class absFood
{
public abstract void SouthIndianThali();
public abstract void Chinese();
}
3.Even if Single method is Abstract the whole class must be Abstract.You can put non abstract method in abstract class.
4.A Class can’t be abstract and Final
Interface
1.Interface is like contract which says what a class can do without telling how the class is going to do that.
2.Interface are like abstract class but abstract class can have both abstract and non abstract methods whereas interface can have only abstract methods.
3.Other Rules for Interfaces are
a.Interface Methods Must not be Final
b.Interface Methods Must not be Static
c.Variables in Interface should be public, Static and Final.
d.Methods in Interface are Implicitly Public and Abstract
e.Interface can only extend other interface
f.Interface cannot implement another interface.
4.Public modifier is required if you want teh interface to have public rather than default access.
5.All Interfaces methods are Implicitly public and abstract
e.g
public interface bounceable
{
void Running();
void setRunningSpeed(int Speed);
}
The Interface methods above are public and abstract as it used to be by default.The following applies the same for the below method.
void runnable(); //Public public void runnable(); //Abstract abstract void runnable(); //Public abstract public void runnable(); public abstract void runnable();
The following interface method declaration wont compile
final void runnable() //Interface shld nt be final static void runnable() //Interface define instance Methods protected void runnable() //Interface methods are public private void runnable()
Interface constants are public static final.But there is no need to declare them.
Assigning Constant in Interface
interface Run
{
int BAR = 42; //Public final and Static by Default
void go();
}
class Marathon implements Run
{
public void go()
{
BAR = 27; //Not Allowed Interface
//Constant value should not be changed
}
}
Access Modifiers
A class can use only two(public, default) of four modifiers.The four modifiers are
1.Public
2.protected
3.default
4.static
Class Zoo
class Zoo
{
public string coolMethod()
{
return "I am Cool";
}
}
Class Animal
class Animal extends coolMethod
{
public void coolAnimalList()
{
//The below code works because of inheritance
System.out.println(this.coolMethod());
//The below code works because of Instance Objects
coolMethod objcoolMethod = new coolMethod();
System.out.println(objcoolMethod.coolMethod());
}
}
Note
Always look for Access level of Class.If the class itself is not accessible no wonder the methods would be.
Protected vs Default
Protected and default access control levels are almost identical.A default member may be accessed only if the class accessing the member belongs to the same package, whereas a protected member can be accessed(through inheritance) by a subclass even if subclass in different package.
Class declared as protected in one package can be accessed only through inheritance in another class in other package
Default Access
Default members are visible to subclasses only if those subclasses are in same package as the superclass.
Note : Access modifiers can’t be applied to local variables
Local Variable can take only one modifier – final
Final Methods
Final methods prevents methods being overridden in a subclass and is often used to enforce the API functionality of method
Abstract Methods
An abstract method is a method that’s been declared but not implemented.The method contains no functional code.When a method is marked abstract the subclasses should provide the implementation.
If you declare a abstract method in class then the class should also be abstract.
There are three ways you could tell whether the method is abstract or not.
- The method is not marked abstract
- The method declaration includes curly braces
- The method provides actual implementation code.
The First Concrete method of an abstract class must implement all abstract methods of the superclass
Concrete means Nonabstract class
eg.
public abstract class Vehicle
{
public abstract goUpHill();
}
public abstract class car extends Vehicle
{
public abstract goUpHill();
public void dpThings()
{
...
...
}
}
//First Concrete class since the above two classes are abstract
public class Mini extends Car
{
public void goUpHill()
{
}
}
A Abstract Method can Never be marked as both abstract and Final or both abstract and Private
Abstract Modifier can never be combined with Static modifier
Abstract means the super class does not know anything about how the subclasses should behave in that method where as final means the super class knows every things about the subclasses.
Constructors
Every Class has a Constructor, although if you don’t create one explicitly, the compiler will build one for you.
1.Constructor can’t ever, ever have return type.
2.Constructors can’t be marked static, they can’t be marked final or abstract.
Primitives
Eight Types – int, float, long, char, boolean, double, short, byte
For the Integers Small to Big Would be
byte, short, int, long, and doubles, floats
Instance Variables can be any of four access levels, final and transient
Instance Variables can’t be abstract, synchronized, strictfp, native and static
Local Variables
Local Variables are variables declared within a method.Local Variables life begins and Ends within a method.
Local variables are always on the stack and not on the heap
Local Variables cannot be public, transient, volatile, abstract, or static but local variables are final.
Shadowing:Declaring a local variable with the same name as instance variable
How to Declare a Array in Java
e.g
int[] key; //Recommended
int key []; //Legal but less readable
It is not legal to add size of array in your declaration
int[5] names; //The code wont compile
Final Object Reference
An object marked as final can never be reassigned to different object.The data within the object can be modified but the reference variable cannot be changed.
There are no final objects but only final references.
1.Final Class Cannot be Subclassed
2.Final Method Cannot be Overridden
3.Final Variable Cannot be assigned a new value.
Transient Variable Skip the variable when you attempt to serialize it.
Volatile Variable Tells the JVM that a thread accessing the variable must always reconcile its private copy of the variable with the master copy in memory.
Static methods and members
Static members exists even before you ever make a new instance of a class and there will be only one copy of static member regardless of number of instances of that class.In other words all instances of the class share the same value for the given static variable.
Classes, Constructors, Interfaces, Method, inner class methods and instances variables, local variables cannot be Static.