Forem: CodeGym

Learn How To Code Your First Game In Java With CodeGym

CodeGym — Fri, 23 Aug 2019 15:34:49 +0000

We’ve got a problem, Cap!

Most attempts to learn programming (or something else) on your own simply fail. Every self-taught risk to catch a loss of motivation for various reasons. For example, some coding topics may seem too complicated and incomprehensible. Or, on the contrary, you move so easily that there are doubts that you move in the right direction. It is tough, to estimate your own successes. How to do it? Where to go? And also, rookie programmers very often lose their motivation due to the fact that they do not see the final or even intermediate result of their work.

It’s too dark in here… I can’t see the results of my job!

This problem is typical not only among students but among professional programmers as well. Software developers who work on large complicated projects in big teams and make a small piece of code of a huge program. The effect of this piece is not always visible, much more often it just lost there, drowning among the same pieces made by their colleagues.

Programming students have slightly different problems. Most often they study some topics, solve some tasks to consolidate knowledge divorced from reality, but globally do not see what they have learned and what they actually can or cannot do. In fact, the result is the same as that of professionals: they do not see the result of their efforts.

Yep, quite a problem… What should you do?

Dropping your programming learning out isn’t a good idea. The better way is to dilute it with something else. Something interesting for you, where the result will be visible.

Programmers who work in big outsourcing and product companies very often “entertain” themselves by creating their own projects. We recommend the same method for advanced students. Most often, novice developers write small games based on classic ones, and sometimes they realize their own ideas.

But what should coding rookies do, those who are not ready for a relatively interesting project on their own? Now on the Internet, you can find enough step-by-step instructions. Following them, a student creates their own project with the help of more experienced developers. A great example is free to use CodeGym Game Section. There you can create your own versions of classical games under the clear guidance of professionals. Now you can try to write your own interpretation of 6 games: Minesweeper, 2048, Snake, Space Invaders, Moon Lander, and Racer.

To code such game, you need to have only basic knowledge of Java, which can be obtained quite quickly: initial knowledge about classes and objects, basic primitive data types, String, loops and branches, arrays and initial knowledge about the ArrayList structure. The CodeGym authors recommend completing the first 5 to 10 levels of the course to get such knowledge. If you don’t feel confident enough, here is a useful theory that helps you to solve the tasks.

However, CodeGym Games section is apart of the main course and available to everyone, not only for CodeGym students.

Each game is divided by two dozen subtasks as well as step-by-step instructions. First, you get your subtask and tips, then write your code. When you finish, CodeGym auto validation system is checking your code. If everything is ok, you go to the next step.

When you complete the last step, you get a ready-to-use game. You are free to publish it on the site, and sharing with your friends or modify the code to improve it or propose something original into old ideas. All the games use simple CodeGym game engine, you can read about it in this article.

CodeGym Games section is a great way to write your first complete game project, modify it and understand how to develop indie projects by yourself. After such exercises, you are ready to continue your learning and to think of your own original projects in the near future.

More about CodeGym Games: https://codegym.cc/groups/posts/137-new-section-on-codegym–games

Go to code: https://codegym.cc/projects/games

First published on Technotification

Top 10 + 1 common mistakes every Java learner makes

CodeGym — Thu, 30 May 2019 13:31:40 +0000

It is said, “Your friend will swallow your mistakes, your enemy will present them on a plate”. I am definitely not your enemy, but I want to present you some mistakes, specific to each Java beginner student and I will do it right here on this blogging “plate”. Sure there are only some of them, I collected from CodeGym.cc courses analytical System. If you don’t know yet, CodeGym is a practical Java course from scratch to upper intermediate.

So, here they are.

0. Assignment or comparison (= or ==)?

This is one of the first mistakes of students who learn Java from scratch. It is easy to confuse that = is an assignment operator whereas == is a relational operator. That’s natural mistake because in math “=” is closer to Java’s “==”, than to Java’s “=”. Usually compiler catch such mistakes, however they could be hidden from it. For example:

boolean myBoolean; 
If (myBoolean = true) {
doSomething; 
}

See? This block will be true anyway because you assign it to be true…

1. Comparing Strings with == operator.

A while after you did your first Java tasks (usually there are some console output and arithmetical problems) you learn String class. However beginners often forget that particular string isn’t a representative of a primitive type like char or int, it’s an object. You can’t compare objects using == operator. Remember using the string.equals(Object object) function to compare strings (or other objects), not the == operator. Equals checks the contents of the string, while the == operator checks whether the references to the objects are equal.

To be honest with you, string constants are usually “interned”. That means two constants with the same value can actually be compared with ==, but don’t really rely on that.Use .equals.

2. Different names of Class and the file where its code is.

This mistake was very popular (maybe even leader of all) some years ago. Now even beginners use modern IDE’s and it is on the verge of extinction. Anyway, it is useful to bear in mind that in Java file name and class name should be the same. If you name your file, for example, Test.java and write there some class CodeGymTest code:

//File name: Test.java 

public class CodeGymTest { 
   public static void main(String[] args) { 
        System.out.println("Hello world"); 
   } 
}

You’ll get the next output:

Test.java:9: error: class CodeGymTest is public, should be
                    declared in a file named CodeGymTest.java
public class CodeGymTest 
^
1 error

By the way, if you remove public modifier from the class name, your program will run.

3. Accessing non-static members from the main method or other static methods

Pretty often beginners don’t know how to work with static context. Static variable is the one shared among all instances of a class. Therefore, there’s only one copy of it which is shared by all objects. So we can’t work with non-static variable in a “static way”. This mistake usually happens in the main() method (which is static!), when novice programmer attempts to access an instance variable or method. If you try such code

public class MyExample {
    public String myString;  

public static void main(String[] args) {
        myExample.String = “non static String”;    
}
  }

We’ve got compile error:

non-static variable number cannot be referenced from a static context.

What should we do to avoid this? First of all we can make our variable static, but it is not always meets the program purpose. One of the solutions is to create an object of our class:

public class MyExample {
    public String myString;  

public static void main(String[] args) {
MyExample myExample = new MyExample(); 

        myString = “non static String”;    
}
  }

Remember, you can work with static variables or methods from static or non-static context. You can work with non-static elements using object reference.

4. Array index is out of Array bounds

It is an extremely popular mistake among beginner programming students. The reason of such popularity is, that the very first more or less complicated tasks are about arrays and cycles. Very easy example:

String[] name = { "Snoopy", "Woodstock", "Charlie Brown" };
for (int i = 0; i <= name.length; i++) {
    System.out.println(name[i]);
}

The cycle starts from zero element “Snoopy”, then goes to the first “Woodstock” and to the second one “Charlie Brown”… and tries to print the third element, but we don’t have it (our “third” is a “second” such as “first” is number zero). Here the mistake is pretty obvious, but it is not always like this.

Cycles and arrays are pretty tough for rookies. However, practice makes diamonds. There are hundreds Arrays & Cycles tasks on CodeGym. Try to solve them (it is free for now on!) to get confident skills.

5. Puting “;” wrong in cycles or conditionals

In the block below you don’t print any of array’s members. First, the cycle is ending with “;” so nothing happens. Even more: the program won’t work because your int i works only inside the cycle and it ends with “;”.

public static void main(String[] args)  {

            int [] myArray = {2,5,7};
            for (int i=0; i<3; i++);
            {
                System.out.println(myArray[i]);
            }
        }

If you try something like this:

public static void main(String[] args)  {

            int [] myArray = {2,5,7};
            int i = 0;

            for (i=0; i<3; i++);
            {
                System.out.println(myArray[i]);
            }
        }

You’ve got java.lang.ArrayIndexOutOfBoundsException, because System.out.println tries to print element #3 and only this one, but we don’t have such an array member. The last one is the second and it is 7.

The same story with ; and conditions. For example:

public static void main(String[] args)  {

            int [] myArray = {2,5,7};
           if (myArray[0] > myArray[1]);
            System.out.println("it is");
        }
    }

The condition is not satisfied here, but “it is” would be printed because of “;” after if construction.

If you start your CodeGym learning, you’ll get your first coding tasks with cycles on the level 4 Java Syntax quest. I guess you’ll forget about this kind of mistakes solving enough problems.

6. Missing the ‘break’ Keyword in a Switch-Case construction

The embarrassing thing about missing a “break” keyword is that there aren’t compiler error. However your code works the wrong way.

Look at the code example below, where we forgot to put a break in “case 0”. The program will work but it prints both “0” and “1” because switch construction ends its work with break.

public static void switchCasePrimer() {
        int counting = 0;

        switch (counting) {
            case 0:
                System.out.println("0");
            case 1:
                System.out.println("1");
                break;
            case 2:
                System.out.println("2");
                break;
            default:
                System.out.println("Default");
        }
}

This rule has an exception. Switch block can finish its work with return operator

public class test {
    public static void main(String[] args) {
        System.out.println(showSwitch(1));
    }

    public static int showSwitch(int condition) {
        switch (condition) {
            case 1:
                System.out.println(1);
                return 1;
            case 2:
                System.out.println(2);
                return 4;
            case 3:
                System.out.println(3);
                return 8;
            default:
                System.out.println("default");
                return 256;
        }
    }
}

In this case switch finishes its job right after case 1.

7. Mess with pass by value and pass by reference

If you pass a primitive data type, such as a char, int or double, to a method, you are passing by value. That means a copy of the data type would be duplicated and passed to your method. If that data is modified inside the method, there are no influence on the “original” data outside the method.

public class Main {

    public static void swap(int i, int j)
    {
        int temp = i;
        i = j;
        j = temp;
        System.out.println("from swap method i = " + i + ", j = " + j);
    }


    public static void main(String[] args) {


        int i1 = 1;
        int j1 = 2;
        swap(i1,j1);
        System.out.println("from main method i = " + i1 + ", j = " + j1);

    }
}

When you pass a Java object, for example, array or string to a method, that means you are passing a reference (address of your data), not a duplicate. So if you change the data in method, it will be changed outside it as well.

public class Main {

    static int[] outer = new int[3];

    public static void swap(int[] array) {
        System.out.println("(swap) Before swap :" + Arrays.toString(array));
        int first = array[0];
        int last = array[array.length - 1];
        array[0] = last;
        array[array.length - 1] = first;
        System.out.println("(swap) After swap :" + Arrays.toString(array));
    }


    public static void main(String[] args) {
        outer[0] = 0;
        outer[1] = 1;
        outer[2] = 2;

        swap(outer);

        System.out.println("(main) After swap :" + Arrays.toString(outer));
    }

8. Attempt to work with uninitialized field or variable

Work with an object type without initialization is pretty dangerous.

Class variables are initialized by the default value (0 for int, 0.0 for double, false for boolean, null for non-primitive types (objects).

public class Test2 {
    static String test;

    public static void main(String[] args) {

     System.out.println(test);
    }
}

The output is:

Null

When you work with a local method variables you need to initialize them manually, otherwise you’ll get a compilation error.

public class Test2 {

    public static void main(String[] args) {
        String test2;
     System.out.println(test2);
    }
}

The output is:

Error:(6, 28) java: variable test2 might not have been initialized

9. Forgetting about integer division

If you divide one int to another int, you’ll get int again. So ½ = 0, not 0.5 in this case:

public static void main(String[] args) {

        int i = 1;
        int j = 2; 
  int k = i/j; //here we’ve got 0 
  }

You may learn about division and real types from Java Syntax quest of CodeGym and solve a lot of coding tasks related to the topic.

10. Mess with order of calling constructors in Child objects

When you try to create an instance of a Child class, Child is called first, and Parent after it. Order of constructors execution in Parent-Child relationship builds from basic (Parent) class to inherited (Child).

public class Test3 {
    static class Parent {
        Parent() {
            System.out.println("a Parent is created");
        }
    }
    static class Child extends Parent {
        Child(){
            System.out.println("a Child is created");
        }
    }

    public static void main(String[] args) {
        Child child = new Child();
    }
}

Output:

a Parent is created
a Child is created

If you join CodeGym, you’ll meet OOP and inheritance in Java Core Quest. There are really many tasks of this topic. So sooner or later you’ll get a subtle understanding of OOP principles.

Conclusions

I presume, there is no article that can accumulate all the potential mistakes of newbie Java students. Nevertheless, such lists are very useful to avoid the popular mistakes… and have time to find less trivial issues! Praemonitus, praemunitus (* forewarned is forearmed).

However the most important step is not avoiding mistakes but practice coding itself. That’s why we created CodeGym, Java Core course with more than 1000 practicing tasks, fun lectures and instant feedback on your improvements. When you make a mistake, popular or rare, CodeGym System warning you about it and gives you recommendations to avoid it. Try the course by yourself, it is free for now on.

Don’t stop practice and you become a better software developer for sure. Good luck with your learning!

P.S.: Have you ever made mistakes from this article? What mistakes have you faced with during your learning? Tell us in comments!

The post by Alex Yelenevych, Computer software industry enthusiast and CMO at CodeGym.cc. First was published on CodeGym Medium blog.

CodeGym.cc: Play a Game to Learn Java Programming

CodeGym — Thu, 25 Apr 2019 15:23:51 +0000

A gamified education is ready to kick the boring studying out of our lives. Today let’s take a look on CodeGym.cc, a gamified course, where one can learn how to code in Java from scratch.

But first of all, why choose Java among dozens of languages to start a career? The statistics tell no lies. Java has been on top positions of the programming languages popularity rankings for the past 20 years. Today there are more than 10 millions of Java developers worldwide, and there’s enough of space for the newcomers.

Java is everywhere: Big Data developments, Internet of things, enterprise solutions, and even space exploration. It is a flexible, secure, cross-platform and multi-purpose programming language for writing programs for any devices.

What’s more important, you can learn programming anywhere thanks to a wide range of online courses. Let’s see, what’s the best way to learn Java coding and is it possible not to lose your motivation when you learn alone.

CodeGym.cc is a relatively new online platform for mastering Java programming. Here are five key features of the course, which may help in learning how to code in Java and become confident at it.

1. A gamified Java tutorial for the beginners

CodeGym.cc is geared towards learners with zero experience in programming. Though students with a developer’s background will surely embrace many features of this platform.

The course is designed with numerous gaming technologies to bring a better learning experience, and help users in clearing the major obstacle — a lack of motivation in self-education. In this case, a futuristic plot, the vivid characters and a way of explaining complicated concepts through real-life examples are pushing students to move forward.

CodeGym’s storyline expands in the future. It is the year 3018 when the spaceship crashes on a “wild” planet with robots. The crew needs to teach them programming to clear the rocks and free the ship. A user’s character is a young robot called Amigo, who will learn Java fundamentals by passing four educational quests.

Each quest guides a user through a certain general subject like Java Core, Java Syntax, Java Collections, and Java Multithreading. Each quest consists of 10 levels with 12-13 lectures and few dozens of different tasks.

To become a programmer you need to code — that’s the motto of the course. And this is exactly what you need to do approximately 80% of the time you spend on this online platform. If you want to progress and open new lessons, you need a “dark matter”, which you receive for completing tasks.

Each new subject in Java is explained by one of the crew’s members, while captain John Squirrels is responsible for bringing a dash of motivation at the beginning of each level. All lectures are written in the conversational format with jokes and easy to understand examples. Imagine you’re reading a funny story and learning Java at the same time. Sounds cool, right?

2. Up to 500+ hours of practice and coding from the first lesson

Again, coding skill is sharpened only through practice. It’s almost impossible to memorize a new piece of theory without trying to implement what you’ve just learned immediately.

CodeGym offers powerful capabilities to practice Java programming. Overall, there are 1200+ tasks of three different types:

writing your own code
fixing the source code
retyping code parts

The course accustoms students to use professional Java developers’ tools like IntelliJ IDEA. Though it’s still handy to solve tasks online directly on CodeGym.cc website. Each task is presented in a frame (web IDE) with different tabs. The first one contains the task requirements:

After you read them carefully, click on the “Solution” tab to write your code or fix the source code:

Then click on the “Verify” button to check your solution:

You will get the result in a matter of seconds, right after the validator matches the solution with the task requirements.

Each successful solution brings you a few points of the “dark matter”. Of course, more complicated tasks bring you more reward.

3. Useful tips on improving your code

You rarely think about the style of the code while you learn, and it’s okay. First of all, you need to get the grip of Java fundamentals. But the style of the code is something that differs a “pro” from a starter. Click the “Code analysis” button after you complete the solution to get some recommendations from the virtual mentor at CodeGym and improve your code.

4. Java fundamentals with the real-life examples

Let’s be honest, it’s possible to learn Java programming endlessly. A great software developer will study something new for life to broaden his stack of technologies and follow the trends.

But you need far less theoretical learning to simply start coding and get the Junior position. At CodeGym’s course, you’ll get a minimum theory within a short timeframe to form a strong basis for further profession growth.

Each lecture in the course is short and easy to read. It takes 5 to 10 minutes to read the new subject and move straight to the tasks.

5. A growing and helpful community

Need a hint on solving a tricky task? Of course, you’ll need it someday. There’s a “Help” section at CodeGym, where you can discuss any task and get explanations from other students and skilled software developers.

Also, you can discuss almost any subject from the programming field in the “Groups” sections of CodeGym. It’s early to say about CodeGym as a great source of Java programming content, but there is plenty of additional material, which enhances the course itself.

Conclusion

CodeGym is a course for learning Java programming through practice in a fancy way.

Pros:

hands-on practice, plenty of cool tasks with instant verification and tips on code improvement;
entertaining gamified learning instead of boring lectures and video tutorials;
a strong motivation to continue studying until you master coding.

Cons:

requires the extra reading to get a thorough understanding of Java language;
as for now, isn’t fully adjusted for studying on mobile devices.

Was published on Tech Notification blog

The Best Way To Learn Java Programming

CodeGym — Tue, 09 Apr 2019 10:09:51 +0000

There are plenty of compelling reasons to learn Java coding, even if you're a beginner. Java is a popular programming language, known for its reliability, versatility, and backwards compatibility (meaning it works with older legacy systems). It can also run on almost every computer without changing behavior.

But is Java hard to learn? The simple answer is that yes, it can be tricky. As you learn Java programming, you'll encounter some simple concepts like variables and functions, but there are also more abstract, complex ones like objects, bringing inheritance, and polymorphism that can be difficult to understand. Java also changes on a regular basis, with new features being added from time to time.

But even though there's a learning curve, it's smoother when you know some basic tips for how to learn Java coding. Once you get the hang of some basics and become fluent at a beginning level, it's much easier (and more enjoyable) to learn the complex topics.

In this special sponsored post in partnership with CodeGym, you'll discover the most effective and best ways to learn Java successfully, plus one of the best resources to learn Java for free. If you're unsure how to learn Java as a beginner, or have struggled to learn Java from scratch in the past, this article is for you.

Why Should I Learn Java?

Before we get into the best ways to learn Java programming, there's a more pressing question: why learn Java in the first place?

Java is a great choice for career-oriented beginners because it's a skill that's in high demand (three billion devices run Java!), which means more job/internship opportunities. Evidence suggests that 90% of Fortune 500 companies use Java for building applications and back-end systems. And it's a financially lucrative career option, with the average Java developer earning $102,514 per year.

You can use Java to build a variety of platforms and applications for different devices, including laptops, computers, gaming consoles, car navigation systems, Blu-ray players, medical monitoring devices, lottery terminals, parking meters, etc. This versatility makes the language exciting and unique, since the options for specialization are endless.

It's worth noting that Android apps are also built using Java, opening up opportunities not just in web and software development, but also mobile development.

Finally, Java has a strong community that can provide support as you're learning:

2nd largest StackOverflow community
4th largest meetup community (there are over 1,400 Java Meetup groups, totaling over 580,000 members worldwide)
2nd most-tagged language on GitHub (over 1.5 million Java projects live on GitHub)

Ultimately, Java might not be the easiest language to learn, but there are many reasons why it's worth buckling down to the task.

5 Best Ways To Learn Java Successfully

Now that we've convinced you to start learning Java (or pick it back up), you're probably wondering what's the best way to learn Java successfully.
We've got you covered! Let's take a look at five tips for how to learn to code in Java and keep going even when things get tough. Along the way you'll learn about CodeGym, one of the best resources out there to start learning Java for free in a successful, sustainable way.

1. Balance Between Theory And Practice

Some theory is good to build yourself a knowledge foundation, but avoid too much theory at the expense of little practice. Reading a lot of Java books won't help if you don't actually write any programs. Don't try to understand everything at once: read a bit at a time and then code, code, and code! You'll learn as you go, and things will click as you actually use the concepts in a hands-on exercise.

That's why CodeGym is 80% focused on practice and 20% on theory. The course can provide complex help with the theoretical part of your education (Java syntax, OOP, structures, multithreading, etc.), without getting you too bogged down in theory with nothing to show for it.

After you solve all 1200+ of the tasks on CodeGym, you'll walk away with about 500 hours of actual programming experience under your belt.

2. Schedule Your Learning Experience And Set Milestones And Achievable Goals To Stay Focused

Jumping from skill to skill is not usually an effective way to learn. It's best to dive deep into one language at a time so you don't get distracted or confuse one language with another. It's like trying to learn Spanish and Italian at the same time - you'll probably end up speaking some kind of hybrid.

Once you've chosen to learn a language like Java, keep your momentum by working through your chosen curriculum seven days a week. Even if it's only for half an hour at a time, committing to coding every day will help solidify the habit and make it feel like a normal part of your routine.

To stay focused when motivation is low, remind yourself why you want to learn Java. Do you want to become a full-time developer? Build your own app? Determine your goals and use them to keep you on track.

Using time management strategies will also make it much less stressful to carve out time to learn in your busy life.

CodeGym's course is helpful in this way because it sets milestones for you. The course is divided into a clear roadmap and timeline of what to work on, and sets achievable bite-size goals for you along the way.

3. Use Gamification To Stay Motivated

Not everyone can successfully learn from books and lectures alone. Gamification works by making the learning experience much more engaging, fun, and interactive. You'll look forward to sitting down and completing tasks instead of feeling intimidated and overwhelmed. It's also a lot harder to get distracted when you're immersed in a game!

This is one of the main reasons that CodeGym is ideal for those seeking how to learn Java with no programming experience - their gamification is on point:

CodeGym plays out like a video game; when you solve a problem correctly, you get "dark matter" (the points you need to open the next lecture or the next level)
You play as an anthropomorphic robot named Amigo, and you go through the course level by level, collecting and spending dark matter
The course/game is story-based and involves space travel, extraterrestrial life, and robots
It's divided into 40 levels (4 quests with 10 levels), with each level including about 15–30 coding tasks, 10–20 Java lectures, and motivation articles to keep you going - even when things get tricky

By making it into a game, you'll basically trick yourself into learning to code!

4. Communicate With Other Java Students And Developers + Ask Questions

You'll learn more effectively if you work closely with like-minded people. Plus, forming connections will improve your confidence and accelerate your learning.

When times get tough, asking the right questions helps you solve tricky tasks and complete complicated projects when you might give up otherwise. Be sure to ask specific questions instead of "something went wrong, can you help?" Don't be embarrassed that you don't know the answer.

Building a sense of community for yourself is also important for staying motivated. Learning to code is hard, but knowing that you're not doing this alone helps!

Once you've built a foundation of knowledge, you can give back to the community by sharing tips of your own. You don't even have to wait until you're an expert, because teaching and mentoring someone else can actually help you retain information better and learn faster.

If you choose to learn with CodeGym, they have a community of students in their help section. Here, students ask for hints, help to break through roadblocks, and advice for finding out what they did wrong in their code.

5. Start Building An Online Portfolio

As you learn, it's extremely valuable to build real projects and give others a chance to see your work. When you're ready to apply for Java developer jobs or take on freelance projects, you'll already have a portfolio ready to show potential employers or clients.

One popular option for developers is to create a GitHub account and post your projects there. Or, you could build your own portfolio website. Having a portfolio of your own also lets you look back with pride on the work you've accomplished.

Conclusion

Now you're armed with the strategies and techniques to help you learn Java the right way. Overall, the keys to learning Java are practice and consistency - and it doesn't hurt to keep it fun!

I really recommend starting your journey by signing up for CodeGym - completing the first quest is totally free, so you can try it out before moving on to the next quests. What better way to get your start in Java?

Previously was published on LearnToCodeWith.me blog.

OOP Concepts in Java

CodeGym — Tue, 09 Apr 2019 09:13:08 +0000

One of the strongest points of Java is OOP or Object Oriented Programming. That’s the reason why this language has became so popular and suits really well for projects of any scale.

What is Object Oriented Programming? It is not a magic but it looks like magic if you really get in to it. OOP is about how to build your software. A concept or rather a bunch of concepts that allows you to construct some specific interactions and relations between Java objects for effective development and usage of software.

Сlassical version includes 3 + 1 main OOPs concepts. Let’s start with the classics.

The Object

Objects in Java as well as real-world objects have two characteristics, state and behavior.

For example object Human has state (name, gender, sleeping…) and behavior (studying Java, walking, talking...). Any Java object stores its state in fields and exposes its behavior through methods

Encapsulation

Data encapsulation is hiding internal data from the outside world, and accessing it only through publicly exposed methods.What does that mean? What data, hiding from whom? Hiding means restriction direct access to data members (fields) of a class.

How it works in Java:

Fields are set to private
Each field of class gets two special methods: a getter and a setter. Getter methods return the field. Setter methods let you change the value of the field in non-direct but legal way.

Example of encapsulation, Java code:

public class Student {
private int age;
private String name;

public int getAge() {
return age;
}

public void setAge(int age) {
this.age = age;
}

public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}

public class Test{
public static void main(String[] args) {
Student firstStudent = new Student();
firstStudent.setName("John");
//now you can’t do this:  firstStudent.name = “John”, the name field is private!
}
}

Why you should do it?

The main reason is simplification of your code changes. Imagine, you have an application for Hockey School and there is a class HockeyStudent with two fields: name and age of a student when he joined school. Something like that:

public class HockeyStudent {
public String name;
public  int ageOfEnrollment;
}

Public ageOfEnrollment, no getters or setters… This class is used by many other classes and everything was ok before one guy said, that the int age is not enough. Some hockey players in group are almost one year older than others so it would be more convenient to apart them on two groups depending upon the month they were born. So new field ageOfEnrollment should be array int[][] the first number is for full years and the second is for months. Now you should refactor all code that uses class Student! However if your ageOfEnrollment is private and you have getters and setters everything gets easier. If the requirement for setting the age of a student changes, just update the logic in the setter method setAgeOfEnrollment() and your classes may continue using Student without problems!

This example is somewhat artificial, but I hope it explains why using encapsulation is a great idea.

Inheritance

This principle is more understandable even without practicing. Don’t repeat yourself (DRY) could be the motto of inheritance concept.

Inheritance lets to create a child class that inherits the fields and methods of the parent class without redefinition them. Sure you can override the fields and methods of the parent class in child class, but it’s not a necessity. Also you can add new states and behaviors in child class. Parent classes sometimes are called superclasses or base classes, and child classes are known as subclasses. Java extends keyword uses to implement the principle of inheritance in code.

How it works in Java:

Create a Parent class.
Create a Child class using extends keyword.
In Child’s class constructor use super(parentField1, parentField2,...) method to inherit the parent’s fields.

Constructor is a special method to initialize the newly created object. Constructor has the same name as its class name. There are two types of constructors: default (no-arg constructor) and parameterized constructor. Class must have at least one constructor (it is always is by default) and it can have a lot of them.

Every time you create a new object you call its constructor. In the example above the line

Student firstStudent = new Student();

You call the default constructor Student() of class Student using word new

Some rules:

One class could have only one parent.
One parent class may have many child classes.
Child class can have its own child classes.

Example Inheritance, Java code

Let’s create a Phone class.

public class Phone {
    int price;
    double weight;

//constructor
public Phone(int price, double weight) {
        this.price = price;
        this.weight = weight;
    }

    void orderPhone(){
        System.out.println("ordering phone...");
    }
}

Well, there are different type of phones, so let’s create two child classes, one for Android phones and the second for iPhones, and add some fields and methods their parent didn’t have. The fields that their parent has, let’s call in constructors using super().

Java inheritance example

public class Android extends Phone {

//some new fields
String androidVersion;
int screenSize;

    String secretDeviceCode;

//constructor
    public Android(int price, double weight, String androidVersion, int screenSize, String secretDeviceCode) {
        super (price, weight); //Android inherits Phone’s fields

        //this - reference to the current class object
        //super - reference to the parent class object

        this.androidVersion = androidVersion;
        this.screenSize = screenSize;
        this.secretDeviceCode = secretDeviceCode;
    }

    //new method specific for Android only, but not for Phone class
    void installNewAndroidVersion() {
        System.out.println("installNewAndroidVersion invoked...");

    }

}

public class IPhone extends Phone {
    int price;
    double weight;

    boolean fingerPrint;

    public IPhone(int price, double weight, boolean fingerPrint) {
        super (price, weight, countryProduced);
        System.out.println("IPhone constructor was invoked...");
        this.fingerPrint = fingerPrint;
    }

    void deleteIPhoneFromDb() {
        System.out.println("deleteIPhoneFromDb invoked...");
    }

@Override //This is about polymorphism, see below
void orderPhone(){
        System.out.println("ordering my new iPhone and deleting the old one...");
    }
}

So, once more: in Java inheritance allows you to extend a class with child classes that inherit the fields and methods of the parent class. It’s an excellent way to achieve code reusability.

Polymorphism

Polymorphism is the ability of an object to take on different forms or rather to act in different ways. Usually polymorphism in Java happens if a parent class reference is used to refer to a child class object.

What does it mean and how it works in Java:

What is polymorphism in Java? In general that means you can use the same method name for different purposes. There are two two types of polymorphism in Java: method overriding (dynamic polymorphism) and method overloading (static polymorphism).

Method overriding

You can override parent’s method in child class forcing it to work in different way. Let’s create a parent class Musician with a play() method.

Java Polymorphism example

public class Musician {
    String name;
    int age;

    //default constructor
    public Musician() {
    }

    //parameterized constructor
    public Musician(String name, int age) {
        this.name = name;
        this.age = age;
    }

    void play() {
        System.out.println("I am playing my instrument...");
    }
}

Musicians use different instruments. Let’s create two child classes Pianist and Violinist. They both will be playing using their own versions of play() method thanks to polymorphism. For overriding you can use @Override notation but it is not necessary.

public class Pianist extends Musician {

    String favoritePianoType;

    public Pianist(String name, int age, String favoritePianoType) {
        super(name, age);
        this.favoritePianoType = favoritePianoType;
    }


    @Override
void play(){
        System.out.println("I am playing piano...");
    }
}

The violin player could be soloist or orchestra participant. Let’s take it into consideration while overriding our play() method.

public class Violinist extends Musician {
    boolean isSoloist;

public Violinist(String name, int age, boolean isSoloist) {
            super(name, age);
            this.isSoloist = isSoloist;
        }


    @Override
void play(){
if (isSoloist)
        System.out.println("I am playing violin solo...");
else
System.out.println("I am playing violin in Orchestra...");

    }
}

Let’s create a Demo class where we create three objects, one of every class and check out the result.

public class Demo {
    public static void main(String[] args) {
  Musician musician = new Musician();
        Violinist violinist = new Violinist("John", 32,true);
  Pianist pianist = new Pianist("Glen", 30, "Wooden");

        System.out.println("Musician said:");
        musician.play();
        System.out.println("Violinist said:");
        violinist.play();
  System.out.println("Pianist said:");
  pianist.play();
    }
}

That’s what we’ve got here:

Musician said:
I am playing my instrument...
Violinist said:
I am playing violin solo…
Pianist said:
I am playing piano...

Every violinist and pianist is a musician, but not vice versa. That means you may use the musician’s play method if you don’t need to create a new one. Or you can call the parent’s method from child’s one using super keyword. Let’s do it in Pianist’s code:

public class Pianist extends Musician {

    String favoritePianoType;

    @Override
    void play(){
        super.play();
        System.out.println("I am playing piano...");
    }
}

Now let’s call our Demo class. Here the result:

Musician said:
I am playing my instrument...
Violinist said:
I am playing violin solo...
Pianist said:
I am playing my instrument...
I am playing piano...

Method overloading

Method overloading means using various methods with the same name in the same class. They should be different by number, order, or types of their parameters. Say, pianist can play classics piano and electric piano. To play the last one this musician needs electricity. Let’s create two different play() methods. The first one without parameters, for wooden instrument, and the second with electricity checker for electric piano.

public class Pianist extends Musician {

    String name;
    int age;
    String favoritePianoType;

    @Override
    void play(){
        super.play();
        System.out.println("I am playing piano...");
    }
    void play(boolean isElectricity){
        if (isElectricity) {
            System.out.println("Electricity on");
            System.out.println("I am playing piano...");
        }
        else System.out.println("I can't play this without electricity");
    }
}

By the way, you can use the first play() method in the second play(boolean) method this way:

void play(boolean isElectricity){
        if (isElectricity) {
            System.out.println("Electricity on");
            play();
        }
        else System.out.println("I can't play this without electricity");
    }

Let’s add some lines in our Demo class to check out our overloading:

public class Demo {
    public static void main(String[] args) {

        Musician musician = new Musician();
        Violinist violinist = new Violinist("John", 23,true);
        Pianist pianist = new Pianist("Glen", 30, "Wooden");

        System.out.println("Musician said:");
        musician.play();
        System.out.println("Violinist said:");
        violinist.play();
        System.out.println("Pianist said:");
        pianist.play();
        System.out.println("Now pianist tries electronic Piano:");
        pianist.play(true);
        System.out.println("now electricity's gone and electronic Piano player said:");
        pianist.play(false);
    }
}

Here is the result:

Musician said:
I am playing my instrument...
Violinist said:
I am playing violin solo...
Pianist said:
I am playing my instrument...
I am playing piano...
Now pianist tries electronic Piano:
Electricity on
I am playing my instrument...
I am playing piano...
now electricity's gone and electronic Piano player said:
I can't play this without electricity

Java knows what method should be used according to its parameters and object’s type. That’s polymorphism.

Abstraction

When we describe an object we are trying to build a model of it. For example, we write a racer video game MyRacer with different cars. A player can choose one of them, then update or buy newer. So… What is a car? A car is pretty complicated thing, but if we are trying to create an arcade racing game (not simulator) we shouldn’t describe all thousands of cogs it contains.

We need its model, maximal speed, maneuverability, price, color… And maybe that’s enough. That’s a model of a car for this game.

Later in MyRacer 2 we decided to add tires that affect resilience on a road. Here the model is different because we need more details.

Let’s define Data Abstraction as the process of identifying only the important (or required) characteristics of an object and ignoring the irrelevant details.

There are different levels of abstraction. For example if you are a passenger of a bus, you should know how your bus looks and where it goes but you shouldn’t know how to drive it. If you are a bus driver you don’t need to know how to create a new bus, you should know how to drive it. But if you are a bus constructor you should go onto the lower level of abstraction…The details about the bus architecture are very important to you. Hope you understand what I mean.

How it works in Java:

Let’s build four level of abstraction in Java or rather in OOP from the lowes (the most particular) to the highest (more abstract).

Lower level of abstraction is a particular Object. It is an entity with a set of characteristics inherent in a specific instance of a class. It has specific field values
Template for creating objects is a Class. It’s a description of the set of objects of similar properties and internal structure.
Abstract class is an abstract description of the characteristics of a set of classes (acts as a template for inheritance by other classes). It has a high level of abstraction, therefore, it is impossible to create objects directly from the abstract class, only through the creation of objects from the child classes. Abstract class, may include methods with an implementation but not necessarily.
Interface is a Java programming language construct within which only abstract public methods and static property constants (final static) can be described. That is, as well as on the basis of abstract classes, it is impossible to generate objects on the basis of interfaces.

Btw, in Java 8 or later you can use in interfaces not only abstract methods and constants, but also default and static methods.

In Java interface defines a behavior and abstract class creates hierarchy. One interface may implement different classes.

Java interface example

interface Human {
    public void struggle();
    public void protect();
}

interface Vulcanian {
int earSharpnessAngle;
    public void emotionOff(boolean isOn);
    public void telepathy();
}

You can implement more than one interface

Class Spock implements Human, Vulcanian {
public void struggle() {
System.out.println (“I am struggling...”);
}
    public void protect() {
System.out.println(“You are under my protection!”);
}
public void emotionOff(boolean isOn){
If (isOn) {
System.out.println(“I am turning off my emotions”);
isOn= !isOn;
}
}
    public void telepathy() {
System.out.println(“Connecting to your brain... ”);
}

}

That’s all about the main object oriented programming concepts in Java for beginner students. Besides the 4 main principles of OOP, there are also association, aggregation and composition in Java. You may call them “additional OOP principles” and they deserve their own article.

Previously was published on CodeGym blog.

Why You Should Learn Java in 2019

CodeGym — Tue, 09 Apr 2019 08:58:19 +0000

Learning how to code might be slightly scary for the newcomers, and that’s hardly a surprise. It’s not easy to stay cool and smash along millions of programmers globally with zero experience and an intangible idea of your goals and career. Would your education be intense? Yes. Is it too late to try? Of course, not.

You probably look for a rapid progress, if you’re serious about programming, and the language is your basis to start with. Even if you search for the answer to the question, which is the best programming language to learn, you won’t find a unanimous opinion. First of all, every developer will try to “push” you his own choice. Secondly, there’s no such thing as the best language, because they serve different purposes.

There are at least half a dozen programming languages, which keep the highest positions of different rankings. According to TIOBE Programming Community ranking, Java firmly keeps the first place with the largest number of searches through the most popular search engines. It is tracked by C, Python and C++ languages. As for GitHub’s Octoverse ranking, the top three most popular languages of all time are Javascript, Java, and Python.

Why Java is so popular

Now you’re probably thinking something like: “why exactly do I need Java of all options”? As told before, there will never be a programming language with unchallenged authority. But still, you can make a choice quite easy, if you analyze the long-term benefits of mastering a certain language. Let’s talk about why Java is so popular and why little is going to change in the closest time.

You may heard something like “Java is too old, it will become out of use in a few years”. Actually, it’s of the same age as other widely used programming languages. The story of its creation begins in the 90s at a Californian company Sun Microsystems. You may know (or remember), that back in the 90s a TV was truly influential in communications and entertainment. For this reason, it inspired many useful progressive inventions. And, by implication, it kickstarted the creation of Java language.

It was initially developed for interactive television to let application developers write code once and run it on any platform without the need to decompile it, thanks to JVM (Java virtual machine). For the obvious reason, such flexibility and multiplatform usability can be applied anywhere.

What is Java used for

So, nowadays, what is Java used for? Particularly, for a majority of modern demands. Java is object-oriented, class-based, all-purpose language that allows developers to create programs, which are compatible with any devices. It has many benefits for a beginner in programming and for a further career development. Let’s see what’s waiting for a future Java developer step by step.

Step #1 Learning to code from point zero

One of the main reasons why you should learn Java is because it's quite easy to learn. You don’t even need to be a pro in math to start coding: you simply need to understand the logic. Secondly, it is a high-level language. This means that many processes in Java programming run automatically and you don’t have to delve too deep to create a program that actually works. Referring to a simple example, Java is like a car with automatic transmission: it’s easy to grasp a skill with a little help from your “machine”.

Even if you have any difficulties in learning Java, you can easily get help from a global community. There are more than 9 millions Java developers in the world, and their online community is vast and dynamic. You can easily find an answer to almost any question, that appears while you study and get useful sources to deepen your knowledge.

Some programmers say, that Java isn’t the first choice in learning how to code from scratch. Probably, it can be harder for a freshman to learn Java, than other languages. But a hard drill makes an easy battle. Once you learn Java, it will become a handy tool for a great number of tasks.

Step #2 Starting as a junior developer

Once you’ve gained core knowledge, you start a career as a programmer on Java: this is what you aspire, don’t you? As a beginner, you’ll feel more confident knowing that Java has a huge number of libraries and frameworks for numerous tasks. As a learner, you write your own routines to get plenty of practice and make sense of programming process. But later, as a developer, you can adjust ready-made solutions to your project. They will help you save time in numerous large-scale projects. Plus everything you need is there for you in a great Java documentation at Oracle and Stack Overflow.

Step #3 Boosting your career

When you get familiar with the Java Virtual Machine, you can easily use other languages with such a runtime environment. For example, Groovy, Scala, Kotlin and Clojure. So if you want to, you can join as many interesting projects as you wish and enhance the knowledge of the technology stack.

Anyway, Java itself will always inspire your progress. The latest versions were released within six months of each other, and the newest is coming up in spring, 2019. They are enhanced with new features, which answer the needs of modern enterprises, startups, medium and small-sized businesses. That puts Java developers in a high demand. Hence, they work on promising projects and earn high salaries. According to Indeed.com, an average Java developer salary in the U.S. is more than $100 000 per year.

Why learn Java in 2019? Because you will use all the benefits of a flexible, security-oriented, dynamic language. As told before, Java is among all-time leaders in the programming world.

Java is used for writing mobile applications, both Android and iOS. You can also choose it to create web pages by compiling to JavaScript (Google Web Toolkit). Considering that nowadays almost all B2C companies need to reach their clients through the mobile channel, there are thousands of projects waiting for you.

Java is everywhere and in the closest time is expected to become even more important in Big Data and the Internet of things developments. Building platforms and applications for any devices, such as laptops, computers, gaming consoles, navigation systems, monitoring facilities, terminals, etc., makes Java the best programming language to learn in 2019

All in all, the short answer fotohe question what is Java used for is “to create a mainstream software any business needs”.

How to learn Java

If you want to learn to code on Java, be sure you are ready to devote at least 3 to 6 month to a self-education and study daily. You probably already know, that programming is about practice, so you should have three times or even four times more coding than researching. In such a way you will get skilled at coding and won’t fall into an endless “rabbit-hole” of programming theory.

If you want to know how to learn Java fast, these tips are for you:

Set your goals in a career by answering a question “Why exactly do I need Java”.
With this context, create your personal educational plan with a schedule.
Choose tools to help your needs: books, courses, coding platforms, etc.
Find additional sources of information: media, forums, Java communities — everything to keep you up to date.
Practice a lot: you need hundreds of hours of coding before it becomes your habit.
Don’t get stuck on something you don’t quite understand — go on with your study and practice.
Never stop learning: this is what successful programmer do.

And if you were searching for the (almost) perfect environment for learning Java, this is what probably brought you to CodeGym :) There’s no better time for starting than right now.

Previously was published on CodeGym blog.

Java LinkedList Tutorial with Examples

CodeGym — Mon, 04 Mar 2019 14:34:00 +0000

All the latest CodeGym lessons have been devoted to ArrayList. This data structure is very convenient and useful. It can handle plenty of tasks. But Java has lots of other data structures.

Why? Above all, because the range of tasks is enormous, and the most efficient data structures are different for different tasks.

Today we'll meet a new structure: LinkedList, a doubly-linked list.

Let's see how it's organized, why it's called doubly-linked, how it differs from ArrayList.

The elements in a LinkedList are actually links in a single chain. In addition to data, each element stores references to the previous and next elements. These references let you move from one element to another.

This is how you create one:

public class Main {

   public static void main(java.lang.String[] args) {

       String str1 = new String("Hello World!");
       String str2 = new String("My name is Earl");
       String str3 = new String("I love Java");
       String str4 = new String("I live in Canada");

       LinkedList<String> earlBio = new LinkedList<>();
       earlBio.add(str1);
       earlBio.add(str2);
       earlBio.add(str3);
       earlBio.add(str4);

       System.out.println(earlBio);

   }
}

Output:

[Hello World! My name is Earl, I love Java, I live in Canada]

Here's what our list looks like:

Let's see how to add a new element. This is done using the add() method.

earlBio.add(str2);

At the point in the code, our list consists of one element: the String str1.

Let's see what happens next in the picture:

As a result, str2 and str1 become linked via the next and previous links stored in this nodes of the list:

Now you should understand the main idea of a doubly-linked list. This chain of links is precisely what makes LinkedList elements a single list. Unlike ArrayList, LinkedList doesn't have an array or anything array-like inside.

Any (well, most) work with ArrayList boils down to working with the internal array.

Any work with LinkedList boils down to changing links.

This can be seen very clearly by adding an element to the middle of the list:

public class Main {

   public static void main(java.lang.String[] args) {

       String str1 = new String("Hello World!");
       String str2 = new String("My name is Earl");
       String str3 = new String("I love Java");
       String str4 = new String("I live in Canada");

       LinkedList<String> earlBio = new LinkedList<>();
       earlBio.add(str1);
       earlBio.add(str3);
       earlBio.add(1, str2);

       System.out.println(earlBio);

   }
}

As you can see, the overloaded add() method lets you specify a specific index for a new item. In this case, we want to add String str2 between str1 and str3.

This is what will happen internally:

After changing the internal links, str2 has been successfully added to the list:

Now all 3 elements are connected. You can move via the next link from the first element on the chain to the last and back again.

So, we're fairly comfortable with insertion, but what about removing elements?

The principle is exactly the same. We just update the links in the two elements "to the left and the right" of the element being removed:

public class Main {

   public static void main(java.lang.String[] args) {

       String str1 = new String("Hello World!");
       String str2 = new String("My name is Earl");
       String str3 = new String("I love Java");
       String str4 = new String("I live in Canada");

       LinkedList<String> earlBio = new LinkedList<>();
       earlBio.add(str1);
       earlBio.add(str3);
       earlBio.add(1, str2);

       earlBio.remove(1);
       System.out.println(earlBio);
   }
}

Here's what happens if we delete the item with index 1 (it's in the middle of the list):

After updating the links, we get the desired result:

Unlike the removal operation in ArrayList, here there is no need to shift array elements or do anything of the kind. We just update the links for str1 and str3. They now point to each other, and str2 has "dropped out" of the chain of links and is no longer part of the list.

Overview of methods

LinkedList has a lot of methods in common with ArrayList.

For example, both classes have methods such as add(), remove(), indexOf(), clear(), contains() (indicates whether an item is in the list), set() (replaces an existing element), and size().

Although many of them work differently internally (as we found with add() and remove()), the end result is the same.

However, LinkedList does have separate methods for working with the beginning and end of the list, which ArrayList does not have:

addFirst(), addLast(): These methods for adding an element to the beginning/end of the list

public class Car {

   String model;

   public Car(String model) {
       this.model = model;
   }

   public static void main(String[] args) {
       LinkedList<Car> cars = new LinkedList<>();
       Car ferrari = new Car("Ferrari 360 Spider");
       Car bugatti = new Car("Bugatti Veyron");
       Car lambo = new Car("Lamborghini Diablo");
       Car ford = new Car("Ford Modneo");
       Car fiat = new Car("Fiat Ducato");

       cars.add(ferrari);
       cars.add(bugatti);
       cars.add(lambo);
       System.out.println(cars);

       cars.addFirst(ford);
       cars.addLast(fiat);
       System.out.println(cars);
   }

   @Override
   public String toString() {
       return "Car{" +
               "model='" + model + '\'' +
               '}';
   }
}

Output:

Car{model='Ferrari 360 Spider'}, Car{model='Bugatti Veyron'}, Car{model='Lamborghini Diablo'}]
[Car{model='Ford Modneo'}, Car{model='Ferrari 360 Spider'}, Car{model='Bugatti Veyron'}, Car{model='Lamborghini Diablo'}, Car{model='Fiat Ducato'}]

We end up with "Ford" at the top of the list, and "Fiat" at the end.

peekFirst(), peekLast(): The methods return the first/last element in the list. They return null if the list is empty.

public static void main(String[] args) {
   LinkedList<Car> cars = new LinkedList<>();
   Car ferrari = new Car("Ferrari 360 Spider");
   Car bugatti = new Car("Bugatti Veyron");
   Car lambo = new Car("Lamborghini Diablo");

   cars.add(ferrari);
   cars.add(bugatti);
   cars.add(lambo);
   System.out.println(cars.peekFirst());
   System.out.println(cars.peekLast());
}

Output:

Car{model='Ferrari 360 Spider'}
Car{model='Lamborghini Diablo'}

pollFirst(), pollLast(): These methods return the first/last element in the list and remove it from the list. They return null if the list is empty

public static void main(String[] args) {
   LinkedList<Car> cars = new LinkedList<>();
   Car ferrari = new Car("Ferrari 360 Spider");
   Car bugatti = new Car("Bugatti Veyron");
   Car lambo = new Car("Lamborghini Diablo");

   cars.add(ferrari);
   cars.add(bugatti);
   cars.add(lambo);
   System.out.println(cars.pollFirst());
   System.out.println(cars.pollLast());

   System.out.println ("What's on the list?");
   System.out.println(cars);
}

Output:

Car{model='Ferrari 360 Spider'}
Car{model='Lamborghini Diablo'}
What's left on the list?
[Car{model='Bugatti Veyron'}]

toArray(): This method returns an array containing the list items

public static void main(String[] args) {
   LinkedList<Car> cars = new LinkedList<>();
   Car ferrari = new Car("Ferrari 360 Spider");
   Car bugatti = new Car("Bugatti Veyron");
   Car lambo = new Car("Lamborghini Diablo");

   cars.add(ferrari);
   cars.add(bugatti);
   cars.add(lambo);
   Car[] carsArray = cars.toArray(new Car[3]);
   System.out.println(Arrays.toString(carsArray));
}

Output:

[Car{model='Ferrari 360 Spider'}, Car{model='Bugatti Veyron'}, Car{model='Lamborghini Diablo'}]

Now we know how LinkedList works and how its organization differs from ArrayList. What are the benefits of using LinkedList?

Above all, we benefit when working in the middle of the list. Insertion and removal operations in the middle of a LinkedList are much simpler than in an ArrayList. We simply update the links of neighboring elements, and the unwanted element "drops out" of the chain of links.

But in an ArrayList, we must

check whether there is enough space (when inserting)
if not, then we create a new array and copy the data there (when inserting)
we remove/insert the element, and move all the other elements to the right/left (depending on the type of operation). And the complexity of this process depends heavily on the size of the list. It's one thing to copy/move 10 elements, and quite another to do the same with a million elements.

In other words, if your program insertion/removal operations in the middle of the list are most common in your program, LinkedList should be faster than ArrayList.

In theory

public class Main {

   public static void main(String[] args) {
       List<Integer> list = new LinkedList<>();

       for (int i = 0; i < 5_000_000; i++) {
           list.add(new Integer(i));
       }

       long start = System.currentTimeMillis();

       for (int i = 0; i < 100; i++) {
           list.add(2_000_000, new Integer(Integer.MAX_VALUE));
       }
       System.out.println("Time taken by LinkedList (in milliseconds) = " + (System.currentTimeMillis()-start));
   }
}

Output:

Time taken by LinkedList (in milliseconds) = 1873

public class Main {

   public static void main(String[] args) {
       List<Integer> list = new ArrayList<>();

       for (int i = 0; i < 5_000_000; i++) {
           list.add(new Integer(i));
       }

       long start = System.currentTimeMillis();

       for (int i = 0; i < 100; i++) {
           list.add(2_000_000, new Integer(Integer.MAX_VALUE));
       }
       System.out.println("Time taken by ArrayList (in milliseconds) = " + (System.currentTimeMillis()-start));
   }
}

Output:

Time taken by ArrayList (in milliseconds) = 181

That was unexpected!

We performed an operation where LinkedList should be much more efficient: inserting 100 items in the middle of a list.

And our list is huge: 5,000,000 elements. ArrayList had to shift a couple of million items with every insertion!

How did it win?

First, the time required for ArrayList to access elements is fixed (constant). When you write

list.add(2_000_000, new Integer(Integer.MAX_VALUE));

then ArrayList [2_000_000] is a specific memory address (after all, the list has an internal array).

But, a LinkedList does not have an array. It will search for element number 2_000_000 along the chain of links. For LinkedList, this is not a memory address, but a link that still needs to be reached:

fistElement.next.next.next.next.next.next.next.next.next.next.next.next.next.next.next.next.next.next.next.next.next.next.next.next.next.next.next.next.next.next………

As a result, during each insertion (removal) in the middle of the list, ArrayList already knows the exact memory address to access, but LinkedList still needs to "get there".

Second, there is the structure of the ArrayList itself. A special internal function (System.arrayCopy()) expands the internal array, and copies and shifts all the elements. It is very fast, because it is optimized for this specific work.

But when you don't have to "get to" a particular index, LinkedList is the winner. Suppose we insert at the very beginning of the list.

Let's try inserting a million elements there:

public class Main {

   public static void main(String[] args) {
       getTimeMsOfInsert(new ArrayList());
       getTimeMsOfInsert(new LinkedList());
   }

   public static long getTimeMsOfInsert(List list) {
       // Write your code here
       Date currentTime = new Date();
       insert1000000(list);
       Date newTime = new Date();
       long msDelay = newTime.getTime() - currentTime.getTime(); // Calculate the difference
       System.out.println("The result in milliseconds: " + msDelay);
       return msDelay;

   }

   public static void insert1000000(List list) {
       for (int i = 0; i < 1000000; i++) {
           list.add(0, new Object());
       }
   }

}

Output:

The result in milliseconds: 43448
The result in milliseconds: 107

Now we get an entirely different result!

ArrayList spent more than 43 seconds inserting a million items at the front of the list took, while LinkedList managed to do it in 0.1 seconds!

LinkedList benefited here, because it did not have to run through the chain of links to the middle of the list every time. It immediately finds the needed index at the beginning of the list, so the different algorithm is already an advantage. :)

In fact, the "ArrayList versus LinkedList" discussion is very widespread, and we won't dive deep into it at the current level.
The main thing that you need to remember is this:

Not all of the theoretical advantages any particular collection always work in reality (we saw this with the example involving the middle of the list)
Don't adopt an extreme position when it comes to choosing a collection ("ArrayList is always faster. Use it and you can't go wrong. Nobody has been using LinkedList for a long time").

Although even LinkedList's author, Joshua Bloch, says this is the case. :)

Still, this perspective is far from 100% correct, and we've convinced ourselves of this. In our previous example, LinkedList was 400 (!) times faster. Another thing is that there really are few situations where LinkedList is the best choice. But they do exist, and at the right moment LinkedList can reward you handsomely. Don't forget what we said at the beginning of the lesson: the most efficient data structures are different for different tasks.

It's impossible to be 100% sure which data structure will be best until you know all the conditions of your task.

You'll know more about these collections later, which will make the choice easier. But the simplest and most effective option is always the same: try both on the actual data used in your program. Then you will be able to see for yourself how both types of lists perform and you definitely won't go wrong. :)

Previously was published on CodeGym blog.

18 Best Java Books For Beginners In 2019

CodeGym — Mon, 04 Mar 2019 13:54:26 +0000

18 Best Java Books For Beginners In 2019

Getting the hang of coding might be confusing for a complete beginner. There are dozens and dozens of Java books on Amazon — it’s so easy to get lost! How about a little piece of advice, based on experience of the other Java learners? If you still haven’t put together your reading list for 2019, we’re here to help with our choice of the best books for Java learners.

The best Java books for beginners

These are completely safe sources for ones that only start to learn coding in Java. We advise you to have a look at all of them, because they use different approaches in presenting core concepts. When you get stuck with a certain topic in one book, the chances are strong that you will get a clear explanation somewhere else.

1. Head First Java by Kathy Sierra & Bert Bates

If you can’t imagine a clear explanation without a proper visual, like scheme, diagram or a graphic drawing, you’ll enjoy this book for beginners. It’s arguably the best introduction to Java, which explains the core language and the concepts of OOP on the real-world examples. Even though it’s a book, it has a very “user-friendly interface”: you’ll get engaged from the first page till you finish it.

You won’t immediately start to code after you read Head First Java, but you will understand without any difficulties the logic of this language and its main concepts. Each chapter ends with exercises and puzzles: they will help you memorize the material.

Pros: engaging storytelling, great illustrations, and real-life explanations. Probably the best book to learn Java from scratch.
Cons: sometimes the puzzles are a bit confusing.

2. Beginning Programming with Java For Dummies

You have all the right to be skeptic about “the dummies series” since they are of no use for readers with even a minimal experience and understanding of any subject. But due to the plain language, they explain the main terms simply without any confusions. You will learn the major things you need to start with Java coding, like how to install Java, compile code and complete different practical exercises after you finish the reading. It is as easy as books for kids.

Pros: very simple examples and lots of “how-tos” if you have no idea of programming concepts.
Cons: nothing more than a plain introduction in Java.

3. Java: Programming Basics for Absolute Beginners by Nathan Clark

Another book for readers with a zero experience in coding will guide you step-by-step through the basics. You will learn how to choose an IDE and write the first program. The book familiarizes you with Java Development Kit and Java Runtime Environment and gives the description for each part of the code in examples. It serves as a rather good preliminary environment before you delve into more serious subjects.

Pros: smooth intro to Java programming and its main features.
Cons: there’s no profound explanation of the Object Oriented Programming concept, this is why some practical examples might be confusing.

4. Java: A Beginner’s Guide by Herbert Schildt

Generally, Schildt’s guide is considered to be among the 3 or at least 5 best books for Java beginners. But this book requires a little bit more understanding of programming comparing to the previous sources. It will deepen your understanding of Java origins and its relations to other programming languages.

It is profound research about the core concepts of Java which explains the code by line and guides you from the basic understanding of data types, classes and objects to more complex concepts like lambda expressions and functional interfaces. The great part of this book is a self-test section at the end of each chapter.

Pros: a plain tone of voice, self-testing, full coverage of Java core.
Cons: you need at least a small prior understanding of programming.

5. Core Java Volume I — Fundamentals

Don’t mind the impressive 1000 pages — you can easily read this book from cover to cover. It puts aside the playful tone and focuses on detailed explanations of Java core. Each chapter is devoted to a certain subject, starting from introduction to the language and Java programming environment and moving to data structures, objects and classes and so on. Unlike many books for beginners, Core Java gives an explicit coverage of collections and generics, which is useful for real programming.

All in all, it is a great reference book. Read it once and return to it anytime you need to refresh your knowledge.

Pros: a full reference to Java Core and attention to collections and generics, profound explanations.
Cons: some topics, like generics, are covered less diligent than others.

6. Think Java: How to Think Like a Computer Scientist by Allen Downey and Chris Mayfield

This book for complete beginners will teach you how to think in code. Like many others, it starts with an introduction to OOP. It is also a rather good reference book. Each chapter has the vocabulary and exercise sections to consolidate theory and master the skill of programming thinking. It is more suitable for beginners than readers with even a small experience in coding. For starters, it is simple and kind of fun to read.

Pros: a source for adjusting your way of coding, practice, basic concepts explained clearly.
Cons: cannot be considered as the complete reference for core Java; the same level of complexity in all exercises.

Java books for advanced learners

You’re already familiar with the main concepts and have already made coding your daily habit? Cheers to that! Let’s move forward to Java books, which will deepen your knowledge and set a focus on the number of useful topics in real-world coding.

7. Effective Java is written by Joshua Bloch

This is not a book for a complete beginner but is must-read research for every Java developer. You will quickly see that it’s written by an expert with a serious practical background, because it explains not only the general subjects but the subtleties, too. If you want to understand the inner processes and get a clue of how and why they are arranged this way, this book serves the purposes well. Each chapter consists the “items” with lots of practical advice and a good review of the latest Java features. It will teach you how to write the code and how to do it well.

Pros: easy to read, covers best practices in programming, useful advice for improving your coding.
Cons: requires an understanding of core concepts and at least a small experience in coding.

8. Java: The Complete Reference by Herbert Schildt

Probably you won’t start learning Java from scratch with this book, but sooner or later you will refer to it, as it’s a well-structured fully-featured source on Java programming with examples from the real world programming. It covers the Java 8 APIs, and clearly explains the basic concepts and beyond that. The “additional” material is devoted to JavaBeans, servlets, applets, and swing. So it’s totally right decision to have this book on your bookshelf or on your book reader.

Pros: the real world examples, clear and detailed explanations, a good reference for the latest Java APIs.
Cons: requires a basic knowledge of Java programming.

9. Java 8 in Action

If you need a Java 8 book with full coverage of its features, this one is for you.

It will be easier for you to understand the material with some background in Java. But what’s great about this book is the many-sidedness of practice. The examples include both “proper” and “wrong” code samples. Just be sure not to mix them up :) All in all, this is a book with an obvious focus on practice, so you can use it as an additional source for the enhanced studying.

Pros: focused on practice, shows the difference between the right and the wrong code.
Cons: requires supplementary sources for a deeper understanding of Java basics.

10. Thinking in Java by Bruce Eckel

This book offers you a rather refreshing approach to explaining Java fundamentals. It has a focus on Java language design and behavior, and includes many detailed explanations. You will get the understanding of how each topic fits in with OOP. The basic subjects are fully covered on the first 200 pages of the book. The larger part can help you to cover the new ground. It is one of those books, which you will return to even after years of studying and coding.

Although some of the examples are a bit outdated, this book is still a profound source for learners, because it actually teaches you to think like a Java programmer and encourages you to code.

Pros: a thorough source, plenty of code samples and exercises, excellent explanation of OOP concepts in Java.
Cons: might be too complicated for a beginner.

11. Grokking Algorithms: An illustrated guide for programmers and other curious people by Aditya Y. Bhargava

If you need the best book about algorithms, this one may be the right choice. It is comprehensible for readers with an entry level of knowledge and presents popular algorithms such as sorting and searching in a graphical manner. Not many people would say that this specific subject is very exciting. This is why a visual approach to presenting data will help the newcomers to quickly engage themselves in learning.

The book is divided into short chapters with a variety of examples, so you perceive the new information in the right proportions. And a plain and vivid narration will guide you through the concepts in such a way that you’ll be prepared to advanced content.

Pros: visuals, engaging narration, full coverage of fundamentals.
Cons: great for beginners, but cannot be considered as a full reference.

12. Introduction to Algorithms by Thomas H. Cormen, Charles E. Leiserson, Ronald L. Rivest, Clifford Stein

If you can’t get enough of algorithms, try this one. The unusual feature of the “Introduction…” is that it includes examples in a “pseudocode”. Despite it’s been presented as an introduction, it has a large scope of covered topics, and the whole concept of data structures and algorithms is explained pretty well. It is written in plain English and covers everything you need to know. The only thing is that it’s focused on describing algorithms rather than designing them. Still, it is a good reference book. If you feel you need to learn more about algorithms, then keep this book in mind.

Pros: a detailed catalogue of algorithms to which for a variety of situations.
Cons: a lack of practice, requires a background reading.

13. Think Data Structures: Algorithms and Information Retrieval in Java by Allen B. Downey

This is a helpful guide for utilizing data structures in Java programming. It will be an easy read for experienced developers, as it goes beyond the fundamentals straight to the deep understanding of interfaces, arrays, hash maps, jsoup using, etc.

Each chapter includes an introduction to the topic, example, additional explanations plus the exercise to consolidate theory. You will enjoy the clear language and plain examples and how this book helps you to implement your knowledge immediately.

Pros: a condensed material with useful examples.
Cons: might be tough for the novices.

14. Learning Java by Building Android Games: Learn Java and Android from scratch by building six exciting games by John Horton

Android is among the most popular mobile operating systems, and Java is one of the major languages for building apps on it. If being a mobile developer is your goal, why not take one of the best books for learning Java programming in this field? For the record, this book doesn’t require a Java proficiency. The level of difficulty grows gradually from the key subjects (variables, loops, methods, object-oriented programming). After each stage, you’re given a task to develop your own game for Android platform, six of them in total.

Not a fan of game development? Still worth trying to see Java programming in action.

Pros: a practical guide to game development.
Cons: serves a specific goal.

General-purpose books on programming

These books should be on your list somewhere between the sources for the newcomers in Java and readers with a slight experience. They will broaden your scope about coding in general and teach you the major concepts of programming, creating clean code and getting started your career. Here’s our choice of the best programming books for beginners, regardless of the language they learn.

15. Head First Learn to Code by Eric Freeman

Head First series is presented by the best book to learn Java and also books on learning other programming languages. This one is devoted to programming in general. You will easily recognize the unique style of narration once you open it. Read this if you need a hand of the key concepts of coding in a fun and easy to understand way.

Pros: gives a general understanding of programming.
Cons: uses examples on Python (as it is considered to be easier for newbies).

16. Clean Code: A Handbook of Agile Software Craftsmanship by Robert C. Martin

When you’re new to programming, you don’t pay much attention to your code style, as you’re focused on avoiding the obvious mistakes. But improving your style is very important in your further work. This book will show you the difference between good code and bad code and teach you major rules of writing clean and readable code, using the best practices. The book is highly recommended for beginner developers.

Pros: good examples and advice on crafting a readable code.
Cons: come rules are taken to an extreme.

17. Code: The Hidden Language of Computer Hardware and Software by Charles Petzold

Well, this is not a beginners’ book on Java, but it is a must-read for every developer. It will help you to clearly understand how computers work, from hardware to software. The author covers a wide range of subjects like electricity, circuits, relays, binary, logic, gates, microprocessors, code, and others to gradually create an understanding of how computer technology works. After reading this book, you would see behind the pixels on your desktop and know what’s happening every time you use your devices.

Pros: a great summary of computer technologies, lots of examples.
Cons: some part of the book might be complicated.

18. Cracking the Coding Interview by Gayle Laakmann McDowell

This is the best book for Java learners that have a goal to get a job as a software developer. It includes a wide list of practical questions and solutions you might be asked during a coding interview. Of course, the time zips along and many trends in “testing” developers change, but this book will help a newcomer to seize the idea of what to expect. However, we advise you to update your insights on forums and Java communities.

Pros: prepares for the real-world coding interviews.
Cons: won’t help you without additional sources.

Well, we’ve finally reached the end of our list of best books to learn Java. Applauses for you being so patient and curious!

Have you already read some of those? Do you have other books to recommend? Share your thoughts with us in the comments!

Previously was published on CodeGym blog.

Creating a Telegram Bot in Java: from conception to deployment

CodeGym — Tue, 26 Feb 2019 09:43:44 +0000

So what are bots? You can read more about this here.

To start, you need to review the official documentation for the library used to develop Telegram bots (hereafter the “API”). It can be found here.

Everything there is very accessible and clear. It seems we can just write code and rejoice! But it’s not so simple. After spending a lot of time searching, I’ve found tidbits of knowledge on bot development, for example, how to make a keyboard, handle a CallbackQuery, and so forth. But, I didn't find a complete, exhaustive guide for Java bot development. That prompted me to write this article.

There are a lot of websites where you can create your own easily deployable bot. But the fact is, most of the bots created provide reference information and the like. Our bot is a full-fledged web application. You can bind a database, execute various API requests, parse websites, perform complex calculations, and more. The possibilities are limited only by your imagination. I hope that the above has helped clarify what I'm going to write about.

It's very easy to register a bot on Telegram. This process is described in detail in the documentation linked to above. For our application, you only need to know the bot's name and the token you receive when registering the bot.

Basically, a bot is just a console-based web application. There is no front end, just pure command processing. If you want to master Hibernate or learn how to parse JSON, then this is the project for you. Let's start by adding a dependency to pom.xml (I'll assume you're using Maven). You can do that like this:

<dependency>
            <groupId>org.telegram</groupId>
            <artifactId>telegrambots</artifactId>
            <version>3.5</version>
</dependency>

Then create a Bot class that inherits the TelegramLongPollingBot class, and override its methods:

public class Bot extends TelegramLongPollingBot {

    /**
     * Method for receiving messages.
     * @param update Contains a message from the user.
     */
    @Override
    public void onUpdateReceived(Update update) {
    String message = update.getMessage().getText();
    sendMsg(update.getMessage().getChatId().toString(), message);
    }

    /**
     * Method for creating a message and sending it.
     * @param chatId chat id
     * @param s The String that you want to send as a message.
     */
    public synchronized void sendMsg(String chatId, String s) {
        SendMessage sendMessage = new SendMessage();
        sendMessage.enableMarkdown(true);
        sendMessage.setChatId(chatId);
        sendMessage.setText(s);
        try {
            sendMessage(sendMessage);
        } catch (TelegramApiException e) {
            log.log(Level.SEVERE, "Exception: ", e.toString());
        }
    }

    /**
     * This method returns the bot's name, which was specified during registration.
     * @return bot name
     */
    @Override
    public String getBotUsername() {
        return "BotName";
    }

    /**
     * This method returns the bot's token for communicating with the Telegram server
     * @return the bot's token
     */
    @Override
    public String getBotToken() {
        return "BotToken";
    }
}

And now the contents of the main method:

public static void main(String[] args) {
        ApiContextInitializer.init();
        TelegramBotApi telegramBotApi = new TelegramBotApi();
        try {
            telegramBotApi.registerBot(Bot.getBot());
        } catch (TelegramApiRequestException e) {
            e.printStackTrace();
        }
}

After filling in the getBotUsername() and getBotToken() methods, start the bot. For now, it just redirects to us any messages we send to it, kind of like a "mirror". It works like this: when you start the application, it starts sending requests to the Telegram server, once every n seconds, at the following URL: https://api.telegram.org/BotToken/getMe, where BotToken is your bot's token. In response, it receives JSON containing all the messages. Each of these messages is processed by the library and is passed to the OnUpdateReceived(Update update) method as an Update object. And that's what we work with. Herein lies the beauty of Telegram bots: they can run on any computer, testing it just requires starting the application, and you don't need to deploy it to the host after each change. This is very convenient.

Of course, you can configure a bot to work using webhooks. You can find directions for that on the Internet. For simplicity, we'll use LongPolling.

How messages are processed and what you send in response are only limited by the capabilities of the language and library. Everything else is up to you. You can make a bot that will search YouTube videos for you. You can make a bot that will send you what you send yourself everyday, like a time capsule from a year ago. Or you can learn to integrate with CRM systems and make bots for small businesses—you're only limited by your imagination.

Moving on. Those who have used bots know that it's convenient to interact with them using commands that start with the "/" character, for example, /start. But there is a more convenient way: buttons. There are two kinds of buttons: those that appear under an input field (ReplyKeyboardMarkup) and buttons that are directly below the message they're linked to (InlineKeyboardMarkup). You can get a basic understanding of them from their descriptions in the documentation.

ReplyKeyboardMarkup

In reality, this is an array of button arrays: List<KeyboardRow <KeyboardButton>>. Here's sample code that creates a keyboard:

public synchronized void setButtons(SendMessage sendMessage) {

        // Create a keyboard
        ReplyKeyboardMarkup replyKeyboardMarkup = new ReplyKeyboardMarkup();
        sendMessage.setReplyMarkup(replyKeyboardMarkup);
        replyKeyboardMarkup.setSelective(true);
        replyKeyboardMarkup.setResizeKeyboard(true);
        replyKeyboardMarkup.setOneTimeKeyboard(false);

        // Create a list of keyboard rows
        List<KeyboardRow> keyboard = new ArrayList<>();
        // First keyboard row
        KeyboardRow keyboardFirstRow = new KeyboardRow();

        // Add buttons to the first keyboard row
        keyboardFirstRow.add(new KeyboardButton("Hi"));

        // Second keyboard row
        KeyboardRow keyboardSecondRow = new KeyboardRow();
        // Add the buttons to the second keyboard row
        keyboardSecondRow.add(new KeyboardButton("Help");

        // Add all of the keyboard rows to the list
        keyboard.add(keyboardFirstRow);
        keyboard.add(keyboardSecondRow);
        // and assign this list to our keyboard
        replyKeyboardMarkup.setKeyboard(keyboard);
    }

We call this method in the sendMsg() method, after passing it a message. This is how we set up a keyboard for that message. When we send this message to the user, he will see the text of our message and 2 buttons that say "Hi" and "Help", one under the other.

When one of these buttons is clicked, the bot is sent a message containing the button text. So, if the client clicks "Help", the bot will receive a message with "Help". To the bot, it will seem that the client itself wrote "Help" and sent the text to the bot. And then you process the messages.

InlineKeyboardMarkup

This is also an array of arrays. It is similar to the previous Markup, but the logic works a little differently here. This type of keyboard is attached to a specific message and exists only for it. Here’s a method for setting up an inline keyboard:

private void setInline() {
        List<List<InlineKeyboardButton>> buttons = new ArrayList<>();
        List<InlineKeyboardButton> buttons1 = new ArrayList<>();
        buttons1.add(new InlineKeyboardButton().setText("Button").setCallbackData(17));
        buttons.add(buttons1);

        InlineKeyboardMarkup markupKeyboard = new InlineKeyboardMarkup();
        markupKeyboard.setKeyboard(buttons);
    }

Create a List within the List, and add the inline button to the first row. This button can contain a URL, a link to a channel, or a CallbackQuery, which I'll write about a little later. This is where we set our button's text, which is what the user will see, and then we set the data that will be sent to the bot. In our example, the user sees "Hi", and when the button is pressed the number 17 will be sent to the bot. This is our CallbackQuery.

A few words regarding CallbackQuery. To obtain this data from the Update object, you need to execute update.getCallbackQuery(). This method returns a CallbackQuery, from which you can access the data passed to the bot. Don't try to get this data through the update.getMessage().getText() method—you'll get a NullPointerException.

@Override
    public void onUpdateReceived(Update update) {
        if(update.hasMessage()) {
            ThreadClass thread = new ThreadClass(update.getMessage());
        } else  if(update.hasCallbackQuery()) {
            AnswerCallbackThread answerThread = new AnswerCallbackThread(update.getCallbackQuery());
        }
    }

If there’s a message, we send it to a new thread for processing; if there’s a CallbackQuery, we send to the appropriate thread for processing. You can send a response to a CallbackQuery. Every object in Telegram has its own id. To send a response to a specific CallbackQuery, you just need to know its id, which we get from the corresponding object. To send a response, we call this method:

public synchronized void answerCallbackQuery(String callbackId, String message) {
        AnswerCallbackQuery answer = new AnswerCallbackQuery();
        answer.setCallbackQueryId(callbackId);
        answer.setText(message);
        answer.setShowAlert(true);
        try {
            answerCallbackQuery(answer);
        } catch (TelegramApiException e) {
            e.printStackTrace();
        }
    }

IMPORTANT: The text in a response to a CallbackQuery must be no longer than 200 characters!

After sending such a response, the client will see a pop-up window containing the message. This window can disappear a few seconds after it appears, or it can persist until the user presses OK. To switch modes, we call the answer.setShowAlert(true) method. If you pass true to the method, the window persists until OK is pressed. If you pass false, then it disappears after 5 seconds.

These are all of the Telegram Bot library's basic features. If you want, you can learn things like how to send multimedia, geolocation, etc.

Let's move on to deploying our bot to a hosting platform.

For my project, I chose Heroku. I think it's a rather convenient hosting platform with its own CLI. It's free, but on this plan your bot will hibernate after 30 minutes of receiving no requests. It will wake up when a request is received. This happens so quickly, you won't even notice (unless, of course, the database connection doesn't restart). The free plan is limited by a 5MB database, 100MB disk space, 2TB data per month, and 1 dyno. A dyno is your running application.

I'll say right away that it was deployment that caused me difficulties, since I had never deployed my applications before.

During deployment, Heroku requires a file named Procfile (without an extension). We create it in the project root. Inside, we write worker: sh target/bin/workerBot, where workerBot is the name specified in pom.xml. A sh script, generated by the Maven Application Assembler Plugin (appassembler-maven-plugin), will launch. The script describes how to launch a compiled jar file. The name of the class to launch is specified between <mainClass> and </mainClass>, while the name of the script is given between <name> and </name> in pom.xml:

...
<build>
    <plugins>
        ...
       <plugin>
            <groupId>org.codehaus.mojo</groupId>
            <artifactId>appassembler-maven-plugin</artifactId>
            <version>1.1.1</version>
            <configuration>
                <assembleDirectory>target</assembleDirectory>
                <programs>
                    <program>
                        <mainClass>com.home.server.TelegramBot</mainClass>
                        <name>workerBot</name>
                    </program>
                </programs>
            </configuration>
            <executions>
                <execution>
                    <phase>package</phase>
                    <goals>
                        <goal>assemble</goal>
                    </goals>
                </execution>
            </executions>
        </plugin>
    </plugins>
</build>

Before starting this process, you should register on Heroku, and install both Git and the Heroku CLI. If your application needs a database, then don’t forget to add the required database when you create a new application. Further, you need to determine the host, username, password and port for your database, and then indicate them in your application. Next, before deploying, build your project using Maven.

mvn clean install

First, we go to our project directory and initialize the repository with the command git init. Then we add our project to this repository.

git add .

Then we commit the changes

git commit -m "First commit in the project"

Next, you need to sign in to heroku. Write the following on the command line

heroku login

Enter the credentials you created during registration. After that, determine your repository’s URL on heroku. You do this in the settings. Then we write

git remote add heroku [url]

A remote heroku repository is added for your repository. Next we write

git push heroku master

Then we wait… if the application deploys successfully, execute the following command

heroku ps:scale worker=1

And that’s it, your application is up and running. If it isn’t, look at the logs carefully. Most likely, an error in your application has caused it to fail.

Thank you for reading such a long article. I hope someone will find it useful and that it will save you a lot of time in the areas that gave me trouble during development.

Previously was published on CodeGym blog.

Forem: CodeGym

Learn How To Code Your First Game In Java With CodeGym

We’ve got a problem, Cap!

It’s too dark in here… I can’t see the results of my job!

Yep, quite a problem… What should you do?

Top 10 + 1 common mistakes every Java learner makes

0. Assignment or comparison (= or ==)?

1. Comparing Strings with == operator.

2. Different names of Class and the file where its code is.

3. Accessing non-static members from the main method or other static methods

4. Array index is out of Array bounds

5. Puting “;” wrong in cycles or conditionals

6. Missing the ‘break’ Keyword in a Switch-Case construction

7. Mess with pass by value and pass by reference

8. Attempt to work with uninitialized field or variable

9. Forgetting about integer division

10. Mess with order of calling constructors in Child objects

Conclusions

CodeGym.cc: Play a Game to Learn Java Programming

1. A gamified Java tutorial for the beginners

2. Up to 500+ hours of practice and coding from the first lesson

3. Useful tips on improving your code

4. Java fundamentals with the real-life examples

5. A growing and helpful community

The Best Way To Learn Java Programming

Why Should I Learn Java?

5 Best Ways To Learn Java Successfully

1. Balance Between Theory And Practice

2. Schedule Your Learning Experience And Set Milestones And Achievable Goals To Stay Focused

3. Use Gamification To Stay Motivated

4. Communicate With Other Java Students And Developers + Ask Questions

5. Start Building An Online Portfolio

Conclusion

OOP Concepts in Java

Encapsulation

How it works in Java:

Why you should do it?

Inheritance

Polymorphism

What does it mean and how it works in Java:

Abstraction

How it works in Java:

Why You Should Learn Java in 2019

Why Java is so popular

What is Java used for

Step #1 Learning to code from point zero

Step #2 Starting as a junior developer

Step #3 Boosting your career

How to learn Java

Java LinkedList Tutorial with Examples

Overview of methods

In theory

18 Best Java Books For Beginners In 2019

18 Best Java Books For Beginners In 2019

The best Java books for beginners

1. Head First Java by Kathy Sierra & Bert Bates

2. Beginning Programming with Java For Dummies

3. Java: Programming Basics for Absolute Beginners by Nathan Clark

4. Java: A Beginner’s Guide by Herbert Schildt

5. Core Java Volume I — Fundamentals

6. Think Java: How to Think Like a Computer Scientist by Allen Downey and Chris Mayfield

Java books for advanced learners

7. Effective Java is written by Joshua Bloch

8. Java: The Complete Reference by Herbert Schildt

9. Java 8 in Action

10. Thinking in Java by Bruce Eckel

11. Grokking Algorithms: An illustrated guide for programmers and other curious people by Aditya Y. Bhargava

12. Introduction to Algorithms by Thomas H. Cormen, Charles E. Leiserson, Ronald L. Rivest, Clifford Stein

13. Think Data Structures: Algorithms and Information Retrieval in Java by Allen B. Downey

14. Learning Java by Building Android Games: Learn Java and Android from scratch by building six exciting games by John Horton

General-purpose books on programming

15. Head First Learn to Code by Eric Freeman

16. Clean Code: A Handbook of Agile Software Craftsmanship by Robert C. Martin

17. Code: The Hidden Language of Computer Hardware and Software by Charles Petzold

18. Cracking the Coding Interview by Gayle Laakmann McDowell

Creating a Telegram Bot in Java: from conception to deployment

ReplyKeyboardMarkup

InlineKeyboardMarkup

Top 21 Interview Questions for Java Developers You Totally Should Know

1. “Disassemble” public static void main(String args[]).

1. “Disassemble” `public static void main(String args[])`.

2. What is the difference between `equals()` and `==` ?

3. Can we execute a program without `main()` method?

4. What is `immutable` object? Can you create `immutable` object?

7. What is the difference between `String`, `StringBuilder` and `StringBuffer` classes in Java?

8. Is there any difference in `String` that was created using literal and with `new()` operator?

9. Can you override `private` or `static` method in Java?

10. Difference between `Abstract Class` and `Interface`

11. Can we declare `static` variables and methods in an `abstract` class?

14. Can we overload the `main()` method?

15. Can we declare a constructor as `final`?

16. Can we declare an interface as `final`?

17. What is the difference between `static binding` and `dynamic binding`?

20. Each `try` block must be followed by a `catch` block, mustn’t it?

21. What is the difference between `throw` and `throws` keywords?