Java Fundamentals – Course Description. Overview. This course engages students with little or no programming experience to create Java programs. Chapter 1: Java Fundamentals. 3. The Origins of Java. Computer language innovation is driven forward by two factors: improvements in the art of programming. My first encounter with the Java programming language was during a one-week Java training session in I did not get a chance to use Java in a project.
|Language:||English, Spanish, Japanese|
|ePub File Size:||18.57 MB|
|PDF File Size:||12.21 MB|
|Distribution:||Free* [*Register to download]|
S. Overview. Introduction xxi. Week 1 at a Glance. Day. 1. An Introduction to Java Programming. 3. 2. Object-Oriented Programming and Java. 3. Java Basics. advanced concepts related to Java Programming language. Prerequisites can use to execute your Java programs at the spot and enjoy your learning. are not portable. 2. The library. The Java class library is available on any machine with a Java runtime system, because a portable program is of no use if you.
Many types: Class Method Area: Class Area stores per-class structures such as the runtime constant pool, field, method data, and the code for methods. Heap: It is the runtime data area in which the memory is allocated to the objects Stack: Java Stack stores frames. It holds local variables and partial results, and plays a part in method invocation and return. Each thread has a private JVM stack, created at the same time as the thread. A new frame is created each time a method is invoked. A frame is destroyed when its method invocation completes. Program Counter Register: PC program counter register contains the address of the Java virtual machine instruction currently being executed.
The book familiarizes you with Java Development Kit and Java Runtime Environment and gives the description for each part of the code in examples. It serves as a rather good preliminary environment before you delve into more serious subjects.
Pros: smooth intro to Java programming and its main features.
But this book requires a little bit more understanding of programming comparing to the previous sources. It will deepen your understanding of Java origins and its relations to other programming languages.
It is profound research about the core concepts of Java which explains the code by line and guides you from the basic understanding of data types, classes and objects to more complex concepts like lambda expressions and functional interfaces.
The great part of this book is a self-test section at the end of each chapter.
Pros: a plain tone of voice, self-testing, full coverage of Java core. Cons: you need at least a small prior understanding of programming. It puts aside the playful tone and focuses on detailed explanations of Java core. Each chapter is devoted to a certain subject, starting from introduction to the language and Java programming environment and moving to data structures, objects and classes and so on.
Unlike many books for beginners, Core Java gives an explicit coverage of collections and generics, which is useful for real programming. All in all, it is a great reference book. Read it once and return to it anytime you need to refresh your knowledge. Pros: a full reference to Java Core and attention to collections and generics, profound explanations. Cons: some topics, like generics, are covered less diligent than others. Like many others, it starts with an introduction to OOP. It is also a rather good reference book.
Each chapter has the vocabulary and exercise sections to consolidate theory and master the skill of programming thinking. It is more suitable for beginners than readers with even a small experience in coding. For starters, it is simple and kind of fun to read. Pros: a source for adjusting your way of coding, practice, basic concepts explained clearly.
Cons: cannot be considered as the complete reference for core Java; the same level of complexity in all exercises.
Cheers to that! Effective Java is written by Joshua Bloch This is not a book for a complete beginner but is must-read research for every Java developer.
If you want to understand the inner processes and get a clue of how and why they are arranged this way, this book serves the purposes well. It will teach you how to write the code and how to do it well. Pros: easy to read, covers best practices in programming, useful advice for improving your coding.
Cons: requires an understanding of core concepts and at least a small experience in coding. It covers the Java 8 APIs, and clearly explains the basic concepts and beyond that.
Pros: the real world examples, clear and detailed explanations, a good reference for the latest Java APIs. Cons: requires a basic knowledge of Java programming. Java 8 in Action If you need a Java 8 book with full coverage of its features, this one is for you.
It will be easier for you to understand the material with some background in Java. Just be sure not to mix them up : All in all, this is a book with an obvious focus on practice, so you can use it as an additional source for the enhanced studying. Pros: focused on practice, shows the difference between the right and the wrong code.
Cons: requires supplementary sources for a deeper understanding of Java basics. Thinking in Java by Bruce Eckel This book offers you a rather refreshing approach to explaining Java fundamentals.
We can do the same thing with class car. Vehicle 1 info: The vehicle has a speed of: 50 and at gear 2 Vehicle 2 info: The vehicle has a speed of: 50 and at gear 2 The car has 4 seats. Follow the steps detailed in Lesson 1 of this book. Override a method in Parent, and overload another one in Child. In the Navigator view to the left of you Eclipse editor, right click on folder src. From the menu that shows up, point to New, and then click on Class c.
Click Finish e. Open file Parent. Type in it the following code package com. Open file Child. Type in the following code package com. Open file IParent.
Method thirdMehod in class Child is overloaded. Exceptions Handling errors is an essential part of writing a robust code. Java uses exceptions to handle errors. This section explains exceptions and how to use them. When an error occurs, the Java runtime environment handles an error object that is created by the method where the error occurs.
This object is called exception, and contains basic information about the error like the type of the error, the location, the stack of methods that lead to the error…etc.
The process of creating an exception object and handling it by the system is called throwing an exception. When handling the error, the system searches through that stack to find an error handler in the code; i. All exception objects are children of the parent class Exception. The different types or errors thrown are children of class Exception.
For example, reading from a file on the disk, a programmer should expect is non- existent. In this case, the programmer should expect a java. FileNotFoundException, thrown, and thereafter catch this exception and notify the user of a proper action. Unchecked Exception These come in two types themselves: Errors and Runtime exceptions. They are grouped in one category because both cannot be anticipated or recover from by a programmer.
Errors are external to the applications. The unsuccessful read will throw java. IOError, and it makes sense for the program to print a stack trace and exit.
Errors are those exceptions of type Error class and its sub-classes. Runtime exceptions usually indicate programming bugs such as logic errors. They are or type RuntimeException class and its subclasses. Handling errors exceptions in Java is done through the try-catch-finally blocks. While the finally block is optional, the try and catch are obligatory to fulfill error handling.
The finally block can be used after the exception block. This block of code will always run whether there is an exception thrown or not.
If an exception was thrown, the line of code that closes the file might be skipped. The finally block would be the best place to close the file in.
Java Collections Java provides a set of classes and interfaces to help developers handle a collection of objects.
These collection classes similar to an array, except their size can grow dynamically during run time. This section will provide an overview of some of the more popular Java collection classes. It provides two main Interfaces: Collection and Map. These two are the core of the Java Collection framework.
Other interfaces inherit from these two. For example, the List and Set interfaces inherit from Collection interface. All of these interfaces are generic; i. There is a main difference between subclasses of Collection interface and those of Map interface.
The collection contains a group of objects that can be manipulated and passed around. The elements can be duplicated or unique, depending on the type of sub-class. For example, a Set only contains unique objects.
The Map interface, however, maps keys to values and cannot contain duplicate keys and each key can only map one value at most. Implementations Implementations are the data objects used to store collections, which implement the previous section. This lesson describes the following implementations: ArrayList An Arraylist is a resizable-array implementation of the List interface.
It implements all optional list operations, and permits all elements, including null. It also provides methods to manipulate the size of the array that is used internally to store the list.
This collection does not allow duplicates. It creates a collection that uses a hash table for storage. A hash table stores information by using a mechanism called hashing where the value stored is used to determine a unique key, which is used as the index at which the data is stored.
The advantage of hashing is that it allows fast execution times for basic operations, like add and remove. The following is an example of HashSet. HashMap This is a hash table based implementation of the Map interface.
It allows null elements and does not add any methods of its own. The following program illustrates HashMap. It maps names to account balances. Pre-requisites You need to create a new Java project under Eclipse before solving these exercises. Demonstrate the usage of methods: add , remove , and indexOf. Open file Exercise3. You should see the desired output. Nested Classes Using Java, you can define a class within another class.
Non-static inner classes have access to other members of the outer class, even if they are declared private. However, static inner classes do not. Similar to member variables and methods, an inner class can be declared private, public, protected, or package private. If a class B is useful to only one other Class A, then it is logical to make class B an inner class of class A.
If class B needs to access private members of class A, a programmer can hide class B inside A and keep all members of A private, and at the same time hide class B from external classes. Creating inner classes within an outer class provides a clearer placement of code.
Class Variables static When we create several objects of the same class, each object instance has its own distinct copy of member variables.
Object-oriented paradigm aims to incorporate the advantages of modularity and reusability. Objects are the instances of classes which interacts with one another to design applications and programs. There are the following features of the object-oriented paradigm. Follows the bottom-up approach in program design. Focus on data with methods to operate upon the object's data Includes the concept like Encapsulation and abstraction which hides the complexities from the user and show only functionality.
Implements the real-time approach like inheritance, abstraction, etc. The Object is the real-time entity having some state and behavior. In Java, Object is an instance of the class having the instance variables as the state of the object and the methods as the behavior of the object. The object of a class can be created by using the new keyword. There are the following basic differences between the object-oriented language and object-based language.
All object references are initialized to null in Java. The constructor can be defined as the special type of method that is used to initialize the state of an object. It is invoked when the class is instantiated, and the memory is allocated for the object. Every time, an object is created using the new keyword, the default constructor of the class is called. The name of the constructor must be similar to the class name.
The constructor must not have an explicit return type. Based on the parameters passed in the constructors, there are two types of constructors in Java. Default Constructor: default constructor is the one which does not accept any value. The default constructor is mainly used to initialize the instance variable with the default values.
It can also be used for performing some useful task on object creation. A default constructor is invoked implicitly by the compiler if there is no constructor defined in the class. Parameterized Constructor: The parameterized constructor is the one which can initialize the instance variables with the given values. In other words, we can say that the constructors which can accept the arguments are called parameterized constructors.
The purpose of the default constructor is to assign the default value to the objects. The java compiler creates a default constructor implicitly if there is no constructor in the class. Here 0 and null values are provided by default constructor.
Ans: yes, The constructor implicitly returns the current instance of the class You can't use an explicit return type with the constructor. No, The constructor is not inherited. No, the constructor can't be final.