java program structure,java Tokens, keywords,

java program structure

                Java program may contain many classes of which only one class define a main method. Class contain data members and methods that operate on the data members of the class.

 















Documentation Section

In Java, comments are used to annotate code and are ignored by the compiler. Java supports two types of comments: single-line and multi-line comments.


1.Single-Line Comments

Syntax: Single-line comments start with `//` and continue to the end of the line.


Use Case: Ideal for brief explanations or notes that occupy only one line.


Example:

class MyClass

{

     public static void main(String[] args) 

        {
             int number = 10; // This is a single-line comment
             System.out.println(number); // Output the number
         }

}


2. Multi-Line Comments

Syntax: Multi-line comments start with `/*` and end with `*/`. They can span multiple lines.


Use Case: Useful for longer explanations, notes, or temporarily commenting out blocks of code.


Example:

        class MyClass {

         public static void main(String[] args) {
             /*
              * This is a multi-line comment.
              * It can span multiple lines.
              * Useful for detailed explanations.
              */
             int number = 10;
             System.out.println(number);
         }
     }


In this example, the multi-line comment provides a more detailed explanation, which might be too long for a single line.

When to Use Which Type

Single-line comments

best for short notes, like clarifying a single statement or marking something that needs attention.


Multi-line comments

better for providing detailed descriptions, such as explaining a complex section of code, or when you need to comment out a block of code for debugging purposes.

Package Declaration (Optional)

If your class belongs to a package, you declare it at the top of your Java file.

Syntax:

package packageName; 

Example:

package com.example.myapp;

 

Import Statements (Optional)

Used to import other Java classes or packages that you need in your program.

Syntax:

import java.test.*; 

Example:

import java.util.Scanner;

 

Interface Statements

            In Java, an interface is a reference type, similar to a class, that can contain only constants, method signatures, default methods, static methods, and nested types. Interfaces cannot contain instance fields, and their methods do not have a body (except for default and static methods). Interfaces are used to specify what a class must do, but not how it does it.

 

Class Declaration

class is the fundamental building block of a Java program. Every Java program must have at least one class.

The class name should be the same as the file name (case-sensitive).
 
Syntax:
 
class ClassName
{
    // Class body
}
 
Java Main Method
 
The main method in Java is a special method that serves as the entry point for any standalone Java application. When you run a Java program, the Java Virtual Machine (JVM) looks for this method to start the execution of the program.
 
Syntax :Main Method
 
public static void main(String[] args)

------------------end the Java Program Structure----------------------


Java Tokens
 
In Java, a **token** is the smallest element of a program that is meaningful to the compiler. Tokens are the building blocks of Java code. When you write Java code, the compiler breaks it down into these tokens to understand and process it. Java has several types of tokens:

Types of Tokens in Java

1. Keywords
2. Identifiers
3. Literals
4. Operators
5. Separators
6. Comments

1. Keywords

Definition : Keywords are reserved words in Java that have a predefined meaning in the language. These cannot be used as identifiers (names for variables, classes, methods, etc.).

Examples : 

  - `int`
  - `class`
  - `if`
  - `else`
  - `public`
  - `return`
  - `static`
 
Usage :
 
class MyClass 
{
        public static void main(String[ ] args) 
        {
            int number = 10; // 'int' and 'public' are keywords
        }
}


2. Identifiers
 
Definition : Identifiers are names given to various program elements such as variables, classes, methods, and arrays. An identifier must begin with a letter (A-Z or a-z), a currency symbol (`$`), or an underscore (`_`). Subsequent characters can include digits (0-9).

Examples :

Variable names: `myVariable`, `age`
Class names: `MyClass`, `Student`
Method names: `calculateSum`, `getName`

Rules :

Cannot start with a digit.
Cannot be a keyword.
Case-sensitive: `myVariable` and `MyVariable` are different identifiers.

Usage :
 
class MyClass 
{
      int myVariable = 10;
      String myName = "Java";
  }


3. Literals
 
Definition : Literals are fixed values that appear directly in the code. Java supports several types of literals:
Integer Literals: Whole numbers, e.g., `10`, `0`, `-15`
Floating-point Literals: Decimal numbers, e.g., `3.14`, `0.5`, `-2.7`
Character Literals: Single characters, e.g., `'a'`, `'Z'`, `'1'`
String Literals: Sequences of characters, e.g., `"Hello"`, `"Java"`
Boolean Literals: `true` or `false`
Null Literal: `null`

Examples :
 
int number = 100;            // Integer literal
double pi = 3.14;            // Floating-point literal
char letter = 'A';           // Character literal
String greeting = "Hello";   // String literal
boolean isJavaFun = true;    // Boolean literal
Object obj = null;           // Null literal


4. Operators

Definition : Operators are symbols that perform operations on variables and values. Java supports several types of operators:

  1. Arithmetic Operators            :    `+`, `-`, `*`, `/`, `%`
  2. Relational Operators             : `==`, `!=`, `<`, `>`, `<=`, `>=`
  3. Logical Operators                  : `&&`, `||`, `!`
  4. Bit-wise Operators                 : `&`, `|`, `^`, `~`, `<<`, `>>`
  5. Assignment Operators           : `=`, `+=`, `-=`, `*=`, `/=`
  6. Increment/Decrement Operators: `++`, `--`
  7. Conditional Operator (Ternary Operator): `? :`

Examples :
 
int a = 5;
int b = 10;
int sum = a + b;  // '+' is an arithmetic operator
boolean isEqual = (a == b);  // '==' is a relational operator
boolean isTrue = (a < b) && (b > 0);  // '&&' is a logical operator

5. Separators

Definition : Separators are symbols used to separate code elements in Java. These include:
 
  1. Parentheses    : `( )`
  2. Braces             : `{ }`
  3. Brackets         : `[ ]`
  4. Semicolon       : `;`
  5. Comma           : `,`
  6. Period             : `.`

Usage:
 
class MyClass 
{
    public static void main(String[ ] args) 
    {
        int[ ] array = {1, 2, 3};  // Braces '{ }' and semicolon ';' as separators
          System.out.println(array[0]); // Parentheses '( )', brackets '[]', and period '.' as separators
      }
  }


6. Comments :
 
Definition: Comments are used to annotate the code and are ignored by the compiler. Comments can be single-line or multi-line.

Single-line comments: Start with `//` and go to the end of the line.

Multi-line comments: Start with `/*` and end with `*/`.

Examples:
 
class MyClass 
{
    public static void main(String[] args) 
    {
        // This is a single-line comment
        System.out.println("Hello, World!"); /* This is a multi-line comment */
      }
}

Java Keywords

Java keywords are reserved words that have a predefined meaning in the Java language. These keywords are integral to the syntax and structure of Java programs, and they cannot be used as identifiers (names for variables, classes, methods, etc.). Each keyword serves a specific purpose and contributes to the flow and logic of the code.

### List of Java Keywords

Java has a total of 52 reserved keywords (as of Java 17), which are divided into several categories based on their usage:

1. **Data Type Keywords**
2. **Control Flow Keywords**
3. **Access Modifiers**
4. **Class, Method, and Variable Keywords**
5. **Exception Handling Keywords**
6. **Package and Import Keywords**
7. **Concurrency Keywords**
8. **Other Keywords**

### 1. Data Type Keywords
These keywords are used to define data types in Java.

- **`byte`**: Defines an 8-bit integer.
- **`short`**: Defines a 16-bit integer.
- **`int`**: Defines a 32-bit integer.
- **`long`**: Defines a 64-bit integer.
- **`float`**: Defines a 32-bit floating-point number.
- **`double`**: Defines a 64-bit floating-point number.
- **`char`**: Defines a 16-bit Unicode character.
- **`boolean`**: Defines a boolean value (`true` or `false`).
- **`void`**: Specifies that a method does not return any value.

### 2. Control Flow Keywords
These keywords control the flow of execution within a program.

- **`if`**: Starts a conditional statement.
- **`else`**: Provides an alternative block of code if the `if` condition is false.
- **`switch`**: Allows variable values to be compared against a set of constants.
- **`case`**: Defines a branch in a `switch` statement.
- **`default`**: Specifies the default branch in a `switch` statement.
- **`while`**: Starts a loop that continues while a condition is true.
- **`do`**: Used with `while` to create a loop that executes at least once.
- **`for`**: Starts a loop that iterates a fixed number of times.
- **`break`**: Exits a loop or `switch` statement.
- **`continue`**: Skips the current iteration of a loop and continues with the next iteration.
- **`return`**: Exits from the current method and optionally returns a value.

### 3. Access Modifiers
These keywords define the access level for classes, methods, and variables.

- **`public`**: The member is accessible from any other class.
- **`protected`**: The member is accessible within its own package and by subclasses.
- **`private`**: The member is accessible only within its own class.
- **`default`** (no modifier): The member is accessible only within its own package.

4. Class, Method, and Variable Keywords
These keywords are used to define classes, methods, and variables.

`class`: Declares a class.
`interface`: Declares an interface.
`enum`: Declares an enumerated type.
`extends`: Indicates that a class is inheriting from a superclass.
`implements`: Indicates that a class is implementing an interface.
`static`: Defines a class-level method or variable (shared among all instances).
`final`: Defines constants, prevents method overriding, or inheritance.
`abstract`: Defines an abstract class or method.
`synchronized`: Used for threads to ensure that only one thread accesses the resource at a time.
`volatile`: Indicates that a variable may be changed unexpectedly, and ensures visibility of changes across threads.
`transient`: Prevents serialization of a field.
`native`: Specifies that a method is implemented in native code using JNI (Java Native Interface).
`strictfp`: Ensures floating-point calculations adhere to IEEE 754 standards.

5. Exception Handling Keywords

These keywords handle exceptions and errors in Java.

`try`: Defines a block of code that might throw an exception.
`catch`: Handles the exception thrown by the `try` block.
`finally`: Defines a block of code that executes after the `try` block, regardless of whether an exception was thrown.
`throw`: Used to explicitly throw an exception.
`throws`: Declares exceptions that a method can throw.

6. Package and Import Keywords

These keywords manage the organization and access of classes.

`package`: Declares a package, which is a namespace for organizing classes and interfaces.

`import`: Imports other Java classes or entire packages so they can be used in the current class.

7. Concurrency Keywords

These keywords are used in the context of multithreading and concurrency.

`synchronized`: Ensures that only one thread can execute a block of code at a time.

`volatile`: Indicates that a variable's value will be modified by different threads.

8. Other Keywords
These keywords serve various special purposes in Java.

`this`: Refers to the current object instance.
`super`: Refers to the superclass of the current object.
`instanceof`: Tests whether an object is an instance of a specific class or subclass.
`new`: Creates new objects.
`return`: Exits from a method and optionally returns a value.
`null`: Represents the null reference (no object).
`assert`: Used for debugging purposes to make assertions.
`goto`: Reserved but not used in Java.
`const`: Reserved but not used in Java.

Keywords Introduced in Later Java Versions

var (Java 10): Used for local variable type inference, where the compiler automatically determines the type of the variable.

yield (Java 13): Used in switch expressions to return a value.

record (Java 14): Used to define a new type of class that holds immutable data.

sealed , permits (Java 17): Used to restrict which classes can extend or implement a class or interface.

Special Note

const and goto : These are reserved words but are not used in Java. They were reserved for future use but remain unused.



 
 
 
 

Comments

Post a Comment

Popular posts from this blog

digital marketing ppt-u1

 ppt unit 1-1   download unit 1-2 download unit 2-1 download unit 2-2 download Migrating from Traditional Channels to Digital Channels Migrating from traditional to digital channels can be a significant undertaking for businesses, but it can also lead to significant benefits, such as increased reach, improved customer engagement, and better data-driven decision-making. Here's a breakdown of the process: 1. Define Your Goals and Objectives: What are you hoping to achieve with your digital presence? What specific metrics will you use to measure success? Who is your target audience, and what are their digital habits? 2. Assess Your Current Situation: What are your strengths and weaknesses in terms of digital marketing? What resources do you have available (budget, personnel, technology)? What are the potential risks and challenges of migrating to digital? 3. Choose the Right Digital Channels: Social Media: Which platforms are your target audience most active on? S...
Read more

SOFTWARE

Image
 01 Winrar -64-bit version-623 Download link click- 02 chrome setup Download link click- 03 Turbo-c Download link click-  Dev  C , C ++ 04 typing master 11 Download link click- 05 java software 64-bit version-8 Download link click-               64-bit                                        32-bit        06 Adobe-version-10 Download link click- 07 sublime text -64-version-4 Download link click- 08 python -64-bit-version-3.8.6 -32-bit-version-3.8.10 Download link click- 64-bit                                                  32-bit     09 MS-office 2007 Download link click-    Download link click-wps-office-2020    10 xampp ...
Read more

cn lab

Image
download   01 programs import java.net. * ; import java.io.*; class Ports { public static void main (String [] args) throws Exception { InetAddress h = InetAddress.getLocalHost(); String host =h. getHostName(); String haddr = h. getHostAddress();  System.out.println("\nHost Name: :"+ host);  System.out.println("In Host Address:: "+haddr); for (int i=0; i < 1024; i++) { Socket s=null; try  { s = new Socket ((host), i); System.out.println(" port "+ i + "Active"); } catch (SocketException se) { } catch(Exception e) { System.out.println(" Error...."); } } } } Output:- 02 -program 2 a) import java.io.*; import java.net. *; import java.lang. * ; class chats extends Thread { public static void main (String args []) { try { ServerSocket ss = new ServerSocket (111);  System.out.println ("server ready ");  Socket s = ss.accept (...
Read more

Computer Operations and Performing - D L Unit-1-1

Image
unit-1-1 download   unit-1-2 download   unit-1-3 download  unit-1-1 download  DIGITAL LITERACY syllabus :    Computer      A computer is a programmable electronic device that processes data to perform various tasks. It can store, retrieve, and process information and it is capable of executing a wide range of operations based on instructions provided to it. Computers come in various forms, including personal computers, laptops, servers, and embedded systems. 1.       Central Processing Unit (CPU): Often referred to as the brain of the computer, the CPU performs calculations and executes instructions.   2.       Memory (RAM): Random Access Memory is used to temporarily store data that the CPU needs to access quickly. It is volatile memory, meaning it loses its contents when the power is turned off.   3.       Storage: This includes devices l...
Read more

DBMS Degree Lab Records

Image
  PRACTICAL-I ER-DIAGRAM FOR TRAIN SERVICES  DRAW   ER-DIAGRAM FOR TRAIN SERVICES IN A RAILWAY STATION                              An Entity can be any object, place, person or class. Entity is represented using rectangles. An “ Entity–Relationship Model’’ ( ER- model ) modelling was developed for database design by “ Peter Chen ” and published in a “1976”. An ER- model describes about the inter-related things of interest in a specific domain of knowledge. An ER model is composed of entity types and specifies relationships that can exist between instances of those entity types. RAILWAY MANAGEMENT SYSTEM :-     ·         Railway management System is the computerized system of reserving the seats of train seats in advanced . ·      On-line reservation has made t...
Read more

DS-Record-mca-04) write a program for evaluating a given postfix expression using stack.

Image
    Program:-04   AIM:- write a program for evaluating a given postfix expression using stack. #include<stdio.h> #include<conio.h> int stack[20]; int top = -1; void push(int x) { stack[++top] = x; } int pop() { return stack[top--]; } void main() { char exp[20]; char *e; int n1,n2,n3,num; clrscr(); printf("\nEnter the expression :: "); scanf("%s",exp); e = exp; while(*e != '\0') { if(isdigit(*e)) { num = *e - 48; push(num); } else { n1 = pop(); n2 = pop(); switch(*e) { case '+': { n3 = n1 + n2; break; } case '-': { n3 = n2 - n1; break; } case '*': { ...
Read more

Java unit-1 history , C++ vs Java , java environment

Java History   Java is one of the most influential programming languages, widely used in various applications, from web development to mobile applications and large-scale enterprise systems. Here's a brief overview of its history: 1. Origins and Development: 1991: Java's development began at Sun Microsystems as part of the Green Project, led by James Gosling, Mike Sheridan, and Patrick Naughton. The project aimed to create a language for programming digital devices like set-top boxes and televisions. 1995:Originally called Oak (after an oak tree outside Gosling's office), the language was later renamed Java, inspired by Java coffee. It was officially released by Sun Microsystems as Java 1.0. The language was designed to have the "Write Once, Run Anywhere" (WORA) capability, allowing code to run on any device that supports the Java Virtual Machine (JVM). 2. Key Features: Java's popularity grew due to several features: Platform Independence: Java applications a...
Read more

Access the Internet to Browse Infromation & E-Mail Operation- D L Unit-2-1

    1. what is internet and what are the applications        The internet is a global network of interconnected computers and other electronic devices that communicate with each other using standardized protocols. It allows users to access and share information, resources, and services across vast distances. The internet facilitates various activities such as communication, research, entertainment, commerce, and much more. Key components of the internet include: 1. **Network Infrastructure** :       This comprises physical and virtual components, including cables, routers, switches, servers, and data centers, that enable the transmission of data across the network. 2. **Protocols** :       Protocols are rules and standards that govern how data is transmitted, routed, and received across the internet. Examples include TCP/IP (Transmission Control Protocol/Internet Protocol), HTTP (Hypertext Transfer Protoc...
Read more

OAT-Record-01) Visiting card

Image
  Aim:-To a Design a visiting card for Managing Director of a company as per the following specification. ·          Sizeofvisitingcardis3½×2 ·          Name of the company with big font ·          Phone number, Fax number and E-mail address with appropriate symbols. ·     Office and Residence address separated by a line Procedure:- STEP 1:       Enter into MS-Word environment by choosing start à Programs à Ms Office à MS Word STEP 2:       Now save the opened Blank document with the following step Office Button à save à visiting card STEP 3:       Insert a text box by clicking insert—> text box. STEP 4:       Set the size of the text box to 3(1/2) X2 either with the help of ruler or with Format text box option, which is Available on right click, w...
Read more