Thinking in Java,Fourth Edition(Java 编程思想,第四版)学习笔记(八)之Reusing Classes
The trick is to use the classes without soiling the existing code.
1. composition--simply create objects of your existing class inside the new class. simply reusing the functionality of the code, not its form
2.inheritance--creates a new class as a type of an existing class. Take the form of the existing class and add code to it without modifying the existing class.
Inheritance is one of the cornerstones of object-oriented programming, and has additional implications that will be explored in the Polymorphism chapter.
Composition syntax
references initialized:
1. At the point the objects are defined
2. In the constructor for that class
3. Right before you actually need to use the object (lazy initialization)
4. Using instance initialization
如:
public class Bath {
private String s1 = "Happy"; //Initialization at the point of definition
private String s2,s3,s4;
public Bath() {
s2 = "Happy"; // In the constructor
}
{ s3 = "Happy"; } // Instance Initialization
public String toString() {
// Lazy initialization
if( s4 == null) {
s4 = "Happy";
}
return s4;
}
}
Inheritance syntax
super.methodName() 调用父类的方法
Initializing the base class
When you create an object of the derived class, it contains within it a subobject of the base class. This subobject is the same as if you had created an object of the base class by itself. It's just that from the outside, the subobject of the base class is wrapped within the derived-class object.
Java automatically inserts calls to the base-class constructor in the derived-class constructor.
Constructors with arguments
The call to the base-class constructor with arguments must explicit, and be the first thing you do in the derived-class constructor, etc: super(1)
Delegation
A third relationship, which is not directly supported by Java, is called delegation. This is midway between inheritance and composition.
You place a member object in the class you're building (like composition), but at the same time you expost all the methods from the member object in your new class (like inheritance).
Combining composition and inheritance
Guaranteeing proper cleanup
If you want something cleaned up for a class, you must explicitly write a special method to do it, and make sure that the client programmer knows that they must call this method.
On top of this--as described in the Erro Handling with Exceptions chapter-- you must guard against as exception by putting such cleanup in a finally clause.
Note that in your cleanup method, you must also pay attention to the calling order for the base-class and member-object cleanup methods in case one subobject depends on another. In general, First perform all the cleanup work specific to your class, in the reverse order or creationg. Then call the base-class cleanup method.
用户可以自己调用对象的finalize方法,但是这种调用是正常的方法调用,和对象的销毁过程无关
Name hiding
Overloading works regardless of whether the method was defined in the base-class or the derived-class
overload 重载
override 重新、覆盖
Java SE5 has added the @Override annotation. Whne you mean to override a method, you can choose to add this annotation and the compiler will produce an error message if you accidentally overload instead of overriding.
Choosing composition vs. inheritance
Composition is generally used when you want the features of an existing class inside your new class, but not its interface. That is, you embed an object so that you can use it to implement features in your new class, but the user of your new class sees the interface you've defined for the new class rathg than the interface from the embedded object. For this effect, you embed private objects of existing classes inside your new class.
Sometimes it makes sense to allow the class user to directly access the composition of your new class; that is,to make the member objects public. When the user know you're assembling a bunch of parts, it makes the interface easier to understand
例子: 汽车,包含 门(行为:open)、发动机(行为:start)
汽车.门.open (public 门)
汽车.start (private 发动机)
Note keep in mind that in general you should make fields private.
When you inherit, you take an existing class and make a special version of it. In general, this means that you're taking a general-purpose class and specializing it for a particular need.
Composition: has-a relationship
Inheritance: is-a relationship
Interface: like-a relationship
protected
This is private as far as the class user is concerned, but available to anyone who inherits from the class or anyone else in the same package.
Upcasting
The most important aspect of inheritance is not that it provides methods for the new class. It's the relationship expressed between the new class and the base class.
Upcasting is always safe because you're going from a more specific type to a more general type.
You can also perform the reverse of upcasting, called downcasting, but this involves a dilemma that will be examined further in the next chapter, and in the Type Information chapter.
Composition vs. inheritance revisited
In object-oriented programming, the most likely way that you'll create and use code is by simply packaging data and methods together inti a class, and using object of that class. You'll also use existing class to build new classes with composition. Less frequently, you'll use inheritance.
One of the clearest ways to determine whether you should use composition or inheritance is to ask whether you'll ever need to upcast from your new class to the base class.If you don't need to upcast, then you should look closely at whether you need inheritance.
The final keyword
final can be used: for data, methods, and classes.
final data
to tell the compiler that a piece of data is constant. A constant is useful for two reasons:
1. It can be a compile-time constant that won't ever change.
2. It can be a value initialized at run time that you don't want changed.
In the case of a compile-time constant, the compiler is allowed to "fold" the constant value into any calculations in which it's used; that is, the calculation can be performed at compile time, eliminating some run-time overhead. In java, these sorts of constants must be primitives and are expressed with the final keyword. A value must be given at the time of definition of such a constant.
A field that is both static and final has only one piece of storage that cannot be changed.
When final is used with object references rather than primitives, makes the reference a constant. Once the reference is initialized to an object, it can never be changed to point to another object. Howerver, the object itself can be modified.
private static final int i = 5; //compile-time
private final int i = 5; //comile-time
private static final int i = new Random().nextInt(20); //run-time
private final int i = new Random().nextInt(20); //run-time
Making references final seems less useful than making primitives final.
Blank finals
public class BlankFinal {
private final int i = 0; // Initialized final
private final int j; // Blank final
public BlankFinal(int jj) {
j = jj; // Initialize blank final
}
}
You're forced to perform assignments to finals either with an expression at the point of definition of the field or in every constructor.
final arguments
Java allows you to make arguments final by declaring them as such in the argument list. This means that inside the method you cannot change what the argument reference points to.
This feature is primarily used to pass data to anonymous inner classes
final methods
There are two reasons for final methods.
1. to put a "lock" on the method to prevent any inheriting class from changing its meaning.
2. efficiency.(old, Java SE5之后由编译器和JVM来考虑)
final and private
Any private methods in a class are implicitly final. Because you can't access a private method, you can't override it.
"Overriding" can only occur if something is part of the base-class interface. (即父类和子类中的private方法即时签名一样,也互不影响) If a method is private, it isn't part of the base-class interface.
final classes
When you say that an entire class is final, you state that you don't want to inherit from this class or allow anyone else to do so.
Note that the fields of a final class can be final or not. The same rules apply to final for fields regardless or whether the class is defined as final. However, because it prevents inheritance, all methods in a final class are implicitly final, since there's no way to override them.
final caution
Initialization and class loading
In general, you can say that "class code is loaded at the point of first use." This is usually when the first object of that class is constructed, but loading also occurs when a static field or static method is accessed.
The point of first use is also where the static initialization takes place. All the static objects and the static code block will be initialized in textual order at the point of loading. The statics are initialized only once.
Initialization with inheritance
Summary
Both inheritance and composition allow you to create a new type from existing types. Composition reuses existing types as part of the underlying implementation of the new type, and inheritance reuses the interface.
With Inheritance, the derived class has the base-class interface, so it can be upcast to the base which is critical for polymorphism.
When you set out to design a system, it's important to realize that program development is an incremental process, just like human learning. It relies on experimentation; you can do as much analysis as you want, but you still won't know all the answers when you set out on a project. You'll have much more success-and more immediate feedback-if you start out to "grow" your project as an organic, evolutionary creature, rather than constructing it all at once like a glass-box skyscraper.
Thinking in Java,Fourth Edition(Java 编程思想,第四版)学习笔记(八)之Reusing Classes的更多相关文章
- Thinking in Java,Fourth Edition(Java 编程思想,第四版)学习笔记(十)之Inner Classes
The inner class is a valuable feature because it allows you to group classes that logically belong t ...
- Thinking in Java,Fourth Edition(Java 编程思想,第四版)学习笔记(八)之Polymorphism
Polymorphism is the third essential feature of an object-oriented programming language,after data ab ...
- Thinking in Java,Fourth Edition(Java 编程思想,第四版)学习笔记(七)之Access Control
Access control ( or implementation hiding) is about "not getting it right the first time." ...
- Thinking in Java,Fourth Edition(Java 编程思想,第四版)学习笔记(六)之Initialization & Cleanup
Two of these safety issues are initialization and cleanup. initialization -> bug cleanup -> ru ...
- Thinking in Java,Fourth Edition(Java 编程思想,第四版)学习笔记(十三)之Strings
Immutable Strings Objects of the String class are immutable. If you examine the JDK documentation fo ...
- Thinking in Java,Fourth Edition(Java 编程思想,第四版)学习笔记(二)之Introduction to Objects
The genesis of the computer revolution was a machine. The genesis of out programming languages thus ...
- Thinking in Java,Fourth Edition(Java 编程思想,第四版)学习笔记(十四)之Type Information
Runtime type information (RTTI) allow you to discover and use type information while a program is ru ...
- Thinking in Java,Fourth Edition(Java 编程思想,第四版)学习笔记(十二)之Error Handling with Exceptions
The ideal time to catch an error is at compile time, before you even try to run the program. However ...
- Thinking in Java,Fourth Edition(Java 编程思想,第四版)学习笔记(十一)之Holding Your Objects
To solve the general programming problem, you need to create any number of objects, anytime, anywher ...
随机推荐
- OpenCV-Python 霍夫线变换 | 三十二
目标 在这一章当中, 我们将了解霍夫变换的概念. 我们将看到如何使用它来检测图像中的线条. 我们将看到以下函数:cv.HoughLines(),cv.HoughLinesP() 理论 如果可以用数学形 ...
- Centos7 中打开和关闭防火墙及端口
1.firewalld的基本使用 启动: systemctl start firewalld 关闭: systemctl stop firewalld 查看状态: systemctl status f ...
- Matlab——m_map指南(2)
3.海岸线和深度测量 3.1.1 海岸线选项 m_coast('line', ...optional line arguments ); m_coast('line', ...optional lin ...
- 【纯净镜像】原版Windows7集成USB3.0+NVME补丁+UEFI引导旗舰版下载
系统简述: 1. 基于MSDN原版Windows7 Ultimate With SP1系统制作,无任何插件和垃圾软件. 2. 系统集成IE11浏览器,装完系统后默认浏览器就是IE11. 3.系统注入了 ...
- 从 Linux 操作系统谈谈 IO 模型(终)
Linux 为什么要区分内核空间与用户空间? Linux 操作系统的 IO 模型有哪几种?有啥区别? 常说的阻塞现象,到底是咋回事? 网络编程研发时,那块到底耗时最多,代码是否还有优化空间? 前几期的 ...
- vue中通过修改element-ui的类修改相关组件的样式
可以在App.vue中的style中修改element-ui的样式. 注意:一定要在属性值后面加上 !important 使自己定义的css样式处于权重最高,不加的话在本地调试的时候是没有问题的,不过 ...
- js 调用铃声
<audio autoplay="autoplay" id="auto" src=""> </audio> play ...
- PTA数据结构与算法题目集(中文) 7-26
PTA数据结构与算法题目集(中文) 7-26 7-26 Windows消息队列 (25 分) 消息队列是Windows系统的基础.对于每个进程,系统维护一个消息队列.如果在进程中有特定事件发生, ...
- Visual Studio Code 1.44 解决中文代码显示乱码问题(小白图文教程)
现今主流的计算机中文字符编码方案是:GBK和UTF-8. 不同编码方案使用不同的字符集,GBK字符集在中文字符长度和字符数量上存在绝对优势,但对国外字符并不支持.所以,完全面向国内的程序/网页使用的是 ...
- 基于.NetCore3.1搭建项目系列 —— 使用Swagger导出文档 (补充篇)
前言 在上一篇导出文档番外篇中,我们已经熟悉了怎样根据json数据导出word的文档,生成接口文档,而在这一篇,将对上一篇进行完善补充,增加多种导出方式,实现更加完善的导出功能. 回顾 1. 获取Sw ...