Быстрое погружение в 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 NumberFormatException, throws IOException { // Не закрывается
transient String name; // имеет смысл указывать в многопоточном приложении, не сохраняйте это, я позабочусь об этом сам Serializable
// При именовании переменных, буквы, цифры, знак подчеркивания. С цифры не начинается
// Язык регистрозависимый, желательна верблюжья нотация
int a,d = 2,c; // Массовое создание переменных одного типа, где d уже присвоено значение.
String s; // null, Строки в java не изменяемые, они создают каждый раз новый объект строки
// Работа с ENUM, создаем тип данных Color, а не переменную
enum Color
{
red, blue, green;
// Переопределить базовый метод 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", hi, name); // этот вариант лучше, т.к. не будет создаваться лишних экземпляров класса 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 = x ^ y; // 2 побитовый XOR
int g = x ^ y ^ y; // == x всегда
Обменять местами переменные
x = x ^ y;
y = y ^ x;
x = x ^ y;
b3 = (5 == 3); // Равно
b3 = (5 != 3); // Не равно
b3 = (5 > 3); // Больше
b3 = (5 < 3); // Меньше
b3 = (5 >= 3); // Больше или равно
b3 = (5 <= 3); // Меньше или равно
x++; // x = x + 1
x--; // x = x - 1;
x *= 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 (a > 0 && a < 10)
{
System.out.print("В диапазоне");
}
else
{
System.out.print("Вне диапазона");
}
// Краткая запись if-else
String s = (a > 0 && a < 10) ? "В диапазоне" : "Вне диапазона";
if (name.Length() == 0) // Проверка длины строки
if (name.isEmpty()) // Проверка на пустоту
if (name.Equals("")) // Равно пустоте
Equals("") // Проверка идентичности (зависит от типа) объектов, переменных, строк и т.д.
== // Проверка на одинаковость(примитивы, ссылаются ли 2 ссылки на один и тот же объект). Испльзуется для проверки Битов в переменных.
?>
Циклы
<?
for(int x = 0; x < 10; x = x + 1){
if (x == 3) continue; // Прерывает цикл и прыгает на следующую итерацию
if (x == 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(x > 3){
x = x - 1;
}
Dog myDogs = new Dog();
myDogs[0] = new Dog();
myDogs[1] = new Dog();
int x = 0;
while(x < 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 {
X = (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(names, 2); // Создаем массив выбирая часть данных из другого
String[] names2 = Arrays.copyOfRange(names, 1,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<String> iterator = 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;
b = 7; // a=5,b=7, а остается со своим значением
// Булевные выражения
// "И" и "ИЛИ" (&&, ||) Проверяется только одна сторона, на вторую не смотрим
// "И" и "ИЛИ" (&, |) Проверяет обе стороны, чаще применяются для работы с битами
// != (не равно) и ! (отрицание)
if (!x.Equals("") && z != 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 = (Dog) o; // Приводим объект к типу Dog, если уверены, что в нем точно Dog
d.roam(); // Вызываем метод roam объекта Dog
((Dog)o).roam(); // вызов метода при привидении типа объекта к объекту Dog, если уверены, что он и есть в объекте
if(o instanceof d) // Проверяем на принадлежность
Dog d = (Dog) o;
?>
ИНТЕРФЕЙСЫ И КЛАССЫ
<?
// Создание интерфейса - решает проблему множественного наследования, полностью абстрактный
// Определение интерфейса, интерфейс определяет роль, например: животное домашнее, дружелюбное, любит играть
// Интерфейсы можно наследовать от интерфейсов
interface a
{
public function foo();
}
interface b extends a
{
public function baz(Baz $baz);
}
// Это сработает
class c 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 = 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(0, Math.PI/2,
new MathFunction()
{
public double F (double x)
{
return Math.sin(x);
}
}
);
System.out.println(r);
}
// Передаем 3 параметром значение интерфейса
public static double Integral(double a, double b, MathFunction f) {
double h = (b-a)/1000000L;
double summa = 0.0;
for (long i=0; i < 1000000L; i++)
{
double x = a+h*i+h/2;
double y = f.F(x); // Вызываем функцию F из анонимного класса на основе интерфейса
//double y = Math.sin(x);
summa += y * 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 (a instanceof String)
acc = (AccType)((String)acc + (String)a);
if (a instanceof Integer)
acc = (AccType)((Integer)((Integer)acc + (Integer)a));
}
}
// Создаем по созданному нами шаблону
public class main {
public static void main(String[] args) {
// Например, так и таким же образом для других типов
Accumulator<String> acc1 = new Accumulator<String>("Начало");
acc1.add("Hi");
System.out.println(acc1.getAcc());
Accumulator<Integer> acc2 = 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 ((s = 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
?>
|