没有合适的资源?快使用搜索试试~ 我知道了~
java介绍外文翻译.doc
1.该资源内容由用户上传,如若侵权请联系客服进行举报
2.虚拟产品一经售出概不退款(资源遇到问题,请及时私信上传者)
2.虚拟产品一经售出概不退款(资源遇到问题,请及时私信上传者)
版权申诉
0 下载量 88 浏览量
2022-06-09
21:04:24
上传
评论
收藏 79KB DOC 举报
温馨提示
试读
12页
java介绍外文翻译
资源推荐
资源详情
资源评论
外文原文
Introduction to Java
autor:Martin Ngobye.
source:Computing Static Slice for Java Programs
Java is designed to meet the challenges of application development in the context of
heterogeneous, network-wide distributed environments. Paramount among these challenges is
secure delivery of applications that consume the minimum of system resources, can run on
any hardware and software platform, and can be extended dynamically.
Java originated as part of a research project to develop advanced software for a wide
variety of network devices and embedded systems. The goal was to develop a small, reliable,
portable, distributed, real-time operating platform. When the project started, C++ was the
language of choice. But over time the difficulties encountered with C++ grew to the point
where the problems could best be addressed by creating an entirely new language platform.
Design and architecture decisions drew from a variety of languages such as Eiffel, SmallTalk,
Objective C, and Cedar/Mesa. The result is a language platform that has proven ideal for
developing secure, distributed, network based end-user applications in environments ranging
from network-embedded devices to the World-Wide Web and the desktop.
The design requirements of Java are driven by the nature of the computing environments
in which software must be deployed.
The massive growth of the Internet and the World-Wide Web leads us to a completely
new way of looking at development and distribution of software. To live in the world of
electronic commerce and distribution, Java must enable the development of secure, high
performance, and highly robust applications on multiple platforms in heterogeneous,
distributed networks.
Operating on multiple platforms in heterogeneous networks invalidates the traditional
schemes of binary distribution, release, upgrade, patch, and so on. To survive in this jungle,
Java must be architecture neutral, portable, and dynamically adaptable.
The Java system that emerged to meet these needs is simple, so it can be easily
programmed by most developers; familiar, so that current developers can easily learn Java;
object oriented, to take advantage of modern software development methodologies and to fit
into distributed client-server applications; multithreaded, for high performance in applications
that need to perform multiple concurrent activities, such as multimedia; and interpreted, for
maximum portability and dynamic capabilities.
Together, the above requirements comprise quite a collection of buzzwords, so let’s
examine some of them and their respective benefits before going on.
What’s completely new is the manner in which Java and its run-time system have
combined them to produce a flexible and powerful programming system..
Developing your applications using Java results in software that is portable across
multiple machine architectures, operating systems, and graphical user interfaces, secure, and
high performance, With Java, your job as a software developer is much easier—you focus
your full attention on the end goal of shipping innovative products on time, based on the solid
foundation of Java. The better way to develop software is here, now, brought to you by the
Java language platform.
Very dynamic languages like Lisp, TCL, and SmallTalk are often used for prototyping.
One of the reasons for their success at this is that they are very robust—you don’t have to
worry about freeing or corrupting memory.
Similarly, programmers can be relatively fearless about dealing with memory when
programming in Java, The garbage collection system makes the programmer’s job vastly
easier; with the burden of memory management taken off the programmer’s shoulders,
storage allocation errors go away. Another reason commonly given that languages like Lisp,
TCL, and SmallTalk are good for prototyping is that they don’t require you to pin down
decisions early on—these languages are semantically rich.
Java has exactly the opposite property: it forces you to make explicit choices. Along with
these choices come a lot of assistance—you can write method invocations and, if you get
something wrong, you get told about it at compile time. You don’t have to worry about
method invocation error.
The Java beginner must grasp 30 basic concepts
Basic concept
1.In OOP the only relations is what the object’s interface, such as the computer seller
he leaves alone internal structure of electrical source, but he is only concerned about that
whether the power will be supplied to you, also so long as know can or not but is not how and
why.All procedures are make up of certain attribute and the behavior object, the different
object visit invokes through the function invocation, between the object all intercommunion
are invoke through the method invocation, By object data encapsulation, enhances reuse rate
very much..
2.In OOP the most important thought is class, the class is the template ,is a blueprint,
construct an object from a class, namely construct an instance of the class.
3. Encapsulation: is that combines the data and the behavior in a package) and hides
the data the realization process to the object user, in an object data is called its instance field.
4.Through expands a class to obtain a new class is called inheritance, but all classes
are constructed by the object super root class of expansion, super root class of as follows can
make the introduction.
5.Object 3 principal characteristics
Behavior--- explained this object can make what.
Tate--- when the object exerts the method object reflection.
Dentity--- and other similar behavior objects discrimination symbols.
Each object has only indentity and among three characteristics they affect mutually.
6. Relations among classes:
Use-a:Dependent relation
Has-a:Polymerization relation
Is-a: inheritor relation -- example:A class has inherited B class, this time A class not
only has B class of method, but also has its own method(Individuality exists in general
character)
7.Structure object use structure:Structure proposing, the structure is one special
method, the structure object and to its initialization.
Example:A Data class of structure calls Data
New Data () --- structure a new object, also initialize current time.
Data happyday=new Data () --- an object evaluates an variable happyday, thus
enables this object to be used many times, here be stated the cause variable and the object
variable are different.
New returns the value is a quotation.
Constructor characteristic:The constructor may have 0, one or many parameters
The constructor and the class have the same name
A class may have many constructor. The constructor has not returned value
The constructor always be together used with the new operator
8. Over loading: When many methods have the same name when includes the
different parameter, then has the over loading Which method does the compiler have to
choose invokes.
9.Package : Java allow one or many classes to become together as group, is called
package, to organizing duty easily, the standard Java storehouse divides into many packages
Java.Lang java.Util java, net and so on, the package is layered and all java packages are in
java and in a javax package.
10. Extendable thought: permit to construct new class on existing classes , when
you extend the class which already existed, then you reuse this class of method and the field,
at the same time you might add the new method and the field in the new class.
11.Expandable class:The expandable class fully manifested is-a to extend the relations
The form is:Class (subclass) extends (base class).
12. Multi-modality: In java, the object variable is multi-modality But in java does
not support multiple extend.
13.Dynamic combine: the mechanism of invoking object method mechanism.
1) compiler examines object statement type and method name.
2) the compiler examines that method invokes parameter type.
3) static combine: If the method type is priavte static the final ,compiler can
accurately know which method should invoke.
4) when the procedure runs and uses dynamic combine to invoke a method, the
method edition which then hypothesized machine must invoke x the object actual type which
aims at to match.
5) dynamic combine: is a very important characteristic, it can cause the procedure
to change again may expand but does not need to translate has saved the code.
14.Final class:In order to prevent other people derive the new class from yours class,
this class is cannot expanded.
15.The dynamic invocation spend longer time than the static invocation
expenditure.
16.Abstract class:Stipulated or many abstract methods class of itself must define is
abstract.
Example: Public abstract string getDescripition
17.In Java each class is be extended by object class.
18. equal and toString method in object class .
Equal uses in testing an object is whether equal with another object.
ToString returns to represent this object the string of character, each class can nearly
剩余11页未读,继续阅读
资源评论
oligaga
- 粉丝: 52
- 资源: 2万+
上传资源 快速赚钱
- 我的内容管理 展开
- 我的资源 快来上传第一个资源
- 我的收益 登录查看自己的收益
- 我的积分 登录查看自己的积分
- 我的C币 登录后查看C币余额
- 我的收藏
- 我的下载
- 下载帮助
安全验证
文档复制为VIP权益,开通VIP直接复制
信息提交成功