Scribd Logo
Upload

Welcome to Scribd!

  • 3 views

    Untitled Document

    Uploaded by

    tannuswami150
    Java notes

    Copyright:

    © All Rights Reserved
    Download as PDF, TXT or read online from Scribd

    Untitled Document

    Uploaded by

    tannuswami150
    3 views9 pages
    Java notes

    Original Title

    Untitled document

    Copyright

    © © All Rights Reserved

    Available Formats

    PDF, TXT or read online from Scribd

    Did you find this document useful?

    Is this content inappropriate?

    Java notes

    Copyright:

    © All Rights Reserved
    Download as PDF, TXT or read online from Scribd
    Download as pdf or txt
    3 views9 pages

    Untitled Document

    Uploaded by

    tannuswami150
    Java notes

    Copyright:

    © All Rights Reserved
    Download as PDF, TXT or read online from Scribd
    Download as pdf or txt
    of 9

    **1.

    Java Program to Print "Hello" Command**

    ```java
    //HelloWorld.java
    public class HelloWorld {
    public static void main(String[] args) {
    System.out.println("Hello");
    }
    }
    ```

    **Output:**

    ```
    Hello
    ```

    **2. Java Program to Represent Abstract Class with Example**

    ```java
    // AbstractClass.java
    abstract class Shape {
    abstract double getArea();
    }

    class Rectangle extends Shape {


    double length, width;

    Rectangle(double length, double width) {


    this.length = length;
    this.width = width;
    }

    @Override
    double getArea() {
    return length * width;
    }
    }

    class Circle extends Shape {


    double radius;

    Circle(double radius) {
    this.radius = radius;
    }

    @Override
    double getArea() {
    return Math.PI * radius * radius;
    }
    }

    public class AbstractClassExample {


    public static void main(String[] args) {
    Shape[] shapes = {new Rectangle(5, 10), new Circle(3)};

    for (Shape shape : shapes) {


    System.out.println("Area: " + shape.getArea());
    }
    }
    }
    ```

    **Output:**

    ```
    Area: 50.0
    Area: 28.274333882308138
    ```

    **3. Java Program to Show Different Levels of Inheritance**

    ```java
    // InheritanceExample.java
    class Animal {
    String name;

    Animal(String name) {
    this.name = name;
    }

    public void speak() {


    System.out.println("Animal says...");
    }
    }

    class Dog extends Animal {


    Dog(String name) {
    super(name);
    }

    @Override
    public void speak() {
    System.out.println("Dog barks...");
    }
    }
    class Cat extends Animal {
    Cat(String name) {
    super(name);
    }

    @Override
    public void speak() {
    System.out.println("Cat meows...");
    }
    }

    public class InheritanceExample {


    public static void main(String[] args) {
    Animal animal = new Animal("Animal");
    Dog dog = new Dog("Dog");
    Cat cat = new Cat("Cat");

    animal.speak();
    dog.speak();
    cat.speak();
    }
    }
    ```

    **Output:**

    ```
    Animal says...
    Dog barks...
    Cat meows...
    ```

    **4. Java Program to Find the Fibonacci Series Using Recursive Functions**

    ```java
    // Fibonacci.java
    public class Fibonacci {
    public static int fib(int n) {
    if (n <= 1) {
    return n;
    }

    return fib(n - 1) + fib(n - 2);


    }

    public static void main(String[] args) {


    int n = 10;
    for (int i = 0; i < n; i++) {
    System.out.print(fib(i) + " ");
    }
    }
    }
    ```

    **Output:**

    ```
    0 1 1 2 3 5 8 13 21 34
    ```

    **5. Java Program to Show Method Overloading**

    ```java
    // MethodOverloading.java
    class Calculator {
    int sum(int a, int b) {
    return a + b;
    }

    double sum(double a, double b) {


    return a + b;
    }

    public static void main(String[] args) {


    Calculator calculator = new Calculator();

    System.out.println(calculator.sum(10, 20)); // Integer arguments


    System.out.println(calculator.sum(12.5, 15.3)); // Double arguments
    }
    }
    ```

    **Output:**

    ```
    30
    27.8
    ```

    **6. Java Program to Create Inner Classes**

    ```java
    // InnerClassExample.java
    class OuterClass {
    int x = 10;

    class InnerClass {
    int y = 5;

    public void display() {


    System.out.println("x = " + x);
    System.out.println("y = " + y);
    }
    }

    public static void main(String[] args) {


    OuterClass outerClass = new OuterClass();
    OuterClass.InnerClass innerClass = outerClass.new InnerClass();

    innerClass.display();
    }
    }
    ```

    **Output:**

    ```
    x = 10
    y=5
    ```

    **7. Java Program to Show Constructor Overloading**

    ```java
    // ConstructorOverloading.java
    class Student {
    int rollNumber;
    String name;

    Student() {
    // Default constructor
    }

    Student(int rollNumber) {
    this.rollNumber = rollNumber;
    }

    Student(int rollNumber, String name) {


    this.rollNumber = rollNumber;
    this.name = name;
    }
    public static void main(String[] args) {
    Student student1 = new Student();
    Student student2 = new Student(10);
    Student student3 = new Student(20, "John");

    System.out.println(student1.rollNumber + " " + student1.name);


    System.out.println(student2.rollNumber + " " + student2.name);
    System.out.println(student3.rollNumber + " " + student3.name);
    }
    }
    ```

    **Output:**

    ```
    0 null
    10 null
    20 John
    ```

    **8. Java Program to Exhibit Polymorphism**

    ```java
    // PolymorphismExample.java
    class Animal {
    public void speak() {
    System.out.println("Animal says...");
    }
    }

    class Dog extends Animal {


    @Override
    public void speak() {
    System.out.println("Dog barks...");
    }
    }

    class Cat extends Animal {


    @Override
    public void speak() {
    System.out.println("Cat meows...");
    }
    }

    public class PolymorphismExample {


    public static void main(String[] args) {
    Animal[] animals = { new Animal(), new Dog(), new Cat() };
    for (Animal animal : animals) {
    animal.speak();
    }
    }
    }
    ```

    **Output:**

    ```
    Animal says...
    Dog barks...
    Cat meows...
    ```

    **9. Java Program to Show Concepts of Encapsulation and Overriding**

    ```java
    // EncapsulationAndOverridingExample.java
    class Animal {
    private String name;

    public String getName() {


    return name;
    }

    public void setName(String name) {


    this.name = name;
    }

    public void speak() {


    System.out.println("Animal says...");
    }
    }

    class Dog extends Animal {


    @Override
    public void speak() {
    System.out.println("Dog barks...");
    }
    }

    public class EncapsulationAndOverridingExample {


    public static void main(String[] args) {
    Animal animal = new Animal();
    animal.setName("Animal");
    System.out.println("Animal's name: " + animal.getName());
    animal.speak();
    Dog dog = new Dog();
    dog.setName("Dog");
    System.out.println("Dog's name: " + dog.getName());
    dog.speak();
    }
    }
    ```

    **Output:**

    ```
    Animal's name: Animal
    Animal says...
    Dog's name: Dog
    Dog barks...
    ```

    **10. Java Program to Represent ArrayList Class**

    ```java
    // ArrayListExample.java
    import java.util.ArrayList;

    public class ArrayListExample {


    public static void main(String[] args) {
    ArrayList<Integer> numbers = new ArrayList<>();

    numbers.add(10);
    numbers.add(20);
    numbers.add(30);

    System.out.println(numbers);

    for (int number : numbers) {


    System.out.println(number);
    }
    }
    }

    **Output:**

    [10, 20, 30]


    10
    20
    30

    You might also like