Pass Your Oracle 1z0-808 Exam Easy!

Oracle 1z0-808 Java SE 8 Programmer exam dumps vce, practice test questions, study guide & video training course to study and pass quickly and easily. Oracle 1z0-808 Java SE 8 Programmer exam dumps & practice test questions and answers. You need avanset vce exam simulator in order to study the Oracle 1z0-808 certification exam dumps & Oracle 1z0-808 practice test questions in vce format.

Introduction to Objects

1. Section Overview

You just finished building your very first Java application, and we've been talking about programming as an object-oriented programming language. So what we're going to do in this particular section is really dive down into that concept. What do we mean when we say "objects"?And we'll also compare and contrast that to something else called a primitive. So let's get into the first lecture.

2. Object Oriented Programming (OOP)

at this point. Everyone who's taking this course knows that Java is an object-oriented programming language. But what does it mean to be an object-oriented programming language? And that's a mouthful, right? People will just say "object-oriented programming language," or "OOP," for short. So it represents a way of creating and organising our code. And one of the things we try to do a lot in software is take a real-world process and convert it to something that can be done in a software solution space. So the nice thing about O programming is that the organisation tends to mimic the way that we see and interact with the real world. Now, that's not to say you're always going to be writing code that mimics the real world, but organising our code as if we're dealing with real-world things tends to make it easier to reuse, to maintain, and so on. So what do we mean by an object? Well, an object is anything that has data and related procedures, and we'll often call this state and behavior. So let's take a real-world example. Let's say you're writing a banking application, and one of the real-world objects that you've encountered is a bank account. Now think about a bank account. It's going to have states and behaviors. The state would be things like the balance, the ID, the owner, and so on. A bank account, too, exhibits behavior. We can debit the bank account, we can credit it, we can open, close, apply interest, and so on. So really, that's what we're trying to do with O programming. We're trying to assemble our code into modules that mimic the real world and that have states and behaviors. And I should say that not everything is going to have states and behaviors. Some objects will only have states; some objects will only have behaviors. But typically, if you think about the real world that you interact with, most things have both. They have states and behaviors. So that's one of the nice side effects, if not the goal, of programming: that it's easier to mimic the real world so that when we look at our code, it's easier to organize, reuse, et cetera. So this process of writing code to be like the real world is called abstraction. We are simplifying the real world into a software-solutions space. As we continue to talk about object-oriented programming, we'll talk about the pillars of it, and abstraction is one of the pillars. There are three or four pillars, depending on who you talk to. So there's abstraction, encapsulation, inheritance, and polymorphism, and we're going to cover all of those in this class. To simplify, to make things less complex, is what abstraction really means. And as we learn more about objects and object hierarchies and object graphs, that term and that process will start to make a lot more sense. But for right now, just think of abstraction as simplifying. So what are the advantages of doing OO programming? First of all, it's more extensible, and we can extend it faster than we can with other types of programming. So we'll learn about something called inheritance a little bit later. And we'll see if there's an object that already exists and I want to create something that is a specialised version of it. For example, maybe we have a person object and I want to make an employee object as well. The employee's going to pretty closely resemble a person, but there's going to be a few things added to it. So with object-oriented programming, they have something called inheritance. They have composition, and it allows us to create new objects that are built from existing objects. Arguably, object-oriented programming is easier to maintain. Now this is debatable. I tend to think it is easier to maintain. There are plenty of people who would argue against that bullet point. However, the idea is that by simulating the real world, it will be easier to figure out where I would look for certain parts of code, where new parts of code belong, and so on. provides better organisation for code reuse and library functionality. So let's say that I create a person object and make it available to anyone in my company that wants to write code that uses people. As a result, they could be reused under this person. Maybe they're going to specialise it by turning it into an employee. Maybe they're going to include it as an object for an order or for a registration for a class, and so on. So once we define the class, which is the object? Well, I should just say right now what the difference is between a class and an object because we're going to be throwing these terms back and forth. Think of a class as a blueprint, and an object as the thing that's made from that blueprint. Okay? So if we just start with that, that'll get you through a lot of these definitions that we're going to hit. So with objects, we have the ability to just reuse them. And once we reuse them, that means that's code we don't have to rewrite; that's not code we have to test as aggressively. I'm always a little weary of saying that we should always test aggressively. But if you've got a good object that's already been written, hopefully it has a test harness already built for it. So those are the basics of object-oriented programming. We're going to dive deeper into those pillars I mentioned, and we'll see lots and lots of examples as we continue on through this class.

3. Objects vs. Primitives

at this point. We know Java is an object-oriented programming language, which means that we're really going to spend a lot of time writing, reading, and interacting with objects. But it's not the only type that we'll interact with. There is also something called a "primitive datatype," and usually just the word "primitive" is used.There are eight primitives to learn, and most of six of the eight) are just numeric. So we've got byte, short, int, and long. And those are integer values. They're whole numbers. We have floats in doubles. Those are decimal or real numbers. We've got a question, which is just true or false. And then we've got a char, which is a single character. Now I know that saying the word "charis" is going to drive some of you crazy. This is one of those words in software where there's no agreement on how it should be pronounced. A lot of people will say it should be pronounced care because it's short for character. and I tend to agree with that. But so many people that I work with have saidchar, and I've been programming for way too long. I'm just going to continue to say Char. That's what I got used to. That's what I'm going to say. Now. Besides that, everything else in Java that we're going to work with is an object. So we'll talk a little bit more about primitives in an upcoming section. But one little thing that I want to mention in terms of the difference between a primitive and an object is that a primitive is really just a single value. That's all it is. As a result, we discuss objects with state and behavior. And remember, some objects might just have state; some objects might just have behavior; but they have the potential to have both. And with the state, it can be any number of pieces of state. With a primitive, there's just one piece of state and absolutely no behavior; it just has a value. The other thing that's different between all of these different types is that, for example, a float and a double are both decimal numbers. So what's the difference? The difference is really in the size. So a float has 32 bits and a double has 64 bits. and we'll go over those details a little bit later. The other thing is that the JVM does treat primitives differently. As a result, one of the reasons these were added to the Java programming language was that they could be treated more efficiently than objects. Now let's go back to objects. So Java is an OO programming language. We're going to be using a lot of objects. The first thing to learn is how we instantiate a Java object. So here are a couple of examples. three different examples of instantiating an object. I'll go into the syntax a little bit more deeply in a minute, but we have three examples. We've got a String object that we're instantiating first. We've got a Customer object that we're reinstantiating second, and then a Circle object. And whenever you instantiate an object, we're probably going to use it more than once. So what you're seeing here is that we're assigning that object to some kind of variable. as a reminder. A variable is just something to hold a piece of information. And so this piece of information is a reference. It's going to create the object, and that reference is going to refer to the object that was created. In other words, string S equals a new string. We're creating the string object on the right side of the equals, and then we're assigning it to a variable called s on the left side of the equals. Let's start with the left side, looking at this example of a customer. So the first thing that we have is the reference type. Whenever we're going to declare a variable in Java, we have to specify what its type is. It might be an object type, it might be a primitive type, but we have to declare what it is. So in this case, we're saying that this variable C is of type Customer, and Java is a strongly typed language, which means that when we compile our program, it's going to run some checks and try to make sure that, in fact, what we're assigning to see is in fact a Customer object. Now there are a couple of instances where that can get muddied a bit and we might not find out about the problem until runtime, but we'll talk about those scenarios a little bit later. So the first thing, on the left side, we're creating a reference variable. And what will happen is I'll use that variable in the future to send messages to the object to say, "Hey, I need you to do something" or "I need to find out some information about your current state." On the right side of the equals, we have a special keyword called "new" that says that we're creating an instance of a type, an object, a new object. So what's the type of object that we're creating? In this case, it's a customer. Now notice that there are parentheses on the right side of that type. We'll talk about why later—very soon, actually. But for now, just know that we need to call a method when we're going to be creating a new object,we're going to have to call a method.and it's a special kind of method. It's known as a constructor. And so that's what we're doing here. This is how we call a constructor. To construct the object, the very last thing to notice is that there is a semicolon, and all statements in Java must end with a semicolon. Now how about primitives? Primitives don't have states; they don't have behavior. So we don't need to create a new object from some sort of blueprint. What we just need to do is assign the value. And so that's what we're doing here. We've got three examples. I've got my data typed in. The first example is int. My variable is I, and I'm assigning it the value of five. There's one for the char where I'm assigning it a value of A, and I've got a double called pi that I'm assigning 3.15. So that's all you have to do for primitives. You just declare the variable, and then you assign the value. Now, when we create an object, and I already use this term, it's called instantiation. So let's try that word again. It's called instantiation. And so we typically say that we're instantiating an object. Another thing that's interesting is to realise when an object is actually being created. The thing to note is that when you create a reference variable, that's not when we're creating the object. It's only defining the reference variable so that we can send a message to the object later on in the program. The object is actually created when we say the keyword "new." So here's an example wherewe've created circle C semicolon. That is a legal Java statement. All that we've done is say that we're creating a variable called C and its typical circle. At that point we have a referencevariable, but no object exists yet. The object does not exist until we say C equals a new circle. And it's the right side of that equal sign that's creating the object, not the left side. So we say "new circle," which creates the circle object, and then it assigns it to the variable C. Now notice that I didn't repeat the reference typed in that second line, and that's very important. In fact, if I had said circle C equals new circle, I would have gotten a compile error because it would have said see, it already exists; you've already told me what the type is. You can't just change C here with a new reference type, and actually there is a way to do it, but we'll get to that later. Right now, just note that you can't just say "circle again" because that would redefine the variable as a new variable. And that's not legal in Java; it's already been set. And so we just assign a new circle to C. Now why is it important to understand the single reference? Well, we can keep using a single reference over and over again as long as it changes to objects of the same type. So let's start with a customer. Here I've got a new customer that I'm assigning to a customer variable. The variable is called C. And notice that inside the parentheses now we're passing in some information. If you think back to when we were talking about main and I gave you that 500-foot walkthrough, I said one of the things that can happen with main is that we can accept parameters; we can accept an array of strings. And we weren't dealing with the array string at that time. But we are defining in that method that yes, we take an array of strings. So what's happening here is that this customer function Object() { [native code] } is accepting a parameter. Apparently, it's accepting a string parameter. Now, you don't get to just make this up when you're calling a function Object() { [native code] } or instantiating an object. What you have to do is look at the actual class and say, "What constructors do you have?" Now that's something we'll talk about later. But for now, just pretend that the customerclass, which is what we're calling here, has a function Object() { [native code] } that says "I take a string." And so that's what we're passing into. So now what I'm going to do is take that same C variable and assign it to a new customer, and I'm going to do it again and again and so on. and that's perfectly legal. But what's going to happen is that every time I point C to a new customer, Cis no longer points to the old customer. And I really shouldn't use the termpointing even though it's fairly correct. It's not precise. The precise term would be "referencing": we're not really pointing to the object, we're referencing the object. There has to be a lookup of where that object exists in memory. But when you hear me use "referencing" or "pointing," I mean it in the same way that it's referring to a customer object. So in that second, third, and fourth line, every time C is assigned to refer to a new customer, it's no longer referring to the old customer. And what will happen in Java is that we've got something called a garbage collector, and it's just going to run periodically. We really can't force it to run. The best thing we can even do is give it a hint. Hey, it would be really cool if you thought about running right now, and it may or may not happen. We'll talk about garbage collectors a little bit later, but in general, it's just going to go and run on its own. And it's going to look at all the objects that exist and say, Is anyone referring to this object? And if no one is referring to the object, then it's able to be destroyed. It's able to be collected. And so destroying objects is actually a good thing. We want to do that because we're getting rid of the objects that are no longer needed and regaining access to the memory that they were taking. So we'll talk again about garbage collection, destruction, and cleanup of objects a little bit later.

4. Stack & Heap

One of the key concepts that you're going to have to master in order to become a very proficient Java developer is how our data is being organised in memory. If we don't understand how the data is being organised in memory, we'll try to act on the information. When it's not available, we'll keep stuff around for too long, and so on. So in order to understand how memory is managed in Java, we can deal with two concepts. One is called the stack, and the other is called the heap. And this is how memory is organized. Now, the Heap is a large portion of memory, and it's where all the objects are going to live. And the stack is a more short-term piece of memory where we have reference variables and so on. As we continue on with different lectures and we look at code, we'll occasionally come back to the Stack and Heap to see how all of our code is organized. So the stack is a list of references that are defined within a given block of code. So we refer to this as scope. And scope simply means: when is this available, and who can see it? Who is it available to? And when does it go away? That's the idea of scope. So one of the ways that we can recognise scope when we're looking at code is just by looking at curly braces. Because the curly braces are going to define ownership. We refer to that as a code block. And so that gives us a sense of scope—when something will come into existence, who can see it, and when will it go away? And again, this is something we'll dive into a little bit deeper in a future lecture. As I mentioned, the heap is where all objects are stored in memory. The heap is a larger portion of memory, and really just calling it the heap is a bit of an abstraction. There are different areas of the heap for specific purposes, but just dealing with sort of a general idea of objects living in this space is good enough for what we need to learn. Now, the references in the stack, whenever we create a reference variable, can point to objects in the heap, and some references will point to the very same object. So here's just a very simple stack and heap example. If you see our code, we've got customer C, which equals a new customer. And we know that what we're doing is creating a customer object on the right side, and that object gets put into the heap, and then we assign a reference to that object. That's the arrow that you're seeing down below, and we assign that to a variable called C on the stack. So we'll dive deeper into this concept of stacking heat, but we want to just set a nice foundation for the terms at this point.

5. Using Objects

Now that we've seen how we can create an object, let's look at how we can use the object. And using an object really means sending it messages to do things. So objects contain state and behavior. And when we talk about behavior, we have a special name for that. In Java, the term is method. So all of our behaviour in Java is put together in a method. And remember that a method is really just a code block. It contains one or more statements that we can call or invoke. The terms "call" and "invoke" are the same thing. And once it's called, it's able to then execute all of those statements. It's able to provide the behaviour that we need. So if you've used other programming languages, you've probably run into the same concept. They have different names, procedures, functions, and subroutines. These are all different names for more or less the same thing. Now I say more or less because some people argue—well, there's a difference between a function and a method—and they'll go through and break down the differences. But for our purposes at a high level, when we're referring to behaviour that's executed through code, we're more or less talking about the same thing. So how do we invoke behavior? And what we do in object-oriented programming is use something called the dot notation. We call it the dot notation because you use a dot to send a message. So assume that we created a string. We had some code that said "string s" equals "new string." I can use the dot operator on the variable, on the reference variable, to send a message to that string object to do something. And if I want to pass in some data, I can do that too. And that's what's happening here. So there's some sort of reference variable called S, and we are sending a message to it to say, Hey, I want you to do something for me. I want you to run your substring method. And so we use the dot, and then we say the name of the method that we're calling. And then we've got parentheses there. And the parentheses have two numbers, four, comma, ten. So remember that a method can accept parameters. And then at runtime, when we actually call the method, what we're doing is passing in arguments. So if we were to look at the definition of the substring method, we'd see that it takes two INTs. And so at runtime, we're passing in two int arguments. We're passing in four and ten. And you may be wondering, well, okay, what does that do? Well, we could go to the Java API documentation and we'd see that substring is going to create a brand-new string, and it's going to create it out of the old string that S is referring to. The number four is saying, what character should it start at? And number ten is saying, up to what character should it include? So that's just cutting a string and some text out of an existing string and making a new one. So that's how we invoke a method. We use the dot operator, and methods can return things. You remember that we saw a method that returns void public static, void main, and void, which means we're not returning anything. Well, if we were to look at the actual implementation of the substring method, we'd see that it's going to return to us a new string, the one that it just made. and so we can take what it returns after it's done executing all of its statements. We can take what's returned and now assign that to another variable if we'd like. So here we're creating a variable called sub. We're taking the return value of that substring and assigning it to sub. So now we've got two variables. We've got S, and we've got Sub. And we can keep sending messages to both objects. Now what if a method doesn't take any parameters? Well, in that case, you'd still have the parentheses. You just wouldn't have anything inside there. We wouldn't have four commas; we would just have the empty parentheses. So another way to think of the dot is to call the method on the object that this reference is pointing to, and you can see it right here on our stack. We've got the S variable, and it is referring to the string object. In this case, the string says "Hello world." And strings have lots of different methods—substring, trim, carat, and so on. and we'd be able to invoke those methods. We were able to call the methods just by using the dot operator. And I really like the analogy of calling because a little bit later we're going to talk about access modifiers. And understanding that concept makes a lot more sense when we think of it as picking up the telephone that looks like a bat phone and picking it up, and it instantly dials the object at the other end and connects us through it. And then we say, Hey, we want you to execute substring. And String says, "Well, that's great." Do you have any arguments for me? And we say yes. We do. Here's a four, and here's a ten. And it says thank you, and it does its work. And then it sends back a new string, which we are assigning now to a variable called sub. Let's look at some more examples. So here's that Hello World string that we're creating. So string S equals new string. Hello world. And notice that we've got a few spaces at the end of the string, just adding some white space there. So after we create the object, what we can now do is send it messages. So we've already seen the substring method that we just talked about, and that's going to return. Oworl. You can sort of count that as O-W-O-R-L. If I use my mouse here, we can count to the fourth character, zero. By the way, most things in Javastart have an index of zero. So 01234, there's the O, and we're going to go all the way up to ten. So 5678, 910. So D is the location of ten. Now, if we went to the Java doc and read the details of this, we'd learn that ten is exclusive. It's not going to include the 10th character. It's going to stop right before it. So that method gives us a whiff. And now, sub is pointing to a string called Oworl. Strings also have a method called trim. And what trimming will do is remove all the white space before and after, at the beginning and end of the string. So what it's going to do is create a brand new string just called Hello World without any extra spaces, and it's going to return that. We're grabbing the return value and assigning it to a new variable, "string trimmed." Now, you'll notice that I keep saying that strings create a new string. We'll refer to that again a little bit later. But something to remember very carefully about strings is that you can't really change a string. You can only make a new string out of some old string. You can base it on an old string. But strings are what we call immutable; we can't change them. and we'll talk about that a little bit later. Here's another example. We've got two uppercase words sending that message using the dot operator. It's creating a brand new string called Hello World, which we're then assigning to the upper variable. Finally, consider the automobile. So here we're trying to get a single character at index two, and that's going to return the first L. So at the beginning of this section, I reiterated that objects are bundles made out of state and behavior. We know that the behaviour is referred to as a method in Java, but objects aren't limited to just having behavior, although some objects might be. You may have an object that only has behaviors. They are less common, but they do exist. Objects typically also contain data. And so this data is referred to as an instance variable. And actually, there are a bunch of different places where we can store data. An instance variable is the most common space for storing data for an object. We'll talk about others a little bit later. Now, instance variables have a lot of different names, and people will use these sort of haphazardly. They'll say instance variables; they'll say attributes; properties; fields; member variables; and so on. State, of course, and a way to see how we actually use an instance variable can be demonstrated here with a point object. So what is the point? Now just think about it without software for a second. A "point" is an X and Y value on a graph. So what would be the state of the object? Well, it would be an x value and a y value. So how would that look in code? Here is our code where we are going to use a point object. The first thing we're going to have to do is instantiate an object. So we create a reference variable called "point" my point). So the name of the variable is my point. And we've said that it has to refer to a point object, and then on the right side, we're saying "new point," and so that will create our point object. Now if I want to change the state, I'm still going to use that dot operator that we used before. So in MyPoint x and MyPoint y, the difference is that there are no parentheses. That's your biggest clue as to whether you're referring to a piece of behaviour or a piece of state. If it has parentheses, we're referring to behavior. If it doesn't, we're referring to state. So what's happening here is that we are taking the literal value of two and assigning it to the x instance variable. On my point, we're taking the value five and assigning it to my point's Y variable. And so the question is, when I send a message toan object with state, am I trying to read the valueor am I trying to write over the value? And you can tell whether it's on the left or right side of an equal. If the call, such as MyPoint x, is on the left side of an equals, then that means we're not reading the value. We're going to assign it, in fact, with the equals sign, which is the assignment operator. You always read it from the right side to the left. So we're taking the value of two, and then we're going to assign it to MyPoint x. We're taking the value of five and we're going to assign it to my point value of Y. And if my point out x was on the right side, it would be a read if it was on the right side of the equals sign. So all the assignment is going to happen toward the left side of that equals sign. So here's my my point object. It's pointing to an object on the heap, and at the end of this code, x is now set to two and y is now set to five. So a point is an object. So it probably has more than just data. It's probably going to have methods as well. And like I said, you can tell if you're referring to a field or calling a method just by seeing whether or not there are parentheses there after the dot fields and instance variables. State does not use parentheses. And when we have methods, they will always use parentheses even if no arguments are passed in. So let's look at some examples. And we don't really need to know what these are doing. We're really just looking at the syntax at this point. So reading from right to left, I see we're calling agents' ID. So we've got some kind of reference variable called Agent, and we're sending in a message and saying, "I want your value. Tell me what ID is." And it says, "Well, the ID at this moment in time is," and it gives us some value. And then what we're doing is we're assigning it to this variable called "int badge." So ID must be returning to us an integer, and we are assigning it to a new variable called badge. Here, we're taking what's called a string literal. So we're just writing some text and quotes, and we are taking Marcus and assigning it to the name variable that's located in the Agent object. Now, the first two that we had were fields; they were instance variables, and we can tell because we are using the dot operator and there are no parentheses. Now here we've got Agents Spy, and we do see parentheses. So that tells us that we're calling a method. So we call spy. And in this case, it's returning some sort of object whose type is called data, and we're assigning that to a variable called secret. Here's another method known as Abort Mission. I know it's a method because there are parentheses—and this time we're passing in a parameter. Spy didn't have any parameters that were specified. So with the Abort Mission, I'm taking the argument as false and passing that in. Now, notice we're not assigning anything to a new instance variable or a new variable, and Data Secret equals Agent Spy. There we were taking the return value and assigning it to a variable. We're not doing that with this one. So, does this mean that an aborted mission will return void? that it's not returning anything? and the answer is maybe. But even if a method says that it's going to return something to us, if we're not interested in it, we can drop it. And so that may be what's happening here; we were just not interested in whatever is returning. We wanted it to execute its code and do its thing, but we didn't really care about what it was returning to us. And the same thing with the Agent Show Badge: we really can't tell here if there is no return type; if there's nothing being returned, we're just saying we don't care. And, by the way, if it doesn't return anything, make sure you aren't attempting to assign, in other words, Agent Spy that I have right here. If Agent Spy says that it returns void, which means it doesn't return anything, then I can't have that equal sign and that data secret; I have to get rid of it because it won't even compile it'll.Say, "I'm sorry, agent spy doesn't return anything." You can't try to assign "nothing" to Data Secret. So going back to agents, show your badge. This is just another method that we're describing. It doesn't take any arguments, and so we still use the parentheses to be able to say, "You're a method, and I want you to execute your code."

Go to testing centre with ease on our mind when you use Oracle 1z0-808 vce exam dumps, practice test questions and answers. Oracle 1z0-808 Java SE 8 Programmer certification practice test questions and answers, study guide, exam dumps and video training course in vce format to help you study with ease. Prepare with confidence and study using Oracle 1z0-808 exam dumps & practice test questions and answers vce from ExamCollection.