Web Technology Sessional Answers

Section-A
What is dynamic html?
Dynamic HTML, or DHTML, refers to a collection of technologies used to create interactive
and animated websites by dynamically changing a web page's content and layout after it has
loaded. Unlike static HTML, where content remains fixed, DHTML combines HTML, CSS,
and JavaScript to allow for responsive elements that can change in response to user actions.

What do you mean by XML?

XML (Extensible Markup Language) is a flexible, text-based language designed to store and
transport data in a structured format. It allows developers to create custom tags to define data,
making it easy to read and share across various systems and platforms. XML is widely used in
web applications for data interchange, as it is both human-readable and machine-readable.

What is CSS?
CSS (Cascading Style Sheets) is a language used to style and design web pages. It allows
developers to control the layout, colors, fonts, and spacing of elements in HTML documents.
By using CSS, you can make your website look more visually appealing and organized. It
separates content (HTML) from presentation (CSS), making the design process easier and more
flexible.

Differentiate between class and interface.

Aspect Class Interface
A class is a blueprint for creating An interface defines a contract with abstract
Definition
objects with attributes and methods. methods that a class must implement.
A class can contain both
An interface only contains abstract methods
Implementation implemented methods (with code)
(no implementation).
and abstract methods.
A class can inherit from only one A class can implement multiple interfaces
Inheritance
class (single inheritance). (multiple inheritance).
Methods and variables in a class can All methods in an interface are implicitly
Access
have access modifiers (public, public and abstract, and variables are public,
Modifiers
private, etc.). static, and final.
You can create an instance of a class You cannot instantiate an interface directly. A
Instantiation
using the new keyword. class must implement the interface.
What is AWT in java?
AWT (Abstract Window Toolkit) in Java:
AWT is a set of APIs (Application Programming Interfaces) used for creating graphical user
interface (GUI) components like buttons, text fields, and windows in Java. It is part of the
java.awt package and provides the necessary tools to develop cross-platform graphical
applications. AWT components are heavy-weight because they rely on the native operating
system's windowing system.
Key points:
• Platform-dependent: It uses the underlying system's windowing toolkit.
• Components: Includes buttons, text boxes, scroll bars, etc.
• Event-driven: AWT uses event listeners to handle user actions like clicks and key
presses.

Section-B

Explain Xml schema, DTD and explain parser.

XML Schema (XSD):
XML Schema defines the structure, content, and data types of XML documents. It serves as a
blueprint that ensures XML data is organized and follows certain rules. Unlike DTD, which
only defines the structure in a loose manner, XML Schema is more powerful and flexible. It
allows you to define complex types, data types (like integer, date), and constraints (such as
min/max length). XML Schema is written in XML format and supports namespaces, making
it more versatile in large-scale systems.
Key Features:
• Data Types: Can define primitive data types (string, integer, date) and custom
complex types.
• Validation: Helps in validating the structure of XML data, ensuring data consistency.
• Extensibility: Supports complex and reusable definitions using complex types and
elements.

DTD (Document Type Definition):

DTD is a set of rules used to define the structure and legal elements of an XML document. It
specifies what tags can appear in the document, their attributes, and the order of these
elements. DTD can be defined within the XML document or as an external file. However,
DTD is limited compared to XML Schema as it doesn't support data types or complex
structures.
Key Features:
• Element Definitions: Defines which elements are allowed in the XML document.
• Attribute Specifications: Specifies attributes that elements can have.
• Document Structure: Ensures the correct order of elements.

Parser:
A parser is a tool or program that reads XML documents and interprets them according to a
specified grammar (such as DTD or XML Schema). It helps validate the structure of an XML
file and extract the data. There are two main types of parsers:
 1. DOM (Document Object Model) Parser: Loads the entire XML document into
memory and creates a tree structure that can be traversed.
2. SAX (Simple API for XML) Parser: A stream-based parser that reads the XML
document sequentially and triggers events when it encounters elements or attributes.
Key Features:
• Validation: Ensures the XML document adheres to the specified rules (DTD or XML
Schema).
• Data Extraction: Extracts data from XML based on the structure defined by the
schema or DTD.
• Efficiency: DOM loads the whole document, whereas SAX processes data as it reads,
which is more memory efficient.

What is exception handling in Java?

Exception Handling in Java
In Java, exception handling is a mechanism to handle runtime errors, allowing the program
to continue executing smoothly without crashing. It is implemented using a combination of
try, catch, throw, throws, and finally blocks.
1. Try Block: This block contains code that might throw an exception. If an exception
occurs, the rest of the code in the try block is skipped.
2. Catch Block: If an exception occurs in the try block, the catch block is executed. It
catches the exception and handles it, preventing the program from terminating
abruptly.
3. Throw: The throw keyword is used to manually throw an exception in a program. For
example, you can throw a custom exception when a certain condition is met.
4. Throws: The throws keyword is used in method declarations to indicate that a method
may throw one or more exceptions, allowing the caller to handle them.
5. Finally Block: This block is optional and executes after the try and catch blocks,
regardless of whether an exception occurred or not. It's used for clean-up activities
(e.g., closing files or database connections).
Example:
java
Copy code
public class Example {
public static void main(String[] args) {
try {
int result = 10 / 0; // This will throw an ArithmeticException
} catch (ArithmeticException e) {
System.out.println("Error: Division by zero.");
} finally {
System.out.println("This block is always executed.");
}
}
}
In this example:
• The try block throws an ArithmeticException.
• The catch block handles the exception and prints an error message.
• The finally block executes regardless of the exception, ensuring clean-up.
What are the principles of object oriented programming
language?
Principles of Object-Oriented Programming (OOP)
Object-Oriented Programming (OOP) is based on several key principles that help structure
code in a modular, reusable, and scalable way. The main principles of OOP are:
1. Encapsulation:
o Encapsulation refers to the bundling of data (attributes) and methods
(functions) that operate on the data into a single unit known as a class.
o This helps in restricting direct access to some of an object's components and
only exposes necessary parts via public methods.
o Example: A class Student may have private data like marks, and provide
public methods like getMarks() to access it.
2. Abstraction:
o Abstraction involves hiding the complexity of the system and showing only
the essential features to the user.
o It allows focusing on high-level functionalities and reduces unnecessary detail.
o Example: A car's interface (accelerator, brake) abstracts the internal workings
of the engine.
3. Inheritance:
o Inheritance allows one class to inherit properties and behaviors (methods)
from another class. This promotes reusability and establishes a relationship
between classes.
o Example: A Dog class can inherit from an Animal class, so it inherits common
attributes like name and age, but can also have specific attributes like breed.
4. Polymorphism:
o Polymorphism means "many forms". It allows objects of different classes to
be treated as objects of a common superclass.
o The two types of polymorphism are method overloading (same method name
with different parameters) and method overriding (same method signature in
both superclass and subclass).
o Example: A Shape class may have a method draw(), and different shapes like
Circle and Rectangle can override this method to provide specific
implementations.
These principles together make OOP a powerful paradigm for designing software that is
modular, easy to maintain, and flexible.

Section-C

What is DOM & SAX?

DOM (Document Object Model)
Definition: The Document Object Model (DOM) is a programming interface for web
documents. It represents the structure of a document as a tree of nodes, where each node
corresponds to part of the document (elements, attributes, text, etc.).
Explanation:
 • DOM is an in-memory representation of an XML or HTML document.
• It allows programs to access, modify, or delete parts of the document (such as
elements, attributes, and text).
• The document is represented as a tree structure, with each node being an object that
can be manipulated via programming languages like JavaScript.
Key Features:
1. Tree Structure: DOM represents the document as a tree of nodes (like a family tree).
2. Language-independent: DOM can be used with different programming languages
(JavaScript, Python, Java, etc.).
3. Read-Write: You can read, modify, and delete the content of the document.
Example: In an HTML document:
html
Copy code
<html>
<head><title>DOM Example</title></head>
<body>
<h1>Welcome to Web Technology!</h1>
</body>
</html>
This will be represented in the DOM as a tree:
css
Copy code
Document
├── html
│ ├── head
│ │ └── title
│ └── body
│ └── h1
Advantages of DOM:
• Supports dynamic manipulation of documents.
• Allows full access to the document’s structure.
• Can be used to change the content, structure, and style of documents.

SAX (Simple API for XML)

Definition: SAX (Simple API for XML) is an event-driven, streaming XML parser that
reads XML documents sequentially and generates events as it processes elements.
Explanation:
• Unlike DOM, which loads the entire XML document into memory, SAX reads the
document sequentially.
• SAX is event-driven, meaning it triggers events (like element start, element end, etc.)
while parsing the document.
• It is generally used for large XML documents since it does not require the entire
document to be loaded into memory.
Key Features:
1. Stream-based: SAX parses XML documents sequentially, making it memory
efficient.
2. Event-driven: It generates events during parsing (start element, end element, etc.)
that can be handled by the program.
3. Read-only: SAX can only be used to read XML data; you cannot modify the
document like with DOM.
Example: Consider an XML document:
xml
Copy code
<book>
<title>Web Technology</title>
<author>John Doe</author>
</book>
SAX events would trigger like:
• Start of <book> element.
• Start of <title> element.
• End of <title> element.
• Start of <author> element.
• End of <author> element.
• End of <book> element.
Advantages of SAX:
• More memory-efficient than DOM, as it doesn’t store the entire document in memory.
• Faster for large XML files, as it reads the document only once and doesn’t build a
complete tree structure.

What is Applet and Explain it’s Life cycle?

What is an Applet? An Applet is a small Java program that runs inside a web browser. It is a
type of Java application designed to be embedded in a webpage and can interact with the user
through graphical elements like buttons, text fields, etc. Applets are written in the Java
programming language, and they run in the context of a web browser or an applet viewer,
which provides the environment for execution.
Unlike regular Java applications, which are run by a Java Virtual Machine (JVM) installed on
a computer, Applets are run by a JVM embedded in the web browser. Applets were widely
used for interactive content on websites but have become less common due to security
concerns and the rise of more modern technologies like HTML5, JavaScript, and CSS.
Applet Lifecycle:
The lifecycle of an applet consists of specific stages that determine how the applet is
initialized, displayed, and destroyed. These stages are managed by the browser (or applet
viewer). The main methods involved in the lifecycle are:
1. init():
o This method is called once when the applet is loaded for the first time. It is
used to initialize the applet, such as setting up the user interface and reading
data.
o Example: Setting up initial configurations for the applet, like defining
variables or initializing UI components.
2. start():
o After the init() method, the start() method is called. This method is called
whenever the applet is started or resumed (e.g., when the user revisits a page
with the applet).
o The start() method can be used to start animations or threads that the applet
might be running.
o Example: Starting a thread to animate a moving object or load additional
content.
3. paint():
 o This method is called to display or repaint the applet’s user interface. It is
called whenever the applet needs to be redrawn, such as when it is resized or
when the screen is refreshed.
o Example: Drawing graphics or text on the applet window.
4. stop():
o This method is invoked when the user leaves the page or when the applet is
stopped. The stop() method allows the applet to release resources or stop
ongoing threads to save memory and processing power.
o Example: Stopping threads or saving data before the applet is unloaded.
5. destroy():
o This method is called when the applet is destroyed, i.e., when the browser is
closed or the applet is removed from the page. It allows for the cleanup of any
resources, such as closing files or releasing memory.
o Example: Releasing resources, closing database connections, etc.
Summary of the Applet Lifecycle:
1. init() – Initializes the applet.
2. start() – Starts the applet’s execution.
3. paint() – Repaints the applet’s window.
4. stop() – Stops the applet.
5. destroy() – Destroys the applet and cleans up resources.