{"id":615,"date":"2012-07-21T13:26:52","date_gmt":"2012-07-21T13:26:52","guid":{"rendered":"http:\/\/codeatelier.wordpress.com\/?p=112"},"modified":"2012-07-21T13:26:52","modified_gmt":"2012-07-21T13:26:52","slug":"java-basics-part1","status":"publish","type":"post","link":"https:\/\/codethataint.com\/blog\/java-basics-part1\/","title":{"rendered":"Java Basics Part1"},"content":{"rendered":"

Welcome to Java<\/strong><\/p>\n

\npublic class Sample \n{\t\n  public static void main(String args[])\n  {\n    System.out.println(\"Welcome Back to Java\");\n  }\n}\n<\/pre>\n
Assigning Variables<\/strong><\/p>\n
\npublic class Sample \n{\t\n  public String strName;\n\t\n  public static void main(String args[])\n  {\n    Sample1 objSample1 =  new Sample1();\n    objSample1.strName = \"MugilVannan\";\n    System.out.println(objSample1.strName);\n  }\n}\n<\/pre>\n
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<\/p>\n
Class Sample1.java has a class sample3 with default access applied to it.<\/strong><\/p>\n
Sample1.java<\/strong><\/p>\n
\npackage pkgSampler;\n\npublic class Sample1 \n{\n\tpublic static void main(String[] args) \n\t{\n\t  SampleA objSampleA =  new SampleA();\n\t  System.out.println(objSampleB.strName);\n\t}\n}\n\nclass SampleA\n{\n\tpublic String strName;\n\t\n\tSampleA()\n\t{\n\t  this.strName = \"Mugil\";\t\n\t}\n}\n\n<\/pre>\n
Some Other Class in Same Package Accessing Variable with in Class with Default Access<\/strong>
\nSampleB.java<\/strong><\/p>\n
\npackage pkgSampler;\n\npublic class SampleB \n{\n  public static void main(String[] args) \n  {\n\tSampleA objSampleA =  new SampleA();\n\tSystem.out.println(objSampleA.strName);\n  }\n}\n\n<\/pre>\n
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.<\/p>\n
Package1 with Class SampleA <\/strong><\/p>\n
\n package Package1;\n class SampleA{}\n<\/pre>\n
Package2 with Class SampleB <\/strong><\/p>\n
\n package Package2;\n import Package1.SampleA;\n class SampleB extends SampleA{}\n<\/pre>\n
Classes Declared as Final cannot be inherited.Nor its methods and variable can be overridden or extended.<\/p>\n
\n package Pack1;\n public final class SampleA\n {\n  public void Sampler(){}\n }\n<\/pre>\n
Now ClassB tries to access classA<\/p>\n
\n package Pack2;\n import Pack1;\n public class SamplerNew extends Sampler{}\n<\/pre>\n
The above code will result in error<\/p>\n
Abstract Classes<\/strong>
\n1.Abstract classes cant be instantiated.It could be only extended. <\/p>\n
2.Methods marked as abstract should end with semicolon at its end.<\/p>\n
eg:<\/p>\n
\n  abstract class absFood\n  {\n     public abstract void SouthIndianThali();\n     public abstract void Chinese(); \n  } \n<\/pre>\n
3.Even if Single method is Abstract the whole class must be Abstract.You can put non abstract method in abstract class.<\/p>\n
4.A Class can’t be abstract and Final<\/p>\n
Interface<\/strong>
\n1.Interface is like contract which says what a class can do without telling how the class is going to do that.
\n2.Interface are like abstract class but abstract class can have both abstract and non abstract methods whereas interface can have only abstract methods.<\/p>\n
3.Other Rules for Interfaces are
\n  a.Interface Methods Must not be Final
\n  b.Interface Methods Must not be Static
\n  c.Variables in Interface should be public, Static and Final.
\n  d.Methods in Interface are Implicitly Public and Abstract
\n  e.Interface can only extend other interface
\n  f.Interface cannot implement another interface.<\/p>\n
4.Public modifier is required if you want teh interface to have public rather than default access.<\/p>\n
5.All Interfaces methods are Implicitly public and abstract<\/p>\n
e.g<\/p>\n
\npublic interface bounceable\n{\n   void Running();\n   void setRunningSpeed(int Speed);\n}\n<\/pre>\n
The Interface methods above are public and abstract as it used to be by default.The following applies the same for the below method.<\/p>\n
\nvoid runnable();                      \/\/Public \npublic void runnable();               \/\/Abstract     \nabstract void runnable();             \/\/Public \nabstract public void runnable();    \npublic abstract void runnable();    \n<\/pre>\n
The following interface method declaration wont compile <\/p>\n
\nfinal void runnable()         \/\/Interface shld nt be final\nstatic void runnable()        \/\/Interface define instance Methods\nprotected void runnable()     \/\/Interface methods are public  \nprivate void runnable()\n<\/pre>\n
Interface constants are public static final<\/strong>.But there is no need to declare them.<\/p>\n
Assigning Constant in Interface<\/p>\n
\n  interface Run\n  {\n    int BAR = 42;          \/\/Public final and Static by Default\n    void go(); \n  }\n\nclass Marathon implements Run\n{\n  public void go()\n  {\n   BAR = 27;             \/\/Not Allowed Interface \n                         \/\/Constant value should not be changed\n  }\n}\n<\/pre>\n
Access Modifiers<\/strong>
\nA class can use only two(public, default) of four modifiers.The four modifiers are
\n  1.Public
\n  2.protected
\n  3.default
\n  4.static <\/p>\n
Class Zoo<\/strong><\/p>\n
\nclass Zoo\n{\n  public string coolMethod()\n  { \n     return \"I am Cool\";\n  }\n}\n<\/pre>\n
Class Animal<\/strong><\/p>\n
 \nclass Animal extends coolMethod\n{\n  public void coolAnimalList()\n  {\n    \/\/The below code works because of inheritance\n    System.out.println(this.coolMethod());\n\n    \/\/The below code works because of Instance Objects\n    coolMethod objcoolMethod = new coolMethod();\n    System.out.println(objcoolMethod.coolMethod());\n  }\n}\n<\/pre>\n
Note<\/strong>
\nAlways look for Access level of Class.If the class itself is not accessible no wonder the methods would be.<\/p>\n
Protected vs Default<\/strong>
\nProtected 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.<\/p>\n

\nClass declared as protected in one package can be accessed only through inheritance in another class in other package
\n<\/strong><\/p>\n
Default Access<\/strong>
\nDefault members are visible to subclasses only if those subclasses are in same package as the superclass.<\/p>\n
Note <\/strong>: Access modifiers can’t be applied to local variables<\/p>\n
Local Variable can take only one modifier – final<\/strong><\/p>\n
Final Methods<\/strong>
\nFinal methods prevents methods being overridden in a subclass and is often used to enforce the API functionality of method<\/p>\n
Abstract Methods<\/strong>
\nAn 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.<\/p>\n
If you declare a abstract method in class then the class should also be abstract. <\/p>\n
There are three ways you could tell whether the method is abstract or not.<\/p>\n