Introduction to Objects

The progress of abstraction

1.   Everything is an object . Think of an object as a fancy variable; it stores data, but you can “make requests” to that object, asking it to perform operations on itself. In theory, you can take any conceptual component in the problem you’re trying to solve (dogs, buildings, services, etc.) and represent it as an object in your program. 

2.   A program is a bunch of objects telling each other what to do by sending messages . To make a request of an object, you “send a message” to that object. More concretely, you can think of a message as a request to call a method that belongs to a particular object. 

3.   Each object has its own memory made up of other objects.  Put another way, you create a new kind of object by making a package containing existing objects. Thus, you can build omplexity into a program while hiding it behind the simplicity of objects. 

4.   Every object has a type.  Using the parlance, each object is an instance of a class, in which “class” is synonymous with “type.” The most important distinguishing characteristic of a class is “What messages can you send to it?” 

5.   All objects of a particular type can receive the same messages.  This is actually a loaded statement, as you will see later. Because an object of type “circle” is also an object of type “shape,” a circle is guaranteed to accept shape messages. This means you can write code that talks to shapes and automatically handle anything that fits the description of a shape. This substitutability is one of the powerful concepts in OOP.

An object has an interface

An object provides services 

高聚合，每个对象只做好一件事情。

The hidden implementation

Java uses three explicit keywords to set the boundaries in a class:  public, private, and  protected. These access specifiers determine who can use the definitions that follow.  public means the following element is available to everyone. The  private keyword, on the other hand, means that no one can access that element except you, the creator of the type, inside methods of that type.  private is a brick wall between you and the client programmer. Someone who tries to access a  private member will get a compile-time error. The  protected keyword acts like  private, with the exception that an inheriting class has access to  protected members, but not  private members. Inheritance will be introduced shortly.  

Java also has a “ default” access, which comes into play if you don’t use one of the aforementioned specifiers.  This is usually called package access because classes can access the members of other classes in the same package (library component), but outside of the package those same members appear to be private.  

Reusing the implementation

Because inheritance is so important in object-oriented programming, it is often highly emphasized, and the new programmer can get the idea that inheritance should be used everywhere.  This can result in awkward and overly complicated designs. Instead, you should first look to composition when creating new classes, since it is simpler and more flexible. If you take this approach, your designs will be cleaner. Once you’ve had some experience, it will be reasonably obvious when you need inheritance.  

Inheritance 

When you inherit from an existing type, you create a new type.  This new type contains not only all the members of the existing type (although the  private  ones are hidden away and inaccessible), but more importantly it duplicates the interface of the base class. That is, all the messages you can send to objects of the base class you can also send to objects of the derived class. Since we know the type of a class by the messages we can send to it, this means that the derived class is the same type as the base class. 

Interchangeable objects with polymorphism

The singly rooted hierarchy

Containers

Parameterized types (generics) 

For example, with a parameterized container, the compiler could customize that container so that
it would accept only  Shapes and fetch only  Shapes.

Object creation & lifetime

Java uses dynamic memory allocation, exclusively. Every time you want to create an object, you use the new operator to build a dynamic instance of that object. 

Exception handling: dealing with errors

It’s worth noting that exception handling isn’t an object-oriented feature, although in object-
oriented languages the exception is normally represented by an object. Exception handling
existed before object-oriented languages.  

Concurrent programming

Java and the Internet