public class Puppy {
   int puppyAge;

   public Puppy(String name) {
      // This constructor has one parameter, name .
      System.out.println("Name chosen is :" + name );
   }

   public void setAge( int age ) {
      puppyAge = age;
   }

   public int getAge( ) {
      System.out.println("Puppy's age is :" + puppyAge );
      return puppyAge;
   }

   public static void main(String []args) {
      /* Object creation */
      Puppy myPuppy = new Puppy( "tommy" );

      /* Call class method to set puppy's age */
      myPuppy.setAge( 2 );

      /* Call another class method to get puppy's age */
      myPuppy.getAge( );

      /* You can access instance variable as follows as well */
      System.out.println("Variable Value :" + myPuppy.puppyAge );
   }
}

Если мы скомпилируем и запустим вышеуказанную программу, то она даст следующий результат:

Выход

Name chosen is :tommy
Puppy's age is :2
Variable Value :2

Правила объявления исходного файла

Как последняя часть этого раздела, давайте теперь посмотрим на правила объявления исходного файла. Эти правила необходимы при объявлении классов, операторов импорта и операторов пакетов в исходном файле.

• В исходном файле может быть только один открытый класс.

• Исходный файл может иметь несколько закрытых классов.

• Публичное имя класса также должно быть именем исходного файла, к которому в конце должен быть добавлен .java . Например: имя класса — публичный класс Employee {}, тогда исходный файл должен быть как Employee.java.

• Если класс определен внутри пакета, тогда оператор пакета должен быть первым оператором в исходном файле.

• Если присутствуют операторы импорта, они должны быть записаны между оператором пакета и объявлением класса. Если нет никаких операторов пакета, то оператор импорта должен быть первой строкой в ​​исходном файле.

• Операторы import и package будут относиться ко всем классам, присутствующим в исходном файле. Невозможно объявить разные операторы импорта и / или пакета для разных классов в исходном файле.

В исходном файле может быть только один открытый класс.

Исходный файл может иметь несколько закрытых классов.

Публичное имя класса также должно быть именем исходного файла, к которому в конце должен быть добавлен .java . Например: имя класса — публичный класс Employee {}, тогда исходный файл должен быть как Employee.java.

Если класс определен внутри пакета, тогда оператор пакета должен быть первым оператором в исходном файле.

Если присутствуют операторы импорта, они должны быть записаны между оператором пакета и объявлением класса. Если нет никаких операторов пакета, то оператор импорта должен быть первой строкой в ​​исходном файле.

Операторы import и package будут относиться ко всем классам, присутствующим в исходном файле. Невозможно объявить разные операторы импорта и / или пакета для разных классов в исходном файле.

У классов есть несколько уровней доступа, и есть разные типы классов; абстрактные классы, финальные классы и т. д. Мы расскажем обо всем этом в главе, посвященной модификаторам доступа.

Помимо вышеупомянутых типов классов, в Java также есть некоторые специальные классы, называемые классами Inner и классами Anonymous.

Пакет Java

Проще говоря, это способ классификации классов и интерфейсов. При разработке приложений на Java будут написаны сотни классов и интерфейсов, поэтому классификация этих классов является обязательной, а также значительно облегчает жизнь.

Импортная отчетность

В Java, если задано полное имя, включающее пакет и имя класса, компилятор может легко найти исходный код или классы. Оператор импорта — это способ дать правильное местоположение компилятору для поиска этого конкретного класса.

Например, следующая строка попросит компилятор загрузить все классы, доступные в каталоге java_installation / java / io —

import java.io.*;

Простое тематическое исследование

Для нашего примера мы создадим два класса. Это Employee и EmployeeTest.

Сначала откройте блокнот и добавьте следующий код. Помните, что это класс Employee, а этот класс является публичным. Теперь сохраните этот исходный файл с именем Employee.java.

Класс Employee имеет четыре переменных экземпляра — имя, возраст, назначение и зарплата. Класс имеет один явно определенный конструктор, который принимает параметр.

пример

import java.io.*;
public class Employee {

   String name;
   int age;
   String designation;
   double salary;

   // This is the constructor of the class Employee
   public Employee(String name) {
      this.name = name;
   }

   // Assign the age of the Employee  to the variable age.
   public void empAge(int empAge) {
      age = empAge;
   }

   /* Assign the designation to the variable designation.*/
   public void empDesignation(String empDesig) {
      designation = empDesig;
   }

   /* Assign the salary to the variable	salary.*/
   public void empSalary(double empSalary) {
      salary = empSalary;
   }

   /* Print the Employee details */
   public void printEmployee() {
      System.out.println("Name:"+ name );
      System.out.println("Age:" + age );
      System.out.println("Designation:" + designation );
      System.out.println("Salary:" + salary);
   }
}

Как упоминалось ранее в этом руководстве, обработка начинается с основного метода. Поэтому, чтобы мы могли запустить этот класс Employee, должен быть метод main и объекты должны быть созданы. Мы будем создавать отдельный класс для этих задач.

Ниже приведен класс EmployeeTest , который создает два экземпляра класса Employee и вызывает методы для каждого объекта для назначения значений для каждой переменной.

Сохраните следующий код в файле EmployeeTest.java.

import java.io.*;
public class EmployeeTest {

   public static void main(String args[]) {
      /* Create two objects using constructor */
      Employee empOne = new Employee("James Smith");
      Employee empTwo = new Employee("Mary Anne");

      // Invoking methods for each object created
      empOne.empAge(26);
      empOne.empDesignation("Senior Software Engineer");
      empOne.empSalary(1000);
      empOne.printEmployee();

      empTwo.empAge(21);
      empTwo.empDesignation("Software Engineer");
      empTwo.empSalary(500);
      empTwo.printEmployee();
   }
}

Теперь скомпилируйте оба класса и запустите EmployeeTest, чтобы увидеть результат следующим образом:

Выход

C:\> javac Employee.java
C:\> javac EmployeeTest.java
C:\> java EmployeeTest
Name:James Smith
Age:26
Designation:Senior Software Engineer
Salary:1000.0
Name:Mary Anne
Age:21
Designation:Software Engineer
Salary:500.0

Что дальше?

На следующем занятии мы обсудим основные типы данных в Java и то, как их можно использовать при разработке приложений Java.

Java — Конструкторы

Конструктор инициализирует объект при его создании. Он имеет то же имя, что и его класс, и синтаксически похож на метод. Однако конструкторы не имеют явного возвращаемого типа.

Как правило, вы будете использовать конструктор для присвоения начальных значений переменным экземпляра, определенным классом, или для выполнения любых других процедур запуска, необходимых для создания полностью сформированного объекта.

Все классы имеют конструкторы, независимо от того, определяете вы их или нет, потому что Java автоматически предоставляет конструктор по умолчанию, который инициализирует все переменные-члены нулями. Однако, как только вы определите свой собственный конструктор, конструктор по умолчанию больше не будет использоваться.

Синтаксис

Ниже приводится синтаксис конструктора —

class ClassName {
   ClassName() {
   }
}

Java допускает два типа конструкторов, а именно —

• Без аргументов Конструкторы
• Параметризованные Конструкторы

Без аргументов Конструкторы

Поскольку имя указывает, что конструкторы Java без аргументов не принимают никаких параметров, вместо этого, используя эти конструкторы, переменные экземпляра метода будут инициализированы с фиксированными значениями для всех объектов.

пример

Public class MyClass {
   Int num;
   MyClass() {
      num = 100;
   }
}

Вы бы вызвали конструктор для инициализации объектов следующим образом

public class ConsDemo {
   public static void main(String args[]) {
      MyClass t1 = new MyClass();
      MyClass t2 = new MyClass();
      System.out.println(t1.num + " " + t2.num);
   }
}

Это дало бы следующий результат

100 100

Параметризованные Конструкторы

Чаще всего вам понадобится конструктор, который принимает один или несколько параметров. Параметры добавляются в конструктор так же, как они добавляются в метод, просто объявляйте их в скобках после имени конструктора.

пример

Вот простой пример, который использует конструктор —

// A simple constructor.
class MyClass {
   int x;
   
   // Following is the constructor
   MyClass(int i ) {
      x = i;
   }
}

Вы бы вызвали конструктор для инициализации объектов следующим образом:

public class ConsDemo {
   public static void main(String args[]) {
      MyClass t1 = new MyClass( 10 );
      MyClass t2 = new MyClass( 20 );
      System.out.println(t1.x + " " + t2.x);
   }
}

Это даст следующий результат —

10 20

Java — основные типы данных

Переменные — это не что иное, как зарезервированные области памяти для хранения значений. Это означает, что когда вы создаете переменную, вы резервируете некоторое пространство в памяти.

На основе типа данных переменной операционная система выделяет память и решает, что можно сохранить в зарезервированной памяти. Поэтому, назначая переменным разные типы данных, вы можете хранить целые, десятичные или символы в этих переменных.

В Java есть два типа данных:

• Примитивные типы данных
• Типы данных Ссылка / Объект

Примитивные типы данных

В Java поддерживается восемь примитивных типов данных. Примитивные типы данных предопределены языком и названы ключевым словом. Давайте теперь подробно рассмотрим восемь примитивных типов данных.

байт

• Байтовый тип данных представляет собой 8-разрядное целое число со знаком в виде двух чисел

• Минимальное значение -128 (-2 ^ 7)

• Максимальное значение 127 (включительно) (2 ^ 7 -1)

• Значение по умолчанию 0

• Байтовый тип данных используется для экономии места в больших массивах, в основном вместо целых чисел, поскольку байт в четыре раза меньше целого числа.

• Пример: байт a = 100, байт b = -50

Байтовый тип данных представляет собой 8-разрядное целое число со знаком в виде двух чисел

Минимальное значение -128 (-2 ^ 7)

Максимальное значение 127 (включительно) (2 ^ 7 -1)

Значение по умолчанию 0

Байтовый тип данных используется для экономии места в больших массивах, в основном вместо целых чисел, поскольку байт в четыре раза меньше целого числа.

Пример: байт a = 100, байт b = -50

короткая

• Короткий тип данных — это 16-разрядное целое число со знаком в виде двоичного числа со знаком

• Минимальное значение -32 768 (-2 ^ 15)

• Максимальное значение 32 767 (включительно) (2 ^ 15 -1)

• Короткий тип данных также может использоваться для сохранения памяти в виде байтового типа данных. Короткое в 2 раза меньше целого

• Значение по умолчанию 0.

• Пример: короткое s = 10000, короткое r = -20000

Короткий тип данных — это 16-разрядное целое число со знаком в виде двоичного числа со знаком

Минимальное значение -32 768 (-2 ^ 15)

Максимальное значение 32 767 (включительно) (2 ^ 15 -1)

Короткий тип данных также может использоваться для сохранения памяти в виде байтового типа данных. Короткое в 2 раза меньше целого

Значение по умолчанию 0.

Пример: короткое s = 10000, короткое r = -20000

ИНТ

• Тип данных Int — это 32-разрядное целое число со знаком в виде двоичного числа со знаком.

• Минимальное значение — 2 147 483 648 (-2 ^ 31)

• Максимальное значение — 2 147 483 647 (включительно) (2 ^ 31 -1)

• Целочисленное значение обычно используется как тип данных по умолчанию для целочисленных значений, если только нет проблем с памятью.

• Значение по умолчанию 0

• Пример: int a = 100000, int b = -200000

Тип данных Int — это 32-разрядное целое число со знаком в виде двоичного числа со знаком.

Минимальное значение — 2 147 483 648 (-2 ^ 31)

Максимальное значение — 2 147 483 647 (включительно) (2 ^ 31 -1)

Целочисленное значение обычно используется как тип данных по умолчанию для целочисленных значений, если только нет проблем с памятью.

Значение по умолчанию 0

Пример: int a = 100000, int b = -200000

долго

• Длинный тип данных — это 64-разрядное целое число со знаком в виде двоичного числа со знаком
• Минимальное значение -9,223,372,036,854,775,808 (-2 ^ 63)
• Максимальное значение — 9 223 372 036 854 775 807 (включительно) (2 ^ 63 -1)
• Этот тип используется, когда требуется более широкий диапазон, чем int
• Значение по умолчанию 0L
• Пример: long a = 100000L, long b = -200000L

поплавок

• Тип данных с плавающей запятой — 32-битная IEEE 754 с плавающей запятой одинарной точности

• Float в основном используется для сохранения памяти в больших массивах чисел с плавающей точкой

• Значение по умолчанию 0,0f

• Тип данных с плавающей запятой никогда не используется для точных значений, таких как валюта

• Пример: float f1 = 234.5f

Тип данных с плавающей запятой — 32-битная IEEE 754 с плавающей запятой одинарной точности

Float в основном используется для сохранения памяти в больших массивах чисел с плавающей точкой

Значение по умолчанию 0,0f

Тип данных с плавающей запятой никогда не используется для точных значений, таких как валюта

Пример: float f1 = 234.5f

двойной

• двойной тип данных — 64-разрядная IEEE 754 с плавающей запятой двойной точности

• Этот тип данных обычно используется как тип данных по умолчанию для десятичных значений, как правило, выбор по умолчанию

• Двойной тип данных никогда не должен использоваться для точных значений, таких как валюта

• Значение по умолчанию — 0.0d

• Пример: double d1 = 123,4

двойной тип данных — 64-разрядная IEEE 754 с плавающей запятой двойной точности

Этот тип данных обычно используется как тип данных по умолчанию для десятичных значений, как правило, выбор по умолчанию

Двойной тип данных никогда не должен использоваться для точных значений, таких как валюта

Значение по умолчанию — 0.0d

Пример: double d1 = 123,4

логический

• логический тип данных представляет один бит информации
• Есть только два возможных значения: истина и ложь
• Этот тип данных используется для простых флагов, которые отслеживают истинные / ложные условия
• Значением по умолчанию является false
• Пример: boolean one = true

голец

• тип данных char — это один 16-битный символ Unicode
• Минимальное значение равно «\ u0000» (или 0)
• Максимальное значение ‘\ uffff’ (или 65 535 включительно)
• Тип данных Char используется для хранения любого символа
• Пример: буква char = A

Типы справочных данных

• Ссылочные переменные создаются с использованием определенных конструкторов классов. Они используются для доступа к объектам. Эти переменные объявлены определенного типа, которые нельзя изменить. Например, Сотрудник, Щенок и т. Д.

• Объекты класса и различные типы переменных массива попадают под ссылочный тип данных.

• Значение по умолчанию для любой ссылочной переменной равно нулю.

• Ссылочная переменная может использоваться для ссылки на любой объект объявленного типа или любого совместимого типа.

• Пример: животное животное = новое животное («жираф»);

Ссылочные переменные создаются с использованием определенных конструкторов классов. Они используются для доступа к объектам. Эти переменные объявлены определенного типа, которые нельзя изменить. Например, Сотрудник, Щенок и т. Д.

Объекты класса и различные типы переменных массива попадают под ссылочный тип данных.

Значение по умолчанию для любой ссылочной переменной равно нулю.

Ссылочная переменная может использоваться для ссылки на любой объект объявленного типа или любого совместимого типа.

Пример: животное животное = новое животное («жираф»);

Java Literal

Литерал — это представление исходного кода с фиксированным значением. Они представлены непосредственно в коде без каких-либо вычислений.

Литералы могут быть назначены любой переменной типа примитива. Например —

byte a = 68;
char a = 'A';

byte, int, long и short также могут быть выражены в десятичных (основание 10), шестнадцатеричных (основание 16) или восьмеричных (основание 8) системах счисления.

Префикс 0 используется для обозначения восьмеричного числа, а префикс 0x обозначает шестнадцатеричное при использовании этих систем счисления для литералов. Например —

int decimal = 100;
int octal = 0144;
int hexa =  0x64;

Строковые литералы в Java указываются так же, как и в большинстве других языков, заключая последовательность символов между парой двойных кавычек. Примеры строковых литералов:

пример

"Hello World"
"two\nlines"
"\"This is in quotes\""

Строковые и символьные типы литералов могут содержать любые символы Юникода. Например —

char a = '\u0001';
String a = "\u0001";

Язык Java также поддерживает несколько специальных escape-последовательностей для строковых и символьных литералов. Они —

Что дальше?

В этой главе описаны различные типы данных. Следующая тема объясняет различные типы переменных и их использование. Это даст вам хорошее понимание того, как их можно использовать в классах Java, интерфейсах и т. Д.

Java — типы переменных

Переменная предоставляет нам именованное хранилище, которым наши программы могут манипулировать. Каждая переменная в Java имеет определенный тип, который определяет размер и расположение памяти переменной; диапазон значений, которые могут быть сохранены в этой памяти; и набор операций, которые могут быть применены к переменной.

Вы должны объявить все переменные, прежде чем их можно будет использовать. Ниже приведена основная форма объявления переменной:

data type variable [ = value][, variable [ = value] ...] ;

Здесь тип данных является одним из типов данных Java, а переменная — это имя переменной. Чтобы объявить более одной переменной указанного типа, вы можете использовать список через запятую.

Ниже приведены допустимые примеры объявления и инициализации переменных в Java.

пример

int a, b, c;         // Declares three ints, a, b, and c.
int a = 10, b = 10;  // Example of initialization
byte B = 22;         // initializes a byte type variable B.
double pi = 3.14159; // declares and assigns a value of PI.
char a = 'A';        // the char variable a iis initialized with value 'a'

В этой главе будут описаны различные типы переменных, доступные на языке Java. В Java есть три вида переменных:

• Локальные переменные
• Переменные экземпляра
• Класс / Статические переменные

Локальные переменные

• Локальные переменные объявляются в методах, конструкторах или блоках.

• Локальные переменные создаются при вводе метода, конструктора или блока, и эта переменная будет уничтожена после выхода из метода, конструктора или блока.

• Модификаторы доступа нельзя использовать для локальных переменных.

• Локальные переменные видны только внутри объявленного метода, конструктора или блока.

• Локальные переменные реализованы на уровне стека внутри.

• Не существует значения по умолчанию для локальных переменных, поэтому следует объявить локальные переменные и назначить начальное значение перед первым использованием.

Локальные переменные объявляются в методах, конструкторах или блоках.

Локальные переменные создаются при вводе метода, конструктора или блока, и эта переменная будет уничтожена после выхода из метода, конструктора или блока.

Модификаторы доступа нельзя использовать для локальных переменных.

Локальные переменные видны только внутри объявленного метода, конструктора или блока.

Локальные переменные реализованы на уровне стека внутри.

Не существует значения по умолчанию для локальных переменных, поэтому следует объявить локальные переменные и назначить начальное значение перед первым использованием.

пример

Здесь возраст является локальной переменной. Это определено внутри метода pupAge (), и его область действия ограничена только этим методом.

Live Demo

public class Test {
   public void pupAge() {
      int age = 0;
      age = age + 7;
      System.out.println("Puppy age is : " + age);
   }

   public static void main(String args[]) {
      Test test = new Test();
      test.pupAge();
   }
}

Puppy age is: 7

public class Test {
   public void pupAge() {
      int age;
      age = age + 7;
      System.out.println("Puppy age is : " + age);
   }

   public static void main(String args[]) {
      Test test = new Test();
      test.pupAge();
   }
}

Test.java:4:variable number might not have been initialized
age = age + 7;
         ^
1 error

import java.io.*;
public class Employee {

   // this instance variable is visible for any child class.
   public String name;

   // salary  variable is visible in Employee class only.
   private double salary;

   // The name variable is assigned in the constructor.
   public Employee (String empName) {
      name = empName;
   }

   // The salary variable is assigned a value.
   public void setSalary(double empSal) {
      salary = empSal;
   }

   // This method prints the employee details.
   public void printEmp() {
      System.out.println("name  : " + name );
      System.out.println("salary :" + salary);
   }

   public static void main(String args[]) {
      Employee empOne = new Employee("Ransika");
      empOne.setSalary(1000);
      empOne.printEmp();
   }
}

name  : Ransika
salary :1000.0

import java.io.*;
public class Employee {

   // salary  variable is a private static variable
   private static double salary;

   // DEPARTMENT is a constant
   public static final String DEPARTMENT = "Development ";

   public static void main(String args[]) {
      salary = 1000;
      System.out.println(DEPARTMENT + "average salary:" + salary);
   }
}

Development average salary:1000

public class className {
   // ...
}

private boolean myFlag;
static final double weeks = 9.5;
protected static final int BOXWIDTH = 42;

public static void main(String[] arguments) {
   // body of method
}

variable x = (expression) ? value if true : value if false

public class Test {

   public static void main(String args[]) {
      int a, b;
      a = 10;
      b = (a == 1) ? 20: 30;
      System.out.println( "Value of b is : " +  b );

      b = (a == 10) ? 20: 30;
      System.out.println( "Value of b is : " + b );
   }
}

Value of b is : 30
Value of b is : 20

( Object reference variable ) instanceof  (class/interface type)

public class Test {

   public static void main(String args[]) {

      String name = "James";

      // following will return true since name is type of String
      boolean result = name instanceof String;
      System.out.println( result );
   }
}

true

class Vehicle {}

public class Car extends Vehicle {

   public static void main(String args[]) {

      Vehicle a = new Car();
      boolean result =  a instanceof Car;
      System.out.println( result );
   }
}

true

for(declaration : expression) {
   // Statements
}

public class Test {

   public static void main(String args[]) {
      int [] numbers = {10, 20, 30, 40, 50};

      for(int x : numbers ) {
         System.out.print( x );
         System.out.print(",");
      }
      System.out.print("\n");
      String [] names = {"James", "Larry", "Tom", "Lacy"};

      for( String name : names ) {
         System.out.print( name );
         System.out.print(",");
      }
   }
}

10, 20, 30, 40, 50,
James, Larry, Tom, Lacy,

Exp1 ? Exp2 : Exp3;

int i = 5000;
float gpa = 13.65;
double mask = 0xaf;

public class Test {

   public static void main(String args[]) {
      Integer x = 5; // boxes int to an Integer object
      x =  x + 10;   // unboxes the Integer to a int
      System.out.println(x); 
   }
}

15

char ch = 'a';

// Unicode for uppercase Greek omega character
char uniChar = '\u039A'; 

// an array of chars
char[] charArray ={ 'a', 'b', 'c', 'd', 'e' }; 

Character ch = new Character('a');

// Here following primitive char 'a'
// is boxed into the Character object ch
Character ch = 'a';

// Here primitive 'x' is boxed for method test,
// return is unboxed to char 'c'
char c = test('x');

public class Test {

   public static void main(String args[]) {
      System.out.println("She said \"Hello!\" to me.");
   }
}

She said "Hello!" to me.

String greeting = "Hello world!";

public class StringDemo {

   public static void main(String args[]) {
      char[] helloArray = { 'h', 'e', 'l', 'l', 'o', '.' };
      String helloString = new String(helloArray);  
      System.out.println( helloString );
   }
}

hello.

public class StringDemo {

   public static void main(String args[]) {
      String palindrome = "Dot saw I was Tod";
      int len = palindrome.length();
      System.out.println( "String Length is : " + len );
   }
}

String Length is : 17

string1.concat(string2);

"My name is ".concat("Zara");

"Hello," + " world" + "!"

"Hello, world!"

public class StringDemo {

   public static void main(String args[]) {
      String string1 = "saw I was ";
      System.out.println("Dot " + string1 + "Tod");
   }
}

Dot saw I was Tod

System.out.printf("The value of the float variable is " +
                  "%f, while the value of the integer " +
                  "variable is %d, and the string " +
                  "is %s", floatVar, intVar, stringVar);

String fs;
fs = String.format("The value of the float variable is " +
                   "%f, while the value of the integer " +
                   "variable is %d, and the string " +
                   "is %s", floatVar, intVar, stringVar);
System.out.println(fs);

dataType[] arrayRefVar;   // preferred way.
or
dataType arrayRefVar[];  // works but not preferred way.

double[] myList;   // preferred way.
or
double myList[];   // works but not preferred way.

arrayRefVar = new dataType[arraySize];

dataType[] arrayRefVar = new dataType[arraySize];

dataType[] arrayRefVar = {value0, value1, ..., valuek};

double[] myList = new double[10];

public class TestArray {

   public static void main(String[] args) {
      double[] myList = {1.9, 2.9, 3.4, 3.5};

      // Print all the array elements
      for (int i = 0; i < myList.length; i++) {
         System.out.println(myList[i] + " ");
      }
     
      // Summing all elements
      double total = 0;
      for (int i = 0; i < myList.length; i++) {
         total += myList[i];
      }
      System.out.println("Total is " + total);
      
      // Finding the largest element
      double max = myList[0];
      for (int i = 1; i < myList.length; i++) {
         if (myList[i] > max) max = myList[i];
      }
      System.out.println("Max is " + max);  
   }
}

1.9
2.9
3.4
3.5
Total is 11.7
Max is 3.5

public class TestArray {

   public static void main(String[] args) {
      double[] myList = {1.9, 2.9, 3.4, 3.5};

      // Print all the array elements
      for (double element: myList) {
         System.out.println(element);
      }
   }
}

1.9
2.9
3.4
3.5

public static void printArray(int[] array) {
   for (int i = 0; i < array.length; i++) {
      System.out.print(array[i] + " ");
   }
}

printArray(new int[]{3, 1, 2, 6, 4, 2});

public static int[] reverse(int[] list) {
   int[] result = new int[list.length];

   for (int i = 0, j = result.length - 1; i < list.length; i++, j--) {
      result[j] = list[i];
   }
   return result;
}

import java.util.Date;
public class DateDemo {

   public static void main(String args[]) {
      // Instantiate a Date object
      Date date = new Date();

      // display time and date using toString()
      System.out.println(date.toString());
   }
}

on May 04 09:51:52 CDT 2009

import java.util.*;
import java.text.*;

public class DateDemo {

   public static void main(String args[]) {
      Date dNow = new Date( );
      SimpleDateFormat ft = 
      new SimpleDateFormat ("E yyyy.MM.dd 'at' hh:mm:ss a zzz");

      System.out.println("Current Date: " + ft.format(dNow));
   }
}

Current Date: Sun 2004.07.18 at 04:14:09 PM PDT

import java.util.Date;
public class DateDemo {

   public static void main(String args[]) {
      // Instantiate a Date object
      Date date = new Date();

      // display time and date
      String str = String.format("Current Date/Time : %tc", date );

      System.out.printf(str);
   }
}

Current Date/Time : Sat Dec 15 16:37:57 MST 2012

import java.util.Date;
public class DateDemo {

   public static void main(String args[]) {
      // Instantiate a Date object
      Date date = new Date();
  
      // display time and date
      System.out.printf("%1$s %2$tB %2$td, %2$tY", "Due date:", date);
   }
}

Due date: February 09, 2004

import java.util.Date;
public class DateDemo {

   public static void main(String args[]) {
      // Instantiate a Date object
      Date date = new Date();
  
      // display formatted date
      System.out.printf("%s %tB %<te, %<tY", "Due date:", date);
   }
}

Due date: February 09, 2004

import java.util.*;
import java.text.*;
  
public class DateDemo {

   public static void main(String args[]) {
      SimpleDateFormat ft = new SimpleDateFormat ("yyyy-MM-dd"); 
      String input = args.length == 0 ? "1818-11-11" : args[0]; 

      System.out.print(input + " Parses as "); 
      Date t;
      try {
         t = ft.parse(input); 
         System.out.println(t); 
      } catch (ParseException e) { 
         System.out.println("Unparseable using " + ft); 
      }
   }
}

1818-11-11 Parses as Wed Nov 11 00:00:00 EST 1818

import java.util.*;
public class SleepDemo {

   public static void main(String args[]) {
      try { 
         System.out.println(new Date( ) + "\n"); 
         Thread.sleep(5*60*10); 
         System.out.println(new Date( ) + "\n"); 
      } catch (Exception e) {
         System.out.println("Got an exception!"); 
      }
   }
}

Sun May 03 18:04:41 GMT 2009
Sun May 03 18:04:51 GMT 2009

import java.util.*;
public class DiffDemo {

   public static void main(String args[]) {
      try {
         long start = System.currentTimeMillis( );
         System.out.println(new Date( ) + "\n");
         
         Thread.sleep(5*60*10);
         System.out.println(new Date( ) + "\n");
         
         long end = System.currentTimeMillis( );
         long diff = end - start;
         System.out.println("Difference is : " + diff);
      } catch (Exception e) {
         System.out.println("Got an exception!");
      }
   }
}