HTML Headings, Lines & Comments

HTML Headings

HTML Headings

Headings are defined with the <h1> to <h6> tags.

<h1> defines the most important heading. <h6> defines the least important heading.

Example

<h1>This is a heading</h1>
<h2>This is a heading</h2>
<h3>This is a heading</h3>


Note: Browsers automatically add some empty space (a margin) before and after each heading.

Importance of Headings

Use HTML headings for headings only. Don't use headings to make text BIG or bold.Search engines use your headings to index the structure and content of your web pages.
               Since users may skim your pages by its headings, it is important to use headings to show the document structure.

H1 headings should be used as main headings, followed by H2 headings, then the less important H3 headings, and so on.

HTML Lines

The <hr>tag creates a horizontal line in an HTML page.

The hr element can be used to separate content:

Example

<p>This is a paragraph</p>
<hr><p>This is a paragraph</p>
<hr><p>This is a paragraph</p>

example of heading and lines :: futureX

HTML Comments

Comments can be inserted into the HTML code to make it more readable and understandable. Comments are ignored by the browser and are not displayed.

Comments are written like this:

Example

<!-- This is a comment -->

Note: There is an exclamation point after the opening bracket, but not before the closing bracket.

« Previous Chapter                                                                                                                                          Next Chapter »

String Handling :: Part 1

String Handling in java

In java, string is basically an immutable object. We will discuss about immutable string later. Let's first understand what is string and how we can create the string object.

Generally string is a sequence of characters. But in java, string is an object. String class is used to create string object.


There are two ways to create String object:

• By string literal
• By new keyword

By String Literal :
String literal is created by double quote.
For Example:

String s="Hello";


Each time you create a string literal, the JVM checks the string constant pool first. If the string already exists in the pool, a reference to the pooled instance returns. If the string does not exist in the pool, a new String object instantiates, then is placed in the pool.For example:


String s1="Welcome";
String s2="Welcome";//no new object will be created

In the above example only one object will be created.First time JVM will find no string object with the name "Welcome" in string constant pool,so it will create a new object.Second time it will find the string with the name "Welcome" in string constant pool,so it will not create new object whether will return the reference to the same instance.

String objects are stored in a special memory area known as string constant pool inside the Heap memory.

Why java uses concept of string literal?

To make Java more memory efficient (because no new objects are created if it exists already in string constant pool).


By new Keyword :

String s=new String("Welcome");//creates two objects and one reference variable


In such case, JVM will create a new String object in normal(non pool) Heap memory and the literal "Welcome" will be placed in the string constant pool.The variable s will refer to the object in Heap(non pool).



Immutable String:

In java, strings are immutable (unmodifiable) objects.For example


class Simple{
 public static void main(String args[]){

   String s="Sachin";
   s.concat(" Tendulkar");//concat() method appends the string at the end
   System.out.println(s);//will print Sachin because strings are immutable objects
 }
}


Output: Sachin


As you can see in the above figure that two objects will be created but no reference variable refers to "Sachin Tendulkar".But if we explicitely assign it to the reference variable, it will refer to "Sachin Tendulkar" object.For example:


class Simple{
 public static void main(String args[]){

   String s="Sachin";
   s=s.concat(" Tendulkar");
   System.out.println(s);
 }
}


Output: Sachin Tendulkar


Why string objects are immutable in java?

Because java uses the concept of string literal.Suppose there are 5 reference variables,all referes to one object "sachin".If one reference variable changes the value of the object, it will be affected to all the reference variables. That is why string objects are immutable in java.


                                           JAVA TUTORIALS HOMEPAGE

Attributes in HTML

HTML Attributes :: futureX

Attributes provide additional information about HTML elements.


HTML Attributes:

• HTML elements can have attributes
• Attributes provide additional information about an element
• Attributes are always specified in the start tag
• Attributes come in name/value pairs like: name="value"

Example:

HTML links are defined with the <a> tag. The link address is specified in the href attribute:

<a href="http://www.futurextech.blogspot.com">This is a link</a>

Attribute values should always be enclosed in quotes.

Double style quotes are the most common, but single style quotes are also allowed.

In some rare situations, when the attribute value itself contains quotes, it is necessary to use single quotes: name='John "Alfred" Nelson'

HTML Tip: Use Lowercase Attributes

Attribute names and attribute values are case-insensitive.

However, the World Wide Web Consortium (W3C) recommends lowercase attributes/attribute values in their HTML 4 recommendation.

Newer versions of (X)HTML will demand lowercase attributes.

« Previous Chapter                                                                                                                                          Next Chapter »

HTML Elements

An HTML element is everything from the start tag to the end tag:

HTML elements :: futurex 

  Start tag                       Element content                               End tag

 <p>                                This is a example paragraph              </p>
 <a href="default.html">  This is a link                              </a>
 <br>  

 The start tag is often called the opening tag. The end tag is often called the closing tag.


HTML Element Syntax

An HTML element starts with a start tag / opening tag.

An HTML element ends with an end tag / closing tag.

The element content is everything between the start and the end tag.

Some HTML elements have empty content.

Empty elements are closed in the start tag.

Most HTML elements can have attributes.

Nested HTML Elements

Most HTML elements can be nested (can contain other HTML elements).

HTML documents consist of nested HTML elements.

Example

<!DOCTYPE html>

<html>

<body>

<p>This is my first paragraph.</p>

</body>

</html>

Don't Forget the End Tag

Some HTML elements might display correctly even if you forget the end tag:

<p>This is a paragraph

<p>This is a paragraph

The example above works in most browsers, because the closing tag is considered optional.

Never rely on this. Many HTML elements will produce unexpected results and/or errors if you forget the end tag .

Empty HTML Elements

HTML elements with no content are called empty elements.

<br> is an empty element without a closing tag (the <br> tag defines a line break).

Tip: In XHTML, all elements must be closed. Adding a slash inside the start tag, like <br />, is the proper way of closing empty elements in XHTML (and XML).

HTML Tip: Use Lowercase Tags

HTML tags are not case sensitive: <P> means the same as <p>. Many web sites use uppercase HTML tags.

We use lowercase because the World Wide Web Consortium (W3C) recommends lowercase in HTML 4, and demands lowercase tags in XHTML.

« Previous Chapter                                                                                                                                          Next Chapter »