JDK 1.0 Features

JDK 1.0 features with explanations and examples:

Java 1.0 (January 1996): The first version of Java was released by Sun Microsystems, the original creators of Java.

1.Object-oriented programming: 

JDK 1.0 introduced object-oriented programming (OOP) concepts, which made it easier to develop complex applications. OOP allows developers to organize code into reusable and modular objects that interact with each other to perform tasks. 

For example, consider the following Java code that creates a class named Person with attributes name and age:

public class Person {
    private String name;
    private int age;
    
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    
    public void sayHello() {
        System.out.println("Hello, my name is " + name + " and I am " + age + " years old.");
    }
}

In this code, we create a Person class with two attributes name and age and a constructor that sets these attributes. We also define a sayHello() method that prints out a message using the name and age attributes.

2. Platform independence: 

JDK 1.0 introduced the concept of "Write Once, Run Anywhere" (WORA), which means that Java code can run on any platform that has a Java Virtual Machine (JVM) installed. This is possible because Java code is compiled into bytecode, which can be executed by any JVM. 

For example, consider the following Java code:

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello, World!");
    }
}

This code can be compiled using the javac compiler and run on any platform that has a JVM installed using the java command.

3. Garbage Collection: 

JDK 1.0 introduced automatic garbage collection, which makes memory management easier and more efficient. Garbage collection automatically frees up memory that is no longer being used by an application.

 For example, consider the following Java code:

public class MyClass {
    public static void main(String[] args) {
        while (true) {
            new Object();
        }
    }
}

This code creates an infinite loop that creates a new Object on each iteration. Even though we are creating new objects infinitely, the garbage collector will free up memory as needed, preventing the program from running out of memory.

4. Java Development Kit (JDK): 

JDK 1.0 included a set of tools like javac (Java compiler) and java (Java Virtual Machine), which made it easier to develop, compile, and run Java applications.

example of using the Java Development Kit (JDK) to compile and run a simple "Hello, World!" program

First, create a file named HelloWorld.java and add the following code:

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello, World!");
    }
}

This code defines a class named HelloWorld with a main() method that prints the string "Hello, World!" to the console.

Next, open a command prompt or terminal and navigate to the directory where you saved the HelloWorld.java file.

javac HelloWorld.java

This will compile the HelloWorld.java file and create a new file named HelloWorld.class, which contains the compiled bytecode.

To run the program using the JDK, enter the following command:

java HelloWorld

This will execute the HelloWorld class and print the message "Hello, World!" to the console.

That's a basic example of using the JDK to compile and run a Java program. The JDK also includes many other tools and libraries for developing and debugging Java applications.

5. Applet support: 

JDK 1.0 included support for Java applets, which are small applications that can be embedded within web pages. This feature allowed developers to create interactive web pages without relying on browser-specific technologies like ActiveX.

here's an example of using Applet support in Java 1.0 to create a simple applet:

First, create a file named MyApplet.java and add the following code:

import java.applet.*;
import java.awt.*;

public class MyApplet extends Applet {
    public void init() {
        // Initialize the applet here
    }
    
    public void paint(Graphics g) {
        // Draw graphics here
        g.drawString("Hello, World!", 20, 20);
    }
}  

This code defines a class named MyApplet that extends the Applet class. The init() method is called when the applet is initialized, and the paint() method is called whenever the applet needs to be redrawn. In this case, the paint() method draws the string "Hello, World!" at position (20, 20) on the applet.

Next, create an HTML file named MyApplet.html and add the following code:

<html>
  <head>
    <title>My Applet</title>
  </head>
  <body>
    <applet code="MyApplet.class" width="200" height="200">
      Your browser does not support Java applets.
    </applet>
  </body>
</html>

This code creates an HTML page that embeds the MyApplet applet using the <applet> tag. The code attribute specifies the name of the applet class (MyApplet.class), and the width and height attributes set the size of the applet.

Save both files in the same directory, then open the HTML file in a web browser that supports Java applets (such as Internet Explorer 3 or Netscape Navigator 3). You should see a gray box with the message "Hello, World!" displayed inside it.

That's a basic example of using applet support in Java 1.0 to create a simple applet. 

6. AWT (Abstract Window Toolkit): 

JDK 1.0 included the AWT, which provided a set of classes and tools for building user interfaces. AWT provides a set of platform-independent widgets like buttons, text fields, and menus that can be used to create graphical user interfaces (GUIs) for Java applications.

example of using the Abstract Window Toolkit (AWT) in Java 1.0 to create a simple graphical user interface (GUI):

   import java.awt.*;

public class MyFrame extends Frame {
    public MyFrame(String title) {
        super(title);
        
        // Add components to the frame here
        Button button = new Button("Click me!");
        add(button);
    }
    
    public static void main(String[] args) {
        MyFrame frame = new MyFrame("My Frame");
        frame.setSize(200, 200);
        frame.setVisible(true);
    }
}

This code defines a class named MyFrame that extends the Frame class. The constructor takes a string argument that sets the title of the frame. In the constructor, we add a Button component to the frame. In the main() method, we create an instance of the MyFrame class, set its size to 200x200 pixels, and make it visible.

Next, compile and run the program using the JDK. To compile, enter the following command:

      javac MyFrame.java
    

To run the program, enter the following command:

     java MyFrame
    

You should see a small window with a button labeled "Click me!".

That's a basic example of using the AWT in Java 1.0 to create a simple GUI. The AWT provides a set of components and layout managers that can be used to create more complex GUIs. Note that the AWT has since been replaced by the Swing framework in later versions of Java.

7. Security: 

JDK 1.0 included a security model that provided a secure environment for running Java code. This feature allows Java applications to run in a sandboxed environment that restricts access to system resources like files and network connections, preventing malicious code from harming the system.

simple example of how to use Java 1.0 to read a password securely from the command line:

import java.io.*;

public class PasswordExample {
   public static void main(String args[]) {
      Console console = System.console();
      if (console == null) {
         System.err.println("No console available");
         System.exit(1);
      }
      char password[] = console.readPassword("Enter your password: ");
      System.out.println("Your password is: " + new String(password));
   }
}
   

This example uses the Console class, which allows secure input and output to be performed from the command line. The readPassword method reads the password characters without echoing them to the console, which provides some level of security against shoulder surfing attacks.

However, this code is not secure enough for modern security standards and should not be used in production. It is important to keep your Java runtime environment and libraries up-to-date to ensure that you have the latest security patches and features.