DEV Community: Shrinidhi S

Assignment 3

Shrinidhi S — Tue, 22 Apr 2025 18:03:13 +0000

package assignment_3;

public class Grandma {
    String name = "Stella";

    public void work () {
        System.out.println("Grandma dead");


    }

}

package assignment_3;

public class Mother extends Grandma {
    String name = "Stella";

    public void work() {
        System.out.println("Name : " + name);
        System.out.println("supername : " + super.name);
        super.work();

    }

}

package assignment_3;
public class Kid extends Mother {
    String name = "Suman";

public static void main(String[] args) {
    // TODO Auto-generated method stub
    Kid kid = new Kid();
    kid.study();
}
public void work() {
    System.out.println("Kid:" + name);
    System.out.println("supername:"+ super.name);
}
public void study() {
    System.out.println("Subject");
    work();
} }




OUTPUT:

Subject
Kid:Suman
supername:Stella

Assignment 1

Shrinidhi S — Mon, 21 Apr 2025 12:42:26 +0000

package section_a;

public class School {
    int mark;
    private int salary;

    static String school_name = "St.Antony's Primary School";

    public void conduct_exams() {
        System.out.println("Conducting exams");
    }
    public void publish_results(int mark) {
        System.out.println("Students mark :" + mark);
    }

}

package section_a;

public class Tecaher {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        School teacher = new School();

        teacher.conduct_exams();
        teacher.publish_results(75);

        System.out.println(School.school_name);
        //System.out.println(teacher.salary); 
        //The field School.salary is not visible

    }

}

Output:

Conducting exams
Students mark :75
St.Antony's Primary School

Static & Non static variables

Shrinidhi S — Sat, 19 Apr 2025 16:13:46 +0000

🔁 What is a Static Variable?
A static variable belongs to the class, not to any specific object of that class. That means all objects share the same static variable. It’s like having one copy of a variable that everyone uses.
Static variables Can be accessed from any part of the program.
When a variable is declared as static, then a single copy of the variable is created and shared among all objects at a class level.
✅We can create static variables at class level only.Static variables can be accessed by static and non static methods.
They are class specified.

🏫 Non-Static Variable
A non-static variable (also called an instance variable) belongs to an object. Every time you create a new object, it gets its own copy of that variable.
✅Non static variables can be accessed using instance (object) of a class.In non Static variable Memory is allocated each time an instance of the class is created.They are object specific.

class Student {
    static String schoolName = "Green Valley High";  // shared by all students (static)
    String studentName;                              // each student has their own name (non-static)
}

public class Main {
    public static void main(String[] args) {
        Student s1 = new Student();
        Student s2 = new Student();

        s1.studentName = "Aarav";
        s2.studentName = "Diya";

        System.out.println("Student 1:");
        System.out.println("Name: " + s1.studentName);              // non-static
        System.out.println("School: " + Student.schoolName);       // static (accessed using class name)

        System.out.println("\nStudent 2:");
        System.out.println("Name: " + s2.studentName);              // non-static
        System.out.println("School: " + Student.schoolName);       // static (same for all)
    }
}

Primitive VS Non-Primitive Datatypes

Shrinidhi S — Sat, 19 Apr 2025 15:38:49 +0000

The Java programming language is statically-typed, which means that all variables must first be declared before they can be used.
Data types in Java specify how memory stores the values of the variable. Each variable has a data type that decides the value the variable will hold.

Primitive Data Types:

Primitive data types specify the size and type of variable values.
They store only single values and have no additional capabilities.

They are the building blocks of data manipulation and cannot be further divided into simpler data types.

**Boolean** - A boolean data type can store either True or False. They can be used to check whether two values are equal or not (basically in conditional statements to return True or False).
The default boolean value is False.

**Char** - The character data type stores a single character. It stores lowercase and uppercase characters, which must be enclosed in single quotes. 

**Int** - An integer type stores an integer number with no fractional or decimal places. Java has four integer types – byte, short, int, and long.

**Long** - long is a 64-bit signed two’s complement integer that stores values ranging from -9223372036854775808(-2^63) to 9223372036854775807(2^63 -1). It is used when we need a range of values more than those provided by int. Its default value is 0L. This data type ends with ‘L’ or ‘l’.

**Float **- It is a floating-point data type that stores the values, including their decimal precision. It is not used for precise data such as currency or research data. can have a 7-digit decimal precision

**Double** - The double data type is similar to float. The difference between the two is that is double twice the float in the case of decimal precision. It is used for decimal values just like float and can be used for precise values. can have a 15-digit decimal precision.

Non-Primitive Data Types:

The Non-Primitive (Reference) Data Types will contain a memory address of variable values because the reference types won’t store the variable value directly in memory. They are strings, objects, arrays, etc.
Unlike primitive data types we define by Java, non-primitive data types are user-defined. Programmers create them and can be assigned with null. All non-primitive data types are of equal size.

**String** - The String data type stores a sequence or array of characters. A string is a non-primitive data type, but it is predefined in Java.

Please refer my previous vlog of datatypes in java for better understanding.

Data Types in Java

Shrinidhi S — Fri, 18 Apr 2025 11:04:48 +0000

In Java, primitive data types are the most basic building blocks of data — they’re not objects, and they store actual values (not references). There are 8 primitive data types in Java, and each has a specific size and purpose.

Data          Size               Example

byte        1 byte (8-bit)    127   
short       2 bytes (16-bit)      32000 
int     4 bytes (32-bit)      100000    
long        8 bytes (64-bit)      10000000000L  
float       4 bytes (32-bit)      3.14f 
double      8 bytes (64-bit)      3.1415926535  
char        2 bytes (16-bit)      'A'   
boolean     1 bit             true or false

public class PrimitiveExample {
    public static void main(String[] args) {
        int age = 20;
        float height = 5.9f;
        char grade = 'A';
        boolean isPassed = true;

        System.out.println("Age: " + age);
        System.out.println("Height: " + height);
        System.out.println("Grade: " + grade);
        System.out.println("Passed: " + isPassed);
    }
}

Unlike primitive types (which store actual values like numbers or characters), non-primitive types store references to objects in memory.
String --> Sequence of characters
EX:"Hello", "Java

Array --> Stores multiple values of the same type
Ex:int[] nums = {1,2,3}

In simple terms:

A primitive is like the actual book.
A non-primitive is like the library card that points you to the book’s location.

Intro to Git

Shrinidhi S — Thu, 17 Apr 2025 11:39:30 +0000

🚀 Git is a distributed version control system that helps you keep track of changes to your code.
Git is free and open-source software.
It was originally created by Linus Torvalds for version control during the development of the Linux kernel.
In software development, distributed version control (also known as distributed revision control) is a form of version control in which the complete codebase, including its full history, is mirrored on every developer's computer.

Why Use Git?
🕹️ Version control – Undo mistakes, view history

🤝 Collaboration – Multiple people can work on the same project

🌿 Branching – Try new features without breaking the main code

🔄 Merging – Combine different code versions easily

🧩 Integration – Works with platforms like GitHub, GitLab, Bitbucket

git init        # Start a new Git repo
git add .       # Stage your changes
git commit -m "Message"   # Save changes with a message
git status      # Check what’s going on
git push        # Upload your code to GitHub
git pull        # Download the latest code

If you're working on personal projects, contributing to open source, or building with a team, learning Git is a must. It’s one of those tools that may seem complex at first, but once you get the hang of it, it becomes second nature.

Object creation

Shrinidhi S — Wed, 16 Apr 2025 15:26:53 +0000

public class Calculator
{
public static void main(String[] args)
{
Calculator casio = new Calculator(); //Constructor
}
public void add()
{
System.out.println(10+20);
}

}

In java, we have a keyword called "new" which should be followed by class name.
Class name should start with capital letter.

new Calculator;

Here, an object is created and then we have to give name.

calculator casio = new Calculator; //constructor

Here casio is object's name.
calculator casio - object's representation.
new Calculator - object creation.

Structure of object creation:

Classname reference_name = new Classname;

What is a method?
A method is a block of code that performs a specific task and can be called for execution by its name.

public void add()

If it contains () it is definitely a method.
main(String[] args) - main method
add() - add method

How to write a java program?

Shrinidhi S — Wed, 16 Apr 2025 14:51:38 +0000

public class First
{
 public static void main(String[] args)
    {
    System.out.println("Welcome To Java"); 
    }
}

Let's breakdown the program:

Line 1: public class First
This line defines a class named First.
In Java, everything must be inside a class.
The keyword public means this class is accessible from anywhere in your program.

Line 2: {
This opening curly brace { marks the start of the class body.
All the code inside the class will go between { and }.

Line 3: public static void main(String[] args)

This is the main method — the entry point of any Java program.
Without this line, we can't run a java program.

public: The method is accessible from outside the class.
static: You don’t need to create an object of the class to run this method.
void: This method does not return any value.
main: The name of the method — Java looks for this to start the program.
String[] args: This is used to accept command-line arguments (an array of Strings).

Line 4: {
This curly brace { starts the body of the main method.

Line 5: System.out.println("Welcome To Java");
This line prints "Welcome To Java" to the screen.
println() is a method that prints the message and moves the cursor to the next line.

Final Output when you run the program:
Welcome To Java

Classes and Objects in Java

Shrinidhi S — Wed, 16 Apr 2025 14:23:29 +0000

Lets discuss about class and object.

Class:
A class is a blueprint or template from which objects are created.
Class is Not a Real-World Entity.
Class Does Not Occupy Memory. Classes themselves do not occupy memory until an object is created from the class.

Object:
Objects represent actual real-world objects and are instances of classes. They include data (attributes) and behaviors (methods) associated with a particular class.

A class defines the properties that objects of that class will have whereas an object has values for those properties.

Example: Vehicle - truck, car, bus.
In this example, vehicle is a class and truck is an object.

JVM, JDK & JRE

Shrinidhi S — Tue, 15 Apr 2025 12:28:18 +0000

JVM-Java Virtual Machine
JVM is responsible for converting bytecode to machine-specific code(binary) and is necessary in both JDK and JRE. It is platform-dependent and performs many functions, including memory management and security.

JDK-Java Development Kit
JDK contains all the tools that are required to compile, debug, and run a program developed using the Java platform.

JRE-Java Runtime Environment
JRE, is a set of software tools responsible for execution of the Java program or application on your system.

Java has two levels of translations.
After writing a program it has to be converted into binary. (computer understandable language 0s and 1s)
For example, we write a code called first.
In other programming languages like C or C++ it is directly converted into binary. But in java it is converted into .class file also known as byte code which is an intermediary file and then into binary.

First.java(our code) --> First.class (byte code) --> Binary code.

Why?
For providing high performance.
While changing into class file it checks for errors.

JDK contains compiler which checks for errors. When a code is error-free it gets converted into .class file. The time taken for this process is called compilation time.

JRE contains JVM which receives the .class file(byte code) and according to the Operating system present it converts the byte code into binary. The time taken for this process is called run time.

Let's understand the difference between compiler and interpreter.
A compiler translates source code into machine code before execution, while an interpreter translates and executes code line by line.
An Interpreter takes single lines of a code.
Compiler is faster than interpreter.

To explain this simply, compiler is a whole translator while intnterpreter is a line by line translator.

Features of Java

Shrinidhi S — Tue, 15 Apr 2025 09:33:55 +0000

Java programming language offers many features that make it both efficient and effective. Here are some of the key features of Java:

1.Simple
Java is a straightforward and easy to understand programming language.It has same grammer as C and C++.

2.Platfrom Independent
The goal of Java developers’ was to create a language that is compatible with all platforms.A platform is the hardware or software environment in which a program runs.
There are two types of platforms software-based and hardware-based. Java provides a software-based platform.
Java code can be executed on multiple platforms, for example, Windows, Linux, Sun Solaris, Mac/OS, etc.

3.Portable
The “write once, run anywhere” concept of Java makes it portable since it enables Java code to be turned into a platform-independent bytecode that can run on any device that has a Java Virtual Machine (JVM).It doesn't require any implementation.

4.Secure
Java programs run inside a virtual machine, which adds an extra layer of protection.Additionally, it uses its own runtime environment called the Java Virtual Machine (JVM), which ensures the controlled execution of programs.

5.Multithreaded
One of the important features of Java programming language is multi-threading. Java supports multithreading, which allows multiple tasks to run at the same time.The main advantage of multi-threading is that it doesn't occupy memory for each thread. It shares a common memory area.

6.Object-Oriented
Java is an object-oriented programming language. Object-oriented programming (OOPs) is a methodology that simplifies software development and maintenance by providing some rules. Everything in Java is an object.
The object is a thing that may be used to symbolize any individual, location, or thing and can be set apart from others. Every object has a state and behavior that are connected to it.

A group of objects that share the same state and behavior is referred to as a class.

7.Distributed
Java's networking capabilities make it well-suited for building distributed applications that involve multiple computers working together.

8.High-performance
Java is faster than other traditional interpreted programming languages.It is still a little bit slower than a compiled language. Java is an interpreted language that is why it is slower than compiled languages, e.g., C, C++, etc.
Compiled languages: A compiler translates the source code into machine code, which is then executed by the processor.
Interpreted languages: An interpreter reads and executes the source code line by line.