Pass Oracle Java Certification Exams in First Attempt Easily

Oracle Java Certification Practice Test Questions, Oracle Java Exam Practice Test Questions

Want to prepare by using Oracle Java certification exam practice test questions efficiently. 100% actual Oracle Java practice test questions and answers, study guide and training course from Exam-Labs provide a complete solution to pass. Oracle Java exam practice test questions and answers in VCE Format make it convenient to experience the actual test before you take the real exam. Pass with Oracle Java certification practice test questions and answers with Exam-Labs VCE files.

Getting Started with Java

5. The Java Development Kit (JDK)

The Java platform that we downloaded was the JDK, the Java Development Kit. Let's take a look at that installation and see what we have. Now, as you know, I'm showing this to you on a Mac. If you are on a Windows machine, it's often installed into C programme files. Java. Check around there, and you should be able to find similar directories to what I'm about to show you on the Mac. You're going to want to go into your library. And by the way, this is not the library folder that's associated with your login. This is right off of the Macintosh hard drive. As a result, Macintosh hard drive libraries Rather than for me, there's also an InterTech library, which is in a different folder. So Macintosh's hard drive library goes to Java. And then after Java, there are the Java Virtual Machines and finally the JDK folder. One other difference between Mac and Windows is that you'll often see a second directory listed right next to the JDK, which will be the JRE. And just as a reminder, the JRE contains the APIs, and it also contains the Java Virtual Machine. And the JDK contains everything that we need to write programs. So I'll open up the JDKhere, and we have some contents and home. And here's what we need. Under Home, we've got several different directories. The first one is Bin, and this is where all of our Java tools exist. For example, we've got Java; that's what we will use to run a program. From the command line, we've got JavaC, that's the Java compiler, Java Doc, that's a documentation tool, and so on. So all the programmes that we need to be able to write and compile and run programmes from the command line exist. In the bin directory, there's a DB directory. This is just a simple database that we have access to. It's nothing that I personally would use in production code, but it's nice for smaller programmes for prototyping and so on. Include contains what we would need if we were writing advanced programmes that are going to communicate with libraries written in other languages, like C or C. Remember that I mentioned that there is another edition called JavaFX and that it is bundled with Java SE Eight? Now that's the source code for the Java FX library. We also have a JRE folder here. This is the Java Runtime Environment. So that will allow us to run programmes as well. Lib: This is where the Java API lives. Man, that's a folder that you're not going to see on Windows. Those are the man files, the manual files for all the different Java tools. And then finally we got the source zip, which contains all of the source code for the Java SE Eight API. So that's our JDK. We're going to learn next how to write a programme and then use this JDK bin tool called Java to be able to compile the file and eventually run it with Java. So let's move on to the next lecture and look at some Java code.

6. Your First Java Program - Part 1 (Code)

We've made it. We are finally at the point where we can start writing and talking about code. This is the fun stuff, but a couple of notes before we do it The first thing to note is that if this is your first object-oriented programming language, this may feel a little overwhelming. There are really just a tonne of concepts behind even the smallest amount of code that we're going to be writing, and eventually it'll become second nature to you. But when you're first learning it, it can be a bit overwhelming. So my advice right now is: don't worry about it. If you're feeling a little overwhelmed by this example or if you're feeling a little confused, that's okay. We will be diving into all these concepts in much greater detail throughout the remainder of this course. Right now it's just going to be kind of a 500-foot view of a short Java program. So what I'm going to do is create a new file for our program, which I'm going to call Hello World. That's a standard programme that we write when we're learning a new language. So. Hello, world. And the extension for our Java source code is going to be Java and has to be Java. Now let's write our first line of code. The first line is going to be public class. Hello World. Then I'll add two small brackets. So a couple of things to note when you're rewriting a program: we call the different components in the program—the main components—a class. And you can think of a class right now as being like a blueprint. This is going to be the blueprint for our program. Another way to think of a class is that it's a type. It's a type of thing. So for example, let's say you're writing a banking application. You might have a class for an account, a class for a customer, and so on. So this class we're just calling HelloWorld; we say "public class" to say that it can be run and used basically anywhere. We'll talk more about what it means to be public and not be public later. But for right now, just know that we have to have a public class so that the code can be used anywhere. And so we also put the name of the type here, the name of the class, and the name is Hello World. Notice that it doesn't have the Java extension in the code, but the name Hello, WorldMatch is exactly the name of the file. In fact, the H and the W have to have the same capitalization. So, with a capital H and a capital W, hello world. That's what we'll have in the name of the file. And then again, the file name has the Java extension. The curly braces here really are kind of showing ownership. So any code that we write in between these two curly braces belongs to the class Hello World. So let's do that. We're going to write something here called a method. I'm going to type it, and then I will explain it. So we've got public static, void, main, string, brackets, arguments, and again I'm going to put in the curly braces. So what do we have here? This is what we call a method, and the purpose of the method is to contain any number of statements. So what's a statement? A statement is really just a kind of instruction or code. Do something. This is what I want you to do. Now the nice thing about methods is that, let's say that we're constantly doing four things, Step A, step B, step C, and step D. It would be a pain in my code if I had to keep writing A-B-C-D everywhere that I wanted that code to run. With a method, I can simply call that method, and it will run all of the code that is in between these curly braces. So it is a collection of statements. Now we're going to keep this pretty simple. We'll only have one statement inside here, and it'll be system out, printline. Hello world. Okay, so let's talk about the statement, and then we'll go back to the method. So the statement that's going to be run whenever this method is called is that it's going to print out to what's called the standard out, which is typically going to be the console. It might be a log file, but basically wherever we run the program, it's going to print out this message. It's just going to print out "Hello, World!" The method of jumping back to line three here is a little bit more complex. So the first thing that I'm going to highlight here is the name Main. And you can see that it's written in purple here. So main is the name of the method, which means that when we want to invoke, when we want to call and run all of the statements in this method, that's the name of the method we'll use. So whenever we make a method, the method is going to have, immediately to its left, what's called a return type. So that simply means it's going to do all the statements that it contains, execute all of those statements, and then whoever called this method and said that it should run, we have the option to pass it back some information in addition to running all the statements. We can give it something back. Now we're not doing that here, so we're just going to say "void," and void means we're not giving anything back; we're not returning anything. Once the main method has finished executing all of the statements, to the right of the name main, we have parentheses, and we have listed in here what are called parameters. So in this case, we only have one parameter. It's a type "string," which is just text. These square brackets mean that it's not necessarily one string. It can be a collection of strings. Specifically, they call it an array of strings, and then we specify what the name of that string array is. We've explained what a parameter looks like, but it's still a little hard to understand what it's doing. So somewhere we're going to have some code that at some point is going to call Main. It's going to say "Main," I want you to run," and when it calls it, it's going to have the opportunity to pass in arguments. So arguments are just any data that it wants to pass into the method that that method might be able to use. So that's what this array of strings is saying. It's saying that main accepts a collection of text, and if this method wants to refer to the collection of text that was passed to it, it'll use this name. Now, in this particular example, we're not doing anything with the array of strings. So if someone passes us in an array of strings when this method is called, we're just kind of ignoring it, but we're declaring that it's possible that we may be interested in working with this array. That's essentially what you need for a method. You have your return type and, on the left, the name of your method. You have parentheses, and then in the parentheses you specify any arguments, any parameters, that you will accept. Now, I've used those two terms a bit interchangeably—parameters and arguments—and frankly, most people do. But if we want to be academic about it and proper, when you declare a method like this, what you write inside of here are your parameters. But at runtime, when we actually call the method and pass something into it, we pass in arguments. But again, a lot of people just use those terms interchangeably. Another thing a method must have are these curly braces to specify which statements will be executed when the method is called, and then to the left of the return type. These things are just called modifiers, and they do exactly what they sound like. They modify the method in some way. So public stature The only thing you need to worry about with that is that it's saying this method can be run by any code, and static simply means that we can do it by sending the message to the class itself rather than an object that has been made from the class. Now that is definitely a mouthful, and we will talk about objects and instantiating objects from classes and what that means a little bit later. But the most important thing to know is that to the left of the return type are the modifiers of how this method should behave, how it is accessed, and so on. Like I said, it can be a little overwhelming. There are a lot of concepts and just a little bit of code. But we will go through all of these concepts through the remainder of the class. Now, this method that I made here for Hello World is not just any ordinary method. I mean, it's a legal method in the Java programming language, but it has a very, very special purpose. It's the front door to our application. So in the next lecture, when we compile and run this program, what we're going to do is run the Hello World program. And what the JVM is going to do is look for this method, main, in the Hello World class and run it. When we say run this program, this is the first method that is called. As such, there are rules for the main method. And I'm going to go over the rules right now. If you need to watch this portion of the lecture a couple of times, there will be a quiz right after this lecture to see if you absorbed all the rules for the main method. The first rule is that the modifiers for main must be public and static. The interesting thing about modifiers is that the order of modifiers does not matter. So you could write static public; that's legal too, and that's fine for the main method, although strictly speaking, most people will write public static. The main rule is that they work together for the main method. And all modifiers must be to the left of the return type. The return type for the main method must be void. It's not going to return anything back to whoever gives it the name of the method. Main must be in all lowercase letters. So Java is a case-sensitive language. If I have a method here and I write main with a capital M, that's a very common mistake when you're first learning Java. It's a legal method, but it is not the front door that the JVM is looking for. The method main (with a capital "M") is a different method than main. That is all lowercase for the parameters. It must accept an array of strings. The array symbol is interesting in that it can be used alongside the type string. There can be a space in between. That's okay. And in fact, although you don't see this as often, it can be to the right of the name. The identifier argues as well. All of that is legal. I'm going to put it where I normally keep it, where most people normally keep it, which is right against the type. And that's nice because we can quickly see that this isn't just a single string, this is an array of strings. The final rule for the main method is this name, which argues And the name can be anything you want. Traditionally speaking, most people call ARGs short for arguments, but we could put it in Java if we wanted to, and that would be legal as well. You can use whatever identifier you want. So there is our first Java programming language example. And so what I want you to do now is maybe watch this lecture a couple of times, make sure you get the rules for the main method, and then take the quiz that follows. After you're done with the quiz, we'll talk about compiling and running this program.

7. Your First Java Program - Part 2 (Compilation and Execution)

So, now that the Hello World programme has been written and saved with the Java extension, should it also be mentioned that the word Java should be all lower case? Now that it's written and saved, we can complete the pile and run it. And so we're going to do this with the command-line tool. Now after this lecture, we're going to move on to Eclipse. And when you do the lab, you'll use both the command line and Eclipse as well. But the reason that we are doing the commandline at all is because, number one, it's good to know you may be in a situation where you don't have access to an idea like Eclipse. And also, if you're taking the exam, it is one of the topics you have to know about in order to compile and run a programme using the command line. So I have a terminal opened up. You would use a command prompt if you're using Windows. and what we'll do is compile it. First of all, I'm going to look at the directory here, and you can see that we've got a file called HelloWorld Java. So the way that we compile it is to say Java C, and the C is for compile. So we're going to run the Java C, and we're going to put in the name of the file, the whole name of the file: hello world, Java. and I'll hit enter. And now it doesn't look like it really did much in the Java world. No news is good news. So if I take a look at the directory again, we now have two different files. We've got HelloWorld Java, which is the source code, and we have the HelloWorld class, which is the bite code. If we were to open up Hello World dotclass, we wouldn't be able to read it. There'd be a lot of binary characters, but that's what the compiler has produced, which is in fact not the class that we distribute. Hello World class, here's our program. And then people would be able to run it if they have the Java platform installed. So how do we run a program? It's very similar. We say Java, leaving off the C, because we're just going to run Java and the name of the class. Now notice that I'm not putting on class when I run this. I just simply say, Java, Hello World," the name of the type, and hit Enter. And now you can see it written out with the words "hello world" right below. So the programme worked, and when you do the lab, that's what you should expect to see as well. Now, that was the happy path. That's where everything went as expected, which is great when it happens, but it doesn't always work out that way. So let's just introduce a couple of errors into our programme and take a look at that robustness of Java where we're able to see compile-time checking. So what I'm going to do is change the name of the class. If you remember, the name of the class must match, in spelling and capitalization, the name of the file. So I'm just going to make this a lowercase W, and I'm going to go back to the terminal and let's run that Java C again. And now you can see I made an error. So I did a check, and it says that Class Hello World is public. It's telling us that it should be declared in a file named Hello World with a lowercase W. So it's telling us exactly what the problem was. So I'll fix that. Let's do another error where I forget some of the syntax. Now we'll talk more about syntax in upcoming lectures, but I'll just tell you right now that when you make a statement, it has to end with a semicolon. So I'm going to get rid of that semicolon. Hit save. Now let's compile it again, and we get a different error. And it tells us the semicolon was expected. and it points to the line of code. It's Hello World Java, line five. It prints out line five and puts a little carrot underneath saying where that semicolon should go. So, as you make various types of errors, the compiler will catch many of them and those that it does not catch. Well, then there's runtime checking as well, when we actually run the application. So that's it for this particular lesson. Just remember that when you save the file, it's got to be Hello World Java. It has to end in Java and match the capitalization of the name of the class. When we compile, we'll do it with Java C. And let me save this file here. Run that again. We compile with JavaScript, and no news is good news. That means it compiles perfectly. And if we take a look at the directory, we'll see that we'll have another file there with the same name, except a different extension. and the extension is class. That is our bite code. That's what we distribute as our application.

8. Hello World Lab & Lab Files

Every section of this course is going to have a lab. And while it's not required for you to do the labs, I do highly encourage you to complete them because you're just going to get a lot more out of this course if you do. And the way it'll work is I'll have a lecture that goes over what you're going to do in the lab, and you'll then go into the resources for that lecture. where you will see a PDF, and you'll download that PDF, which will contain all of the instructions that you need as you're going through the lab. If you get stuck, go right past all the instructions and then you will see a section called Lab Solution. That's where all the source code will be, and you can check your work against the code listed here. Also, in some labs, if you go past the solution, there may be a bonus lab for you to do if you're interested as well. So let's talk about this particular lab. First of all, in this lab in the Resources section, you're going to see something called an "InterTech Learn Java Zip" that is going to contain a few source files that you'll use in future labs in upcoming sections. So download that now, put that to the side, and later when we refer to files that were in the zip, that's the zip we're referring to. Also in this section, you're going to be using a text editor if you are on a Mac. If you're on Windows, you have a built-in text editor. It just needs a little bit of configuration to make it work well with Java. So what I'm going to do now is just show you how to configure your text editors. I'm going to start with the Mac, and then I will show you Windows. If you have a favourite text editor that's not one of these two, then by all means use it if it works. Otherwise, know that you have these available. Let's start with text editing for the Mac. If you're going to use text editing, what you should do is go into format and then choose "Make Plain Text." Then go to Edit, then down to Substitutions, and make sure you uncheck the smart quotes. That's all you'll have to do. As for Windows, you can just use Notepad. There's not a whole lot that you have to do here. However, when you save the file, go to File Save As, and you'll want to change the type to all files. Also, make sure that the encoded text says Antsy. Other than that, you're going to make your first Hello World program. with this lab. You're going to become a little more familiar with the Eclipse IDE. So have at it. Let me know if you have any questions.

9. Java API Documentation (Java docs)

We have one final topic to cover for this section, and that's the documentation for the Java API. So, as a reminder, the Java API is a set of libraries available to us so that we can use preexisting code in our applications. And there is a tonne of it. So you are going to refer to these documents over and over again, and I'll go through them in just a second. But first of all, how did I get to the documentation? I'm currently using the Web to access the documentation. So I have this link to the Java Platform, Standard Edition, eight API specifications. I have that in the sources for this particular lecture. And there is another option, of course—you can download the documentation as well. And so if you go to the Java download page and scroll down a bit, you'll see additional resources. And then there is a button to download the Java SE documentation. So I have that link to the download page as well in the resources section for this lecture. But let's take a look and see what we have here. The API documentation has three main areas. Now at the top left, this is what we have. It's called packages. And so when you think of a package, think of it like a folder. Think of it as a directory. It's a way of organising all the libraries that are available to us. So, for example, if I scroll down, there is a Java Language Package. And when I clicked on that, it changed what was right below it. So now the section below it, the frame below it, lists the interfaces and classes that are available in that package that are in that folder. And we'll talk about the difference between interfaces and classes, but this is the code that we get to use. So what if I wanted to learn more about strings? I can click on string here, and in the main frame of the page are all the details that we need to understand how to use the String class and how to use this particular code. And so it starts off by telling you a little bit about strings. It gives a few examples. And then if you scroll down, there are methods and constructors and so on. And if you click on any of these methods, I'll just click on one, and it will tell you a little bit more about it. How is it used? How should you call it? If you recall, when we made Hello World, you made a method, the public static void main method. So that's what these are. These are just methods that can be called, and so they tell you what the proper syntax is to invoke them. Now, a lot of the concepts that we're seeing here we haven't really gotten into yet. So the usage of the Java doc will make more sense as the course continues. But just be aware that it's there. If you're going to use anything from the APII library in Java, there is a Javadoc available that contains all the information you need on how to use those classes.

So when looking for preparing, you need Oracle Java certification practice test questions and answers, study guide and complete training course to study. Open in Avanset VCE Player & study in real exam environment. However, Oracle Java exam practice test questions in VCE format are updated and checked by experts so that you can download Oracle Java certification exam practice test questions and answers files in VCE format.