NAME-PRIYANSH -RAJ

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

abc(float value) {
[Link] = value;
}
}

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

[Link]("before");
[Link]("a value: " + [Link]);
[Link]("b value: " + [Link]);
 [Link] = 10.0f;

[Link]("after");
[Link]("a value: " + [Link]);
[Link]("b value: " + [Link]);
}
}
OUTPUT-

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

[Link]("Prime numbers up to " + limit + ":");

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

for (int i = 2; i <= [Link](num); i++) {

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

if (isPrime) {
[Link](num + " ");
}
}
}
}

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

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

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

}
}
}
OUTPUT-

4-CODE:
public class q4 {
private String str;
 public void displayStringValue() {
[Link]([Link]);
}

public static void main(String[] args) {

q4 demo = new q4();
[Link]() ;
}
}

OUTPUT-

EXPERIMENT 2:
1-CODE:
public class q1 {

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

[Link]("Comparing " + str1 + "\" and \"" + str2 +
"\":");
[Link]("== : " + (str1 == str2));
 [Link]("!= : " + (str1 != str2));
[Link]("equals() : " + [Link](str2));
[Link]("!equals() : " + );
[Link]();
}

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) {
[Link] = name;
[Link] = says;
}
}

public class q2{

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

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

void bark() {
[Link]("Woof! Woof!");
}

void bark(int times) {

[Link]("Woof! ".repeat(times));
}

void bark(double volume) {

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

void bark(boolean isHappy) {

if (isHappy) {
[Link]("Excited Bark: WOOF WOOF!!!");
} else {
[Link]("Calm Bark: woof.");
}
}
}

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

[Link]("Calling different versions of bark():\n");

 [Link]();
[Link](3);
[Link](0.8);
[Link]('L');
[Link]('S');
[Link](false);
[Link](true);
}
}

OUTPUT:-

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

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

[Link]("Default number: " + [Link]);

[Link]("Default text: " + [Link]);
}
}

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) {

[Link] = number;
[Link] = text;
}

void display() {
[Link]("Number: " + number);
[Link]("Text: " + text);
}
}

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

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() {

[Link]("Field1: " + field1);
[Link]("Field2: " + field2);
}

public static void main(String[] args) {

printFields();
 }
}

OUTPUT:-

2-CODE:-

public class q2 {
public static void main(String... args) {
[Link]("Number of arguments: " + [Link]);
for (String arg : args) {
[Link](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() {

[Link]("Public");
}

private void privateMethod() {

[Link]("Private");
}

protected void protectedMethod() {

[Link]("Protected");
}
 void packageAccessMethod() {
[Link]("default");
}
}

public class q1{

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

[Link]([Link]);
// [Link]([Link]);
[Link]([Link]);
[Link]([Link]);

[Link]();
// [Link]();
[Link]();
[Link]();
}
}
OUTPUT:-

EXPERIMENT 6:
1:-CODE-
class A {
public A() {
[Link]("class A constructor");
}
}

class B {
public B() {
[Link]("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) {
[Link]("Base class constructor: " + message);
}
}

class Derived extends Base {

public Derived() {
 super("no arg constructor");
[Link]("derived class (no arg) constructor");
}

public Derived(String message) {

super(message);
[Link](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() {
[Link]("Hi I'm a person");
}

public void introduce(String name) {

[Link]("Hi, my name is " + name );
}

public void introduce(String name, int age) {

[Link]("Hi, I'm " + name + " and I'm " + age + " years
old");
}
}

class Friend extends Person {

public void introduce(String name, String hobby) {
 [Link]("Hey! I'm " + name + " and I love " + hobby );
}
}

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

[Link]();
[Link]("pranav");
[Link]("pranav", 20);
[Link]("pranav", "playing cricket");
}
}

OUTPUT:-

4(I)-CODE:-
class abc {
public final void greet() {
 [Link]("abc");
}
}

class def extends abc {

// Attempting to override the final method greet() will cause a
compiler error
// public void greet() {
// [Link]("def");
// }
}

public class q41 {

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

// class Sub extends Fina {

// }

public class q42 {

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

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() {

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

OUTPUT:-

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

class my implements me {

public void method1() {

 [Link]("Method 1 is called");
}

public void method2() {

[Link]("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() {
[Link]("Concrete method");
}
}

class my extends ConcreteClass implements CombinedInterface {

public void methodA() {

[Link]("Method A Interface1");
}

public void methodB() {

[Link]("Method B Interface1");
}

public void methodC() {

[Link]("Method C Interface2");
}

public void methodD() {

[Link]("Method D Interface2");
}

public void methodE() {

[Link]("Method E Interface3");
}
 public void methodF() {
[Link]("Method F Interface3");
}

public void methodG() {

[Link]("Method G CombinedInterface");
}
}

public class q3{

public static void acceptInterface1(Interface1 obj) {
[Link]();
[Link]();
}

public static void acceptInterface2(Interface2 obj) {

[Link]();
[Link]();
}

public static void acceptInterface3(Interface3 obj) {

[Link]();
 [Link]();
}

public static void acceptCombinedInterface(CombinedInterface

obj) {
[Link]();
}

public static void main(String[] args) {

my myClass = new my();

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

[Link]();
}
}

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

private void displayValue() {

[Link](value);
}

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

public static void main(String[] args) {

q1 outer = new q1();
[Link]();
[Link]();
[Link]();
}
}

OUTPUT:-

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

private void innerMethod() {

[Link]("inner method called");
}
}

public void accessInnerClass() {

InnerClass inner = new InnerClass();
[Link]([Link]);
[Link]();
}

public static void main(String[] args) {

q2 outer = new q2();
[Link]();
}
}

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) {
[Link]("caught exception: " + [Link]());
} finally {
[Link]("finally executed");
}
}
}
OUTPUT:-
2-CODE:-
class MyCustomException extends Exception {
private String message;

public MyCustomException(String message) {

[Link] = message;
}

public void displayMessage() {

[Link]( message);
}
}

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