NAME-PRIYANSH -RAJ

ROLL NO-123102038
CS-A(03)
EXPERIMENT 1:
1-code
class abc{
float value;

abc(float value) {
this.value = value;
}
}

public class q1 {
public static void main(String[] args) {
abc a = new abc(5.5f);
abc b = a;

System.out.println("before");
System.out.println("a value: " + a.value);
System.out.println("b value: " + b.value);
 b.value = 10.0f;

System.out.println("after");
System.out.println("a value: " + a.value);
System.out.println("b value: " + b.value);
}
}
OUTPUT-

2-CODE
import java.util.Scanner;
public class q2 {
public static void main(String[] args) {
int s=2;
System.out.println("give the limt upto which you want to print
prime nos.");
int limit ;
Scanner sa=new Scanner(System.in);
 limit=sa.nextInt();

System.out.println("Prime numbers up to " + limit + ":");

for (int num = s; num <= limit; num++) {
boolean isPrime = true;

for (int i = 2; i <= Math.sqrt(num); i++) {

if (num % i == 0) {
isPrime = false;
break;
}
}

if (isPrime) {
System.out.print(num + " ");
}
}
}
}

OUTPUT-
3-CODE
public class q3 {
public static void main(String[] args) {

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

System.out.print("Switch case for value: " + i+" ");
switch (i) {
case 1:
System.out.println("first case.");
break;
case 2:
System.out.println("second case.");
break;
case 3:
System.out.println("third case.");
break;
case 4:
System.out.println("fourth case.");
 break;
case 5:
System.out.println("fifth case.");
break;
default:
System.out.println("no other cases match.");
}

}
}
}
OUTPUT-

4-CODE:
public class q4 {
private String str;
 public void displayStringValue() {
System.out.println(this.str);
}

public static void main(String[] args) {

q4 demo = new q4();
demo.displayStringValue() ;
}
}

OUTPUT-

EXPERIMENT 2:
1-CODE:
public class q1 {

public static void compareStrings(String str1, String str2) {

System.out.println("Comparing " + str1 + "\" and \"" + str2 +
"\":");
System.out.println("== : " + (str1 == str2));
 System.out.println("!= : " + (str1 != str2));
System.out.println("equals() : " + str1.equals(str2));
System.out.println("!equals() : " + !str1.equals(str2));
System.out.println();
}

public static void main(String[] args) {

String string1 = new String("Hello");
String string2 = new String("Hello");
String string3 = "World";
String string4 = string1;

compareStrings(string1, string2);
compareStrings(string1, string3);
compareStrings(string1, string4);
compareStrings(string2, string3);
}
}

OUTPUT-
2-CODE:
class Dog {
String name;
String says;
 Dog(String name, String says) {
this.name = name;
this.says = says;
}
}

public class q2{

public static void main(String[] args) {
Dog spot = new Dog("spot", "Ruff!");
Dog scruffy = new Dog("scruffy", "Wurf!");
System.out.println("Dog 1: " + spot.name + " says: " + spot.says);
System.out.println("Dog 2: " + scruffy.name + " says: " +
scruffy.says);
Dog anotherReferenceToSpot = spot;
System.out.println("spot == scruffy: " + (spot == scruffy));
System.out.println("spot.equals(scruffy): " +
spot.equals(scruffy));
System.out.println("spot == anotherReferenceToSpot: " + (spot
== anotherReferenceToSpot));
System.out.println("spot.equals(anotherReferenceToSpot): " +
spot.equals(anotherReferenceToSpot));
}
}

OUTPUT:-
EXPERIMENT 3:
1-CODE:
class Dog {

void bark() {
System.out.println("Woof! Woof!");
}

void bark(int times) {

System.out.println("Woof! ".repeat(times));
}

void bark(double volume) {

System.out.println("Howl! (Volume: " + volume + ")");
}
 void bark(char tone) {
if (tone == 'L') {
System.out.println("Loud Bark: WOOF WOOF!");
} else if (tone == 'S') {
System.out.println("Soft Bark: woof woof...");
} else {
System.out.println("Normal Bark: Woof!");
}
}

void bark(boolean isHappy) {

if (isHappy) {
System.out.println("Excited Bark: WOOF WOOF!!!");
} else {
System.out.println("Calm Bark: woof.");
}
}
}

public class q1 {
public static void main(String[] args) {
Dog dog = new Dog();

System.out.println("Calling different versions of bark():\n");

 dog.bark();
dog.bark(3);
dog.bark(0.8);
dog.bark('L');
dog.bark('S');
dog.bark(false);
dog.bark(true);
}
}

OUTPUT:-

2-CODE:-
class MyClass {
int number;
 String text;
}

public class q2 {
public static void main(String[] args) {
MyClass obj = new MyClass();

System.out.println("Default number: " + obj.number);

System.out.println("Default text: " + obj.text);
}
}

OUTPUT-

3-CODE:-
class MyClass {
int number;
String text;

MyClass(int number) {
 this(number, "Default Text"); // Call the second constructor
}

MyClass(int number, String text) {

this.number = number;
this.text = text;
}

void display() {
System.out.println("Number: " + number);
System.out.println("Text: " + text);
}
}

public class q3 {
public static void main(String[] args) {
MyClass obj = new MyClass(10);
obj.display();
}
}

OUTPUT:-
EXPERIMENT 4:
1-CODE:-

public class q1 {
static String field1 = "Initialized at definition";
static String field2;

static {
field2 = "Initialized in static block";
}

public static void printFields() {

System.out.println("Field1: " + field1);
System.out.println("Field2: " + field2);
}

public static void main(String[] args) {

printFields();
 }
}

OUTPUT:-

2-CODE:-

public class q2 {
public static void main(String... args) {
System.out.println("Number of arguments: " + args.length);
for (String arg : args) {
System.out.println(arg);
}
}
}

OUTPUT-
EXPERIMENT 5:
1-CODE:-
class AccessModifiersDemo {
public String publicField = "Public";
private String privateField = "Private";
protected String protectedField = "Protected";
String packageAccessField = "default";

public void publicMethod() {

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

private void privateMethod() {

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

protected void protectedMethod() {

System.out.println("Protected");
}
 void packageAccessMethod() {
System.out.println("default");
}
}

public class q1{

public static void main(String[] args) {
AccessModifiersDemo demo = new AccessModifiersDemo();

System.out.println(demo.publicField);
// System.out.println(demo.privateField);
System.out.println(demo.protectedField);
System.out.println(demo.packageAccessField);

demo.publicMethod();
// demo.privateMethod();
demo.protectedMethod();
demo.packageAccessMethod();
}
}
OUTPUT:-

EXPERIMENT 6:
1:-CODE-
class A {
public A() {
System.out.println("class A constructor");
}
}

class B {
public B() {
System.out.println("class B constructor");
}
}

class C extends A {
 B bMember = new B();
}

public class q1 {
public static void main(String[] args) {
C c = new C();
}
}
OUTPUT-

2-CODE:-
class Base {
public Base(String message) {
System.out.println("Base class constructor: " + message);
}
}

class Derived extends Base {

public Derived() {
 super("no arg constructor");
System.out.println("derived class (no arg) constructor");
}

public Derived(String message) {

super(message);
System.out.println(message);
}
}

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

Derived derived1 = new Derived();

Derived derived2 = new Derived("abc");

}
}

OUTPUT:-
3-CODE:-
class Person {
public void introduce() {
System.out.println("Hi I'm a person");
}

public void introduce(String name) {

System.out.println("Hi, my name is " + name );
}

public void introduce(String name, int age) {

System.out.println("Hi, I'm " + name + " and I'm " + age + " years
old");
}
}

class Friend extends Person {

public void introduce(String name, String hobby) {
 System.out.println("Hey! I'm " + name + " and I love " + hobby );
}
}

public class q3 {
public static void main(String[] args) {
Friend friend = new Friend();

friend.introduce();
friend.introduce("pranav");
friend.introduce("pranav", 20);
friend.introduce("pranav", "playing cricket");
}
}

OUTPUT:-

4(I)-CODE:-
class abc {
public final void greet() {
 System.out.println("abc");
}
}

class def extends abc {

// Attempting to override the final method greet() will cause a
compiler error
// public void greet() {
// System.out.println("def");
// }
}

public class q41 {

public static void main(String[] args) {
def o = new def();
o.greet();
}
}
OUTPUT-
4(II)-CODE:
final class Fina {
public void sayHello() {
System.out.println("Hello ");
}
}

// class Sub extends Fina {

// }

public class q42 {

public static void main(String[] args) {
Fina fi = new Fina();
fi.sayHello();
}
}

OUTPUT:-
EXPERIMENT 7:-
1-CODE;-
abstract class Base {
public Base() {
print();
}

public abstract void print();

}

class Derived extends Base {

int value = 42;

public void print() {

System.out.println("Value in Derived class: " + value);
}
}
public class q1 {
public static void main(String[] args) {
Derived derived = new Derived();
derived.print();
}
}

OUTPUT:-

2-CODE:-
interface me {
void method1();
void method2();
}

class my implements me {

public void method1() {

 System.out.println("Method 1 is called");
}

public void method2() {

System.out.println("Method 2 is called");
}
}

public class q2{

public static void main(String[] args) {
me myClass = new my();
myClass.method1();
myClass.method2();
}
}

OUTPUT:-

3-CODE:
interface Interface1 {
void methodA();
void methodB();
}

interface Interface2 {
void methodC();
void methodD();
}

interface Interface3 {
void methodE();
void methodF();
}

interface CombinedInterface extends Interface1, Interface2,

Interface3 {
void methodG();
}

class ConcreteClass {
public void concreteMethod() {
System.out.println("Concrete method");
}
}

class my extends ConcreteClass implements CombinedInterface {

public void methodA() {

System.out.println("Method A Interface1");
}

public void methodB() {

System.out.println("Method B Interface1");
}

public void methodC() {

System.out.println("Method C Interface2");
}

public void methodD() {

System.out.println("Method D Interface2");
}

public void methodE() {

System.out.println("Method E Interface3");
}
 public void methodF() {
System.out.println("Method F Interface3");
}

public void methodG() {

System.out.println("Method G CombinedInterface");
}
}

public class q3{

public static void acceptInterface1(Interface1 obj) {
obj.methodA();
obj.methodB();
}

public static void acceptInterface2(Interface2 obj) {

obj.methodC();
obj.methodD();
}

public static void acceptInterface3(Interface3 obj) {

obj.methodE();
 obj.methodF();
}

public static void acceptCombinedInterface(CombinedInterface

obj) {
obj.methodG();
}

public static void main(String[] args) {

my myClass = new my();

acceptInterface1(myClass);
acceptInterface2(myClass);
acceptInterface3(myClass);
acceptCombinedInterface(myClass);

myClass.concreteMethod();
}
}

OUTPUT:-
EXPERIMENT 8:
1-CODE:
class q1 {
private int value = 10;

private void displayValue() {

System.out.println(value);
}

class InnerClass {
public void modifyOuter() {
value += 5;
displayValue();
}
}
 public void useInnerClass() {
InnerClass inner = new InnerClass();
inner.modifyOuter();
}

public static void main(String[] args) {

q1 outer = new q1();
outer.displayValue();
outer.useInnerClass();
outer.displayValue();
}
}

OUTPUT:-

2-CODE:
class q2 {
private String outerField = "outer var";
 class InnerClass {
private String innerField = "inner variable";

private void innerMethod() {

System.out.println("inner method called");
}
}

public void accessInnerClass() {

InnerClass inner = new InnerClass();
System.out.println(inner.innerField);
inner.innerMethod();
}

public static void main(String[] args) {

q2 outer = new q2();
outer.accessInnerClass();
}
}

OUTPUT-
EXPERIMENT 9:
1-CODE;
class q1 {
public static void main(String[] args) {
try {
throw new Exception("this is an exception message");
} catch (Exception e) {
System.out.println("caught exception: " + e.getMessage());
} finally {
System.out.println("finally executed");
}
}
}
OUTPUT:-
2-CODE:-
class MyCustomException extends Exception {
private String message;

public MyCustomException(String message) {

this.message = message;
}

public void displayMessage() {

System.out.println( message);
}
}

public class q2 {
public static void main(String[] args) {
try {
throw new MyCustomException("This is a custom exception");
} catch (MyCustomException e) {
e.displayMessage();
}
}
}
OUTPUT:-