bowling

Mohammed Moussa Soliman

Star Wars: The Rise of Skywalker (aka Star Wars IX): A somewhat messy, but entertaining movie, that does its best to wrap up the trilogy of movies that started in The Force Awakens (Star Wars VII), as well as the trilogy of trilogies that make up the Star Wars canon.

The resistance is pursued by the first order, Rey is entangled with Kylo Ren, Palpatine has returned and is about to launch a ridiculously huge army (this really makes no sense), and Poe and Finn and Rey have to defeat them all. And there are light-sabers.

The movie has many things going for it, including decent acting, good characters and a few good character arcs, some good action sequences, some funny and some touching moments, great visuals, sound, and music, and a reasonable wrap-up of some parts of the story.

It also has many problems, of two main types: those that are the fault of Rian Johnson and the terrible mess he left us with Star Wars VIII: The Last Jedi, and those that are J. J. Adams fault, essentially the same problems that we saw in his Star Wars VII: The Force Awakens.

People criticize this film for the sins of the trilogy: the trilogy has no cohesive story arc. This is because VIII deliberately destroyed dozens of story arcs that were started in VII, and, even worse, destroyed many of the essential elements and ideas of the entire SW universe: good isn't good, bad isn't bad, heroes aren't heroes, the Force is universal, there is no resistance, etc, etc. To write IX, you either had to ignore much of what happened in VII (and pretty much the rest of Star Wars) or much of what happened in VIII.

IX chose the latter by awkwardly retconning lines and characters from VIII. This was only partially successful. Snope was set up in VII and made meaningless in VIII; VIII desperately tried to remove the concept of overarching villains from the series, which was terrible. So IX tried to shoehorn in the old emperor Palpatine as pulling the strings behind Snope, but it did so quite badly, without any surprise reveal and in without any real threat or dramatic presence. In VII, Rey had some kind of important background and story; VIII tried to destroy any meaning to her background and story. So IX tried to subvert what happened in VIII, but it did so quite badly. She has a story again, but it didn't make any sense, didn't give us any real dramatic interest, and left dozens of important hints from VII unanswered. And so on.

As for IX on its own, maybe Adams was hobbled from making any kind of sensible story by trying to fit in VIII and also wrap up a trilogy of trilogies. While VII had a pretty decent (if predictable) story, the story in IX is sometimes insane. The "Goonies-like" treasure map that they find, and how they find it, is unbelievable nonsense. The new force powers are cool in abstract, but don't fit the story or the trilogy. Characters appear for fan service, or don't appear (or don't appear much) for no sensible reasons. The end threat scenes are Marvel-level and just too unbelievable to take seriously. The dialog is forgettable; the only memorable line is "A Jedi's weapon deserves more respect", and it is memorable because it is a metashot at Rian Johnson's disrespect of the lightsaber at the beginning of VIII.

Still, there are many good scenes, and each scene, other than the ones with Palpatine and the ridiculous end battle, are entertaining and well-shot. It was nice to end the movie with callbacks to both of the original trilogies. The movie doesn't add up to the sum of its scenes; the story just isn't any good. Lucas may have hired some so-so actors and written some clunky dialog, but I always loved the stories (even the prelude trilogy). It's almost possible to forget all this while watching this movie; almost, but not quite.

Emma.: Like the recent attempts at the Great Gatsby and Anna Karenina, this movie is unfortunately directed by someone who is in love with process and sets, but has no interest in actors other than to use them as props for their photography. It's no surprise to me that the director is most well known for her photography.

The sets and actors fly around the landscapes, and the camera takes notice of all of the scenery and settings, but little of the characters. The movie would still have been a little better than the above two mentioned movies (which were not watchable). Unfortunately, the director or screenwriter's second major mistake destroys the movie.

Emma is supposed to be sympathetic but flawed. Book Emma as a heroine is full of good intentions and good Christian works, beautiful manners and kindness to everyone, though served poorly by her self-righteousness and blinded by lack of insight. That's not what we get here. In this movie, Emma is loathsome, snobbish, and entirely unsympathetic. There is no chemistry between her and Mr. Knightly, and no apparent reason for him to fall in love with her. Maybe that is the fault of the actors, maybe of the directors; it's hard to say.

I guess Emma learns something by the end, as she must, but she doesn't retain much of it, doesn't change her character, and doesn't become any more sympathetic. So, if you remove the pretty shots and sets, the story is about an obnoxious, unsympathetic snob who makes a few mistakes and realizes one or two of them by the end, is sorry and fixes one of them, but otherwise doesn't change, and then a handsome rich man marries her. Mmmm ... okay? That's not a very interesting story.

Honestly, stick with the 1995 version with Gwyneth Paltrow, which was silly but faithful, at least.

Knives Out: A gem of a movie, this was unexpected fun. Lots of great actors in an old-fashioned, southern whodunit. Daniel Craig, Ana de Armas, and the rest of the cast are exciting and lovely, and the script is tight, tense, and funny, with multiple flashbacks from alternate points of view. This movie is also by Rian Johnson, who redeems himself in my mind after having ruined the Star Wars franchise.

In a family house, a grandfather has a questionable relationship with all of his children, their spouses, and their kids, and somehow he ends up dead. Was it one of them? Or the nurse? Or suicide? Who will inherit his fortune? Enter private detective Benoit Blanc (Craig) to figure it out.

Captivating. Worth watching on the small screen.

Joker: This controversial origin story was actually quite good. Joaquin Phoenix does nearly as good a job as the Joker as Heath Ledger did in The Dark Knight. The sound and visuals were fantastic.

Arthur Fleck is a clown who is poor, who has a sick mother and no father, and who, every day, gets beat up and the sad end of the stick in Metropolis, which is NYC at its most disgusting and ready to boil over. He also has a disease that makes him laugh inappropriately, which is, as you may guess, likely to get you hated, ridiculed, and beaten up on occasion. He is also a failed comedian who loves a Johnny Carson type (played by Robert De Niro). One day while in clown makeup he shoots three entitled white dudes, partially in self-defense but mostly because he has nothing left to lose, and he (maybe?) inadvertently starts a revolution with himself as the cult leader. In the end, some or all of what happened is revealed to be a fiction of his imagination, so it's not clear how much of it to believe.

Although I admit that the movie was well made, I still didn't like it too much. It's not that, as some critics said, it excuses violence by the downtrodden or entitled white men; the movie makes it pretty clear that this guy is an exception who is disturbed, and that some or all of what happens might be in his deranged mind. It's more that the movie doesn't say much more than that. He's a deranged guy who suffers and ends up killing people. Okay, that's all? I wished it would have given us something more. Dark Knight had The Joker, and it gave us much more to think about and much more story. This gave us very little. It seems like an homage to Taxi Driver and King of Comedy, both of which also gave us a lot more in the way of character, story, and moral complexity.

Still, amazing performances, some great cinematography and directing, and fascinating in a "can't look away from the car crash" kind of way.

Little Women (2019): Gillian Armstrong's 1994 version of this book, starring Winona Ryder, Kirsten Dunst, Claire Danes, Susan Sarandon and others was a sweet and innocent classic, faithful to the book: it was moderately feminist, slipped over a lot of the transcendentalist morals, and cut out much of the last half of the book.

Greta Gerwig's new version, starring Saoirse Ronan, Emma Watson, Florence Pugh, Laura Dern and others, is quite nice, strongly feminist, and very different. It adds scenes hinted at in the book, removes others, and thoroughly changes the character of Amy. The book and the 1994 movie are Jo's story, with input from the others adding to, and contrasting with, Jo's sentiments. This movie is equally Amy's movie (played by Florence Pugh), and she tromps, scowls, and grabs at opportunities and the scenes whenever she appears. We are now far from the transcendentalist roots that informed the source material.

But the story is still the story, which needs no explanation here. It is split into flashbacks, since we start with Jo trying to publish her book. Gerwig as a writer and actress starred in movies with excessive quirkiness that sometimes detracted from the stories. As director, in Lady Bird and this movie, that hand is present with some excessively quick dialog and quirky characters, but it is lighter, allowing the actors and story to properly flow and shine.

Mohammed Moussa Soliman

This part of the city has been sealed. Whatever happened here was enough for the government to call it quits on anyone and everyone that survived whatever created the CyMS. But we still live. We still have to live. That is why you are going out after supplies. Besides the CyMS, others are going to be after those supplies, so keep your eyes wide and keep it quiet.

-----

Omicron Protocol is a scenario based strategy combat game. There are 2 sides competing to accomplish the objective of the scenario. Although they are not facing off against each other, they are competing for the same objective which means the opposing force has to be dealt with.

I played a prototype of Omicron Protocol as Brendan Kendrick and Bernie Lin of Dead Alive Games were preparing their Kickstarter campaign in 2019.

When I read the backstory for Omicron Protocol, the name created more questions of what happened in our future world to require quarantining a city and leaving the residents to fend for themselves. Omicron is the fifteenth letter of the Greek alphabet. A protocol is an official response of procedure with how to deal with a situation. Usually a diplomatic response from a government, but also used in business dealings. Not only is Omicron the fifteenth letter of the Greek alphabet, in mathematics it is used as the symbol for growth rates, and in other instances it is tied with Omega, the end. This leads the imagination to believe we are far beyond "Plan A" for containment.

We played Omicron Protocolwith three players. Two of us controlled one faction against the other player's faction. The offset didn't put the game out of balance from the point of the pieces on the mat. It is also hard to say if the two-headed team was better than the one. There was an advantage for the two players being able to talk over their strategy. At the same time, the individual player was able to coordinate their actions easier.

There are starter scenarios for learning movement and abilities. The system is straight forward and we found it easy to understand. The number of options available and deciding which was the best path forward to complete the objective was where the difficulty was. That was where the individual had some advantage by handling the entire team instead of just part of it. The multi-player team was able to focus on the character abilities more, which required more conversation and bartering between the players.

Omicron Protocol contains multiple levels of strategy. It started in the pre-game setup when each faction chose the characters to go on the mission. The introductory scenarios have preselected characters; however, in the full game scenarios the player(s) have control. Individual character abilities and how they can interact are important considerations along with how those abilities pair up with the faction's special abilities.

While racing the other faction to achieve the goal you also need to deal with the Cyber-Memetic Sociopaths (CyMS). CyMS (pronounced "sims") are zombies attracted by sound. Any time characters take actions causing noise, there is a chance the CyMS in the area will come to feed. Noise, therefor, is also part of the strategy employed when dealing with the opposing faction.

Playing the Game

The main goal is to complete the objective. Omicron Protocol is not an arena combat (but you could create such a scenario). The backstory is one where people are working to survive the situation they have found themselves in and working to get out of the quarantined city.

In the prototype there were only two factions: the Survivalists and the Peacemakers. It was noted additional factions are planned for. So when you play you will need to decide the faction you are going to play based on their special faction abilities.

Decide on the scenario. Each scenario has specific rules for that game session. They define the objective and the starting layout of the scene.

Players now decide which characters from their faction are going on the mission. The characters are revealed and added to the game board in the scenario designated starting areas.

As the scenario progresses more CyMS enter the playing field. This increases in pressure on completing the objective and the risks players have to take.

Turns alternate between the factions as they take turns with a character. The CyMS take action after each character turn when the conditions are right.

A faction starts their turn with a set number of action points. Those points are divided by the player(s) for all of the characters they have in play—the player needs to balance the use of their action points to utilize all of their characters. This led to some interesting conversations with the team of two players controlling one faction.

Combat uses a dice pool. A number of dice are rolled and those equal to or above the target score hits. The hits are used for several different actions by the character. They can deal damage, trigger abilities, or if the dice are not spent (including those that don't score) they can be used for improving future rolls.

Overall

We enjoyed Omicron Protocolwith its unique presentation and options.

Omicron Protocol has a strong backstory. The backstory along with the additional information in the rulebook allowed us to immerse ourselves into the game scenario. Links to additional stories set in Omicron Protocol were also given.

Players are allowed to develop their own scenarios as they learn the game. It was mentioned in the information that Dead Alive Games will be making more scenarios and working with players to share scenarios developed by the broader community of players. This could also include solitaire and larger group scenarios. I believe the larger group scenarios would be harder and longer to play due to player interaction.

Omicron Protocol was developed by Brendan Kendrick, Bernie Lin and published be Dead Alive Games. It is designed for 2–4 players of ages 13+, and the scenarios are designed to last 60–120 minutes.

-----

Well done on securing the medical supplies. They will go a long ways for those who are still with us. Rest up. We have skimmed some information the government may not have given up completely on us, they're going to be making a food drop tomorrow. We just need to figure out where and at what time.

I'm working at keeping my material free of subscription charges by supplementing costs by being an Amazon Associate and having advertising appear. I earn a fee when people make purchases of qualified products from Amazon when they enter the site from a link on Guild Master Gaming and when people click on an ad. If you do either, thank you.

If you have a comment, suggestion, or critique please leave a comment here or send an email to guildmastergaming@gmail.com.

I have articles being published by others and you can find most of them on Guild Master Gaming on Facebookand Twitter(@GuildMstrGmng).

Mohammed Moussa Soliman

See all of my movie reviews.

Crazy Rich Asians: This was surprisingly good, considering the trailers. Not great, but good. it's about an American Chinese economics professor who goes to meet her boyfriend's Chinese family in Singapore. She soon discovers that his family is very, very rich, and that his mother doesn't think an American Chinese woman belongs in the family.

From the trailer, I expected this to be stupid, marketed only on the basis of having an all-Asian cast of comedians. Thankfully, this was not the case. I guess because a) trailers are often put together by idiots, and b) it came from a rather decent novel, which I have not yet read.

Like Me Before You, I am now interested in reading the novel. This movie is a little Jane Austeny - nowhere on that caliber - but interesting, with characters and confrontations that seem to have something to say. It works, I feel, almost in spite of itself. It looks like the director/screenwriter tried to cut it down to something resembling a Me Before You, but couldn't quite cut everything.

There are throwaway characters who I suspect have far more dept and character in the book; here they are stand-up comics doing two or three minutes of material. And there is a plot so tired and retread as to make any tension non-existent. But ... but the main characters have something to them, and they do a few things that make you feel that the plot is more than just something on which to hang comedy. I suspect that the book highlights these parts and makes them more prominent.

It is well acted, other than some of the comedy bits which seem out of place. There are scenes of sumptuous foods and wealth, as one would expect from the title. And a few too many party scenes. But fun and - nearly - satisfying. As for the fact that it had an all-Asian cast, well, duh. Like Black Panther, this doesn't prove anything. Any idiot already knew that an ethnic cast could lead a movie that contains ethnic story overtones and interactions. Any idiot should also know that the same people could be main characters in any, generic movie, but apparently there are a lot of people who are not yet as smart as just any idiots.

Destination Wedding: This was a surprisingly great movie. Lindsay (Winona Ryder) and Frank (Keanu Reeves) are the ex-fiance and the estranged brother of a guy getting married. They don't want to be there, don't like the groom, don't like the bride, or the place, or the airline, or the food, or each other, or themselves. And so they snark and insult their way through 90 minutes of screen-time. Literally no one else in the movie talks: it's just Lindsay and Frank. They are both so vile and bitter that even the usual rom-com tropes are subverted: they know that they should end up together, but they refuse to allow it to happen.

This movie follows in the tradition of the Before series of movies, as well as other heavy dialog movies. It's not quite as good as a Before movie, which had a more wide-ranging series of discussions and characters who were a little (a lot) less jaded. The movie is smart with snarky dialog and has some interesting things to say about relationships, self-worth, decency, obligation, and so forth. It's often very funny. I had a blast and really want to see it again.

Yes, they are miserable. Unlike the real misery that repelled me in movies like Logan and Three Billboards, these guys are funny-miserable, so it's fun to watch.

I Feel Pretty: This movie has a great message, or it pretends to, anyway: don't let what you look like rob you of your confidence. And Amy Schumer has certainly been known to be funny ... sometimes, and in small doses. This one is a disaster.

The movie has no artistry: Amy's character is supposed to feel bad about her looks, so she writes ten scenes in a row with her looking in a mirror with disappointment and people insulting her looks in various ways. It's so straightforward and artless that it is painful to watch. Compare this to the exact same message that Anne Hathaway conveys in The Devil Wears Prada and you see what I mean: Anne's lack of self-worth derives from the story around it and the occasional barbs thrown at her in passing, not ten flat scenes of "you're ugly". And let's not forget that Amy is not unattractive; she is a plus size, but she is not a flat blob and she is also perky and white with good skin. So the premise is a stretch.

Amy wakes up after a head injury believing that she is now beautiful (although her body hasn't changed, and no one else knows what she is talking about), and with her new head injury she confidently strides her way into the job and relationship she wants, while everyone else looks on in a) disbelief, b) with amusement, or c) with respect at her confidence based on nothing outwardly visible.

Her head injury also, apparently, causes her to become completely social unaware of what everyone else thinks, says, or does, causes her to steamroll over every conversation without listening to anyone, causes her to be cruel to everyone else, and somehow causes everyone else to respect her, despite the fact that she is still a complete klutz and idiot. One scene of this is tolerable; the same scene of her talking over people and insulting them, over and over and over and over and over is wearying, and eventually very very unfunny.

What's worse is that the entire point of the movie is that what's inside counts, not what's outside, but she ends up working for and being spokesman for a beauty company, which defeats the entire damn point. Crassness is one thing, artless is another. I really tried, but I couldn't tolerate more than half of the movie.

The Wife: A decent but not not great movie with great acting and an unambitious and uncomplicated fictional plot. Glenn Close and Jonathan Pryce star as Joan and Joe Castleman. They, their son, and a nosy, persistent journalist travel to Sweden so that Joe can get the Nobel prize for literature, The son is behaving like a spoiled teenager (he is supposed to be in his thirties) and the journalist is writing a book about Joe and suggesting some possible problems with his past.

It doesn't descend into something deep, dark, and criminal, like an action thriller. It's just a question of authorship, validity, and respect. This movie is reminiscent of the far superior Big Eyes, a true story that made it quite clear early on that a supposed genius was passing his wife's art off as his own. This movie, entirely fiction, gives us the revelation further into the movie, and handles it badly. The movie doesn't have anything new or interesting to say and also doesn't maintain much tension, other than who will get mad at whom, when, and how much. It is an acting exercise, which is a waste of time, since neither Close nor Pryce need to prove how well they can act.

Admittedly, if Big Eyes didn't exist, I might give this more of a break. As it is, I can't recommend it, but lovers of the actors or of acting scenes will enjoy it. It's really not all that bad. My particular non-enjoyment comes from the son, who is just too miserable throughout the movie, and the odious behavior of one of the other main characters, which drove me to distraction.

Won't You Be My Neighbor: Growing up I didn't like Mr. Rogers' Neighborhood too much, since it was slow, the production was rather low, and puppets on television didn't excite me. As an adult, I have watched videos of Fred Rogers, including his speech defending public television and some of his great moments (such as telling a room full of celebrities to think about, in total silence, who got them to where they are today, and so forth). These videos move me. I have nothing but the greatest respect and admiration for the man. Nevertheless, I'm sure there were many others like me who could not connect to the messages he tried to convey in his TV series, for the reasons that I mentioned.

This biopic movie covers many major stories and facts about him and his philosophy, with only a small amount of material not related to his TV program. I doubt that anyone who never saw the TV show will be interested in it. It is a paean to a simple, slow goodness that seems to be fading away ... that I suspect will always seem to be fading away. There will always be a few great, lovely people with simple messages who lead wholesome lives, even while most of us are consumed by the latest glitz, glamour, gossip, guns, or sensationalist brawls that pass for entertainment or debate. I think it is great to be reminded about better values, at least once in a while. Of course, if we go right back to the guns and brawls, it doesn't come to much.

As a movie, it was okay. It is riveting if you find his personality riveting. Not much, otherwise.

Mohammed Moussa Soliman

This year we travelled to a (not so) sunny San Francisco on Epic Games' invitation to show Oceanhorn 2 at the Unreal Engine venue at GDC 18. What an amazing opportunity! We prepared a great demo to show at the expo, so if you're an Oceanhorn fan, make sure to drop by and play the latest build of our game. You will also meet us, the developers, and have a chat!

Look at that! Our latest demo takes you to the Great Jungle of Pirta, where the Owru nation is divided by an old grudge. Will our heroes be able to unite the owrus and get them to join the fight against Mesmeroth's Dark Army.

Yes, I said heroes! One of the defining features of Oceanhorn 2 is the party members, who will be on your side through the adventure. Trin, the granddaughter of Arcadia's leader Archimedes and Gen, a mysterious robot wielding an old samurai weapon eki.

The game is still far from being finished, but it will be worth the wait!

Mohammed Moussa Soliman

Crysis 2 Free Download

===============================================

How To Install Crysis 2 without Errors and Problems

===============================================

🔶🔴🔶🔶🔴🔶 DOWNLOAD HERE 🔶🔴🔶🔶🔴🔶

🌹 Please use IDM (Internet Download Manager) to download the files without any error.

=======================================

💘 To Download Latest Movies In 720P & 1080P Visit My Other Site :- https://www.worldfree4utechno.ml/

Crysis 2 Free Download:-

Link 1
Link 2
Link 3
Link 4
Link 5
Link 6
Link 7
Link 8
Link 9
Link 10

=======================================

Please Install "7-zip and WINRAR" to extract the files.

💘 Download Winrar :-

🌹 (32bit PC)
🌹 (64bit PC)

💘 Visual C++ Redistributable 2012 :-

🌹 Download

If your PC has no net framework then, you can

download net framework from here :-

💘 net framework 4.6

🌹 Download

💘 IMPORTANT 💘:-

🌹 ALWAYS DISABLE YOUR ANTIVIRUS BEFORE EXTRACTING THE FILES.

----------------------------------------------

Thank You For Watching My Video.....

We Are Thank Full To You...

And Don't Forget To Subscribe To My Channel...

And Keep Visiting Our Channel, Keep Supporting Our Channel, And Keep Loving Our Channel ...

Thank You So Much................

----------------------------------------------------------------------

THANK YOU SOO MUCH FOR VISITING OUR SITE.

Mohammed Moussa Soliman

The OWASP Foundation would like to thank the OWASP Las Vegas Chapter Volunteers for taking the time out of their busy schedule to give back and volunteer to work the booth at BlackHat 2019. It was great meeting our Las Vegas OWASP members and working with Jorge, Carmi, Dave, and Nancy.
Also, take a moment to thank Global Board Members Martin Knobloch, Owen Pendlebury, and Gary Robinson for also working the booth and speaking with individuals and groups to answer questions on projects and suggestions on the use of our tools to address their work problems.
OWASP can not exist without support from our members. Related links

Mohammed Moussa Soliman

CHAPTER

2 An Overview of Java

As in all other computer languages, the elements of Java do not exist in isolation. Rather, they work together to form the language as a whole. However, this interrelatedness can make it difficult to describe one aspect of Java without involving several others. Often a discussion of one feature implies prior knowledge of another. For this reason, this chapter presents a quick overview of several key features of Java. The material described here will give you a foothold that will allow you to write and understand simple programs. Most of the topics discussed will be examined in greater detail in the remaining chapters of Part I.

Object-Oriented Programming

Object-oriented programming (OOP) is at the core of Java. In fact, all Java programs are to at least some extent object-oriented. OOP is so integral to Java that it is best to understand its basic principles before you begin writing even simple Java programs. Therefore, this chapter begins with a discussion of the theoretical aspects of OOP.

Two Paradigms

All computer programs consist of two elements: code and data. Furthermore, a program can be conceptually organized around its code or around its data. That is, some programs are written around "what is happening" and others are written around "who is being affected." These are the two paradigms that govern how a program is constructed. The first way is called the process-oriented model. This approach characterizes a program as a series of linear steps (that is, code). The process-oriented model can be thought of as code acting on data. Procedural languages such as C employ this model to considerable success. However, as mentioned in Chapter 1, problems with this approach appear as programs grow larger and more complex.

To manage increasing complexity, the second approach, called object-oriented programming, was conceived. Object-oriented programming organizes a program around its data (that is, objects) and a set of well-defined interfaces to that data. An object-oriented program can

be characterized as data controlling access to code. As you will see, by switching the controlling entity to data, you can achieve several organizational benefits.

Abstraction

An essential element of object-oriented programming is abstraction. Humans manage complexity through abstraction. For example, people do not think of a car as a set of tens of thousands of individual parts. They think of it as a well-defined object with its own unique behavior. This abstraction allows people to use a car to drive to the grocery store without being overwhelmed by the complexity of the parts that form the car. They can ignore the details of how the engine, transmission, and braking systems work. Instead, they are free to utilize the object as a whole.

A powerful way to manage abstraction is through the use of hierarchical classifications.

This allows you to layer the semantics of complex systems, breaking them into more manageable pieces. From the outside, the car is a single object. Once inside, you see that the car consists of several subsystems: steering, brakes, sound system, seat belts, heating, cellular phone, and so on. In turn, each of these subsystems is made up of more specialized units. For instance, the sound system consists of a radio, a CD player, and/or a tape player. The point is that you manage the complexity of the car (or any other complex system) through the use of hierarchical abstractions.

Hierarchical abstractions of complex systems can also be applied to computer programs.

The data from a traditional process-oriented program can be transformed by abstraction into its component objects. A sequence of process steps can become a collection of messages between these objects. Thus, each of these objects describes its own unique behavior. You can treat these objects as concrete entities that respond to messages telling them to do something. This is the essence of object-oriented programming.

Object-oriented concepts form the heart of Java just as they form the basis for human understanding. It is important that you understand how these concepts translate into programs. As you will see, object-oriented programming is a powerful and natural paradigm for creating programs that survive the inevitable changes accompanying the life cycle of any major software project, including conception, growth, and aging. For example, once you have well-defined objects and clean, reliable interfaces to those objects, you can gracefully decommission or replace parts of an older system without fear.

The Three OOP Principles

All object-oriented programming languages provide mechanisms that help you implement the object-oriented model. They are encapsulation, inheritance, and polymorphism. Let's take a look at these concepts now.

Encapsulation

Encapsulation is the mechanism that binds together code and the data it manipulates, and keeps both safe from outside interference and misuse. One way to think about encapsulation is as a protective wrapper that prevents the code and data from being arbitrarily accessed by other code defined outside the wrapper. Access to the code and data inside the wrapper is tightly controlled through a well-defined interface. To relate this to the real world, consider the automatic transmission on an automobile. It encapsulates hundreds of bits of information about your engine, such as how much you are accelerating, the pitch of the surface you are on, and the position of the shift lever. You, as the user, have only one method of affecting this complex encapsulation: by moving the gear-shift lever. You can't affect the transmission by using the turn signal or windshield wipers, for example. Thus, the gear-shift lever is a well-defined (indeed, unique) interface to the transmission. Further, what occurs inside the

transmission does not affect objects outside the transmission. For example, shifting gears does not turn on the headlights! Because an automatic transmission is encapsulated, dozens of car manufacturers can implement one in any way they please. However, from the driver's point of view, they all work the same. This same idea can be applied to programming. The power of encapsulated code is that everyone knows how to access it and thus can use it regardless of the implementation details—and without fear of unexpected side effects.

In Java, the basis of encapsulation is the class. Although the class will be examined in great detail later in this book, the following brief discussion will be helpful now. A class defines the structure and behavior (data and code) that will be shared by a set of objects. Each object of a given class contains the structure and behavior defined by the class, as if it were stamped out by a mold in the shape of the class. For this reason, objects are sometimes referred to as instances of a class. Thus, a class is a logical construct; an object has physical reality.

When you create a class, you will specify the code and data that constitute that class.

Collectively, these elements are called members of the class. Specifically, the data defined by the class are referred to as member variables or instance variables. The code that operates on that data is referred to as member methods or just methods. (If you are familiar with C/C++, it may help to know that what a Java programmer calls a method, a C/C++ programmer calls a function.) In properly written Java programs, the methods define how the member variables can be used. This means that the behavior and interface of a class are defined by the methods that operate on its instance data.

Since the purpose of a class is to encapsulate complexity, there are mechanisms for hiding the complexity of the implementation inside the class. Each method or variable in a class may be marked private or public. The public interface of a class represents everything that external users of the class need to know, or may know. The private methods and data can only be accessed by code that is a member of the class. Therefore, any other code that is not a member of the class cannot access a private method or variable. Since the private members of a class may only be accessed by other parts of your program through the class' public methods, you can ensure that no improper actions take place. Of course, this means that the public interface should be carefully designed not to expose too much of the inner workings of a class (see Figure 2-1).

Inheritance

Inheritance is the process by which one object acquires the properties of another object. This is important because it supports the concept of hierarchical classification. As mentioned earlier, most knowledge is made manageable by hierarchical (that is, top-down) classifications. For example, a Golden Retriever is part of the classification dog, which in turn is part of the mammal class, which is under the larger class animal. Without the use of hierarchies, each object would need to define all of its characteristics explicitly. However, by use of inheritance, an object need only define those qualities that make it unique within its class. It can inherit its general attributes from its parent. Thus, it is the inheritance mechanism that makes it possible for one object to be a specific instance of a more general case. Let's take a closer look at this process.

Most people naturally view the world as made up of objects that are related to each other in a hierarchical way, such as animals, mammals, and dogs. If you wanted to describe animals in an abstract way, you would say they have some attributes, such as size, intelligence, and type of skeletal system. Animals also have certain behavioral aspects; they eat, breathe, and sleep. This description of attributes and behavior is the class definition for animals.

Figure 2-1 Encapsulation: public methods can be used to protect private data.

If you wanted to describe a more specific class of animals, such as mammals, they would have more specific attributes, such as type of teeth and mammary glands. This is known as a subclass of animals, where animals are referred to as mammals' superclass.

Since mammals are simply more precisely specified animals, they inherit all of the attributes from animals. A deeply inherited subclass inherits all of the attributes from each of its ancestors in the class hierarchy.

Inheritance interacts with encapsulation as well. If a given class encapsulates some attributes, then any subclass will have the same attributes plus any that it adds as part of its specialization (see Figure 2-2). This is a key concept that lets object-oriented programs grow in complexity linearly rather than geometrically. A new subclass inherits all of the attributes of all of its ancestors. It does not have unpredictable interactions with the majority of the rest of the code in the system.

Figure 2-2 Labrador inherits the encapsulation of all its superclasses.

Polymorphism

Polymorphism (from Greek, meaning "many forms") is a feature that allows one interface to be used for a general class of actions. The specific action is determined by the exact nature of the situation. Consider a stack (which is a last-in, first-out list). You might have a program that requires three types of stacks. One stack is used for integer values, one for floating- point values, and one for characters. The algorithm that implements each stack is the same, even though the data being stored differs. In a non–object-oriented language, you would be required to create three different sets of stack routines, with each set using different names. However, because of polymorphism, in Java you can specify a general set of stack routines that all share the same names.

More generally, the concept of polymorphism is often expressed by the phrase "one interface, multiple methods." This means that it is possible to design a generic interface to a group of related activities. This helps reduce complexity by allowing the same interface to be used to specify a general class of action. It is the compiler's job to select the specific action (that is, method) as it applies to each situation. You, the programmer, do not need to make this selection manually. You need only remember and utilize the general interface.

Extending the dog analogy, a dog's sense of smell is polymorphic. If the dog smells a cat, it will bark and run after it. If the dog smells its food, it will salivate and run to its bowl. The same sense of smell is at work in both situations. The difference is what is being smelled, that is, the type of data being operated upon by the dog's nose! This same general concept can be implemented in Java as it applies to methods within a Java program.

Polymorphism, Encapsulation, and Inheritance Work Together

When properly applied, polymorphism, encapsulation, and inheritance combine to produce a programming environment that supports the development of far more robust and scaleable programs than does the process-oriented model. A well-designed hierarchy of classes is the basis for reusing the code in which you have invested time and effort developing and testing. Encapsulation allows you to migrate your implementations over time without breaking the code that depends on the public interface of your classes. Polymorphism allows you to create clean, sensible, readable, and resilient code.

Of the two real-world examples, the automobile more completely illustrates the power of object-oriented design. Dogs are fun to think about from an inheritance standpoint, but cars are more like programs. All drivers rely on inheritance to drive different types (subclasses) of vehicles. Whether the vehicle is a school bus, a Mercedes sedan, a Porsche, or the family minivan, drivers can all more or less find and operate the steering wheel, the brakes, and the accelerator. After a bit of gear grinding, most people can even manage the difference between a stick shift and an automatic, because they fundamentally understand their common superclass, the transmission.

People interface with encapsulated features on cars all the time. The brake and gas pedals hide an incredible array of complexity with an interface so simple you can operate them with your feet! The implementation of the engine, the style of brakes, and the size of the tires have no effect on how you interface with the class definition of the pedals.

The final attribute, polymorphism, is clearly reflected in the ability of car manufacturers to offer a wide array of options on basically the same vehicle. For example, you can get an antilock braking system or traditional brakes, power or rack-and-pinion steering, and 4-, 6-, or 8-cylinder engines. Either way, you will still press the brake pedal to stop, turn the steering wheel to change direction, and press the accelerator when you want to move. The same interface can be used to control a number of different implementations.

As you can see, it is through the application of encapsulation, inheritance, and polymorphism that the individual parts are transformed into the object known as a car. The same is also true of computer programs. By the application of object-oriented principles, the various parts of a complex program can be brought together to form a cohesive, robust, maintainable whole.

As mentioned at the start of this section, every Java program is object-oriented. Or, put more precisely, every Java program involves encapsulation, inheritance, and polymorphism. Although the short example programs shown in the rest of this chapter and in the next few chapters may not seem to exhibit all of these features, they are nevertheless present. As you

will see, many of the features supplied by Java are part of its built-in class libraries, which do make extensive use of encapsulation, inheritance, and polymorphism.

A First Simple Program

Now that the basic object-oriented underpinning of Java has been discussed, let's look at some actual Java programs. Let's start by compiling and running the short sample program shown here. As you will see, this involves a little more work than you might imagine.

/*

This is a simple Java program. Call this file "Example.java".

*/

class Example {

// Your program begins with a call to main(). public static void main(String args[]) {

System.out.println("This is a simple Java program.");

}

NOTE The descriptions that follow use the standard Java SE 7 Development Kit (JDK 7), which is available from Oracle. If you are using a different Java development environment, then you may need to follow a different procedure for compiling and executing Java programs. In this case, consult your compiler's documentation for details.

Entering the Program

For most computer languages, the name of the file that holds the source code to a program is immaterial. However, this is not the case with Java. The first thing that you must learn about Java is that the name you give to a source file is very important. For this example,

the name of the source file should be Example.java. Let's see why.

In Java, a source file is officially called a compilation unit. It is a text file that contains (among other things) one or more class definitions. (For now, we will be using source files that contain only one class.) The Java compiler requires that a source file use the .java filename extension.

As you can see by looking at the program, the name of the class defined by the program is also Example. This is not a coincidence. In Java, all code must reside inside a class. By convention, the name of the main class should match the name of the file that holds the program. You should also make sure that the capitalization of the filename matches the class name. The reason for this is that Java is case-sensitive. At this point, the convention that filenames correspond to class names may seem arbitrary. However, this convention makes it easier to maintain and organize your programs.

Compiling the Program

To compile the Example program, execute the compiler, javac, specifying the name of the source file on the command line, as shown here:

C:\>javac Example.java

The javac compiler creates a file called Example.class that contains the bytecode version of the program. As discussed earlier, the Java bytecode is the intermediate representation of

your program that contains instructions the Java Virtual Machine will execute. Thus, the output of javac is not code that can be directly executed.

To actually run the program, you must use the Java application launcher called java. To do so, pass the class name Example as a command-line argument, as shown here:

C:\>java Example

When the program is run, the following output is displayed:

This is a simple Java program.

When Java source code is compiled, each individual class is put into its own output file named after the class and using the .class extension. This is why it is a good idea to give your Java source files the same name as the class they contain—the name of the source file will match the name of the .class file. When you execute java as just shown, you are actually specifying the name of the class that you want to execute. It will automatically search for a file by that name that has the .class extension. If it finds the file, it will execute the code contained in the specified class.

A Closer Look at the First Sample Program

Although Example.java is quite short, it includes several key features that are common to all Java programs. Let's closely examine each part of the program.

The program begins with the following lines:

/*

This is a simple Java program. Call this file "Example.java".

*/

This is a comment. Like most other programming languages, Java lets you enter a remark into a program's source file. The contents of a comment are ignored by the compiler. Instead, a comment describes or explains the operation of the program to anyone who is reading its source code. In this case, the comment describes the program and reminds you that the source file should be called Example.java. Of course, in real applications, comments generally explain how some part of the program works or what a specific feature does.

Java supports three styles of comments. The one shown at the top of the program is called a multiline comment. This type of comment must begin with /* and end with */. Anything between these two comment symbols is ignored by the compiler. As the name suggests, a multiline comment may be several lines long.

The next line of code in the program is shown here:

class Example {

This line uses the keyword class to declare that a new class is being defined. Example is an identifier that is the name of the class. The entire class definition, including all of its members, will be between the opening curly brace ({) and the closing curly brace (}). For the moment, don't worry too much about the details of a class except to note that in Java,

all program activity occurs within one. This is one reason why all Java programs are (at least a little bit) object-oriented.

The next line in the program is the single-line comment, shown here:

// Your program begins with a call to main().

This is the second type of comment supported by Java. A single-line comment begins with a // and ends at the end of the line. As a general rule, programmers use multiline comments for longer remarks and single-line comments for brief, line-by-line descriptions. The third type of comment, a documentation comment, will be discussed in the "Comments" section later in this chapter.

The next line of code is shown here:

public static void main(String args[ ]) {

This line begins the main( ) method. As the comment preceding it suggests, this is the line at which the program will begin executing. All Java applications begin execution by calling main( ). The full meaning of each part of this line cannot be given now, since it involves a detailed understanding of Java's approach to encapsulation. However, since most of the examples in the first part of this book will use this line of code, let's take a brief look at each part now.

The public keyword is an access modifier, which allows the programmer to control the visibility of class members. When a class member is preceded by public, then that member may be accessed by code outside the class in which it is declared. (The opposite of public is private, which prevents a member from being used by code defined outside of its class.) In this case, main( ) must be declared as public, since it must be called by code outside of its class when the program is started. The keyword static allows main( ) to be called without having to instantiate a particular instance of the class. This is necessary since main( ) is called by the Java Virtual Machine before any objects are made. The keyword void simply tells the compiler that main( ) does not return a value. As you will see, methods may also return values. If all this seems a bit confusing, don't worry. All of these concepts will be discussed in detail in subsequent chapters.

As stated, main( ) is the method called when a Java application begins. Keep in mind that Java is case-sensitive. Thus, Main is different from main. It is important to understand that the Java compiler will compile classes that do not contain a main( ) method. But java has no way to run these classes. So, if you had typed Main instead of main, the compiler would still compile your program. However, java would report an error because it would be unable to find the main( ) method.

Any information that you need to pass to a method is received by variables specified within the set of parentheses that follow the name of the method. These variables are called parameters. If there are no parameters required for a given method, you still need to include the empty parentheses. In main( ), there is only one parameter, albeit a complicated one.

String args[ ] declares a parameter named args, which is an array of instances of the class String. (Arrays are collections of similar objects.) Objects of type String store character strings. In this case, args receives any command-line arguments present when the program is executed. This program does not make use of this information, but other programs shown later in this book will.

The last character on the line is the {. This signals the start of main( )'s body. All of the code that comprises a method will occur between the method's opening curly brace and its closing curly brace.

One other point: main( ) is simply a starting place for your program. A complex program will have dozens of classes, only one of which will need to have a main( ) method to get things started. Furthermore, in some cases, you won't need main( ) at all. For example, when creating applets—Java programs that are embedded in web browsers—you won't use main( ) since the web browser uses a different means of starting the execution of applets.

The next line of code is shown here. Notice that it occurs inside main( ).

System.out.println("This is a simple Java program.");

This line outputs the string "This is a simple Java program." followed by a new line on the screen. Output is actually accomplished by the built-in println( ) method. In this case, println( ) displays the string which is passed to it. As you will see, println( ) can be used to display other types of information, too. The line begins with System.out. While too complicated to explain in detail at this time, briefly, System is a predefined class that provides access to the system, and out is the output stream that is connected to the console.

As you have probably guessed, console output (and input) is not used frequently in most real-world Java applications. Since most modern computing environments are windowed and graphical in nature, console I/O is used mostly for simple utility programs, demonstration programs, and server-side code. Later in this book, you will learn other ways to generate output using Java. But for now, we will continue to use the console I/O methods.

Notice that the println( ) statement ends with a semicolon. All statements in Java end with a semicolon. The reason that the other lines in the program do not end in a semicolon is that they are not, technically, statements.

The first } in the program ends main( ), and the last } ends the Example class definition.

A Second Short Program

Perhaps no other concept is more fundamental to a programming language than that of a variable. As you probably know, a variable is a named memory location that may be assigned a value by your program. The value of a variable may be changed during the execution of the program. The next program shows how a variable is declared and how it is assigned a value. The program also illustrates some new aspects of console output. As the comments

at the top of the program state, you should call this file Example2.java.

/*

Here is another short example. Call this file "Example2.java".

*/

class Example2 {

public static void main(String args []) {

int num; // this declares a variable called num num = 100; // this assigns num the value 100 System.out.println("This is num: " + num);

num = num * 2;

System.out.print("The value of num * 2 is ");

System.out.println(num);

}

When you run this program, you will see the following output:

This is num: 100

The value of num * 2 is 200

Let's take a close look at why this output is generated. The first new line in the program is shown here:

int num; // this declares a variable called num

This line declares an integer variable called num. Java (like most other languages) requires that variables be declared before they are used.

Following is the general form of a variable declaration:

type var-name;

Here, type specifies the type of variable being declared, and var-name is the name of the variable. If you want to declare more than one variable of the specified type, you may use a comma-separated list of variable names. Java defines several data types, including integer, character, and floating-point. The keyword int specifies an integer type.

In the program, the line

num = 100; // this assigns num the value 100

assigns to num the value 100. In Java, the assignment operator is a single equal sign.

The next line of code outputs the value of num preceded by the string "This is num:".

System.out.println("This is num: " + num);

In this statement, the plus sign causes the value of num to be appended to the string that precedes it, and then the resulting string is output. (Actually, num is first converted from an integer into its string equivalent and then concatenated with the string that precedes it. This process is described in detail later in this book.) This approach can be generalized. Using the + operator, you can join together as many items as you want within a single println( ) statement.

The next line of code assigns num the value of num times 2. Like most other languages, Java uses the * operator to indicate multiplication. After this line executes, num will contain the value 200.

Here are the next two lines in the program:

System.out.print ("The value of num * 2 is "); System.out.println (num);

Several new things are occurring here. First, the built-in method print( ) is used to display the string "The value of num * 2 is ". This string is not followed by a newline. This means that when the next output is generated, it will start on the same line. The print( ) method is just like println( ), except that it does not output a newline character after each call. Now look at the call to println( ). Notice that num is used by itself. Both print( ) and println( ) can be used to output values of any of Java's built-in types.

Two Control Statements

Although Chapter 5 will look closely at control statements, two are briefly introduced here so that they can be used in example programs in Chapters 3 and 4. They will also help illustrate an important aspect of Java: blocks of code.

The if Statement

The Java if statement works much like the IF statement in any other language. Further, it is syntactically identical to the if statements in C, C++, and C#. Its simplest form is shown here:

if(condition) statement;

Here, condition is a Boolean expression. If condition is true, then the statement is executed. If condition is false, then the statement is bypassed. Here is an example:

if(num < 100) System.out.println("num is less than 100");

In this case, if num contains a value that is less than 100, the conditional expression is true, and println( ) will execute. If num contains a value greater than or equal to 100, then the println( ) method is bypassed.

As you will see in Chapter 4, Java defines a full complement of relational operators which may be used in a conditional expression. Here are a few:

Operator Meaning

< Less than

> Greater than

== Equal to

Notice that the test for equality is the double equal sign. Here is a program that illustrates the if statement:

/*

Demonstrate the if.

Call this file "IfSample.java".

*/

class IfSample {

public static void main(String args[]) { int x, y;

x = 10;

y = 20;

if(x < y) System.out.println("x is less than y"); x = x * 2;

if(x == y) System.out.println("x now equal to y");

x = x * 2;

if(x > y) System.out.println("x now greater than y");

// this won't display anything

if(x == y) System.out.println("you won't see this");

}

The output generated by this program is shown here:

x is less than y x now equal to y

x now greater than y

Notice one other thing in this program. The line

int x, y;

declares two variables, x and y, by use of a comma-separated list.

The for Loop

As you may know from your previous programming experience, loop statements are an important part of nearly any programming language. Java is no exception. In fact, as you will see in Chapter 5, Java supplies a powerful assortment of loop constructs. Perhaps the most versatile is the for loop. The simplest form of the for loop is shown here:

for(initialization; condition; iteration) statement;

In its most common form, the initialization portion of the loop sets a loop control variable to an initial value. The condition is a Boolean expression that tests the loop control variable. If the outcome of that test is true, the for loop continues to iterate. If it is false, the loop terminates. The iteration expression determines how the loop control variable is changed each time the loop iterates. Here is a short program that illustrates the for loop:

/*

Demonstrate the for loop.

Call this file "ForTest.java".

*/

class ForTest {

public static void main(String args[]) { int x;

for(x = 0; x<10; x = x+1) System.out.println("This is x: " + x);

}

This program generates the following output:

This is x: 0 This is x: 1 This is x: 2 This is x: 3

This is x: 4 This is x: 5 This is x: 6 This is x: 7 This is x: 8 This is x: 9

In this example, x is the loop control variable. It is initialized to zero in the initialization portion of the for. At the start of each iteration (including the first one), the conditional test x < 10 is performed. If the outcome of this test is true, the println( ) statement is executed, and then the iteration portion of the loop is executed. This process continues until the conditional test is false.

As a point of interest, in professionally written Java programs you will almost never see the iteration portion of the loop written as shown in the preceding program. That is, you will seldom see statements like this:

x = x + 1;

The reason is that Java includes a special increment operator which performs this operation more efficiently. The increment operator is ++. (That is, two plus signs back to back.) The increment operator increases its operand by one. By use of the increment operator, the preceding statement can be written like this:

x++;

Thus, the for in the preceding program will usually be written like this:

for(x = 0; x<10; x++)

You might want to try this. As you will see, the loop still runs exactly the same as it did before.

Java also provides a decrement operator, which is specified as – –. This operator decreases its operand by one.

Using Blocks of Code

Java allows two or more statements to be grouped into blocks of code, also called code blocks. This is done by enclosing the statements between opening and closing curly braces. Once a block of code has been created, it becomes a logical unit that can be used any place that a single statement can. For example, a block can be a target for Java's if and for statements. Consider this if statement:

if(x < y) { // begin a block x = y;

y = 0;

} // end of block

Here, if x is less than y, then both statements inside the block will be executed. Thus, the two statements inside the block form a logical unit, and one statement cannot execute without the other also executing. The key point here is that whenever you need to logically link two or more statements, you do so by creating a block.

Let's look at another example. The following program uses a block of code as the target of a for loop.

/*

Demonstrate a block of code.

Call this file "BlockTest.java"

*/

class BlockTest {

public static void main(String args[]) { int x, y;

y = 20;

// the target of this loop is a block for(x = 0; x<10; x++) {

System.out.println("This is x: " + x); System.out.println("This is y: " + y); y = y - 2;

}

The output generated by this program is shown here:

This is x: 0

This is y: 20

This is x: 1

This is y: 18

This is x: 2

This is y: 16

This is x: 3

This is y: 14

This is x: 4

This is y: 12

This is x: 5

This is y: 10

This is x: 6

This is y: 8

This is x: 7

This is y: 6

This is x: 8

This is y: 4

This is x: 9

This is y: 2

In this case, the target of the for loop is a block of code and not just a single statement. Thus, each time the loop iterates, the three statements inside the block will be executed. This fact is, of course, evidenced by the output generated by the program.

As you will see later in this book, blocks of code have additional properties and uses.

However, the main reason for their existence is to create logically inseparable units of code.

Lexical Issues

Now that you have seen several short Java programs, it is time to more formally describe the atomic elements of Java. Java programs are a collection of whitespace, identifiers, literals, comments, operators, separators, and keywords. The operators are described in the next chapter. The others are described next.

Whitespace

Java is a free-form language. This means that you do not need to follow any special indentation rules. For instance, the Example program could have been written all on one line or in any other strange way you felt like typing it, as long as there was at least one whitespace character between each token that was not already delineated by an operator or separator. In Java, whitespace is a space, tab, or newline.

Identifiers

Identifiers are used to name things, such as classes, variables, and methods. An identifier may be any descriptive sequence of uppercase and lowercase letters, numbers, or the underscore and dollar-sign characters. (The dollar-sign character is not intended for general use.) They must not begin with a number, lest they be confused with a numeric literal. Again, Java is case-sensitive, so VALUE is a different identifier than Value. Some examples of valid identifiers are

AvgTemp count a4 $test this_is_ok

Invalid identifier names include these:

2count high-temp Not/ok

Literals

A constant value in Java is created by using a literal representation of it. For example, here are some literals:

100 98.6 'X' "This is a test"

Left to right, the first literal specifies an integer, the next is a floating-point value, the third is a character constant, and the last is a string. A literal can be used anywhere a value of its type is allowed.

Comments

As mentioned, there are three types of comments defined by Java. You have already seen two: single-line and multiline. The third type is called a documentation comment. This type of comment is used to produce an HTML file that documents your program. The documentation comment begins with a /** and ends with a */. Documentation comments are explained in the Appendix.

Separators

In Java, there are a few characters that are used as separators. The most commonly used separator in Java is the semicolon. As you have seen, it is used to terminate statements. The separators are shown in the following table:

Symbol Name Purpose

( ) Parentheses Used to contain lists of parameters in method definition and invocation. Also used for defining precedence in expressions, containing expressions in control statements, and surrounding cast types.

{ } Braces Used to contain the values of automatically initialized arrays. Also used to define a block of code, for classes, methods, and local scopes.

[ ] Brackets Used to declare array types. Also used when dereferencing array values.

; Semicolon Terminates statements.

, Comma Separates consecutive identifiers in a variable declaration. Also used to chain statements together inside a for statement.

. Period Used to separate package names from subpackages and classes. Also used to separate a variable or method from a reference variable.

The Java Keywords

There are 50 keywords currently defined in the Java language (see Table 2-1). These keywords, combined with the syntax of the operators and separators, form the foundation of the Java language. These keywords cannot be used as identifiers. Thus, they cannot be used as names for a variable, class, or method.

The keywords const and goto are reserved but not used. In the early days of Java, several other keywords were reserved for possible future use. However, the current specification for Java defines only the keywords shown in Table 2-1.

abstract continue for new switch

assert default goto package synchronized

boolean do if private this

break double implements protected throw

byte else import public throws

case enum instanceof return transient

catch extends int short try

char final interface static void

class finally long strictfp volatile

const float native super while

Table 2-1 Java Keywords

In addition to the keywords, Java reserves the following: true, false, and null. These are values defined by Java. You may not use these words for the names of variables, classes, and so on.

The Java Class Libraries

The sample programs shown in this chapter make use of two of Java's built-in methods: println( ) and print( ). As mentioned, these methods are members of the System class, which is a class predefined by Java that is automatically included in your programs. In the larger view, the Java environment relies on several built-in class libraries that contain many built-in methods that provide support for such things as I/O, string handling, networking, and graphics. The standard classes also provide support for windowed output. Thus, Java as a totality is a combination of the Java language itself, plus its standard classes. As you will see, the class libraries provide much of the functionality that comes with Java. Indeed, part of becoming a Java programmer is learning to use the standard Java classes. Throughout Part I of this book, various elements of the standard library classes and methods are described as needed. In Part II, the class libraries are described in detail.

@£V£RYTHING NT

bowling

الثلاثاء، 22 سبتمبر 2020

Movie Reviews: Star Wars IX: The Rise Of Skywalker, Emma (2020), Knives Out, Joker, Little Women (2019)

الاثنين، 21 سبتمبر 2020

Omicron Protocol, Game Review

السبت، 12 سبتمبر 2020

Movie Reviews: Crazy Rich Asians, Destination Wedding, I Feel Pretty, The Wife, Won't You Be My Neighbor

Come And Play Oceanhorn 2 At GDC 18!

الجمعة، 4 سبتمبر 2020

Crysis 2 Free Download

How To Install Crysis 2 without Errors and Problems

الاثنين، 31 أغسطس 2020

Thank You To Volunteers And Board Members That Worked BlackHat Booth 2019

الأحد، 30 أغسطس 2020

An Overview Of Java

Related articles