[Go to site: main page, start]
Scribd
Upload
76 views3 pages

Simple Java Programs for Beginners

The document contains a series of simple Java programs demonstrating basic programming concepts. Each program addresses a specific task, such as printing 'Hello World', performing arithmetic operations, checking for even or odd numbers, and calculating factorials. These examples serve as introductory exercises for beginners learning Java programming.

Uploaded by

iqra.khanum31
Copyright
© All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
76 views3 pages

Simple Java Programs for Beginners

The document contains a series of simple Java programs demonstrating basic programming concepts. Each program addresses a specific task, such as printing 'Hello World', performing arithmetic operations, checking for even or odd numbers, and calculating factorials. These examples serve as introductory exercises for beginners learning Java programming.

Uploaded by

iqra.khanum31
Copyright
© All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd

Simple Java Programs

1. Print Hello World

class Hello {
public static void main(String[] args) {
[Link]("Hello, World!");
}
}

2. Addition of Two Numbers

class Add {
public static void main(String[] args) {
int a = 10, b = 20;
int sum = a + b;
[Link]("Sum = " + sum);
}
}

3. Check Even or Odd

class EvenOdd {
public static void main(String[] args) {
int num = 7;
if (num % 2 == 0)
[Link]("Even number");
else
[Link]("Odd number");
}
}

4. Find Largest of Two Numbers

class Largest {
public static void main(String[] args) {
int a = 25, b = 30;
if (a > b)
[Link]("Largest = " + a);
else
[Link]("Largest = " + b);
}
}

5. Swap Two Numbers

class Swap {
public static void main(String[] args) {
int a = 5, b = 10, temp;
temp = a;
a = b;
b = temp;
[Link]("After swapping: a = " + a + ", b = " + b);
}
}

6. Factorial of a Number

class Factorial {
public static void main(String[] args) {
int n = 5, fact = 1;
for (int i = 1; i <= n; i++) {
fact = fact * i;
}
[Link]("Factorial = " + fact);
}
}

7. Fibonacci Series

class Fibonacci {
public static void main(String[] args) {
int n1 = 0, n2 = 1, n3, i, count = 10;
[Link](n1 + " " + n2);
for (i = 2; i < count; i++) {
n3 = n1 + n2;
[Link](" " + n3);
n1 = n2;
n2 = n3;
}
}
}
8. Check Prime Number

class Prime {
public static void main(String[] args) {
int num = 7, count = 0;
for (int i = 1; i <= num; i++) {
if (num % i == 0)
count++;
}
if (count == 2)
[Link]("Prime Number");
else
[Link]("Not Prime");
}
}

9. Reverse a Number

class Reverse {
public static void main(String[] args) {
int num = 1234, rev = 0;
while (num != 0) {
rev = rev * 10 + num % 10;
num = num / 10;
}
[Link]("Reversed number = " + rev);
}
}

10. Sum of Digits

class SumDigits {
public static void main(String[] args) {
int num = 1234, sum = 0;
while (num != 0) {
sum = sum + num % 10;
num = num / 10;
}
[Link]("Sum of digits = " + sum);
}
}

Common questions

Powered by AI

The program calculates the sum of the digits by breaking down the number using a 'while' loop. Initiating with a 'sum' variable set to zero, it iteratively adds the last digit of 'num' to 'sum', extracted using 'num % 10'. 'Num' is then reduced by removing the last digit through integer division by 10. This continues until 'num' becomes zero, thereby ensuring that all digits have been processed for their summation. The 'while' loop enables this iterative processing of each digit from least to most significant .

The algorithms in these Java programs are efficient for educational purposes as they demonstrate clear, basic procedural logic using minimal resources. However, their limitations become apparent with larger inputs or more complex data. For instance, the factorial and Fibonacci algorithms can become inefficient due to their lack of optimization or recursion, leading to potential stack overflow or computational delay. Additionally, the prime checking algorithm has a time complexity of O(n), which could be improved to O(√n) through optimized divisibility checks. These simple implementations prioritize clarity over efficiency, highlighting a trade-off inherent in didactic programming .

The algorithm for generating the Fibonacci series involves initializing the first two numbers of the series, 'n1' and 'n2', to 0 and 1, respectively. The program uses a 'for' loop to iterate for a specified number of terms—10 in this case. In each iteration, the next number 'n3' is calculated as the sum of the previous two numbers 'n1' and 'n2'. These variables are updated to prepare for the next iteration: 'n1' takes on the value of 'n2' and 'n2' becomes 'n3'. The sequence is printed as it is generated .

Simple Java programs serve as effective educational tools by providing clear, focused examples of fundamental programming concepts such as variables, control structures (loops and conditionals), and operators. By reducing complexities, they enable learners to comprehend the logic and syntax without distraction. These programs operate as concrete demonstrations of theoretical concepts, allowing hands-on experimentation to consolidate understanding. This pedagogical approach emphasizes practical, incremental learning, providing a foundational framework upon which more complex concepts can be built .

The Java program calculates the factorial of a number by iteratively multiplying integers up to that number. It utilizes a loop structure, specifically a 'for' loop, to iterate from 1 to the number n. In each iteration, the product variable 'fact' is updated by multiplying it with the current iterator variable 'i'. This is demonstrated in the 'Factorial' class where 'fact' starts with a value of 1 and is multiplied by 'i' in each loop iteration up to 'n'. The use of loops and conditional operations are key programming concepts in this implementation .

The program identifies a prime number by counting its divisors. It employs a 'for' loop to traverse all numbers from 1 to the given number 'num'. For each 'i', if 'num' is divisible by 'i' (i.e., 'num % i == 0'), a counter is incremented. After the loop concludes, a prime number is determined by having exactly two divisors: 1 and itself. If the counter equals 2, it prints "Prime Number"; otherwise, "Not Prime". This relies on counting constructs and conditional evaluation to ascertain prime status .

The process involves reversing the digits of a number using a 'while' loop. In the 'Reverse' class, the program initializes 'rev' to 0, which will hold the reversed number. The loop continues as long as 'num' is not zero. In each iteration, 'rev' is updated by multiplying it by 10 and adding the last digit of 'num', obtained using 'num % 10'. 'Num' is then divided by 10 to remove the last digit. This continues until all digits have been processed, resulting in 'rev' holding the reversed number .

The Java program utilizes a straightforward conditional structure to find the largest of two numbers. An 'if-else' statement compares the two numbers, 'a' and 'b'. If 'a' is greater than 'b', it prints "Largest = " followed by 'a'. Otherwise, it prints "Largest = " followed by 'b'. This approach simplifies the problem to a single decision point, using the relational operator '>' for comparison and the 'else' clause for flow control .

The program determines if an integer is even or odd by utilizing the modulo operator '%', which returns the remainder of a division operation. In the 'EvenOdd' class, the program checks the remainder when the number 'num' is divided by 2. If the remainder is 0, the number is even; otherwise, it is odd. This is embodied in the condition 'if (num % 2 == 0)', whereby a true condition results in outputting "Even number" and a false condition yields "Odd number" .

The swapping of two numbers utilizes a temporary variable to hold one of the values temporarily. The process begins with storing the value of 'a' in 'temp', which preserves it during the operation. Next, 'a' is assigned the value of 'b'. Finally, 'b' is set to the value of 'temp', which holds the original value of 'a'. This demonstrates the use of an auxiliary variable to facilitate swapping without data loss, showcasing a fundamental aspect of value interchange in programming .

You might also like