{"id":10106,"date":"2020-10-06T10:31:39","date_gmt":"2020-10-06T10:31:39","guid":{"rendered":"https:\/\/www.experfy.com\/blog\/?p=10106"},"modified":"2023-10-24T17:44:50","modified_gmt":"2023-10-24T17:44:50","slug":"rewiring-your-brain-from-python-to-java","status":"publish","type":"post","link":"https:\/\/www.experfy.com\/blog\/bigdata-cloud\/rewiring-your-brain-from-python-to-java\/","title":{"rendered":"Rewiring Your Brain from Python to Java"},"content":{"rendered":"\t\t
\n\t\t\t\t\t\t
\n\t\t\t\t\t\t
\n\t\t\t\t\t
\n\t\t\t
\n\t\t\t\t\t\t
\n\t\t\t\t
\n\t\t\t\t\t\t\t\t\tSeven conceptual hurdles you might face when learning a new programming language\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t\t<\/div>\n\t\t<\/div>\n\t\t\t\t\t<\/div>\n\t\t<\/section>\n\t\t\t\t
\n\t\t\t\t\t\t
\n\t\t\t\t\t
\n\t\t\t
\n\t\t\t\t\t\t
\n\t\t\t\t
\n\t\t\t\t\t\t\t\t\tConfession: my personal experience is almost the complete opposite of the title of this article. I actually started with C++ in college, moved to Java to teach AP Computer Science A, and then entered Python territory to work with all of the snazzy data science libraries available. Now that I\u2019m working on a Java project again (a\u00a0neural network package<\/a>\u00a0that is really pushing my understanding of the underlying math to its limits), I\u2019m really paying attention to the little differences in how the languages work. In particular, I\u2019ve been making notes about the places where standard Python habits can become huge roadblocks when traveling through Java.\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t\t<\/div>\n\t\t<\/div>\n\t\t\t\t\t<\/div>\n\t\t<\/section>\n\t\t\t\t
\n\t\t\t\t\t\t
\n\t\t\t\t\t
\n\t\t\t
\n\t\t\t\t\t\t
\n\t\t\t\t
\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\"\"\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t\t<\/div>\n\t\t<\/div>\n\t\t\t\t\t<\/div>\n\t\t<\/section>\n\t\t\t\t
\n\t\t\t\t\t\t
\n\t\t\t\t\t
\n\t\t\t
\n\t\t\t\t\t\t
\n\t\t\t\t
\n\t\t\t\t\t\t\t\t\t

This post is directed at Python programmers (in particular, data scientists<\/a>) traveling in the opposite lane; I\u2019ll detail some of the initial conceptual hurdles you may face when learning to adapt your Python instincts to Java territory. In particular, I\u2019m going to be avoiding superficial differences like\u00a0snake_case<\/code>\u00a0vs\u00a0camelCase<\/code>\u00a0or how Java requires you to end a statement with a semicolon while Python makes it optional. I\u2019m also going to avoid diving too deeply into OOP vs. functional programming. The focus of this post is the way in which Java requires you to think differently about how to solve whatever problem you\u2019re working on.<\/p>\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t\t<\/div>\n\t\t<\/div>\n\t\t\t\t\t<\/div>\n\t\t<\/section>\n\t\t\t\t

\n\t\t\t\t\t\t
\n\t\t\t\t\t
\n\t\t\t
\n\t\t\t\t\t\t
\n\t\t\t\t
\n\t\t\t\t\t\t\t\t\t\n
\n

Although it may seem daunting, just remember that many programmers before you have successfully learned Java, so it absolutely can be done.<\/p>\n<\/blockquote>\n\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t\t<\/div>\n\t\t<\/div>\n\t\t\t\t\t<\/div>\n\t\t<\/section>\n\t\t\t\t

\n\t\t\t\t\t\t
\n\t\t\t\t\t
\n\t\t\t
\n\t\t\t\t\t\t
\n\t\t\t\t
\n\t\t\t\t\t

1. Java has more overhead than you\u2019re used to.<\/h2>\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t\t<\/div>\n\t\t<\/div>\n\t\t\t\t\t<\/div>\n\t\t<\/section>\n\t\t\t\t
\n\t\t\t\t\t\t
\n\t\t\t\t\t
\n\t\t\t
\n\t\t\t\t\t\t
\n\t\t\t\t
\n\t\t\t\t\t\t\t\t\tIn Python, you can write an entire \u201cHello World\u201d program with console output in a single line of code:<\/p>\n\n\n\n
print('Oh hi there, globe')<\/pre>\n\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t\t<\/div>\n\t\t<\/div>\n\t\t\t\t\t<\/div>\n\t\t<\/section>\n\t\t\t\t
\n\t\t\t\t\t\t
\n\t\t\t\t\t
\n\t\t\t
\n\t\t\t\t\t\t
\n\t\t\t\t
\n\t\t\t\t\t\t\t\t\t\n
To accomplish this in Java, you need to create an\u00a0entire class<\/em>, complete with a\u00a0main<\/code>\u00a0method to serve as the entry point.<\/p>\n\n\n\n
public class Room {
    public static void main(String[] args) {
        System.out.println(\"Oh hi there, globe\");
   }
}<\/pre>\n\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t\t<\/div>\n\t\t<\/div>\n\t\t\t\t\t<\/div>\n\t\t<\/section>\n\t\t\t\t
\n\t\t\t\t\t\t
\n\t\t\t\t\t
\n\t\t\t
\n\t\t\t\t\t\t
\n\t\t\t\t
\n\t\t\t\t\t\t\t\t\tAt its heart, every Java program is essentially some class\u2019s\u00a0main<\/code>\u00a0method working with variables and telling other classes what to do (and sometimes, that\u00a0main<\/code>\u00a0method is hidden deep within automated files, like with Android projects). Although there are some ways to run Java outside of a complete class\u2013\u2013I was a big fan of the\u00a0interactions<\/code>\u00a0tab in\u00a0jgrasp<\/a>\u00a0while teaching\u2013\u2013there are some hoops to jump through to make this happen.\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t
\n\t\t\t\t
\n\t\t\t\t\t\t\t\t\tIn short, while Python allows you to feed a few commands directly into the interpreter to test out an algorithm, working with Java requires you to place that code in context.\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t
\n\t\t\t\t
\n\t\t\t\t\t\t\t\t\tAnd then there\u2019s the elephant in the\u00a0Room<\/code>\u00a0above:\u00a0System.out.println()<\/code>\u00a0. This seems like way more work than it should be just to produce console output, right? That\u2019s because we\u2019re being very, very particular about how we want our output to be displayed; out of all of the different places we could put that text, we want it to go to the\u00a0console<\/em>, as opposed to a log file, a pop-up window, or a server off in the ether. Python, by default\u00a0assumes<\/em>\u00a0that by\u00a0print<\/code>\u00a0you want the text displayed on the console, but Java does not generally make assumptions like that.\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t\t<\/div>\n\t\t<\/div>\n\t\t\t\t\t<\/div>\n\t\t<\/section>\n\t\t\t\t
\n\t\t\t\t\t\t
\n\t\t\t\t\t
\n\t\t\t
\n\t\t\t\t\t\t
\n\t\t\t\t
\n\t\t\t\t\t\t\t\t\tThis leads to our next point\u2026\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t\t<\/div>\n\t\t<\/div>\n\t\t\t\t\t<\/div>\n\t\t<\/section>\n\t\t\t\t
\n\t\t\t\t\t\t
\n\t\t\t\t\t
\n\t\t\t
\n\t\t\t\t\t\t
\n\t\t\t\t
\n\t\t\t\t\t
2. Java requires you to be way more specific than Python.<\/h2>\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t\t<\/div>\n\t\t<\/div>\n\t\t\t\t\t<\/div>\n\t\t<\/section>\n\t\t\t\t
\n\t\t\t\t\t\t
\n\t\t\t\t\t
\n\t\t\t
\n\t\t\t\t\t\t
\n\t\t\t\t
\n\t\t\t\t\t\t\t\t\tPython lets you get away with a\u00a0lot.\u00a0<\/em>Think about how many times you\u2019ve written code like:<\/p>\n\n\n\n
that_value_i_need = some_object.mystery_method()<\/pre>\n\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t
\n\t\t\t\t
\n\t\t\t\t\t\t\t\t\t\n
only to have to follow it up with:<\/p>\n\n\n\n
type(that_value_i_need)<\/pre>\n\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t\t<\/div>\n\t\t<\/div>\n\t\t\t\t\t<\/div>\n\t\t<\/section>\n\t\t\t\t
\n\t\t\t\t\t\t
\n\t\t\t\t\t
\n\t\t\t
\n\t\t\t\t\t\t
\n\t\t\t\t
\n\t\t\t\t\t\t\t\t\tIn order to figure out what, exactly,\u00a0mystery_method()<\/code>\u00a0is returning.\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t
\n\t\t\t\t
\n\t\t\t\t\t\t\t\t\tThis isn\u2019t necessarily the best way to go about things; obviously, the docs should explain what you\u2019re going to get from\u00a0mystery_method()<\/code>\u00a0, so it\u2019s definitely\u00a0possible<\/em>\u00a0that you already know what you\u2019re getting before you call it. But Python lets you get away with this. You can create a variable for\u00a0that_value_i_need<\/code>\u00a0and know that it can handle whatever\u00a0mystery_method()<\/code>\u00a0spits out.\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t\t<\/div>\n\t\t<\/div>\n\t\t\t\t\t<\/div>\n\t\t<\/section>\n\t\t\t\t
\n\t\t\t\t\t\t
\n\t\t\t\t\t
\n\t\t\t
\n\t\t\t\t\t\t
\n\t\t\t\t
\n\t\t\t\t\t\t\t\t\tFurthermore, you can be pretty confident that you can pull off a high-wire act like this, without even having to think about the data types involved:\n\n
important_value = some_method(a, bunch, of, arguments)
important_value = unrelated_class.another_method()<\/pre>\n\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t\t<\/div>\n\t\t<\/div>\n\t\t\t\t\t<\/div>\n\t\t<\/section>\n\t\t\t\t
\n\t\t\t\t\t\t
\n\t\t\t\t\t
\n\t\t\t
\n\t\t\t\t\t\t
\n\t\t\t\t
\n\t\t\t\t\t\t\t\t\tAfter all,\u00a0important_value<\/code>\u00a0is just a variable, which can hold any data type it needs to\u2026 right?\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t
\n\t\t\t\t
\n\t\t\t\t\t\t\t\t\tIn Java, this is absolutely not the case. When declaring a variable, you need to specify its data type from the get-go, and then you\u2019re locked in throughout its lifetime.\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t
\n\t\t\t\t
\n\t\t\t\t\t\t\t\t\tWhile this might sound daunting and restrictive at first, I find that reading somebody else\u2019s code is\u00a0so much easier<\/em>\u00a0in Java. I can confidently point to a variable and say, \u201cx<\/code>\u00a0is an\u00a0int<\/code>\u00a0, because it was declared as an\u00a0int<\/code>on line 72. If it\u2019s holding a value returned by\u00a0someUsefulMethod<\/code>\u00a0, that tells mesomeUsefulMethod<\/code>\u00a0returns an\u00a0int<\/code>\u00a0(or something that can be promoted to an\u00a0int<\/code>\u00a0, like a\u00a0short<\/code>\u00a0).\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t
\n\t\t\t\t
\n\t\t\t\t\t\t\t\t\tAlthough this initially presents you with what feels like an impenetrable wall of reserved words floating around in everyone else\u2019s code and\u00a0error: cannot find symbol<\/code>messages when you try to run yours, the fact that Java requires you to be so specific leads to code being significantly more self-documenting, predictable, and unambiguous than Python. And although I need to be way more meticulous when writing my Java code, I feel significantly more confident in understanding how it works.\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t\t<\/div>\n\t\t<\/div>\n\t\t\t\t\t<\/div>\n\t\t<\/section>\n\t\t\t\t
\n\t\t\t\t\t\t
\n\t\t\t\t\t
\n\t\t\t
\n\t\t\t\t\t\t
\n\t\t\t\t
\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\"\"\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t\t<\/div>\n\t\t<\/div>\n\t\t\t\t\t<\/div>\n\t\t<\/section>\n\t\t\t\t
\n\t\t\t\t\t\t
\n\t\t\t\t\t
\n\t\t\t
\n\t\t\t\t\t\t
\n\t\t\t\t
\n\t\t\t\t\t\t\t\t\tSpeaking of documentation,\u00a0javadoc<\/code>\u00a0is a powerful tool for generating clean documentation\u2013\u2013even if you haven\u2019t explicitly written comments (which you should).\u00a0javadoc<\/code>\u00a0will read your code and generate organized html files indicating exactly what data types you need to pass a method and what value you can get in return. Most IDEs even have a button that will do this for you.\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t
\n\t\t\t\t
\n\t\t\t\t\t\t\t\t\tAnd in order to keep things as unambiguous as possible\u2026\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t\t<\/div>\n\t\t<\/div>\n\t\t\t\t\t<\/div>\n\t\t<\/section>\n\t\t\t\t
\n\t\t\t\t\t\t
\n\t\t\t\t\t
\n\t\t\t
\n\t\t\t\t\t\t
\n\t\t\t\t
\n\t\t\t\t\t
3. Java is more strict than Python.<\/h2>\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t\t<\/div>\n\t\t<\/div>\n\t\t\t\t\t<\/div>\n\t\t<\/section>\n\t\t\t\t
\n\t\t\t\t\t\t
\n\t\t\t\t\t
\n\t\t\t
\n\t\t\t\t\t\t
\n\t\t\t\t
\n\t\t\t\t\t\t\t\t\tLet\u2019s revisit our Hello World program in Python. How many different ways could we write it?<\/p>\n\n\n\n
# version 1 - single quotes
print('Oh hi there, globe')# version 2 - double quotes
print(\"Oh hi there, globe\")# version 3 - triple single quotes
print('''Oh hi there, globe''')# version 4 - uh, triple double quotes, because why not?
print(\"\"\"Oh hi there, globe\"\"\")<\/pre>\n\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t\t<\/div>\n\t\t<\/div>\n\t\t\t\t\t<\/div>\n\t\t<\/section>\n\t\t\t\t
\n\t\t\t\t\t\t
\n\t\t\t\t\t
\n\t\t\t
\n\t\t\t\t\t\t
\n\t\t\t\t
\n\t\t\t\t\t\t\t\t\tPython gives you a lot of options for accomplishing the same task\u2013\u2013in the above example, we can enclose our string with four distinct syntaxes. This legitimately threw me for a loop when I was learning Python; how could I know which one to use, and when? Is there an elegant rule of thumb to remember?\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t
\n\t\t\t\t
\n\t\t\t\t\t\t\t\t\tIf you\u2019re a Python programmer with even a tiny amount of experience, you already know what\u2019s coming: \u201cMost people just go with single quotes. Unless there\u2019s an apostrophe in the string, in which case you can enclose it with double quotes. Unless there\u2019s both an apostrophe and a double quote in the string, in which case you can enclose it in triple single quotes. And I guess if you have single, double, triple single and triple double quotes inside your string, then you can always just go back to single quotes and use an escape character wherever you need it.\u201d\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t
\n\t\t\t\t
\n\t\t\t\t\t\t\t\t\tBecause Java is so specific and so strict, learning to work with\u00a0String<\/code>\u00a0s is significantly more straightforward: Always enclose them in double quotes. If you have a double quote inside your\u00a0String<\/code>\u00a0, put an escape character\u00a0<\/code>\u00a0before it:\u00a0\u201d<\/code>. If you have a\u00a0<\/code>inside your\u00a0String<\/code>, put an escape character before it:\u00a0\\<\/code>. If you ever see single quotes, like with\u00a0'a'<\/code>\u00a0, that means you\u2019re dealing with a\u00a0char<\/code>\u00a0, not a\u00a0String<\/code>\u00a0.\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t
\n\t\t\t\t
\n\t\t\t\t\t\t\t\t\tAnd if you\u2019ve gotten used to being able to throw every value you can think of\u2013\u2013from an\u00a0int<\/code>\u00a0to a\u00a0KitchenSink<\/code>\u2013\u2013into a list in Python, you\u2019ll find that working with Java arrays require a very different mindset. All elements in a Java array have to have the same data type, similar to an\u00a0ndarray<\/code>\u00a0or a\u00a0Series<\/code>\u00a0, but with careful design, you can get around this limitation with polymorphic references.\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t\t<\/div>\n\t\t<\/div>\n\t\t\t\t\t<\/div>\n\t\t<\/section>\n\t\t\t\t
\n\t\t\t\t\t\t
\n\t\t\t\t\t
\n\t\t\t
\n\t\t\t\t\t\t
\n\t\t\t\t
\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\"\"\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t
\n\t\t\t\t
\n\t\t\t\t\t\t\t\t\tAlthough this specificity can be annoying, it makes your code significantly more\u00a0predictable<\/em>, which is my gold standard for readability. Blocks are grouped together with curly braces rather than indents, so you can easily tell where they start and end. While this isn\u2019t a huge issue on your computer, I\u2019ve found that grouping by indent in a printed Python book (where the code is split over multiple pages) can create problems for people new to that language.\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t
\n\t\t\t\t
\n\t\t\t\t\t\t\t\t\tAdditionally, this strictness means variable scope is significantly easier to wrap your head around in Java than it is in Python, and if you respect the curly braces, it often boils down to, \u201cDefined in the curly braces? Only exists in the curly braces.\u201d You actually have to put in work to declare\u00a0global<\/code>\u00a0variables available to all class methods in Java, whereas in Python you might accidentally wind up using a syntactically valid (yet perfectly inappropriate) value from a completely different part of your program if you ever recycle a variable name. On top of that, you can actually have\u00a0private<\/code>\u00a0fields in your class, instead of hoping everyone respects your underscored variable name.\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t
\n\t\t\t\t
\n\t\t\t\t\t\t\t\t\tAnd if you ever make a mistake? Well, rather than letting your code run for 90% of its runtime then aborting when it encounters its first error\u2026\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t
\n\t\t\t\t
\n\t\t\t\t\t
4. Java is compiled, so many errors resulting from misunderstanding the previous points are caught before runtime.<\/h2>\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t
\n\t\t\t\t
\n\t\t\t\t\t\t\t\t\tObviously, Python will parse your code before running it and generate a\u00a0SyntaxError<\/code>\u00a0if it can\u2019t figure out what you\u2019re going for, but I\u2019m sure all of you (especially data scientists) have been annoyed at one point or another when your code screeches to a halt over a simple error, after accomplishing half of what you wanted it to do.\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t
\n\t\t\t\t
\n\t\t\t\t\t\t\t\t\t\n
Oftentimes (in my experience, anyway), this happens because you\u2019ve attempted to perform some sort of an operation \u2014 say, calling a method \u2014 on an object of the wrong type. It\u2019s not a syntax error (you remembered the\u00a0.<\/code>\u00a0!), so the parser doesn\u2019t catch it, and the traceback takes you down a rabbit hole into the core libraries, so you can see exactly what Python assumed you wanted to do with the mystery object you gave it.\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t
\n\t\t\t\t
\n\t\t\t\t\t\t\t\t\tIn Java, this step happens\u00a0before<\/em>\u00a0you run your code. Because you\u2019ve locked your variable into a specific data type when you declared it, the Java compiler can verify that every operation you attempt to perform on that object actually exists\u00a0before<\/em>\u00a0runtime, and if the compiler detects an operation that isn\u2019t defined for that data type, your program will not compile and run at all.\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t
\n\t\t\t\t
\n\t\t\t\t\t\t\t\t\tThat\u2019s not to say that you\u2019ll never have your Java program terminate unexpectedly \u2014 there is a dynamic aspect to the language, so you\u2019ll become very good friends withNullPointerException<\/code>\u00a0and\u00a0ArrayIndexOutOfBoundsException<\/code>\u2013\u2013but this added layer of verification, combined with the strict and specific nature of Java, tends to funnel these runtime errors down predictable alleys.\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t\t<\/div>\n\t\t<\/div>\n\t\t\t\t\t<\/div>\n\t\t<\/section>\n\t\t\t\t
\n\t\t\t\t\t\t
\n\t\t\t\t\t
\n\t\t\t
\n\t\t\t\t\t\t
\n\t\t\t\t
\n\t\t\t\t\t
5. Designing Java methods is almost nothing like designing Python functions, so you need to think about your problem differently.<\/h2>\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t
\n\t\t\t\t
\n\t\t\t\t\t\t\t\t\t\n
A downside to this strictness is that Java method calls can become unruly pretty quickly. I absolutely love the functional side of Python, and have started relying not only on unordered keyword arguments, but also passing functions and having default values for optional parameters.<\/p>\n\n\n\n
This is totally valid Python code\u2026<\/p>\n\n\n\n
def multiply(a, b, c=1):
    return a * b * cmultiply('hello', 3)<\/pre>\n\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t
\n\t\t\t\t
\n\t\t\t\t\t\t\t\t\t\n
\u2026which would not fly in Java. Because Java is static-typed, you lock in the data type when you declare the variable. This means you have to pass values that have exactly that data type in exactly the same order as they appear in the method signature. While this reduces flexibility, it also reduces misuse of your code.<\/p>\n\n\n\n
While you can have methods with the same name handle different lists of parameters, Java handles this via\u00a0overloading<\/em>, which requires you to write a different version of the method to handle each sequence of data types you want to support as a parameter list. Java checks the data types you passed, sees if there is a method defined for handling that sequence of data types, and calls that method\u2013\u2013methods with the same name and different parameters aren\u2019t really linked in any other way.<\/p>\n\n\n\n
And if you want to provide a default value for one of your parameters? You have to overload that method and drop the default-value parameter from the list.<\/p>\n\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t
\n\t\t\t\t
\n\t\t\t\t\t\t\t\t\t\n
The fact that signatures are defined by the\u00a0data types\u00a0<\/em>in the parameter list instead of the\u00a0name<\/em>\u00a0of the variable also creates issues when you\u2019re used to thinking in Python. For example, if we wanted to provide default arguments for overloaded versions of this method:<\/p>\n\n\n\n
public static double getArea(double length, double width){
    return length * width;
}<\/pre>\n\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t
\n\t\t\t\t
\n\t\t\t\t\t\t\t\t\t\n
We would run into an issue by including two versions with the same data types in their parameter list:<\/p>\n\n\n\n
public static double getArea(double length) {
    return length * 10;
}public static double getArea(double width) {
    return width * 5;
}<\/pre>\n\n\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t
\n\t\t\t\t
\n\t\t\t\t\t\t\t\t\t\n
Both of these methods are called\u00a0getArea<\/code>\u00a0and both expect a\u00a0double<\/code>\u00a0, so when you call\u00a0getArea(12.3);<\/code>\u00a0, Java does not know which path to go down.<\/p>\n\n\n\n
In addition to that, while Java does have some support for lambda expressions, they\u2019re\u00a0a far cry from functional programming<\/a>, and attempting to think through a functional solution in an object-oriented language is begging for disaster.<\/p>\n\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t
\n\t\t\t\t
\n\t\t\t\t\t\t\t\t\t\n
Oh, and return types? Java limits you to one\u2013\u2013and you have to specify the data type when you write the method, which requires you to know what you want to return well in advance. You may be used to thinking about Python as being able to return multiple values\u2026<\/p>\n\n\n\n
def get_stuff():
   return 1, 2, 3x, y, z = get_stuff()<\/pre>\n\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t
\n\t\t\t\t
\n\t\t\t\t\t\t\t\t\t\n
\u2026but it actually returns a single object\u2013\u2013all of the values bundled into a tuple:<\/p>\n\n\n\n
>>> type(get_stuff())
<class 'tuple'><\/pre>\n\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t
\n\t\t\t\t
\n\t\t\t\t\t\t\t\t\t\n
You can be surprisingly productive in Python without ever knowing this fact, but in Java you\u00a0always<\/em>\u00a0have to know what your methods are returning.<\/p>\n\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t
\n\t\t\t\t
\n\t\t\t\t\t
6. In addition to data types, Java requires you think about lower-level concepts like memory management.<\/h2>\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t
\n\t\t\t\t
\n\t\t\t\t\t\t\t\t\t\n
This one might be a bit of a hot take (especially for people coming from a language like C that don\u2019t have automatic garbage collection), but there are certain pieces of Java that require you to think about what\u2019s going on, memory-wise. I\u2019m talking about reference variables!<\/p>\n\n\n\n
For example, what happens when you try to run the following code in Python?<\/p>\n\n\n\n
my_list = [1, 2, 3]
print(my_list)<\/pre>\n\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t
\n\t\t\t\t
\n\t\t\t\t\t\t\t\t\t\n
If you\u2019re coming from a totally-Python background, you\u2019ll expect the following output:<\/p>\n\n\n\n
[1, 2, 3]<\/pre>\n\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t
\n\t\t\t\t
\n\t\t\t\t\t\t\t\t\t\n
On the flip side, what do you get from the following Java code?<\/p>\n\n\n\n
public class JavaFeatures {
    public static void main(String[] args) {
      int[] myList = {1, 2, 3};
      System.out.println(myList);
  }
}<\/pre>\n\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t
\n\t\t\t\t
\n\t\t\t\t\t\t\t\t\t\n
That\u2019s right! It will print the memory address. Here\u2019s where my computer stored that:[I@6d06d69c<\/code><\/p>\n\n\n\n
Again, Python makes the assumption that when you print a variable referencing a list, you want to see the list\u2019s\u00a0contents<\/em>, while Java, by default, prints exactly what is stored in that reference variable: the location of the array in memory. To display the contents, you would need to loop through them:<\/p>\n\n\n\n
for (int i = 0; i < myList.length; i++) {
    System.out.println(myList[i]);
}<\/pre>\n\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t\t<\/div>\n\t\t<\/div>\n\t\t\t\t\t<\/div>\n\t\t<\/section>\n\t\t\t\t
\n\t\t\t\t\t\t
\n\t\t\t\t\t
\n\t\t\t
\n\t\t\t\t\t\t
\n\t\t\t\t
\n\t\t\t\t\t\t\t\t\t\n
While this takes a little bit of effort to wrap your brain around, it forces you to think about what\u2019s\u00a0actually<\/em>\u00a0being passed when you throw around reference variables (the memory address of that object), which gives you a deeper understanding of how your computer is actually carrying out its tasks.<\/p>\n\n\n\n
While Java is not as low-level as other languages, it\u2019s much easier to make the leap from Java reference variables to C pointers than it is to leap from Python references, because you\u2019re used to encountering problems like the one above that force you to consider the memory address.<\/p>\n\n\n\n
But the lack of Python\u2019s \u201cset it and forget it\u201d mentality isn\u2019t limited to reference variables.<\/p>\n\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t
\n\t\t\t\t
\n\t\t\t\t\t
7. Java doesn\u2019t really have a great equivalent for <code>pip<\/code> or <code>conda<\/code>.<\/h2>\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t
\n\t\t\t\t
\n\t\t\t\t\t\t\t\t\t\n
When I think about what makes Python a useful language, I don\u2019t generally think about language features or syntax. I think about the Python\u00a0ecosystem<\/em>. With a quick trip to the command line, you can use something like<\/p>\n\n\n\n
pip install snazzy_new_library<\/pre>\n\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t
\n\t\t\t\t
\n\t\t\t\t\t\t\t\t\t\n
to download a\u00a0snazzy_new_library<\/code>\u00a0for use whenever you need it.<\/p>\n\n\n\n
Although you will find people on message who will insist that package tools like\u00a0maven<\/code>\u00a0or\u00a0gradle<\/code>\u00a0are just as powerful as\u00a0pip<\/code>\u00a0or\u00a0conda<\/code>\u00a0, the reality is that while these tools are, indeed,\u00a0powerful<\/em>, they aren\u2019t really\u00a0equivalent.\u00a0<\/em>Java programs are generally structured differently\u2013\u2013rather than making a package globally available to any program in that environment, packages tend to be bundled directly with the application that needs them, and often need to be either added manually by dropping a jar file into the right place, or included with a tool that manages your dependences (which is what tools likemaven<\/code>\u00a0and\u00a0gradle<\/code>\u00a0are\u00a0actually<\/em>\u00a0great at).<\/p>\n\n\n\n
This can be inconvenient for Python programmers, because it requires you to jump through additional hoops to include a useful existing library on your project, and the size of the project files can get bloated as a result. On the other hand, bundling the included library with the project ensures that the necessary code is actually available when it\u2019s needed.<\/p>\n\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t
\n\t\t\t\t
\n\t\t\t\t\t
Conclusion: You can learn Java, and it will make you a better programmer.<\/h2>\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t
\n\t\t\t\t
\n\t\t\t\t\t\t\t\t\t\n
Having to adapt your problem-solving skills to fit the quirks of a new programming language can be a scary task, but picking up a new language really does expand the arsenal of tools in your tool kit\u2013\u2013even in your first language. C pointers confused me until I got used to working with Java reference variables, and lambda expressions in Java baffled me until I saw how they were used in functional programming with Python\u2026 which in turn wraps back around to clarifying why we need function pointers in C.<\/p>\n\n\n\n
Although it may seem daunting, just remember that many programmers before you have successfully learned Java, so it absolutely can be done.<\/p>\n\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t\t<\/div>\n\t\t<\/div>\n\t\t\t\t\t<\/div>\n\t\t<\/section>\n\t\t\t\t<\/div>\n\t\t","protected":false},"excerpt":{"rendered":"
You can learn Java, and it will make you a better programmer. Although it may seem daunting, just remember that many programmers before you have successfully learned Java, so it absolutely can be done.<\/p>\n","protected":false},"author":933,"featured_media":10114,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"content-type":"","footnotes":""},"categories":[187],"tags":[94,632,408,114],"ppma_author":[3887],"class_list":["post-10106","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-bigdata-cloud","tag-data-science","tag-java","tag-programming","tag-python"],"authors":[{"term_id":3887,"user_id":933,"is_guest":0,"slug":"dan-hales","display_name":"Dan Hales","avatar_url":"https:\/\/www.experfy.com\/blog\/wp-content\/uploads\/2020\/10\/Dan-Hales.jpg","user_url":"","last_name":"Hales","first_name":"Dan","job_title":"","description":"Dan Hales is STEM Teacher at Foxcroft School, a college. He taught Java for a few years."}],"_links":{"self":[{"href":"https:\/\/www.experfy.com\/blog\/wp-json\/wp\/v2\/posts\/10106","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.experfy.com\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.experfy.com\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.experfy.com\/blog\/wp-json\/wp\/v2\/users\/933"}],"replies":[{"embeddable":true,"href":"https:\/\/www.experfy.com\/blog\/wp-json\/wp\/v2\/comments?post=10106"}],"version-history":[{"count":6,"href":"https:\/\/www.experfy.com\/blog\/wp-json\/wp\/v2\/posts\/10106\/revisions"}],"predecessor-version":[{"id":33703,"href":"https:\/\/www.experfy.com\/blog\/wp-json\/wp\/v2\/posts\/10106\/revisions\/33703"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.experfy.com\/blog\/wp-json\/wp\/v2\/media\/10114"}],"wp:attachment":[{"href":"https:\/\/www.experfy.com\/blog\/wp-json\/wp\/v2\/media?parent=10106"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.experfy.com\/blog\/wp-json\/wp\/v2\/categories?post=10106"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.experfy.com\/blog\/wp-json\/wp\/v2\/tags?post=10106"},{"taxonomy":"author","embeddable":true,"href":"https:\/\/www.experfy.com\/blog\/wp-json\/wp\/v2\/ppma_author?post=10106"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}