The Java book series-preface

1th Chapter The origins of Java

For the history of computer language, the industry generally think: B language led to the birth of C language, C language evolved out of C + + language, and the C + + language will give way to the Java language. For a better understanding of the Java language, it is important to understand the causes of it, the power that drives it to evolve, and its inheritance of other languages. Like other successful computer languages, Java inherits the advanced principles of other languages, while at the same time proposing some innovative concepts due to its unique environmental requirements. In the other chapters of this book, the Java language, libraries, and applications are described in more detail, including syntax, from a practical perspective. In this chapter, we will cover the background of the Java language, the development process, and why it has become so important.

Although the Java language is inseparable from the online environment of the Internet, the most important thing to note first is:

It is a programming language. The innovation and development of computer language requires 2 drivers of basic factors:

· Adapting to changing environments and needs

· Realizing the perfection and improvement of the art of programming

As you'll see below, Java is also driven by these two factors.

1.1 The origins of Java

Java is always associated with C + + and C + + is derived from the C language, so the Java language inherits most of the features of both languages. Java's syntax is inherited from C, and Java's many object-oriented features are affected by C + +. In fact, a few of the custom features in Java come from or can be traced back to its predecessor. Moreover, the generation of Java language is closely related to the meticulous improvement and continuous development of computer language in the past 30 years. For these reasons, this section will be based on

The events and driving forces generated by the Java sequence review. As you will see, every revolution in language design is due to the inability of the previous language to solve the basic problems that are currently encountered. Java is no exception.

1.1.1 The birth of modern programming languages: C language

The creation of the C language shocked the entire computer community. Its impact should not be underestimated, because it fundamentally changes the way and idea of programming. The generation of C language is a direct result of people's pursuit of structure, high efficiency and high-level language, which can replace assembly language development system program. When designing a computer language, it is often necessary to weigh the following:

· Ease of use and functionality

· Safety and efficiency

· Stability and Scalability

Before the advent of C, programmers often had to choose between languages that had merit but lacked in some ways. For example, while it is generally accepted that Fortran can write fairly efficient programs for scientific computing applications, it is not suitable for writing system programs. Although basic is easy to learn, it is not powerful enough and is not structured, which makes it doubtful about the effectiveness of its application to large programs. Although assembly language can write efficient programs, it is not easy to learn or use them effectively. Also, debugging the assembler is quite difficult. Another complex problem is that the early design of computer languages (such as Basic,cobol,fortran, etc.) does not take into account structural design principles, and a goto statement is used as a primary method of controlling a program. As a result, programs written in these languages tend to be "spaghetti Code", and a whole bunch of confusing jump statements and conditional branching statements make the program almost impossible to read. Although Pascal is a structured language, it is designed to be less efficient and lacks a few required features to be used within a large programming range (in particular, the standard language for a given Pascal is available at certain times, but it is impractical to encode Pascal as a system-level encoding). Therefore, before the C language production, no one language can fully meet the needs of people, but people's need for such a language is urgent. In the the early 1970s, when the computer revolution began, the demand for software was increasing, and the use of early computer language for software development simply failed to meet this need. Academia has made a lot of efforts to try to create a better computer language. However, the emergence of the C language is another, perhaps the most important factor, is the surplus of computer hardware resources to bring opportunities. Computers are no longer locked in the door as they used to be, and programmers are free to use the computer and have the freedom to try, and thus have the opportunity to develop tools suitable for their own use. So, on the eve of the birth of C language, the time for computer language to leap forward is ripe. When Dennis Ritchie first invented and implemented the UNIX operating system on the Dec PDP-11, a more ancient bcpl language designed by Martin Richards led to the creation of the C language. Influenced by bcpl language, the B language invented by Kenthompson gradually evolved into C language in the the 1970s. For many years, the C programming Language (prentice-hall,1978), written by Brian Kernighan and Dennis Ritchie, was considered the de facto C-language standard, The book argues that C is only a language that supports UNIX operating systems. The National Organization for Standardization (ANSI) system of the United States, December 1989C language Standards, C language is formally standardized. Many people believe that the emergence of C language marks the beginning of the modern computer language era. It successfully comprehensively dealt with the contradictory attributes that plagued the early language for a long time. C is a powerful, efficient, structured language that is easy to learn, and it also includes an intangible aspect: it is the programmer's own language. Before the advent of the C language, computer language was either designed as an academic experiment or by a bureaucratic committee. And the C language is different. Its design, implementation, development by the real programmer to do the work to complete, reflecting the practical way of programming work. Its characteristics through the actual use of the language people continue to refine, test, think and rethink, so that C language as programmers like to use the language. Indeed, the C language quickly attracted many avid followers and was quickly favored by many programmers. In short, C language is a language designed by programmers and used by them. As you will see, Java inherits this idea.

1.1.2 Requirements for C + +

In the the late 1970s and early 80, C became the mainstream computer programming language, which is still widely used today. You might ask, since C is a successful and useful language, why do you need a new computer language? The answer is complexity (complexity). The fact that the program is becoming more complex runs through the history of programming languages. C + + is adapting to this demand. The following describes why better management of program complexity is the basic condition that C + + produces. The programming method has undergone dramatic changes since the invention of the computer. For example, when a computer has just been invented, programming is achieved by inputting a binary machine instruction through a panel trigger using a manual punch. For programs with only hundreds of lines, this approach is feasible. As programs grow, people invent assembly language, which uses symbols instead of machine instructions, so programmers can handle larger, more complex programs. As the program grows, high-level languages are generated, giving programmers more tools to deal with complexity issues.

The first high-level language to be widely used is, of course, Fortran. Although Fortran was initially deeply impressed, it was unable to produce a well-organized and understandable program. A structured programming approach was proposed in the 1960s. This structured programming idea was applied in a language like C, and for the first time made it relatively easy for programmers to write moderately complex programs. However, when a project reaches a certain scale, even with a structured programming approach, programmers cannot effectively manage its complexity. In the the early 1980s, many engineering projects were more complex than the limits of a structured approach. To solve this problem, the new method of object-oriented programming (Object-oriented Programming,oop) was born. Object-oriented programming is discussed in detail later in this book, but here is a short definition: object-oriented programming is a programming method that helps organize complex programs by using inheritance, encapsulation, and polymorphism.

In short, although C is one of the world's great programming languages, its ability to handle complexity is limited. Once the code of a program exceeds 25 000~100 000 lines, it is difficult to grasp its complexity in general. C + + breaks This limit, helping programmers understand and manage larger programs.

In 1979, Bjarne Stroustrup invented C + + when he worked at Murray Hill Laboratory in New Jersey. Stroustrup originally called this new language "C with Class". 1983, renamed C + +. C + + is augmented by the addition of object-oriented features. Because C + + is built on C, it includes all the features, attributes, and benefits of C. This is a key reason for the success of C + + as a language. The invention of C + + is not an attempt to create a new programming language, but an improvement of a language that has been highly successful. C + + was standardized in November 1997, and the current standard is ansi/iso.

1.1.3 The time has come for Java to appear

In the the late 1980s and early 90, the C + + language dominated the use of object-oriented programming. Indeed, for some time the programmer seemed to think that a perfect language had been found. Because C + + has object-oriented features, and C language efficiency and format advantages, it is a widely used programming language. However, as in the past, the power to promote the evolution of computer language is brewing. In the following years, the World Wide Web (WWW) and the internet reached a critical state. This event contributed to another revolution in programming.

1.2 Generation of Java

java was made by James Gosling,patrick Naughton,chris Warth,ed Frank and Mike Sheridan in 1991 at Sun Designed by Microsystems Company. The development of the first version took 18 months. The language began with the name "Oak" and was renamed "Java" in 1995. From the fall of Oak 1992 to the spring of 1995, the Java language was released publicly, and many people contributed to the design and improvement of Java. Bill Joy,arthur van Hoff,jonathan Payne,frank Yellin and Tim Lindholm are the main contributors, and it is their contribution that has enabled the original prototype to mature. It's a little surprising that Java's initial impulse is not the internet! Instead, it stems from the need for platform-independent (i.e., architecture-neutral) languages that create software that can be embedded in various household appliances, such as microwaves and remote controls. CPU chips used as controllers are diverse, but the disadvantage of C and C + + and most other languages is that only specific targets can be compiled. While it is possible to compile a C + + program for any type of CPU chip, doing so requires a complete C + + compiler that targets that CPU, and creating a compiler is a costly and lengthy task. Therefore, a simple and economical solution is needed. To find such a solution, Gosling and others are working together to develop a portable, cross-platform language that can generate code that runs on different CPU chips in different environments. Their efforts ultimately led to the birth of Java. While some of the details of Java are being designed, the second and most important factor arises, and this factor will play a crucial role in the future of Java. The second factor, of course, is the World Wide Web (WWW). If the World Wide Web (WWW) and the implementation of Java do not occur at the same time, then Java may keep it useful, but obscure to the state of the electronic consumer programming language. However, with the advent of the World Wide Web, Java has been pushed to the forefront of computer language design, because the World Wide Web also requires portable programs. Most programmers know that portable programs are as elusive as their ideals when they get involved in the field of programming. While the search for efficient, portable (platform-independent) programming is almost as long as the history of programming, it always gives the more pressing questions that lie elsewhere. In addition, because the computer industry is Intel,macintosh and UNIX

The 3 competitors have a monopoly and most programmers work long hours in one of these areas, so the need for a portable language is not so urgent. However, with the advent of the Internet and the web, the old problems of the portability language have been raised. After all, the Internet is made up of disparate, distributed systems, including various types of computers, operating systems, and CPUs. Although many types of platforms can be connected to the Internet, users still want them to be able to run the same program. The problem that once was an annoyance but did not need to be prioritized now became a problem that needed to be solved.

In 1993, members of the Java design team discovered the portability problems they frequently encountered in compiling embedded controller code, and also in the process of compiling Internet code. In fact, the Java language, which began to be designed to solve small-scale problems, can also be used on a wide range of Internet. This recognition enabled them to shift the focus of Java from consumer electronics to Internet programming. Therefore, the need for a neutral architecture programming language is the source of the power that drives Java, and the internet ultimately leads to Java's success.

As mentioned earlier, most of Java's features are inherited from C and C + +. The reason why Java designers deliberately do this is because they feel that the use of familiar C syntax and The imitation of C + + object-oriented features in new languages will make their language more appealing to experienced C + + programmers. In addition to the superficial similarities, other factors that have contributed to the success of C and C + + have helped java. First, Java's design, testing, and refining is done by people who really work on programming, rooted in the needs and experience of the people who design it, and thus a programmer's own language. Second, Java is tightly coupled and logically coherent. Finally, in addition to the constraints imposed by the Internet environment, Java gives programmers complete control. If your program is well-written, the program you write can reflect that. Conversely, if your programming is clumsy, it can be reflected in your program. In other words, Java is not a language to train beginners, but a language for professional programmers to use. Because of the similarity between Java and C + +, it is easy to think of Java as a "version of C + +" simply. But this is a misunderstanding. Java has important differences in both practice and theory with C + +. Although Java is affected by C + +, it is not an enhanced version of C + +. For example, Java and C + + are neither up-to-up nor backwards compatible. Of course, Java and C + + similarities are also many, if you are a C + + programmer, you will feel very familiar with Java. Another point is: Java is not used to replace C + +, Java is designed to solve some specific problems, and design C + + is to solve another kind of completely different problems. The two will coexist for a long time. As mentioned in this chapter, the innovation of computer language is driven by two factors: the adaptation to the change of computing environment and the progress of the art of programming. Changes in the environment have prompted Java, a platform-independent language, destined to become a distributed programming language on the Internet. At the same time, Java has changed the way people are programmed, especially Java's enhancements and improvements to the object-oriented paradigm used by C + +. Therefore, Java is not a language that exists in isolation, but a result of the evolution of computer language over the years. This fact alone is enough to justify Java's position in the history of computer language. Java's impact on Internet programming is just like the impact of C on system programming: The Power of revolution will change the world.

1.3 Why Java is important to the Internet

The internet has made Java the most popular programming language on the Web, and the impact of Java on the Internet has been profound. The reason is quite simple: Java extends the world of objects that can flow freely in the space of the race. In the network, there are two major types of objects that are transmitted between the server and the personal computer: passive information and dynamic, active programs. For example, when you read an e-mail message, you are looking at passive data. Even when you download a program, the code of the program is also passive data until you execute it. However, another type of object that can be transferred to a personal computer is a dynamic, self-running program that is initialized by the server, although the program is an active agent on the client. For example, a handler is used to correctly display the program that the server transmits data to. Web-based programs are dynamic, but they also show serious security and portability

Defects. Before Java was generated, half of the object entities in the current space were unable to enter the network world, and Java opened the door for them, and in the process defined a completely new form of the program: applets (small applications).

1.3.1 Java applets and applications

Java can be used to generate two types of programs: Applications (applications) and Java applets (small applications). Applications are programs that can be run on your computer's operating system, and in this regard, Java-based applications are somewhat similar to applications that use C or C + +. There is no big difference between Java and other computer languages when creating an application. The importance of Java is that it has the ability to prepare small applications. Small applications are applications that can be transferred over the Internet and run in a Java-compatible Web browser. Small applications are actually small Java programs, like image files, sound files and video clips through the network dynamic download, its important difference with other files is that the small application is an intelligent program, can respond to the user's input, and can dynamically change, Instead of playing the same animation or sound over and over again. If Java doesn't solve two of the toughest problems with small applications: Security and portability, then small applications won't be so exciting. Before we go on to the next topic, let's start by explaining what these two terms mean to the Internet.

1.3.2 Security

As you know, every time you download a "normal" program, you risk being infected by a virus. Before Java appeared, most users did not often download executable program files, and even if they downloaded the program, they would have to check the virus before running them. Still, most users are concerned that their systems may be infected with viruses. In addition to the virus, another malicious program must be vigilant. This malicious program collects your personal information, such as credit card numbers, bank account settlements, and passwords, by searching the contents of your computer's local file system. Java provides a firewall (firewall) between your Web application and your computer, eliminating these concerns for users. When using a Java-compatible Web browser, you can safely download Java applets without worrying about virus infections or malicious attempts. Java implements this protection by restricting Java programs to the Java runtime and not allowing it to access other parts of the computer, as described in how this process is implemented. It is one of the most important aspects of Java to download small applications and ensure that the security of the client is not compromised.

1.3.3 Portability

As discussed earlier, many types of computers and operating systems are connected to the Internet. To make it possible to dynamically download the same program for a wide variety of platforms connected to the Internet, you need a way to generate portability execution code. You will soon see that the mechanisms that help ensure security are also helping to build portability. In fact, Java's solution to both of these problems is graceful and efficient.

1.4 Java Magic: byte-code

Java solves both of these issues-the key to security and portability is that the Java compiler's output is not executable code, but bytecode (bytecode). Bytecode is a set of highly optimized instructions designed to be executed under the Java Runtime system, known as the Java Virtual machine (Javavirtual MACHINE,JVM). In its standard form, the JVM is a byte-code interpreter. This can be a bit of a surprise, because the compiled results of languages like C + + are executable code. In fact, for performance reasons, many modern languages are designed to be compiled rather than interpreted. However, it is the Java program that runs through the JVM to help solve the main problem of downloading programs on the Internet. This is the reason for the Java output bytecode.

Translating a Java program into bytecode helps it make it easier to run programs in a wide range of environments.

The reason is straightforward: just implement the Java Virtual machine on a variety of platforms. In a given system, only

Any Java program can run on the system if the package exists. Remember: Although the details of the Java virtual machines on different platforms are different, they all explain the same Java bytecode. If a Java program is compiled into native code, there should be a corresponding version of the program for each type of CPU connected to the Internet. This, of course, is not a workable solution. Therefore, the interpretation of bytecode is the easiest way to write a real portability program. Explaining the Java program also helps with its security. Because each Java program runs in the Java Virtual machine's

Under control, a Java virtual machine can contain this program and can prevent it from having side effects outside the system. As you will

See, some limitations specific to the Java language enhance its security. The running speed of the interpreted program is usually slower than the same program being compiled into executable code. But for Java, the difference between the two is not too great. Using bytecode allows the Java runtime system to execute programs much faster than you think.

Although Java is designed to explain the execution of the program, Java is technically not a hindrance to dynamically compiling bytecode into this

Machine code. Sun provides a bytecode compiler--jit (Just in time, instant) in the Java 2 release.

JIT is part of a Java virtual machine that compiles bytecode into executable code in real-time, as needed, in part. It cannot compile the entire Java program all at once into executable code, because Java performs various checks that are performed only at run time. It is important to keep this in mind because the JIT compiles only the code it needs to run. However, this method of immediate compilation execution still makes performance much more significant. The portability and security of the Java program is guaranteed even after the bytecode is dynamically compiled, because the runtime system (which compiles the system) still has control over the running environment of the Java program. The functionality is the same regardless of whether Java programs are interpreted as bytecode in the traditional way or are dynamically compiled into executable code.

1.5 Java Common terms

The general introduction to Java is incomplete without introducing the common terminology of Java. While the source power that drives Java to be born is

Portability and security, but other factors also play an important role in the final prototyping of the Java language. Java

Members of the design development team summed up these key factors, calling them Java jargon, including the following:

· Easy (Simple)

· Security (Secure)

· Portable (Portable)

· Object-oriented (object-oriented)

· Robust (robust)

· Multithreading (multithreaded)

· Architecture Neutrality (architecture-neutral)

· Interpreting execution (interpreted)

· High Performance (performance)

· Distributed (distributed)

· Dynamics (Dynamic)

In these features, security and portability have been described earlier, so let's look at the implications of other features.

1.5.1 Simple

Java is designed to make it easy for professional programmers to learn and to use. Assuming you have a programming experience, you will not feel

Java is difficult to master. If you already understand the basic concepts of object-oriented programming, it will be easier to learn java. If you're an experienced C + + programmer, it's best to learn Java in a very effortless way. Because Java inherits the C + + syntax and many C + + object-oriented features, most programmers do not find it too difficult to learn java. In addition, many confusing concepts in C + + are either discarded by Java or implemented in a clearer, more understandable way. In addition to being similar to C + +, another property in Java makes it easier to learn: designers work hard to make a surprising feature appear in Java. In Java, it's very rare to tell you exactly how to accomplish a particular task.

1.5.2 Object-oriented

Although influenced by its predecessors, Java is not designed to be compatible with other language source code programs. This allows the Java Development Group to start free from scratch. One result of this is that the Java language can be more straightforward, easier to use, and more practical to approach objects. By drawing on the advantages of object-oriented software in recent decades, Java has managed to find a balance between the pure evolutionists ' "Everything is an object" and the pragmatist's "no object to Object" argument. The Java object model is simple and extensible, and it maintains high performance, but not an object, for simple data types, such as integers.

1.5.3 Robust

The multi-platform environment on the World Wide Web makes it particularly demanding for programs, because programs must be reliably executed on many systems. In this way, when designing Java, creating a robust program is placed in a high-priority position. To gain reliability, Java restricts you in some key places, forcing you to find errors early in the process of developing your program. At the same time, Java lets you not worry about many of the most common problems that cause programming errors. Because Java is a strict type language, it not only examines the code at compile time, but also checks the code at run time. In fact, many of the hard-to-follow errors that are often encountered at run time are almost impossible to produce in Java. It is a key feature of Java to know that making a program work in a predictable way in a different operating environment. To better understand how Java is robust, let's consider the two main reasons why the program failed: Memory management errors and error operations (that is, run-time errors). In the traditional programming environment, memory management is a difficult and tedious task. For example, in C + +, programmers must manually allocate and release all dynamic memory. This can sometimes cause problems, because the programmer may forget to release the original allocated memory, or release the memory that other parts of the program is using. Java can fundamentally eliminate these problems by managing memory allocations and releases for you (in fact, freeing up memory is completely automatic because Java provides automatic garbage collection of memory for idle objects). In a traditional environment, anomalies can often be caused by "divide by 0" or "File not found", and we must manage them with a multitude of commands that are difficult to understand. Java solves this problem by providing an object-oriented exception handling mechanism. A well-written Java program, all run-time errors can and should be managed by your program itself.

1.5.4 Multi-Threading

One of the goals of Java design is to satisfy people's need to create interactive online programs. To do this, Java supports multithreaded programming, so applications written in Java can perform multiple tasks at the same time. The Java runtime system has a proven solution for multithreaded synchronization, enabling you to create an interactive system that runs smoothly. Java's multithreading mechanism is very useful, so you just focus on the implementation of the program details, do not worry about the background of the multi-tasking system.

1.5.5 Structural neutrality

A major concern for Java designers is the Persistence and portability of program code. One of the main problems that programmers face is that there is no guarantee that the program written today will run smoothly on the same machine tomorrow. Operating system upgrades, processor upgrades, and changes in core system resources can cause the program to continue running. Java designers have tried this problem a lot, and the Java Virtual Machine (JVM) is trying to solve this problem. Their goal is "to write a program once, anywhere, at any time the program will always run." To a large extent, Java has achieved this goal.

1.5.6 Explanatory and high performance

As mentioned earlier, Java can produce programs that run across platforms by compiling programs into Java bytecode as an intermediate process. Bytecode can be interpreted on any system that provides a Java Virtual machine (JVM). Many of the earlier attempts to solve cross-platform scenarios have high performance requirements. Other language systems that explain execution, such as Basic,tcl,perl, have insurmountable performance flaws. However, Java can run smoothly on very low-end CPUs. As explained earlier, Java is indeed an explanatory language, and Java bytecode is carefully designed so that it is easy to use JIT-compilation techniques to convert bytecode directly into high-performance native code. The Java Runtime system provides this feature while still having platform independence, so "efficient and cross-platform" is no longer contradictory to Java.

1.5.7 distributed

Java is designed for the distributed environment of the Internet because it handles the TCP/IP protocol. In fact, the difference between accessing a resource through a URL and directly accessing a file is not very large. The original Java version (Oak) includes the built-in address space message passing (intra-address-space) feature. This allows objects located on two different computers to perform the procedure remotely. Java recently released a package called Remote Method invocation (invocation, RMI), which enables client/server programming to achieve an unparalleled level of abstraction.

1.5.8 News

Java programs have a variety of run-time type information that is used to validate and resolve object access issues at run time. This makes it possible to dynamically connect code in a safe and efficient manner, and is also important for the robustness of small application environments, where small pieces of code within a bytecode can be dynamically updated in a runtime system.

1.6 rudiment

Java's original release was no less than a revolution, but it did not mark the end of the era of rapid innovation in Java. Unlike most other software systems, where small improvements are often made, Java continues to evolve at an explosive pace. Shortly after Java 1.0 was released, Java designers had created Java 1.1. The new features of Java 1.1 are far more meaningful than revisions in the general sense, and are much richer in content. Java 1.1 adds many new library elements, redefining the way small applications handle events, and re-setting many of the features of the library in version 1.0. It also gave up some of the outdated features originally defined by Java1.0. As a result, Java 1.1 not only adds properties that are not in Java 1.0, but also discards some of the original properties. The second major release of Ava is Java 2. Java 2 is a watershed that marks the beginning of the "modern era" of this fast-evolving language! The version number of the first version of Java 2 is 1.2. It seems a little strange. The reason for this is that it references the version of the original Java library, and it doesn't change much for the entire version. Java 2 Adds a lot of support for new features, such as Swing and class-set frameworks, and it improves the performance of Java virtual machines and various programming tools. Java 2 also contains some content that is not in favor of continuing to use, mainly the use of suspend (), resume () and stop () methods in thread classes. The current version of Java is Java 2, version 1.3. This version of Java is the first major upgrade to the original version of Java 2. This version enhances most of the existing functionality of Java and restricts its development environment. In general, the program source code for version 1.2 and version 1.3 is compatible. Although version 1.3 makes some minor changes compared to the previous 3 versions, this is irrelevant. This book is suitable for Java 2 versions 1.2 and 1.3. Of course, most of the content also applies to earlier versions of Java. In this book, when an attribute is applied only to a specific version of Java, it is noted. Otherwise, you can think of it as appropriate for a generic Java version. In addition, for those features that apply to the 22 versions of Java, the term Java 2 is simply used instead of the version number.

1.7 Java is not an enhanced HTML

It is necessary to clarify a common misconception before continuing with the explanation. Because Java is used to create Web pages, beginners sometimes confuse Java with Hypertext Markup Language (HTML), or think Java is just some of the improvements to HTML. Fortunately, this is only a misunderstanding. Essentially, HTML is a way to define the organization of information logic and provide links to relevant information (called Hypertext links). As you may know, hypertext links (also called hyperlinks) are tools that link a hypertext to another hypertext document, which may be hypertext locally or elsewhere on the World Wide Web. Hypertext document features are defined by selecting the Hypertext document as a link to another related document, which can be read in a non-linear manner after the user searches for various paths. Although HTML allows users to read documents dynamically, HTML can never be a programming language. Of course, HTML does help and advance the popularity of the World Wide Web, and HTML is a catalyst for the birth of Java, but it does not directly affect the design of the Java language in a conceptual sense. The only connection between HTML and Java is that HTML provides a Java applet tag that launches a Java applet. In this way, you can embed instructions in a hypertext document to start a Java applet.

The Java book series-preface