Pass Oracle 1z0-808 Exam in First Attempt Easily

Welcome!

1. Course Overviewn

Welcome to learning Java with InterTech. My name is Jason Shapiro. I'm an instructor here at InterTech, and I've been teaching at InterTech for a little over eight years, predominantly Java, iOS, and web technologies. So I made the leap to Java from C. This was back in 1997. I was learning JDK one by one at that time, and I really have never looked back. I absolutely love the language, and I'm excited to be here to help you learn it as well. So let's talk about what we're going to cover in this class. The goal of this class is really to give you a solid foundation not only in Java but in object-oriented programming as well. And so we're going to cover all the basics of Java syntax. We're going to talk about classes and interfaces, abstract classes, and a lot more. And I also know that some of you are planning on taking the associate exam. And this is going to be a fantastic class for you to use in your preparation. But I will tell you, I just recently took the exam, and it's tough. I did pass, but it is tough. And what you're going to find is that this is going to be one major component of your preparation, but you're going to want to do other things as well. Namely, you're going to want to practice, practice, practice, practice. And there are other resources that you might want to consider using as well. There are practise exams, there are online quizzes, and so on. This will be, as I said, a major component of your preparation, but you are going to want to add to that elite a little bit with practice. So let's move on to the first section where we're going to talk about Java as a language and Java as a platform and give you the basics about what it is you're going to be working with.

2. Installing the Java SE Development Kit 8 (JDK)

Okay, so the very first thing that we're going to do is download the Java platform. Now this is known as the JDK or the Java Development Kit, and the URL to get to this page is listed in the resources section for this lecture. So when you get to this page, you may see a slightly different version than the one I'm showing you right now. Here's what's really important. It needs to say Java SE Development Kit, and it needs to be version eight, the number that follows the letter U. In this case, we have the eight U 91 down here. As long as it's U 91 or greater, you're fine. The really important thing here is that it's version eight. So what you have to do is accept the licence agreement. Now you can read the licence agreement by clicking on this link. Once you're okay with that, you click that, you accept the license, and then you have to choose the version for your particular operating system. So I'm using a mac OS. If you're using Windows 64, that's listed there as well: Windows 64 bit. So let's do that. I'm just going to click on this and download. And as you can see down on the bottom left, the download has begun. And once it's done, we'll begin the installation. All right, so the development kit has been downloaded, and so we're ready to run through the installation. Now, I downloaded this for the Mac. If you download it for another operating system, your options may be a little different than mine, but basically it's going to be the same thing. It's going to be a wizard. And really, all that I do is just run through the wizard. I tend to accept whatever default directories they suggest and default installation information as well, and it will let me know when it's finished. Now that the JDK installation is finished, the next thing to do is test it. And I'm on a Mac. So what I've done is opened up a terminal program. If you're on Windows, you'll open up a command prompt, but once that is open, you'll type exactly the same thing that I'm showing here. The one thing you want to make sure is that you're not using a terminal or command prompt that was already open when you were doing the installation. If you do that, the environment variables won't be set up correctly, and this will not work. So you open up the program, and we simply type the Java version. And if it works, then you'll see Java Version 80. And then, whatever that underscore value is, I downloaded U 9-1. So that's what I see here. You might see something different if you've downloaded a later version. Remember, the main thing that's important for this class is that we're using Version one eight. It may appear strange that we have one eight despite having downloaded eight. I'll talk about version numbering in the next section, but basically, they're the same thing. One eight is the same thing as a JDK eight. So with that said, we're done installing Java. The next thing to do is install our integrated development environment, which is called Eclipse. and we'll do that in the next lecture.

3. Installing Eclipse

The final thing that we need to install for this class is Eclipse. Eclipse is an integrated development environment, or IDE. And we're going to use it to write our code. So in the resources section for this lecture, you'll find a link to the Eclipse Eclipse Download page, and that'll bring you here. And so what we're going to do is download and run the Eclipse installer. Now you may notice that I am downloading the Eclipse Mars release. Depending on when you're taking this class, you might not see Mars here. It may say Neon, but either Mars or Neon will suffice. Neon is the next release that's coming out very soon. So again, it doesn't matter if it's Mars or if it's Neon, but it does matter that you choose the right one for your operating system. So here I'm on a Mac, and I'm going to download the 64-bit version. So that will bring you to a mirror, and over on the left side is the download. So I'll click this download button, and we'll give it a few seconds to finish downloading, and then we'll run the installer. I finished downloading the Eclipse Installer, and I've run it. And so now this is the first screen that shows where we will choose which edition of Eclipse we want to download. So for this class, we're going to download the Eclipse IDE for Java developers. There is a version for Java EE, the enterprise edition, but we're not going to be doing anything with that in this particular class. So we'll stick with the basics. the Eclipse IDE for Java developers. Alright, then it's going to let you choose your installation folder. I'm just going to let it choose its default, click the install button, read through, and accept the user agreement. And there it goes. So it's now installing. And once it's finished installing, we will run the application and make sure it's working. All right. So just a couple of minutes passed by, and now we're ready to launch Eclipse just to make sure it's working. So I'm going to click on the launch button. It gives me a little splash screen for Eclipse. Remember, I'm using Mars. You might be using Neon if that's the version that's out at the time you are watching this course. So then it's going to ask you to select a workspace. And a workspace is think of it like a place to hold all of your projects. And so what I'm going to do is, instead of just calling it workspace, I'm going to call mine Java 101. You can call it whatever you want, but it will be the workspace for all the labs that we do in this class. Now I'm going to click Okay. And it'll only take a second to load everything for Eclipse. And here it is, an eclipse. This is the first screen that you see. If this is the first time you've used Eclipse, it wouldn't hurt to go through some of the tutorials that they have here or get an overview of the features. But what I'm going to do is just quickly show you around just a little bit. so I'm going to move this a little bit over. So here is my workspace. And there really isn't a whole lot to see here yet. So in order to just talk about some of the features of Eclipse, I'm going to write a little bit of Java code. I'm not going to explain the Java code, and you are not expected to understand it, but I'm just going to do that so we can see some of the features of Eclipse. So the first thing I'm going to do is create a new project. So I right clicked on the Package Explorer, and I'm going to do a new Java project. And we'll call this Hello, World. And I'm just going to leave all the defaults. It's asking me what version of the JRE I want to use. That's the Java Runtime Environment. And so we installed eight. So that's what we're going to use. Say finish. And now I've got a project, and you can have multiple projects in a single workspace. So what I'm going to do now is right-click and create an actual Java class. Again, we'll go through these wizards in more detail a little bit later. But now I'm just going to create a class called Hello World and add that. And now you can see in the middle that we have our Java code. So I'll write a very simple programme here. Hello World! public static void main string argues system out print line Now this programme that I'm writing right now is your traditional Hello, World program. I will be explaining this in great detail in the next section. And you will end up doing an ALAT where you'll write this very program. So I'm going to save it, and now I'm going to run it. I'm going to right-click on the programme here and say "run as Java application." And you can see down at the very bottom we have a tab called Console, and it prints out Hello World. You're not going to have to do this. Once again, I just want to show you what Eclipse looks like and how we're going to be using it. If you were able to run Eclipse and you could just see the blank screen, then it's working. You're ready for the labs. One thing I want to point out here though is that now that we've got some code written, we know what these tabs are, and so on the very top left, this is our Package Explorer. And by the way, the official term is view. So if I accidentally remove a view and I need to restore it, I can do that through the Eclipse menu. In fact, I'll do that right now. I'll get rid of this console view. Oops, I got rid of the console view. How do I get it back? So to get it back, all I have to do is go to the Window menu. At the very top here, we've got Window, and you'll see Show View. And all of the common views that we can use are listed here. If you don't see the one you need, you can click on Other, and they'll list a bunch of others as well. So I'm just going to click "on console," and then it's added back here. So that's what you can do if you accidentally delete one of the views. Sometimes the whole environment can get a little messed up. You might have accidentally dragged the console over here, and now things are getting squished. So another thing we can do is what's called "resetting the perspective." So if each of these tabs is a view, then the collection of views is known as a perspective. So once again, if I go to Window, you see a perspective menu, and I can just reset the perspective. If I do that, it goes back to all the Java defaults and we're good to go. Now you may notice that Console has disappeared, and that's because when we first started with this particular perspective, Console wasn't there. It was added as soon as I ran the program. But I can read it again. I can go to Show View, hit Console, and there's the console view that we just had, and that's really all you need to know for right now. Again, you don't really need to write the code that I just did. You just have to open Eclipse and make sure that it is working. So with that said, you're good to go. It's time to move to the next section, where we'll start to dive into Java as a programming language and Java as a platform.

Hide

Getting Started with Java

1. Section Overview

Alright, now you have all the software you're going to need to be able to do the labs. So we can finally start talking about Java. In this section, we are going to look atJava as a language and Java as a platform. So consider this your 500-foot view of Java. You will also have a chance to look at your first Java program. And if you do the lab, and I recommend that you do the lab, you'll write your first Java program. So let's move right on to Lecture Number One.

2. The Features of the Java Programming Language

In this lecture we're going to start right at the beginning and we're going to answer the question, What is Java? Now, when you decided to sign up for this class, I'm sure you had a pretty good idea of what Java is. Java, as most people would say, is a programming language, and that is true. But in fact, Java is really two different things. Java is a programming language, but there's also a Java platform. And so in this section, we're going to talk about both of these things. However, in this lecture, the focus is on Java as a programming language. So when Java was created, there were some design goals in mind, and you can actually read the full paper that lists the design goals. I have in the Resources section a link that will bring you to that paper. But I'm going to cover the high-level bullet points right now. So Java was designed to be simple, object-oriented, and familiarly simple. They just wanted it to be an easy language to learn. Object-oriented meant that they wanted the ability to create modules in an object-oriented way. It's kind of a mouthful. We'll talk about what object-oriented means throughout the rest of this class, but for now, just think of it as a way of organising your code into reusable modules. And they wanted it to be familiar. It really does tie back into it being simple, but they didn't want to reinvent the wheel. So a lot of the language syntax was based on C, and C was arguably the most popular object-oriented language at that time. Java was to be robust and secure. So when you write code, you're going to go through several different processes. You're going to write what's called source code, and then you're going to take that source code and run it through a compiler. A compiler is another programme that takes your code and turns it into something that the Java platform can understand, and then eventually you'll run that code. As a result of it being robust, many different checks are performed to ensure that your code will run. Well, there's compile-time checking, so you can find out if you did anything syntactically wrong at that time. And then there's runtime checking—things that can't be resolved until the programme is actually running. For example, if a database is down, you don't really know that when you're compiling the program. You can only discover that when the programme is running. And so it checks for these kinds of issues and lets you know when they happen. Also, they wanted Java to be secure, so everything is sandboxed. There's a lot of effort put into protecting memory that's being used by Java and so on. They wanted it to be architecturally neutral and portable. This is also known as being platform independent, and this is a big bullet point for Java. Java popularised the term "write once, run anywhere." So the idea is that we can write a programme and run it on Unix or on a Windows PC, and we can use the same code that we wrote for both. Now, the way that they are able to achieve platform independence is that we never compile our programmes into machine code that's native to a specific architecture. Other programming languages, for example—let's say I'm creating an exe for Windows. I would write my code with that in mind, and I would compile it for that underlying architecture, that underlying operating system. But with Java, we don't have to do that. We write our code once it gets compiled into something the Java platform understands, and that achieves platform independence. It's interpreted, threaded, and dynamic. So I mention that we have a Java platform that includes an interpreter. And so it's going to interpret the bite code that we write. I just used a new term there, bytecode. That's what we call the code that has been run through the Java compiler. So that byte code is going to be interpreted. It's threaded, so that helps us achieve high performance, and it's dynamic, meaning that it can resolve at runtime how things should be linked together. In other words, let's say I'm writing some code that's going to use a database service at runtime. We can actually choose what that database service is going to be. As a result, our code becomes more dynamic and performant; this is related to the integration interpreter and threading. And again, the URL where you can dive deeper into these bullet points is listed right here, but it's also found in the resources section for this lecture.

3. The Java Platform

Now let's talk about Java as a platform. In the very first section of this class, I had you download the Java Platform so that we could write and run programs. And let's dive just a little bit deeper into seeing what it is that we have. So the Java Platform has two different components. The first component is called the Java Virtual Machine, better known as the JVM. And the Java Virtual Machine is what's going to actually run our programs. So when you downloaded your JDK—the Java Development Kit that included the Java Virtual Machine—remember that you had to pick a download that was for your specific operating system. So each JVM is coded in a way that it's able to interpret Java code, the stuff that we're going to write, and it's able to interpret it for the underlying operating system. So I'm running on a Mac right now. My JVM is going to be different than those that are running on a 64-bit Windows operating system. So the Java Virtual Machine, or JVM, is what helps us achieve our platform independence. We are also given what's called an Application Programming Interface, or API. And you can just think of an API as code someone else has written that we get to use. It's a bunch of libraries of code, things like input and output (input being accepting input from the keyboard, output being writing to the file system, connecting to a database, creating GUIs, a graphical user interface, and so on). Lots and lots of libraries are available for us. And the specific API that we get really depends on what version and addition of Java we're going to use. And that's something we'll talk about in an upcoming lecture. Another thing that's interesting about the Java Platform is that it can be used to run languages that aren't Java. So if you've heard of the programming languages Groovy, Scala, and Closure, there are a bunch of other ones as well. These are programming languages that aren't Java but have been written for the Java Platform. So at a high level, this is how we are going to interact with the Java Platform. First of all, we're going to write a Java application, which is in part going to use the Java API. The great thing about the Java API is that not only is it code that we didn't write, there are libraries that we get to use, but the Java API is already bundled with the Java Platform. That is, if we use a lot of API code, we don't have to bundle it with our own application. It's already there on the client's computer that has the Java Platform. So we distribute our Java application, and we're using the Java API. All of this code is going to be interpreted by the Java Virtual Machine for the underlying hardware or operating system. And that's how we interact with the Java platform. We distribute our code and the Java application, and the platform has the API and the virtual machine. Now, these two things together are known as the Java runtime environment, or the JRE. And we'll talk more about that in a little bit. In a previous lecture, I mentioned that our Java applications are both compiled and interpreted. So let's take a closer look to see what that means. So you and I, as Java developers, are going to write what's called source code. And source code is what we write, but it's not what is actually run on a computer. Eventually what we've written has to be turned into machine code. But when we're running Java, we don't go immediately from source code to machine code. What we do is take our source code and run it through a compiler. And the compiler will produce an intermediate language. and that's something that will be then interpreted by our Java platform, the JVM. Now, that intermediate language is called bytecode. And bytecode is still not machine code. It's still not the kind of language that an operating system will understand. Natively, bitcode is going to be fed to the Java platform. So the JVM will take that bytecode and translate it; it will turn it into machine code, which is run by the underlying platform. So you can think of bytecode like machine code, but for the JVM. So this is where we get our platform independence. When we write our programme and we run it through the compiler, that gives us the bytecode. And we're able to distribute that bytecode to anyone who has the Java platform. And the reason that that works is because when you download the Java platform, as I mentioned previously, it's specific for the underlying hardware and operating system. I'm on a Mac, so that's going to be different than someone who has downloaded a Java platform. For Windows, we'll have two different JVMs, but both JVMs understand how to read and interpret bitcode for the underlying hardware and operating system. So with that in mind, let's take a look at the flow. So, as we write our Java application, we'll run it through a compiler, which will generate some bite code. So we distribute that bytecode, and that's going to be run on the Java virtual machine. The Java Virtual Machine will interpret the bytecode into machine code, which is then executed on the underlying hardware operating system.

4. Editions and Versions

When you're first learning Java, one of the challenges that you're going to run into is picking the right Java platform. And to add to this complexity, there are actually many different kinds of Java platforms. So one of the primary components of the platform is the JVM, the Java virtual machine. And we've already seen that there are a number of JVMs. Essentially every hardware and operating system combination has their own JVM. And that makes sense because the JVM would have to be written a little bit differently for different architectures. And plus, it's going to take our code and interpret it into machine code for the underlying hardware and operating system. So the JVM comes in different editions. I mentioned editions in the previous lecture when I said that we get this Java API. It's great. It's a library of code that we can use. But part of what's going to determine what's in that API is specifically what version of Java we've downloaded. Not only addition, but also versions; more on that later. So there are three primary additions to Java. We have Java EE, Java SE, and Java. MEE stands for Enterprise Edition. SE stands for Standard Edition, and ME stands for Micro Edition. And as you can see here, JavaEE is a superset of Java SE. We are learning in this class. Java is the Standard Edition. You can think of that as the base syntax of the language. all the regular features that you need to write desktop applications, and Java EE, the Enterprise Addition. This is something that we're going to use when we're writing distributed applications. So if you're doing anything for the Web, you're going to use Enterprise Edition. And there are a lot of different use cases. In fact, Enterprise Edition is really big. Some people will argue that you could spend a lifetime learning the libraries of EE and still not get to the end. So there's a lot of stuff there. You tend to focus on specific areas of EE that you need to incorporate into your application. But, regardless, we're concentrating on Java Sand, and that stuff isn't going away. When you later learn Java EE, you're still going to use all the syntax and libraries that are found in Java SE. Java Me micro edition This is for embedded systems on limited devices. We'll probably see a resurgence, arguably, of Java ME with the Internet of Things. If you haven't heard of "the Internet of Things," Google it. It's a term that refers to adding software connectivity to components like, for example, our refrigerator or our thermostat and being able to access these components through the Internet. So technically speaking, there's also a fourth edition, Java FX. But as of Java SE 8, JavaFX is now bundled with Java SE, and so JavaFX is an addition that focuses on creating graphical user interfaces. So each of these three Java editions will target different kinds of applications running on different types of hardware. And that brings us to Java versions. There's a lot of information here on the slide. I'm not going to read it to you all. Feel free to pause and check out the features of each of the different versions. But what I want to point out is what happened with the version numbering over time. So in 1995, when Java was first released, it was just called the JDK. You simply downloaded the Java Development Kit, and 10 and, eventually, One were released. But when One Two came out in 1998, SunRun said, "This is a bigger deal than just a point release." We want to have some sort of marketing that conveys how important this release is. And so they came up with the term "J-Two-Se." And J Two Se was used officially all the way until about 2006, but unofficially, people still use it. You'll hear? J two, Se; j two, EE; j two, me, over and over again. From developers. But officially, that was dropped in 2006. The other difference was that they dropped the J-2 SEC two years before. And that was when they decided that instead of having it be called 1415, let's just call it 5 and 6 and 7. And that's what they do. That's the official marketing number. However, if you open up a command prompt or terminal and you type "Java version," you'll see that underneath the covers, they're still referring to Java with these points. So in other words, in fact, you may remember from a previous lecture that we tested Java, and when I did the Java version command, it said JavaScript. And I said, don't worry. That's fine. Eight is the same as one. So that is the case. So the reason I'm bringing up the versions—well, there are several reasons why I'm bringing up versions. First of all, there's the idea of backwards compatibility. So if you write a programme and compile it with a Java Se Eight compiler, then it can be run on a Java Se Eight platform or anything built later in the future. So let's say that you had an older program—something that you wrote and compiled with Java SE Six—that should, in theory, still be able to be run on a Java SE Eight platform. That's backwards compatibility. The opposite is not true. If I write a programme and compile it with Java SE Eight and I've downloaded the Java SE Six platform, it's not going to run. I'm going to see an error that's going to say there's a major minor mismatch problem. We can't run this code. So just remember that there is backwards compatibility. Older code can be run on newer platforms, but the opposite is not true. Also, versions are going to help us understand what features are available. So if I have Java SE Six as my compiler, which is what I'm writing the code with, then that is going to have more features than J2SE and SC1E would. And finally, often you're going to use libraries that were written by other people, maybe in your own organisation or maybe by a third-party group. And there are usually requirements that are included with the library. They'll say we compiled this with Java SE seven. And so you're going to ask yourself, "Can I run this on my platform"? And if you've got Java SE Seven or greater as your platform, then you can run code that was written with Java SE Seven. However, due to naming changes over time and the fact that not every developer has yet embraced these changes, you may encounter odd numbering and names. So for example, if someone happens to say, "I wrote this code with J2SE 1," and you're wondering, "Will that run in Java SE 8?" The answer is, yes, it will. And the reason is that J2SE is the same as Java Standard Edition, and one six is the same as six. So that's a little bit about Java editions. Inversions will concentrate on Java SE 8, which was released in 2014. And down the road, we should see Java SE 9 being released. That's tentatively scheduled for the spring or summer of 2017.

Hide