Изучаем Java

Быстрое погружение в JAVA, никакой теории... Данные будут пополняться...
http://docs.oracle.com/javase/7/docs/api/ - справочник
сохраняем файл myFirstApp.java
Компилируем javac myFirstApp.java
Запускаем приложение %java myFirstApp.java

<?
java 
-jar nameFile.jar запуск из консоли файла
java com
.acherkasov.sample.Main
?>

Подключение приложений:

<?
import java
.io.*; - подключение дополнительных классов
import 
static java.lang.System.out// теперь обращение возможно не через System.out., а просто через out.
import static java.lang.Math.*; // теперь можно писать sqrt вместо Math.sqrt
?>


Примитивы:

<?
public class Main {

    
// С функции Main начинается запуск программы
    // void означает, что ничего возвращаться не будет
    
public static void main(String[] args
            
throws NumberFormatExceptionthrows IOException // Не закрывается
        
        
transient String name// имеет смысл указывать в многопоточном приложении, не сохраняйте это, я позабочусь об этом сам Serializable 
        // При именовании переменных, буквы, цифры, знак подчеркивания. С цифры не начинается
        // Язык регистрозависимый, желательна верблюжья нотация
        
int a,2,c;    // Массовое создание переменных одного типа, где d уже присвоено значение.
        
        
String s// null, Строки в java не изменяемые, они создают каждый раз новый объект строки
        
        // Работа с ENUM, создаем тип данных Color, а не переменную
        
enum Color 
        
{
            
redbluegreen;
            
            
// Переопределить базовый метод ENUM-а или создать свои собственные методы
            
@override
            
public String toString(){
                return 
super.toString();
            }
            
        }
        
Color color Color.red;    // System.out.println(color); // red
        
color.ordinal();    // Порядковый номер в списке enum, начинается с нуля
        
color.name();        // Возвращает имя - red
        
Color.values();    // Список всех значений enum для прохода в цикле по нему
        
        // Переменная инициализирована
        
int age;
        {
            
System.out.println("Initialize");
        }
        
        
// Тип: int, имя: x, значение: 67
        
int x 67;    // 32 бита. Создали переменную x типа integer
        
int x1 0x67;    // Создали переменную x типа integer десятичная запись
        
float y 2.7f// 32 бита, 6 знаков после запятой, f - указывает на значение float
        
double z 1.5// 64 бита, 12 знаков после запятой
        
byte b 100// 8 бит, от -128 до 127
        
char ср 'А'// 16 бит utf-16S, в одиночных кавычках от 0 до 65535
        
short g 32600// 16 бит целое число, положительное и отрицательное от -32768 до 32767
        
long dd 44L// 64 бита, L или l - целочисленное значение
        
double = (x+(double)y)/2// 1+2 = 1,50000 приводим к явной типизации одно из чисел
        
boolean bb true;    // true / false
        
String "str\\ing\u0021\n"// экранирование специсимволов \, данные помещаются в двойные кавычки
        // На каждый экзмпляр строки создается новый объект, даже, когда она, якобы изменяется, то предыдущий вариант - висит в памяти
        
        
int[] nums;    // Создаем массив, массив - всегда объект, хоть и содержит примитивные переменные
        
nums = new int[7];    // Создаем целочисленный массив и помещаем в переменную nums. Размер массива изменить нельзя
        
nums[0] = 6;    // Присваиваем значение
        
        
Dog[] pets = new Dog[7];
        
pets[0] = new Dog();
        
        
int[][] matrix = new int[2][3];    // многомерный массив 2 строки по 3 в каждой
        
        
        
String[] wordListOne = {"1-1""1-2"}; // Массив со значениями по умолчанию
        
int oneLength wordListOne.length// Подсчет кол-ва элементов массива
        
int rand1 = (int) (Math.random() * oneLength);    // Получаем случайную цифру в пределах массива, Типизируем полученный результат
        
wordListOne[rand1]; // Получаем случайное значение значения массива
        
        
String hi "Привет";
        
String name "Sergey";
        
String result hi " " name// Привет Sergey // Создается 3 строка в памяти, т.е. новый объект - это плохо
        
String result2 String.format("%s %s"hiname); // этот вариант лучше, т.к. не будет создаваться лишних экземпляров класса String
        
        
StringBuilder sb = new StringBuilder();    // Создаем экземпляр объекта, не поддерживает многопоточность
        
sb.append(name);    // Добавляем данные в него (переменную name)
        
sb.append(" ");        // Добавляем пробел
        
System.out.println(sb.toString());    // Преобразовать в строку и вывести
        
        
System.out.printf("%3d"rand1); // Три перед d означает кол-во символов занятых под данный вывод
        
        // Создаем переменную StringBuffer с именем sb
        
StringBuffer sb = new StringBuffer();    // Создаем экземпляр объекта, поддерживает многопоточность
        
sb.append(name);    // Добавляем данные в него (переменную name)
        
sb.append(" ");        // Добавляем пробел
        
System.out.println(sb.toString());    // Преобразовать в строку и вывести
        
        // && - И
        // || - или
        // !b - отрицание
        // b1^b2 - XOR - исключающее ИЛИ (true and true = false, false and false = false, true and false = true) xor = (not or) логический XOR
        
        
int x 5;
        
int y 7;
        
int g y// 2 побитовый XOR
        
int g y// == x всегда
        
        
Обменять местами переменные
        x 
y;
        
x;
        
y;
        
        
b3 = (== 3);    // Равно
        
b3 = (!= 3);    // Не равно
        
b3 = (3);    // Больше
        
b3 = (3);    // Меньше
        
b3 = (>= 3);    // Больше или равно
        
b3 = (<= 3);    // Меньше или равно
        
        
x++;    // x = x + 1
        
x--;    // x = x - 1;
        
*= 2;    // x = x * 2;

        
        
System.out.println("Hello, World");    // Выводит на экран c переводом на следующую строчку
        
System.out.print("Hello, World");    // Выводит на экран без перевода на следующую строчку
        
System.out.printf("Hi, %s" "Sergey");    // Выводит на экран
        
BufferedReader reader = new BufferedReader
                
(new InputStreamReader(System.in));
        
        
System.out.print("Введите строку: ");
        
String s reader.readLine();    // Читает строку из буфера
        
int x Integer.parseInt(s);    // Преобразовать строку в число
        
int y Double.parseDouble(reader.readLine());
        
System.out.println("Вы ввели: " s);
        
    }

}
?>

ЧАСТЬ ВТОРАЯ

<?
// Условия
if (&& 10
{
    
System.out.print("В диапазоне");
}
else
{
    
System.out.print("Вне диапазона");
}

// Краткая запись if-else
String s = (&& 10) ? "В диапазоне" "Вне диапазона";

if (
name.Length() == 0)    // Проверка длины строки
if (name.isEmpty())    // Проверка на пустоту
if (name.Equals("")) // Равно пустоте
Equals(""// Проверка идентичности (зависит от типа) объектов, переменных, строк и т.д.
 
== // Проверка на одинаковость(примитивы, ссылаются ли 2 ссылки на один и тот же объект). Испльзуется для проверки Битов в переменных.
?>

Циклы

<?
for(int x 0101){
    if (
== 3) continue; // Прерывает цикл и прыгает на следующую итерацию
    
if (== 6) break; // Прерывает цикл целиков, т.е. выходит из цикла
    
System.out.println(x);    // Вывод: 0 1 2 4 5
}

// Краткая запись, проходим по массиву m, вынимая значения помещаемые в x
for(int x m){

}

for(
String s2 names){
    
System.out.println(s2);
}

int x 4;
while(
3){
    
1;
}

Dog myDogs = new Dog();
myDogs[0] = new Dog();
myDogs[1] = new Dog();

int x 0;
while(
myDogs.length){
    
myDogs[x].bark();
    
x++;
}
?>


Переключатель

<?
int a 
3;
switch(
a){

    case 
0:
    case 
1:
        
System.out.println("Один");
        break;
        
    case 
2:
        
System.out.println("Два");
    case 
3:
        
System.out.println("Три");
        break;
        
    default;
        
System.out.println("Много");
        break;
}
?>

CLASS

<?
abstract class Animal // абстрактный класс, предотвращает создание объектов данного класса
    
public String body;
    private 
String secret// private - Не наследуется
    
    // Родительский метод
    
public String roar(){
    
    }
    
    
// При объявлении абстрактного метода, класс тоже должен быть асбтрактным
    
public abstract void eat(); // абстрактный метод, без тела

}

// Create class Dog - пример наследования
// Конструкторы не наследуются, кроме дефолтного
// Вызывается 3 конструктора: Dog, Animal and Object
public class Dog extends Animal {    // Наследуем класс Animal получая все его свойства и методы
    
int size 40;    // Устанавливаем значение по умолчанию
    // Значения всегда имеют значения по умолчанию, int = 0, boolean = false, string = null
    
private String breed;
    
String name;
    
    
// Переопределяем родительский метод
    
public String roar(){
        
super.roar(); // Чтобы вызвать родительский метод, используем ключевое слово super
    
}
    
    
// Конструктор, называется также, как и класс - это конструктор по умолчанию
    
public Dog() {
    
    }
    
    
// Конструктор с параметром, в классе можно указать несколько конструкторов и методов с разными параметрами
    
public Dog(String Name) {
        
super(name);    // Вызов родительского метода с передачей в него параметров
        //this();    // Вызов конструктора без параметров в этом классе, может быть вызван либо super(), либо this(), но не оба сразу
        
this.name;
        
this.Dog();
    }
    
    public 
void setBreed(String b){
        
this.breed b;
    }
    
    public 
String getBreed(){
        return 
breed;
    }
    
    
// Статичная переменная или статичный метод
    // Существует один на все экземпляры класса
    // Можно рассматривать как глобальную переменную
    // Обращаемся извне: имя класса, точка, статичный метод Dog.Bark.
    // Внутри класса просто Bark();
    // В статичном методе нет this, т.к. нет экземпляра объекта
    
public static String Bark(){
    
    }
    
    @
Override // Сообщаем, что метод переопределен, не обязательно, но рекомендуется писать данную запись
    
void bark(int numOfBark)
    {
        while(
numOfBark 0) {
            
System.out.println("Гав...");
        
            
numOfBark--;
        }
    }
}

// Test class Dog
public class DogTestDrive {

    
// Финализированная переменная не подлежит изменению, переопределению, расширению (для классов)
    // final - нельзя менять значение

    // Нельзя изменить параметр x
    // Нельзя переопределить метод doStuff
    // Если класс final, то он не может быть унаследован
    
void final doStuff(final int x){
        final 
int z// нельзя изменить
    
}

    
// Имена констант всегда в верхнем регистре с нижним подчеркиванием разделяющим слова
    
final static float PI 3.14;    // Финализированные статические переменные - это константы
    
    // или так создаем константу
    
public static final int X;
    static {
        
= (int) 9;
    }

    public static 
void main(String[] args) {

        
Dog d = new Dog();    // Создаем объект класса

        
d.size 40;    // Устанавливаем значение, оператор доступа - точка
        
d.setBreed(40);    // Устанавливаем значение, через сеттер
        
d.getBreed();    // Вызов геттера, позволяет также получить значение установленной переменной
        
d.bark(3);        // Вызываем метод передав в него значение для numOfBark
    
}
    
    
// Передаем в метод произвольное кол-во элементов типа int
    // Внутри метода данные доступны в виде массива
    
public integer test(int... b)
    {
    }

}
?>

СПИСКИ

<?
// Метод возвращает тип int со значением 42
// Возвращаем только тот тип, который указали
int giveSecret(){
    return 
42;
}

int theSecret live.giveSecret();
// типы значений должны совпадать int theSecret и int giveSecret()

Random r = new Random();
int x nextInt(10);    // Случайное число от 0 до 10

import java.util.Arrays;
Arrays.sort(nameOfArray);    // сортировка массива
String[] names2 Arrays.copyOf(names2); // Создаем массив выбирая часть данных из другого
String[] names2 Arrays.copyOfRange(names1,2); // Создаем массив выбирая часть данных по диапазону из другого

import java.util.ArrayList;
ArrayList list = new ArrayList();    // Создание не типизированного списка
list.add(1);    // Добавляем в списки
list.add(3);
list.
add(4);
list.
remove(4);        // Удаляет
list.contains(3); // Проверяет есть ли совпадение
list.isEmpty(); // Пустой список или нет
list.size();    // Размер списка
list.indexOf(1); // Получить индекс элемента
list.get(1);        // Вывести значение по индексу

// Для каждого значения Object в list (:) - означает "в"
for(Object o : list)    // Проходимся по списку
    
System.out.println(o);

ArrayList<Integer> list = new ArrayList<Integer>();    // Типизация списков
for(Integer i : list)    // Проходимся по списку
    
System.out.println(i);

// Проходимся по списку через итератор
// Порядок вывода через итератор не определен
Iterator<Stringiterator = array.iterator();
while(
iterator.hasNext())
{
    
String s iterator.next();
    
out.println(s);
}


Object m = list.toArray();    // Переводим список в массив
Arrays.sort();                // Сортируем
List ListSorted Arrays.asList();    // Получаем список обратно
for(Object nm ListSorted)    // Проходимся по списку
    
System.out.println(nm);
    
list.
size(); // Получаем кол-во элементов в коллекции
list.get(0); // Вытаскиваем значение из списка
?>

РАЗНОЕ

<?
//vep eclips

int a 5;
int b a;
7// a=5,b=7, а остается со своим значением

// Булевные выражения
// "И" и "ИЛИ" (&&, ||) Проверяется только одна сторона, на вторую не смотрим
// "И" и "ИЛИ" (&, |) Проверяет обе стороны, чаще применяются для работы с битами

// != (не равно) и  ! (отрицание)
if (!x.Equals("") && != h)
    
System.out.println("X не равен пустоте и Z не равно H");

// Помещаем в массив Animal потомков, после чего в цикле можем вызвать один и тот же метод для каждого потомка
Animal[] animals = new Animal();
animals[0] = new Dog();
animals[1] = new Cat();

// Передавая родителя в качестве принимаемого параметра, мы можем вызывать любого потомка родителя
// Чтобы класс не наследовался можно не писать ему метод public, или написать final или сделать приватные конструкторы
// Чтобы оставить какой-то метод от переопределения допишите ему final

int a 5;
Object o1 a;    // Приводим к объекту
int c = (Integer)o1;    // Приводим объект к числу, Integer y1 = 5 = Объект типа интеджер


///////////////////////
Все находится в классе Object
Dog a 
= new Dog;
Cat c = new Cat;

a.equals(c); // false, проверяем равен ли класс
с.getClass(); // Cat, получаем имя класса
c.toString(); // Cat@7d277f, получаем строку
c.hashCode();    //8202111, хеш класса

Object o al.get(index);
Dog d = (Dogo;    // Приводим объект к типу Dog, если уверены, что в нем точно Dog
d.roam();            // Вызываем метод roam объекта Dog
((Dog)o).roam();    // вызов метода при привидении типа объекта к объекту Dog, если уверены, что он и есть в объекте

if(instanceof d)    // Проверяем на принадлежность
    
Dog d = (Dogo;
?>

ИНТЕРФЕЙСЫ И КЛАССЫ

<?
// Создание интерфейса - решает проблему множественного наследования, полностью абстрактный
// Определение интерфейса, интерфейс определяет роль, например: животное домашнее, дружелюбное, любит играть
// Интерфейсы можно наследовать от интерфейсов
interface a
{
    public function 
foo();
}

interface 
extends a
{
    public function 
baz(Baz $baz);
}

// Это сработает
class implements b
{
    public function 
foo()
    {
    }

    public function 
baz(Baz $baz)
    {
    }
}

public interface 
Pet{
    public abstract 
void beFriendly();    // абстрактные методы заканчиваются ; без скобок {}
    
public abstract void play();        // в интерфейсе не обязательно указывать public abstract, по умолчанию они все такие в интерфейсе
}

// Использование интерфейса
public class Dog extends Canine implements Pet{
    
// Необходимо переопределить все методы из интерфейса
}

// CTRL + SPACE - меню в эклипсе с подсказкой

// Если нужно, что примитив вел себя как объект
// Упаковка
int i 228;
Integer iWrap = new Integer(i); // Передаем примитив в конструктор обертки

// Распаковка
int unWrapper iWrap.intValue();    // charValue(); booleanValue();

Сейчас это записывается так:
ArrayList<Integer> list = new ArrayList<Integer>();    // Типизация списков
list.add(3);
Integer num = list.get(0);

Integer num = new Integer(33);
num++;    // Операции с числами, объектами

// Работа с датой
new Date(); // java.util.Date;

// Работа с календарем
Calendar call Calendar.getInstance(); // java.util.GregorianCalendar;
// Указываем русскую локаль и тип формата вывода
DateFormat sdf DateFormat.getDateInstance(DateFormat.LONG, new Locale("ru""ru"));
sdf.format(call.getTime());    // Выведет в русском 21 сентябрь 66

// Выведет данные из одной переменной - даты
// % - знак %, 1 - порядковый номер с 1, $ - знак доллара, d - тип данных
String s String.format("%1$Y.%1$m.%1$d"call); 
// ВЛОЖЕННЫЕ КЛАССЫ
public class MyTest{
    
    
// Вложенный статический класс
    
public static class MyNested{
        
        public 
String NestedField "Nested class";
        
        
// Nested классы ничего не знают о внешнем классе
        
public void showNested() {
            
System.out.println(NestedField);
        }
    }
    
    
MyInner inner = new MyInner();    // Добраться до методов вложенного класса можно также, как и до обычного класса
    
    // Вложенный внутренний класс
    
public class MyInner{
        
        public 
String InnerField "Inner class";
        
        public 
void showInner() {
        
// Обращение к полям класса MyTest, происходит простым вызовом, например, OuterField
        // Это как дополнение к внешнему классу, поэтому есть доступ к полям внешнего класса
            
System.out.println(InnerField ' ' OuterField);
        }
    }
    
    public 
String OuterField "Outer class";
    
    public 
void showOuter() {
        
// Класс внутри метода, ограничение видимости класса - этот метод
        
class Local
        
{
            private 
int x;
            
            
Local(int X)
            {
                
this.X;
            }
            
            public 
getX(){
                return 
this.x;
            }
        }
    
        
Local l = new Local(10);    // Использование класса созданного внутри метода
        
inc abc l.getX();            // Достаем значение из класса
    
        
System.out.println(OuterField);
    }
    
}

// Вызов вложенного класса
public class Main{
    public static 
void main(String[] args) {
    
        
MyTest test = new MyTest(); // Создаем экземпляр объекта MyTest
        
test.showOuter(); // Выведет Outer class
        
        // Добраться до методов вложенного статичного класса Nested
        // Добираемся без создания экземпляра основного класса
        
MyTest.MyNested nested = new MyTest.MyNested();
        
nested.howNested(); // Выведет Nested class
        
        // Чтобы добраться до вложенного класса
        // Необходимо иметь экземпляр основного класса, у нас он есть test
        
MyTest.MyInner inner test.new MyInner();
        
        
inner.showInner();    // Выведет Inner class
    
}
}
?>

ИСКЛЮЧЕНИЯ

<?
// Объявляем, что метод может вызвать исключения
// Исключения надо либо обработать, либо объявить
public void takeRisk() 
    
throws BadException {    // Объявляем исключение, чтобы позволить другому методу его отловить
    
if (AbandonAllHope)
        
throws new BadException();        // Создаем исключение, которое необходимо отловить, при возникновении
}

public 
void crossFinger() {
// Оборачиваем в try-catch
    
try{
        
anObject.takeRisk();
    }catch(
BadException bex) {
    
// Если поймали исключение
        
System.out.println("Досада :( ");
        
bex.printStackTrace();    // Получим трассировку стека
    
}catch(OtherException oex) {
    
// Если поймали исключение
        
System.out.println("Досада, поймали второе из 2 исключений");
        
oex.printStackTrace();    // Получим трассировку стека
    
finally {
        
// Выполнить блок кода здесь несмотря ни на что
        // Независимо от того, было выкинуто исключение или нет
        // Этот блок отработает в любом случае, даже если catch поймало
        // исключение и пробросило его на уровень вверх.
        // Иначе, при отсутствии блока finally, после переброса на уровень вверх - данные после catch не выведутся
    
}
}
?>

АНОНИМНЫЙ КЛАСС

<?
// Создаем экземпляр от родителя или интерфейса и добавляем скобочки {} и там уже описываем свойства и методы анонимного класса
public class Main {
    public static 
void main(String[] args)
    {
    
        
Scalable s = new Scalable()
        {
            
// Тут описываем свойства и методы анонимного класса
            
public void scale()
            {
                
System.out.println("Анонимный класс");
                
            }
        };
    
    }
}

// Можем передать переменную из интерфейса в метод
public interface MathFunction
{
    public 
double F (double x);
}

// Создаем по созданному нами шаблону
public class main {

    public static 
void main(String[] args) {
    
        
// Анонимный класс от интерфейса
        
double r Integral(0Math.PI/2,
            new 
MathFunction()
            {
                public 
double F (double x)
                {
                    return 
Math.sin(x);
                }
            }
        );
        
        
System.out.println(r);
    }

    
// Передаем 3 параметром значение интерфейса
    
public static double Integral(double adouble bMathFunction f) {
        
double h = (b-a)/1000000L;
        
double summa 0.0;
        for (
long i=01000000Li++)
        {
            
double x a+h*i+h/2;
            
double y f.F(x);    // Вызываем функцию F из анонимного класса на основе интерфейса
            //double y = Math.sin(x);
            
summa += h;
        }
    }

}
?>

Шаблоны

<?
// Не можем присваивать значение по умолчанию и все типы заменяем на тип указанный при классе
// Ограничить типы <AccType extends int>
public class Accumulator<AccType> {
    
    private 
AccType acc;
    
    public 
Accumulator(AccType a)
    {
        
acc a;
    }
    
    public 
AccType getAcc()
    {
        return 
acc;
    }
    
    public 
void add(AccType a)
    {
        
// Если тип строка, то приводим к строке, проводим операции и возвращаем к необходимому типу 
        
if (instanceof String)
            
acc = (AccType)((String)acc + (String)a);
            
        if (
instanceof Integer)
            
acc = (AccType)((Integer)((Integer)acc + (Integer)a));
    }
}

// Создаем по созданному нами шаблону
public class main {

    public static 
void main(String[] args) {
        
// Например, так и таким же образом для других типов
        
Accumulator<Stringacc1 = new Accumulator<String>("Начало");
        
acc1.add("Hi");
        
System.out.println(acc1.getAcc());
        
        
Accumulator<Integeracc2 = new Accumulator<Integer>(123);
        
acc2.add(456);
        
System.out.println(acc2.getAcc());
    }
?>

РАБОТА С ФАЙЛАМИ

<?
import java
.io.*;

public class 
DirFile {

    public static 
void main(String[] args) {
        
File f = new File("test.txt");

        if (!
f.exists())
        {
            
System.out.print("file not found " f.getName());
        }
        else
        {
            
System.out.print("file found " f.getAbsoluteFile());
        }
        
    }

}

// Работа с файлом как с потоком
FileOutputStream fo = new FileOutputStream("out.txt");    // Работает с битами
String s "Hello";
Byte bytes s.getBytes(Charset.forName("UTF-8"));    // Переводим в биты
fo.write(bytes);    // Записываем
fo.close();


// Чтение из буфера построчно через цикл
String s "Hello";
BufferedReader reader = new BufferedReader(new FileReader('test.txt'));
while ((
reader.readLine()) != null)
{
    
System.out.println(s);
}
reader.close();


// Работа с файлом, как с содержимым доступом, чтением, записью
//FileWriter
//FileReader

//RandomAccessFile - на чтение и на запись файла

// Запись строк в файл
PrintWriter wr PrintWriter("test2.txt");
wr.println("line 1");
wr.close();
?>

СЕРИАЛИЗАЦИЯ

<?
// Объект, который необходимо сериализовать, его необходимо имплементировать интерфейс сериализации
// Сериализовать
PersonInfo pi = new PersonInfo("name""age");
FileOutputStream fs = new FileOutputStream("out.txt");    // Работает с битами
ObjectOutputStream os = new ObjectOutputStream(fs);
os.writObject(pi);
os.close();
fs.close();

// УнСериализовать
FileInputStream fs = new FileInputStream("out.txt");
ObjectInputStream os = new ObjectInputStream(fs);
PersonInfo restoredPersonInfo = (PersonInfo)os.readObject();
restoredPersonInfo.showInfo(); // Вызываем метод из восстановленного объекта

//extarnalizable - потомок serialazable
//javax.xml.stream.*; // работа с XML
//javax.xml.parsers.*; // чтение XML
//javax.w3c.dom.*; // дерево объектов XML
?>