Developer от Бога

DV
Показаны сообщения с ярлыком Java. Показать все сообщения
Показаны сообщения с ярлыком Java. Показать все сообщения

воскресенье, 9 июля 2017 г.

Java

Java, язык программирования высокого уровня, а это значит что вам необязательно знать электронику и регистры процессоров. Когда я решил заняться разработкой мобильных приложений и программ для компьютеров, долго думал что же выбрать, С++ или Java. Все-таки выбрал Java, конечно не забывая подглядывать в книги по C++.
Да, Java проигрывает в скорости работы приложений минимум на 80% и потребляют больше памяти. Но подобные языки программирования, которые не привязаны к конкретной операционной системе - это будущее. С каждым годом, компьютеры и разная переносимая электроника становятся все быстрее в обработке инструкций, и имеют все больше оперативной памяти. Также появляются новые компании со своей продукцией - новыми процессорами и операционными системами. Монополия на рынке процессоров Intel, AMD рушится под натиском новых чипов с архитектурой ARM и других, а дальше будет все еще более разнообразнее. Microsoft также есть о чем беспокоится, хоть мы замечаем их успешные попытки "подсадить" на Windows разработчиков мобильных приложений.
Но вернемся к Java. Данный язык программирования хорошо продуман, и имеет историю развития более 20 лет. Прежде всего нужно знать общий принцип работы программ на Java. Приложения разрабатываются на JDK, "весом" в несколько сотен мегабайт, а работают на JVM - виртуальной машине Java, которая занимает от 10 мегабайт до нескольких сотен килобайт, в зависимости на чем будут использоваться программы( компьютер или какое-то мобильное устройство). Скачать Java машину можно на официальном сайте.



В даном курсе программирования Java , будем больше обращать внимание на те моменты, по которым больше всего вопросов. Но повторим общие стандарты Java с СИ-подобными языками:


int a = 1;// Переменная типа int - хранит целые числа.
double b = 2.3; // Переменная типа double - хранит числа с плавающей точкой.
float c = 4.56;// Переменная типа double - хранит большие числа с плавающей точкой.
char d = 's';//Переменная типа char - хранит символы в одинарных кавычках.
String str "iVARIOUS";// Переменная типа String, хранит строки.
boolean = true; // Переменная типа boolean - хранит только два значения: true и false.
int[] arr = new int[9];// создания массива на 9 чисел.


{// участок кода без имени, в нем можно объявлять переменные с именами которые уже объявлялись, это не вызовет ошибку.
int a = 7;
double b = 8.3;
}

public void func(){ // Участок кода с именем, вызываться только по имени func(), и не возвращает значений.
//....
}

public int func(){// Участок кода с именем, вызываться только по имени func(), и возвращает значение типа int (как и любого типа).
//....
return 25;
}

public int func(int a){// Участок кода с именем, вызываться только по имени func(), принимает значения, и возвращает значение типа int (как и любого типа).
//....
return a;
}

Java. Классы и Обьекты

Java является языком объектно-ориентированным, это значит что программа состоит из объектов, или классов, которые по своей сути - не зависимы. То есть - если в Java объекте нет метода (или функции , как это принято называть в языках программирования СИ ) который возвращает (return) или предоставляет доступ к присвоению значений своим элементам, вы эти элементы никак не сможете использовать. Java Класс, по структуре чем то напоминает корпускулярно-волновой дуализм света. То-есть, в одних ситуациях свет ведет себя как электромагнитная волна, а в других как частица(с объектом можно вести себя как с переменной типа int, давая ей имена и присваивать значения, а можно вести себя и более шире ).
В СИ подобных языках ( к которым относится и Java) есть переменная типа int.
Int принимает в некотором диапазоне целые значения: 1, 2, 3... Int создается записью:

Int 'название';

Объект из класса создается подобным образом - 'тип' плюс 'название'.
Только если описание типа int уже заложено языком Java, то тип объекта вы должны сами придумать какой вам нужен, создав класс.
Например, класс содержащий размеры чего-то, должен иметь внутри себя имеет запись вида:

public class size {

int x=2;
int y=4;
int z=6;

}

Это был создан только Java класс (тип) ( что то вроде вашей собственной переменной int, но которая может хранить не одно число, а много разных).
Но чтоб создать переменную (вернее-Объект), нужно ей дать еще имя, для
int x;

'int'-это тип переменной, х - название переменной и имя участка в памяти, в которой хранится некое значение. Как типу int нельзя присвоить значение (int = 5), так и классу нельзя присвоить значение ( public class size{} , size = 5 ). Класс это только описание переменной, как буд-то вы сказали: "int-должен хранить только целые числа!".
Работа начинается после создания объекта:


public class size {

int x=2;
int y=4;
int z=6;

}


size object_a;//Имя указателя на Физически существующий объект в памяти.
object_a = new size();// Физически существующий объект в памяти.
size object_b; //Имя указателя на Физически существующий объект в памяти.
object_b=object_a;// Копирование физического адреса на который указывает object_a;
//.....................
object_b=new size();//Создание нового объекта
object_b=object_a;// Создание копии объекта object_a;

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

четверг, 6 июля 2017 г.

Java. Создание графических приложений

В статье - Java. Графики функций было рассмотрено графическая составляющая простейшего приложения - рисование графиков математических функций. Здесь более подробно описан процесс организации графического приложения.
С точки зрения окон, есть два главных момента, это создание собственно окна приложения, унаследовавшее класс JFrame, а также создание панелей, наследовавшие класс JPanel. Окно приложения, есть статичным по своей сути объектом, фундамент, все элементы: кнопки, изображения и другие, ставятся вначале на панель JPanel, а потом на сами окна JFrame. Поэтому после создания класса окна, создаются панели на которых размещены кнопки, в даном примере это класс buttonpanel, и другие панели элементов которые и рисуют графики.
После создания нужных классов панелей, в главном классе JFrame, создаем уже объекты этих вышеперечисленных классов панелей:

buttonpanel btp= new buttonpanel();//Класс с кнопками RadioBut rb=new RadioBut();//Класс с кнопками
scale sc=new scale();// Класс рисующий графику
static Graph_26_02 gp;//главный объект всей программы

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

Container head_container = getContentPane();
Container container_graph = new Container();
head_container.setLayout(new BorderLayout());
container_graph.add(sc);
head_container.add(container_graph,BorderLayout.CENTER);
head_container.add(rb,BorderLayout.SOUTH);
head_container.add(btp,BorderLayout.NORTH);

Также в главном классе присутствует очень важная функция - перерисовки окна

public static void repaintf(){
gp.repaint();
}

С этой функцией часто бывают проблемы, особенно если ее вызывать из других классов. Тут стоит следить, что функции static можно вызывать только их других функций static , главная функция main также является статичной, если с нее вызывать функцию перерисовки окна, то функция должна быть статичной. Вызов не статичной функции из статичной - невозможен, как и static функции из не static.
При построении программ, следует также разделять приложение на специализированные части:
- визуальная графическая часть, для отображения приложения.
-часть которая принимает разного рода сигналы, события.
- алгоритмическая часть, которая вычисляет задачи.

Java. Графики функций - продолжение

В предыдущем примере было рассмотрено графическое представление приложения. Сейчас приступим к алгоритмам.
Все вычисления будут происходить от центральной точки. Весь алгоритм привязан к центральной точке, смещение которой будет приводить к смещению всего графика.
В примере используется метод рисования линий drawLine(). В зависимости от математических функций - просчитываем две точки x1, x2, вернее одну x1, которая идет впереди, x2 всего лишь повторяет x1 но с опозданием на шаг (например для параболы: x1=1/x2=0; x1=4/x2=1; x1=9/x2=4). Все действия проходят через интерфейс ActionListener , который сообщает классу scale какая именно была нажата кнопка, и какое действие следовательно нужно применить.


public class eventbut implements ActionListener{

@Override
public void actionPerformed(ActionEvent arg) {

AbstractButton aButton = (AbstractButton) arg.getSource();
String s=aButton.getText();
scale.positioncenterscale(s);
Graph_26_02.repaintf();
}
}

Класс scale содержит основной алгоритм построения графиков и перемещения по графику.



  1. public class scale extends JPanel {
  2. static boolean line=false;
  3. static boolean parabola=false;
  4. static boolean hiperbola=false;
  5. static int centerx=400;
  6. static int centry=400;
  7. static int step=15;
  8. static int step_line=1;
  9. static int count_step=0;
  10. static int scale_func=100;
  11. public void paint(Graphics g){
  12. System.out.println(step_line);
  13. gradient_func(g);
  14. g.setColor(new Color(0,255,0));
  15. if(line)
  16. g.drawString("Line", 50, 50);
  17. if(parabola)
  18. g.drawString("Parabola", 50, 70);
  19. if(hiperbola)
  20. g.drawString("Hiperbolaa", 50, 90);
  21. scale_div(g);
  22. if(parabola)
  23. parabola (g);
  24. if(hiperbola)
  25. hiperbola (g);
  26. if(line)
  27. line(g);
  28. graph_border(g);
  29. } public static void scale_div(boolean arg){
  30. if(arg){
  31. step+=5;
  32. }
  33. else if (arg==false){
  34. step-=5;
  35. }}
  36. public static void reset(){
  37. centerx=400;
  38. centry=400;
  39. step=5;
  40. count_step=0;
  41. scale_func=100;
  42. }
  43. public static void positioncenterscale(String arg){
  44. switch(arg){
  45. case "zoom +":scale.scale_div(true);scale_func++;break;
  46. case "zoom -":scale.scale_div(false);scale_func--;break;
  47. case "<<":centerx+=step;break;
  48. case ">>":centerx-=step;break;
  49. case "top":centry+=step;break;
  50. case "down":centry-=step;break;
  51. case "vertex -":step_line+=5;break;
  52. case "vertex +":if(step_line>5)step_line-=5;break;
  53. case "reset":reset();break;
  54. case "Line":if(line==true)line=false;else line=true;break;
  55. case "Parabola":if(parabola==true)parabola=false;else parabola=true;break;
  56. case "Hiperbola":if(hiperbola==true)hiperbola=false;else hiperbola=true;break;
  57. }
  58. }
  59. public void gradient_func(Graphics g)
  60. { int gradient=20;
  61. for(int i=3;i<=797;i++)
  62. {
  63. gradient+=(i/6);
  64. g.setColor(new Color(gradient,gradient,gradient));
  65. g.drawLine(3,i,796,i);
  66. gradient=10;
  67. }
  68. }
  69. public void graph_border(Graphics g){
  70. g.setColor(new Color(255,255,255));
  71. g.drawLine(0,0,800,0);
  72. g.drawLine(0,0,0,800);
  73. g.drawLine(800,0,800,800);
  74. g.drawLine(0,800,800,800);
  75. g.setColor(new Color(190,190,190));
  76. g.drawLine(1,1,799,1);
  77. g.drawLine(1,1,1,799);
  78. g.drawLine(799,1,799,799);
  79. g.drawLine(1,799,799,799);
  80. g.setColor(new Color(0,0,0));
  81. }
  82. public void parabola (Graphics g){
  83. int x0=0;
  84. int y0=(x0*x0);
  85. int x1=1;
  86. int y1=x1*x1;
  87. g.setColor(new Color(255,150,150));
  88. for(;(centry-y1)>=0;)
  89. {g.drawLine(centerx+x0,centry-y0,centerx+x1,centry-y1);
  90. g.drawLine(centerx-x0,centry-y0,centerx-x1,centry-y1);
  91. x0=x1;
  92. y0=y1;
  93. x1+=step_line;
  94. y1=x1*x1/scale_func;}
  95. }
  96. public void hiperbola (Graphics g){
  97. int x0=0;
  98. int y0=(x0*x0*x0);
  99. int x1=1;
  100. int y1=x1*x1*x1;
  101. g.setColor(new Color(0,255,255));
  102. for(;(((centry-y1)>=0)||((centry+y1)<=800));)
  103. {g.drawLine(centerx+x0,centry-y0,centerx+x1,centry-y1);
  104. g.drawLine(centerx-x0,centry+y0,centerx-x1,centry+y1);
  105. x0=x1;
  106. y0=y1;
  107. x1+=step_line;
  108. y1=x1*x1*x1/(scale_func*30);}
  109. }
  110. public void line (Graphics g){
  111. int x0=0;
  112. int y0=x0;
  113. int x1=1;
  114. int y1=x1;
  115. g.setColor(new Color(255,200,255));
  116. for(int i=0;i<100;i++)
  117. {g.drawLine(centerx,centry,centerx+x1,centry-y1);
  118. g.drawLine(centerx,centry,centerx-x1,centry+y1);
  119. x0=x1;
  120. y0=y1;
  121. x1+=100;
  122. y1=x1;}
  123. }
  124. public void scale_div(Graphics g){
  125. if(step==0)
  126. step=1;
  127. g.drawLine(centerx,centry,centerx,0);
  128. for(int i=0; i<=(centry/step);i++){ g.drawLine(centerx-2,centry-count_step,centerx+2,centry-count_step);
  129. count_step+=step;
  130. }
  131. count_step=0;
  132. g.drawLine(centerx,centry,800,centry);
  133. for(int i=0; i<=((800-centerx)/step);i++){
  134. g.drawLine(centerx+count_step,centry-2,centerx+count_step,centry+2);
  135. count_step+=step;
  136. }
  137. count_step=0;
  138. g.drawLine(centerx,centry,centerx,800);
  139. for(int i=0; i<=((800-centry)/step);i++){
  140. g.drawLine(centerx-2,centry-count_step,centerx+2,centry-count_step);
  141. count_step-=step;
  142. }
  143. count_step=0;
  144. g.drawLine(centerx,centry,0,centry);//center-left
  145. for(int i=0; i<=(centerx/step);i++){
  146. g.drawLine(centerx+count_step,centry-2,centerx+count_step,centry+2);
  147. count_step-=step;
  148. }
  149. count_step=0;
  150. }
  151. }
  152.  

Java. Графики функций

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

  1. // Главный класс с которого начинается программа Graph_26_02
  2. import java.awt.BorderLayout;
  3. import java.awt.Color;
  4. import java.awt.Component;
  5. import java.awt.Container;
  6. import java.awt.FlowLayout;
  7. import java.awt.Graphics;
  8. import javax.swing.JButton;
  9. import javax.swing.JFrame;
  10. import javax.swing.JPanel;
  11. public class Graph_26_02 extends JFrame{
  12. buttonpanel btp= new buttonpanel();
  13. static Graph_26_02 gp;
  14. scale sc=new scale();
  15. RadioBut rb=new RadioBut();
  16. Graph_26_02() {
  17. super("Graphics Function");
  18. Container head_container = getContentPane();
  19. Container container_graph = new Container();
  20. head_container.setLayout(new BorderLayout());
  21. sc.setSize(800,800);
  22. container_graph.add(sc);
  23. head_container.add(container_graph,BorderLayout.CENTER);
  24. head_container.add(rb,BorderLayout.SOUTH);
  25. head_container.add(btp,BorderLayout.NORTH);
  26. setSize(850,900);
  27. setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  28. setResizable(false);
  29. setVisible(true);
  30. }
  31. public static void repaintf(){
  32. gp.repaint();
  33. }
  34. public static void main(String[] args) {
  35. gp=new Graph_26_02();
  36. }
  37. }
Класс buttonpanel создает кнопки, и применяет к ним "слушаетелей" которые будут реагировать на события.


  1. public class buttonpanel extends JPanel{
  2. eventbut evtb = new eventbut();
  3. static JButton plus=new JButton("zoom +");
  4. static JButton minus=new JButton("zoom -");
  5. static JButton left=new JButton("<<");
  6. static JButton right=new JButton(">>");
  7. static JButton top=new JButton("top");
  8. static JButton down=new JButton("down");
  9. static JButton hight=new JButton("vertex +");
  10. static JButton lower=new JButton("vertex -");
  11. static JButton reset=new JButton("reset");
  12. FlowLayout flbutton=new FlowLayout();
  13. buttonpanel(){
  14. setLayout(flbutton);
  15. this.add(left);
  16. left.addActionListener(evtb);
  17. this.add(plus);
  18. plus.addActionListener(evtb);
  19. this.add(top);
  20. top.addActionListener(evtb);
  21. this.add(down);
  22. down.addActionListener(evtb);
  23. this.add(minus);
  24. minus.addActionListener(evtb);
  25. this.add(right);
  26. right.addActionListener(evtb);
  27. this.add(hight);
  28. hight.addActionListener(evtb);
  29. this.add(lower);
  30. lower.addActionListener(evtb);
  31. this.add(reset);
  32. reset.addActionListener(evtb);
  33. }
  34. }

Класс RadioBut будет отображать выбраный график.


  1. public class RadioBut extends JPanel{
  2. eventbut eb=new eventbut();
  3. JRadioButton pr=new JRadioButton("Parabola");
  4. JRadioButton hp=new JRadioButton("Hiperbola");
  5. JRadioButton ln=new JRadioButton("Line");
  6. RadioBut(){
  7. this.add(ln);
  8. ln.addActionListener(eb);
  9. this.add(pr);
  10. pr.addActionListener(eb);
  11. this.add(hp);
  12. hp.addActionListener(eb);
  13. }
  14. }

Java. Списки ArrayList и LinkedList

ArrayList и LinkedList представляет собой отдельный класс , моделирующий работу массива , вернее сказать интерфейс как у массива но с более расширенными функциями записью/чтением данных и управлением памятью. Основная проблема массивов заключается в их статичности, невозможно изменить размер массива, добавить или удалить его элементы. Поэтому при проектирование приложений приходилось угадывать размер массивов, что приводило к нерациональному потреблению памяти. Все эти проблемы решает класс ArrayList. При его объявление отпадает надобность указывать размер ArrayList, а только тип хранимого содержимого:


ArrayList <String> name = new ArrayList<String>();// объявление

int n = name.size(); //количество элементов

String str = name.get(3); // Чтение третьего элемента, эквивалент array[3];

name.set(9, str); // Запись в девятый элемент

name.add(str); // Добавит строку в конец списка

name.add(9, s); // Добавит строку после 9 элемента

name.add(0, s); // Добавит строку в начало списка

name .remove(6);// Удаление 6-го элемента


Единственное, что следует не путать:


name.set(9, str) - записывает в уже существующий 9 элемент .
name.add(9, str) - вставляет новый элемент, в результате чего увеличивается размер списка ArrayList.


ArrayList <String> name = new ArrayList<String>();

String a = "str-1";
String b = "str-2";
String c = "str-3";


name.add(a);
name.add(b);
name.add(c);


for(int i=0; i < name.size(); i++){
System.out.println(name.get(i));
}


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

Java. Ввод данных с клавиатуры

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


Reader reader = new InputStreamReader(System.in);
BufferedReader bfreader = new BufferedReader(reader);

String string = bfreader.readLine();

System.out.println("Out string: " + string);



Объект InputStreamReader принимает поток байтов данных из System.in , декодирует их в символы. Так как в итоге мы получаем данные типа String , в случае необходимости для конвертации принятой строки в числа, используется метод parseInt() из класса Integer.


int digit = Integer.parseInt(string);


System.out.println(digit*digit);

Java. Перегрузка методов и конструктров

Бывает нужно, чтоб функция исполняла свои вычисления в зависимости от количества переданных ей аргументов. Для этого совсем не обязательно создавать совершенно разные методы (функции). Перегрузка методов - свойство исполнения программы в методе, в зависимости от количества принятых аргументов. Таким образом, есть возможность создать несколько методов с одинаковыми именами но с разным количеством принимаемых аргументов. В случае вызова методов, будет исполнятся тот у которого сойдутся переданные аргументы с своими принимаемыми аргументами.
Перегрузка методов реализуется только за счет совпадения переданных и принимаемых аргументов, возвращаемое значение не является свойством которое влияет на перегрузку метода.



public class overloaded{

public static void overloaded (int a, int b, int c){

System.out.println("Первый перегруженный метод");

}


public static void overloaded (int a, int b){

System.out.println("Второй перегруженный метод");

}


public static void main(String[] args){

overloaded.overloaded(1,2,3);
overloaded.overloaded(1,2);

}
}

---------------------------------------------------------------------
Результат программы:

Первый перегруженный метод
Второй перегруженный метод
---------------------------------------------------------------------

Java. Конструкторы и ключевое слово this

Конструкторы и ключевое слово this часто очень связаны. Начальные значения аргументов класса как говорилось ранее можно прочитать или установить с помощью обычных методов, которые созданы для таких действий, обычно им дают имена которые начинаются с слов: get и set соответственно. Конструкторы записываются похожим образом как методы и дают имена названия класса. Единственное отличие от метода - при записи не нужно указывать возвращаемое значение. Конструктор может как принимать аргументы, так и не принимать, а использовать свои какие то значения.
Ключевое слово this откидывает необходимость придумывать постоянно уникальные имена входящих аргументов функций или конструкторов. Если в классе имеется переменная String с именем, например name, это же имя можно использовать для внутренних переменных методов и конструкторов, но чтоб присвоить его с таким же именем аргументу в объекте, достаточно добавить ключевое слово this.name = name; И переменная метода или конструктора name, будет присвоена переменной name уже объекта, а не самой себе.






  1. public class thisjava{

    String name;
    int weight;
    int height;

    thisjava (String name, int weight, int height){

    this.name=name;
    this.weight=weight;
    this.height=height;


    public static void main (String[] args){

    thisjava one = new thisjava ("One", 4, 2);
    thisjava two = new thisjava ("Two", 5, 3);
    thisjava three = new thisjava ("Three", 6, 4);


    System.out.println(one.name+':'+one.weight+','+one.height);
    System.out.println(two.name+':'+two.weight+','+two.height);
    System.out.println(three.name+':'+three.weight+','+three.height);
    }
    }

Java. Наследование, доступ к переменным класса

С пониманием наследования в Java обычно трудностей нет, объект наследующий некоторый класс, хоть и не явно но имеет все тоже самое + свои какие то элементы:




  1. public class A {
  2. int x = 1;
  3. double y = 2.645;
  4. String name = "name";
  5. }
  6. public class B extends A {
  7. int arg = 9;
  8. public static void B(){
  9. System.out.println(x);
  10. System.out.println(y);
  11. System.out.println(name);
  12. System.out.println(arg);
  13. }
  14. }
  15. //......................
  16. //.......Вывод программы
  17. //......................

1
2.645
name
9


Как видно с программы, при обращении к переменным: x, y, name, они выводятся как присущие классу B. B клас унаследовал все переменные от класса A и имеет свою собственную переменную int arg.
Часто приходится работать с классами разных библиотек. Как уже упоминалось, обьекты в Java не имеют доступа к переменным других обьектов если те находятся в разных пакетах. Поэтому если в программе предусмотрен обмен private переменными между обьектами из разных пакетов, в классах этих обьектов, должны быть методы которые возвращают значения переменных обьектов, по умолчанию все созданые переменные установлены как private :


  1. public class A {
  2. int a=9;
  3. public int return_arg(){
  4. return a;
  5. }
  6. }
  7. public class B {
  8. int a=6;
  9. public int return_arg(){
  10. return a;
  11. }
  12. }
  13. public class example {
  14. public static void main(String[] args){
  15. A a = new A();// a.a = 9;
  16. B b = new B();b.a=6;
  17. a.a=b.return_arg();
  18. System.out.println(a.a);
  19. }
  20. //......Результат программы....
  21. 6
  22. //.............................
  23. a.a=b.a;// Ошибка программы, нужно установить в классе b : public a;