Final Codes Wagera

class Circle{
public double radius;

public double Area(double radius){

return (3.14 * radius * radius);
}
public double Perimeter(double radius){
return (2*3.14*radius);
}
}

class Rectangle{
public int length;
public int breadth;

public int Area(int length, int breadth){

return (length * breadth);
}
public int Perimeter(int length, int breadth){
return (2*(length + breadth));
}
}

public class PeriArea{

public static void main(String[] args) {
Circle c = new Circle();
Rectangle r = new Rectangle();
c.radius = 5.0;
r.length = 4;
r.breadth = 6;
System.out.println("Area of Circle: " + c.Area(c.radius));
System.out.println("Perimeter of Circle: " + c.Perimeter(c.radius));
System.out.println("Area of Rectangle: " + r.Area(r.length,
r.breadth));
System.out.println("Perimeter of Rectangle: " + r.Perimeter(r.length,
r.breadth));
}
}
//Final Class - No inheritance allowed
//Finalmethods - No overriding allowed
//Final variables - No reassigning allowed

final class FinalClass { // Final class, cannot be inherited

final void finalMethod() {
System.out.println("This is a final method and cannot be
overridden.");
}

final int a = 10; // Final variable, cannot be reassigned

class Test{
public static void main(String[] args) {
FinalClass obj = new FinalClass();
obj.finalMethod();
System.out.println("Value of final variable a: " + obj.a);

}
}

import java.util.Scanner;

public class Concat {

public static void main(String args[]){
Scanner sc = new Scanner(System.in);

System.out.print("Enter first name:");

final String first = sc.nextLine();

System.out.print("Enter last name:");

final String last = sc.nextLine();

final String full = first + " " + last;

System.out.println(full);

}
}
public class CommandLine{
/* public static void main(String args[]) {
int i;
int sum = 0;
for (i = 0; i < args.length; i++) {
sum += Integer.parseInt(args[i]);
}
System.out.println("Sum of command line arguments: " + sum);
} */

/* public static void main(String args[]) {

String arg1 = args[0];
String arg2 = args[1];
String arg3 = args[2];
System.out.println(arg1 + " " + arg2 + " " + arg3);
}*/

public static void main(String args[]) {

String arg1 = args[0];
String arg2 = args[1];
int arg3 = Integer.parseInt(args[2]);
System.out.println(arg1 + " " + arg2 + " " + arg3);
}
}

import java.util.Scanner;
// This program checks if a given year is a leap year or not.

public class LeapYear {

public static void main(String[] args) {

Scanner sc = new Scanner(System.in);

System.out.print("Enter a year: ");
int year = sc.nextInt();
sc.close();

String result = ((year % 4 == 0 && year % 100 != 0) || (year % 400 ==

0)) ? "Leap Year" : "Not a Leap Year";
System.out.println(year + " is " + result);
}
}
class Calc {
public int add(int a, int b) {
return a + b;
}
public int subtract(int a, int b) {
return a - b;
}
public int multiply(int a, int b) {
return a * b;
}
public int divide(int a, int b) {
if (b == 0) {
throw new ArithmeticException("Division by zero is not allowed.");
}
return a / b;
}

public class BasicCalc {

public static void main(String[] args) {
Calc calc = new Calc();
int a = 10;
int b = 5;
System.out.println("Addition: " + calc.add(a, b));
System.out.println("Subtraction: " + calc.subtract(a, b));
System.out.println("Multiplication: " + calc.multiply(a, b));
System.out.println("Division: " + calc.divide(a, b));

}
}

import java.util.Scanner;

public class factorial {

public static void main(String[] args) {

Scanner sc = new Scanner(System.in);

System.out.print("Enter a number: ");
int num = sc.nextInt();
sc.close();
int result = 1;

for (int i = 1; i <= num; i++) {

result *= i;
}

System.out.println("Factorial of " + num + " is: " + result);

}
}

public class array {

public static void main(String[] args) {
int[] numbers = {1, 2, 3, 4, 5};

int[] rev = new int[numbers.length];

for (int i=0; i<numbers.length; i++){

rev[i] = numbers[numbers.length-i-1];
}

System.out.print("Reversed array: ");

for (int i=0; i<rev.length; i++){
System.out.print(rev[i] + " ");
}
System.out.println();
}
}

public class Palindrome{

public static void main(String args[]) {
String str = args[0];
String rev = "";

for (int i = str.length() - 1; i >= 0; i--) {

rev += str.charAt(i);
}

if (str.equals(rev)) {
System.out.println(str + " is a palindrome.");
} else {
System.out.println(str + " is not a palindrome.");
}
}
}

class Bhaiya {
int age = 40;

Bhaiya() {
System.out.println("Bhaiya constructor called");
}

void about1() {
System.out.println("Papa hu main, pure duniya ka papa!");
}
}

class Munna extends Bhaiya {

int age = 20;

Munna() {
super(); // Calls Bhaiya's constructor
System.out.println("Munna constructor called");
}

@Override
void about1() {
System.out.println("Bhaiya Bacahaooo!!");
super.about1(); // Call Bhaiya's about1()
System.out.println("Bhaiya's age is: " + super.age); // Access
Bhaiya's variable
System.out.println("Munna's age is: " + this.age); // Access
Munna's variable
}
}

public class Super {

public static void main(String[] args) {
Munna m = new Munna(); // Constructor chain runs
m.about1(); // Method chain runs
}
}
public class MethodOverloading {
public int mul(int a,int b){
return a*b;
}

public int mul (int a,int b,int c){

return a*b*c;
}
}

class Test{
public static void main(String args[]){
MethodOverloading mo = new MethodOverloading();
System.out.println(mo.mul(5, 6)); // prints 30
System.out.println(mo.mul(10,10,10));
}
}

class Bhaiya {
public void about1(){
System.out.println("Papa hu main, pure duniya ka papa!");
}
}

class Munna extends Bhaiya {

@Override

public void about1(){

System.out.println("Bhaiya Bacahaooo!!");
super.about1(); //Forcefully calling the parent class method
}

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

Munna m = new Munna();

m.about1(); // prints "Bhaiya Bacahaooo!!"

}
}
public class ConstructorOverloading {
ConstructorOverloading() {
System.out.println("Default Constructor");
}
ConstructorOverloading(int a) {
System.out.println("Parameterized Constructor with int: " + a);
}
ConstructorOverloading(String s) {
System.out.println("Parameterized Constructor with String: " + s);
}
}

class Test{
public static void main(String[] args) {
ConstructorOverloading obj1 = new ConstructorOverloading();
ConstructorOverloading obj2 = new ConstructorOverloading(10);
ConstructorOverloading obj3 = new ConstructorOverloading("Spandan
Certified Java Programmer");
}
}

//Basically, Static is a class that contains static methods and variables.

// Static methods and variables are shared among all instances of the class.
// Static methods and variables can be accessed without creating an instance
of the class.

class Europe{
static String Club;
int shirt;
String country;

static {
Club = "Barcelona";
System.out.println("Static block of Europe class executed");
}

}
class Test{
public static void main(String args[]){
Europe e1 = new Europe();

e1.country="Brazil";
e1.shirt=11;

Europe e2 = new Europe();

e2.country="Espana";
e2.shirt=19;

System.out.println("Country: " + e1.country + ", Shirt: " + e1.shirt +

", Club: " + Europe.Club);
System.out.println("Country: " + e2.country + ", Shirt: " + e2.shirt +
", Club: " + Europe.Club);
}
}

abstract class Animal{

int age;
String name;
public abstract void makenoise();
}

class Dog extends Animal{

public void makenoise(){
System.out.println("Bhaw Bhaw");
}
}

class Test{
public static void main(String[] args) {
Dog d = new Dog();
d.name="Tommy";
d.age=7;
d.makenoise();
System.out.println("Name:" + d.name + " " + "Age:" + d.age);

}
}
class Bhaiya {
public void about1(){
System.out.println("Papa hu main, pure duniya ka papa!");
}
}

class Munna extends Bhaiya {

public void about2(){
System.out.println("Bhaiya Bacahaooo!!");
}
}

class Test{
public static void main(String args[]){
Munna m = new Munna();
m.about1();
m.about2();
}
}

interface A { // We acn use interaface if we have abstact class with

abstract methods
void show(); //By Default these are abstract methods
void config(); //We cannont instantiate interface
int num = 10;
String s = "Hello"; //We can declare variables in interface but they are by
default static and final

} //A a = new A(); // This is not allowed

class B implements A { //We can implement interface

public void show() {

System.out.println("Hello from show method of interface A");
}
public void config() {
System.out.println("Hello from config method of interface A");
}
}
class Test {
public static void main(String args[]) {
B b = new B();
b.show();
b.config();
System.out.println("Value of num: " + b.num); // Accessing interface
variable
System.out.println("Value of s: " + b.s); // Accessing interface
variable
}
}

interface A{

void hola();
void bhola();
}

class B implements A{

public void hola(){

System.out.println("Hola");
}

public void bhola(){

System.out.println("bhola");
}
}

class C extends B{

@Override
public void hola(){
System.out.println("Hola from C");
}

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

C c = new C();
c.hola(); // Output: Hola from C
c.bhola(); // Output: bhola from B
}
}

abstract class Appliance{

abstract void turnOn();
}

class Fan extends Appliance{

void turnOn(){
System.out.println("Fan is turned on.");
}
}

class TV extends Appliance{

void turnOn(){
System.out.println("TV is turned on.");
}
}

class Main{
public static void main(String args[]){
Fan fan = new Fan();
TV tv = new TV();
fan.turnOn(); // Output: Fan is turned on.
tv.turnOn(); // Output: TV is turned on.

}
}
abstract class Employee{
abstract void calculateSalary(int hoursWorked, int hourlyRate);
}

class FullTimeEmployee extends Employee {

int hoursWorked;
int hourlyRate;

FullTimeEmployee(int hoursWorked, int hourlyRate) {

this.hoursWorked = hoursWorked;
this.hourlyRate = hourlyRate;
System.out.println("Credentials Acquired!");
}

void calculateSalary(int hoursWorked, int hourlyRate) {

int salary = hoursWorked * hourlyRate;
System.out.println("Full-time employee salary: " + salary);
}
}

class Main{
public static void main(String args[]) {
FullTimeEmployee emp = new FullTimeEmployee(40, 20);
emp.calculateSalary(emp.hoursWorked, emp.hourlyRate); // Output: Full-
time employee salary: 800
}
// Output: Credentials Acquired!
}

class Task extends Thread {

public void run() {
for (int i = 1; i <= 5; i++) {
System.out.println(getName() + " - Count: " + i);
}
}

public static void main(String[] args) {

Task t1 = new Task();
Task t2 = new Task();
t1.start();
t2.start();
}
}

// Custom exception class

class NegativeValueException extends Exception {
NegativeValueException(String message) {
super(message);
}
}

public class exception1 {

public static void main(String[] args) {
try {
int a = -1;
if (a < 0) {
throw new NegativeValueException("Value cannot be negative!");
}
}
catch(NegativeValueException e) {
System.out.println("Negative value exception caught: " +
e.getMessage());
}
finally {
System.out.println("Finally block executed.");
}
}
}
abstract class Employee{
abstract void calculateSalary(int hoursWorked, int hourlyRate);
}

class FullTimeEmployee extends Employee {

int hoursWorked;
int hourlyRate;

FullTimeEmployee(int hoursWorked, int hourlyRate) {

this.hoursWorked = hoursWorked;
this.hourlyRate = hourlyRate;
System.out.println("Credentials Acquired!");
}

void calculateSalary(int hoursWorked, int hourlyRate) {

int salary = hoursWorked * hourlyRate;
System.out.println("Full-time employee salary: " + salary);
}
}

class Main{
public static void main(String args[]) {
FullTimeEmployee emp = new FullTimeEmployee(40, 20);
emp.calculateSalary(emp.hoursWorked, emp.hourlyRate); // Output: Full-
time employee salary: 800
}
// Output: Credentials Acquired!
}

class Box {

int value;
Box(int value) {
this.value = value;
}

Box doubleValue(Box b) {
return new Box(b.value * 2);
}
public static void main(String[] args) {
Box b1 = new Box(10);
Box b2 = b1.doubleValue(b1);
System.out.println("Doubled Value: " + b2.value);
}
}