abstraction in java :: futureX

Abstraction is a process of hiding the implementation details and showing only functionality to the user.Abstraction lets you focus on what the object does instead of how it does it.


Ways to achieve Abstraction:
Abstract class (0 to 100%)
Interface (100%)

Abstract class:
A class that is declared as abstract is known as abstract class.It needs to be extended and its method implemented.It cannot be instantiated.


           abstract class class_name{}

Abstract method:
A method that is declared as abstract and does not have implementation is known as abstract method.


          abstract return_type method_name();    //no braces{}

Example:

 abstract class Shape{
abstract void draw();
}

 class Rectangle extends Shape{
void draw(){System.out.println("drawing rectangle");}
}

 class Circle extends Shape{
void draw(){System.out.println("drawing circle");}
}

 class Test{
public static void main(String args[]){
Shape s=new Circle();
s.draw();
}
}


Note: An abstract class can have data member,abstract method,method body,constructor and even main() method.

 Rule: If there is any abstract method in a class, that class must be abstract.

//Shape is not abstract and does not override abstract method //draw() in shape

 class Shape{
abstract void draw();
}
                   JAVA TUTORIALS HOMEPAGE



What is HTML?

indroduction to HTML :: futureX
  • HTML is a language for describing web pages.
  • HTML stands for Hyper Text Markup Language
  • HTML is a markup language
  • A markup language is a set of markup tags
  • The tags describes document content
  • HTML documents contain HTML tags and plain text
  • HTML documents are also called web pages


 HTML Tags
  • HTML markup tags are usually called HTML tags
  • HTML tags are keywords (tag names) surrounded by angle brackets like <html>
  • HTML tags normally come in pairs like <b> and </b>
  • The first tag in a pair is the start tag, the second tag is the end tag
  • The end tag is written like the start tag, with a forward slash before the tag name
  • Start and end tags are also called opening tags and closing tags


                                      <tagname>content</tagname>
HTML Elements

 "HTML tags" and "HTML elements" are often used to describe the same thing.
But strictly speaking, an HTML element is everything between the start tag and the end tag, including the tags.
               <p>This is a paragraph.</p>
Web Browsers

 The purpose of a web browser (such as Google Chrome, Internet Explorer, Firefox, Safari) is to read HTML documents and display them as web pages. The browser does not display the HTML tags, but uses the tags to interpret the content of the page.

 HTML Versions

 Since the early days of the web, there have been many versions of HTML:
Version                        Year
HTML                          1991
HTML+                        1993
HTML 2.0                    1995
HTML 3.2                    1997
HTML 4.01                  1999
XHTML 1.0                  2000
HTML5                        2012
XHTML5                      2013

 The <!DOCTYPE> Declaration

 The <!DOCTYPE> declaration helps the browser to display a web page correctly.
There are many different documents on the web, and a browser can only display an HTML page 100% correctly if it knows the HTML type and version used.

 Common Declarations

 HTML5

 <!DOCTYPE html>

 HTML 4.01

 <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
"http://www.w3.org/TR/html4/loose.dtd">

 XHTML 1.0

 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

 For a complete list of document type declarations, go to our DOCTYPE Reference.

« HTML Home                                                                                                                                                  Next Chapter »

runtime polymorphism in java :: futureX
Runtime polymorphism or dynamic method dispatch is a process in which a call to an overridden method is resolved at runtime rather than at compile-time.In this process, an overridden method is called through the reference variable of a superclass. The determination of the method to be called is based on the object being referred to by the reference variable.


 UPCASTING :
When reference variable of Parent class refers to the object of Child class, it is known as upcasting.
upcasing in java :: futureX
For example:


class Animal{
void eat(){System.out.println("eating food");}
}

 class Human extends Animal{
void eat(){System.out.println("eating delicious food");}

 public static void main(String args[]){
Animal A=new Human();
A.eat();
}
}

 Example of runtime polymorphism


class Bike{
   void run(){System.out.println("running");}
 }
 class Splender extends Bike{
   void run(){System.out.println("running safely with 60km");}

   public static void main(String args[]){
     Bike b = new Splender();//upcasting
     b.run();
   }
 }


In this example, we are creating two classes Bike and Splendar. Splendar class extends Bike class and overrides its run() method. We are calling the run method by the reference variable of Parent class. Since it refers to the subclass object and subclass method overrides the Parent class method, subclass method is invoked at runtime. Since it is determined by the compiler, which method will be invoked at runtime, so it is known as runtime polymorphism.
Rule: Runtime polymorphism can't be achieved by data members.

 class Bike{ int speedlimit=90; } class Honda extends Bike{ int speedlimit=150; public static void main(String args[]){ Bike obj=new Honda(); System.out.println(obj.speedlimit);//output 90 } }

 JAVA TUTORIALS HOMEPAGE
The final keyword in java is used to restrict the user. The final keyword can be used in many context. Final can be:
final keyword in java :: futureX

  • variable
  • method
  • class


Final variable :
If you make any variable as final, you cannot change the value of final variable(It will be constant).

//can't assign a value to final variable class Simple{ final int a=50; void change(){ a=100; //CTE } public static void main(String args[]){ Simple S=new Simple(); S.change(); System.out.println(S.a); } }

Final method :
If you make any method as final, you cannot override it.

//overriden method is final CTE class A{ final void m(){System.out.println("hello");} } class Simple extends A{ void m(){System.out.println("java");} public static void main(String args[]){ Simple S=new Simple(); S.m(); } }

Final class :
If you make any class as final, you cannot inherit it.

//cant inherit from final class CTE final class A{} class Simple extends A{ public static void main(String args[]) {} }
super is a reference variable that is used to refer immediate parent class object.

Uses of super Keyword:

  • super is used to refer immediate parent class instance variable.
  • super() is used to invoke immediate parent class constructor.
  • super is used to invoke immediate parent class method.
1.super is used to refer immediate parent class instance variable.

Problem without super keyword

class Vehicle{ int speed=50; } class Bike extends Vehicle{ int speed=100; void display(){ System.out.println(speed);//will print speed of Bike } public static void main(String args[]){ Bike b=new Bike(); b.display(); } }

In the above example Vehicle and Bike both class have a common property speed. Instance variable of current class is refered by instance bydefault, but I have to refer parent class instance variable that is why we use super keyword to distinguish between parent class instance variable and current class instance variable.

Solution by super keyword

class Vehicle{ int speed=50; } class Bike extends Vehicle{ int speed=100; void display(){ System.out.println(super.speed);//will print speed of Vehicle now } public static void main(String args[]){ Bike b=new Bike(); b.display(); } }

 2.super is used to invoke parent class constructor.

class Vehicle{ Vehicle(){System.out.println("Vehicle is created");} } class Bike extends Vehicle{ Bike(){ super();//will invoke parent class constructor System.out.println("Bike is created"); } public static void main(String args[]){ Bike b=new Bike(); } }

 3. super can be used to invoke immediate parent class method.

class Person{ void message(){System.out.println("welcome");} } class Student extends Person{ void message(){System.out.println("welcome to java");} void dislay(){ message();//will invoke current class message() method super.message();//will invoke parent class message() method } public static void main(String args[]){ Student s=new Student(); s.display(); } }

 JAVA TUTORIALS HOMEPAGE
Subscribe to: Posts (Atom)
Copyright © 2013 futureX | Blogger Template by Clairvo