桌面应用程序中英文资料外文翻译文献
MVC框架中英文对照外文翻译文献
MVC框架中英⽂对照外⽂翻译⽂献中英⽂对照外⽂翻译⽂献(⽂档含英⽂原⽂和中⽂翻译)译⽂：Web 2.0下的Spring MVC框架摘要 - 当要建⽴丰富⽤户体验的WEB应⽤时，有⼤量的WED应⽤框架可以使⽤，却很少有该选择哪⼀种的指导。
WEB 2.0应⽤允许个体管理他们⾃⼰的在线⽹页，并能与其他在线⽤户和服务器共享。
这样分享需要访问控制器来实现。
然⽽，现有的访问控制器解决⽅案不是令⼈很满意。
因为在开放且由⽤户主导的WEB环境下，它满⾜不了⽤户的功能需求。
MVC框架是在所有的WEB开发框架中最受欢迎的。
模型-视图-控制器（MVC）是⼀种软件架构，如今被认为是⼀种体系结构在软件⼯程模式中使⽤。
该模式从⽤户界⾯（输⼊和演⽰）分离出了“领域逻辑”（基于⽤户的应⽤逻辑），它允许独⽴地开发，测试和维护每个分离的部分。
模型-视图-控制器（MVC）模型创建的应⽤分离为不同的层次应⽤，同时在每两者之间建⽴松散的耦合。
关键字 - Spring MVC, 结构， XStudio, SOA, 控制器I.绪论如何确切地定义⼀个⽹站为“WEB 2.0”的呢？关于这有着许多不同见解，使它很难精确地下⼀个确切的定论。
但当我们将所有的WEB开发框架过⼀遍之后它就会变得清晰了。
各种基于WEB开发的架构如下：●Ntier架构（Ntier Architecture）在软件⼯程中，多层架构（常被称为n-tier架构）是⼀种表⽰层，应⽤处理层和数据管理层在逻辑上分开处理的客户端-服务器架构。
例如，⼀个应⽤在⽤户与数据库之间使⽤中间件提供数据请求服务就⽤到了多层体系结构。
最为⼴泛应⽤的多层体系结构是三层架构。
N-tier 应⽤架构为开发者提供了⽤来创建了⼀个灵活且可复⽤的模型。
通过打破应⽤层次，开发者只需修改或添加⼀个特定的层，⽽不是要去重写⼀遍整个应⽤。
它需要有⼀个表⽰层，⼀个业务层或者数据访问层和⼀个数据层。
层（layer）和层(tier)之间的概念常常是可以互换的。
物联网工程中英文对照外文翻译文献
中英文对照外文翻译(文档含英文原文和中文翻译)Android: A Programmer’s Guide1 What Is Android1.1 Key Skills & Concepts● History of embedded device programming● Explanation of Open Handset Alliance● First look at the Android home screenIt can be said that, for a while, traditional desktop application developers have been spoiled. This is not to say that traditional desktop application development is easier than other forms of develop ment. However, as traditional desktop application developers, we have had the ability to create alm ost any kind of application we can imagine. I am including myself in this grouping because I got my start in desktop programming.One aspect that has made desktop programming more accessible is that we have had the ability to interact with the desktop operating system, and thus interact with any underlying hardware, pretty1freely (or at least with minimal exceptions). This kind of freedom to program independently, how ever, has never really been available to the small group of programmers who dared to venture int o the murky waters of cell phone development.NOTE ：I refer to two different kinds of developers in this discussion: traditional desktop applicati on developers, who work in almost any language and whose end product, applications, are built to run on any “desktop” operating system; and Android developers, J ava developers who develop for the Android platform. This is not for the purposes of saying one is by any means better or wors e than the other. Rather, the distinction is made for purposes of comparing the development styles and tools of desktop operating system environments to the mobile operating system environment1.2 Brief History of Embedded Device ProgrammingFor a long time, cell phone developers comprised a small sect of a slightly larger group of developers known as embedded device developers. Seen as a less “glamorous” sibling to desktop—and later web—development, embedded device development typically got the proverbial short end of the stick as far as hardware and operating system features, because embedded device manufacturers were notoriously stingy on feature support.Embedded device manufacturers typically needed to guard their hardware secrets closely, so they gave embedded device developers few libraries to call when trying to interact with a specific device. Embedded devices differ fro m desktops in that an embedded device is typically a “computer on a chip.” For example, consider your standard television remote control; it is not really seen as an overwhelming achievement of technological complexity. When any button is pressed, a chip interprets the signal in a way that has been programmed into the device. This allows the device to know what to expect from the input device (key pad), and how to respond to those commands (for example, turn on the television). This is a simple form of embedded device programming. However, believe it or not, simple devices such as these are definitely related to the roots of early cell phone devices and development.Most embedded devices ran (and in some cases still run) proprietary operating systems. The reason for choosing to create a proprietary operating system rather than use any consumer system was really a product of necessity. Simple devices did not need very robust and optimized operating systems.As a product of device evolution, many of the more complex embedded devices, such as early PDAs, household security systems, and GPSs, moved to somewhat standardized operating system platforms about five years ago. Small-footprint operating systems such as Linux, or even an embedded version of Microsoft Windows, have become more prevalent on many embedded devices. Around this time in device evolution, cell phones branched from other embedded devices onto their own path. This branching is evident whenyou examine their architecture.Nearly since their inception, cell phones have been fringe devices insofar as they run on proprietary software—software that is owned and controlled by the manufacturer, and is almost always considered to be a “closed” system. The practice of manufacturers using proprietary operating systems began more out of necessity than any other reason. That is, cell phone manufacturers typically used hardware that was completely developed in-house, or at least hardware that was specifically developed for the purposes of running cell phone equipment. As a result, there were no openly available, off-the-shelf software packages or solutions that would reliably interact with their hardware. Since the manufacturers also wanted to guard very closely their hardware trade secrets, some of which could be revealed by allowing access to the software level of the device, the common practice was, and in most cases still is, to use completely proprietary and closed software to run their devices. The downside to this is that anyone who wanted to develop applications for cell phones needed to have intimate knowledge of the proprietary environment within which it was to run. The solution was to purchase expensive development tools directly from the manufacturer. This isolated many of the “homebrew” develo pers.NOTE：A growing culture of homebrew developers has embraced cell phone application development. The term “homebrew” refers to the fact that these developers typically do not work for a cell phone development company and generally produce small, one-off products on their own time.Another, more compelling “necessity” that kept cell phone development out of the hands of theeveryday developer was the hardware manufacturers’ solution to the “memory versus need” dilemma. Until recently, cell phones did little more than execute and receive phone calls, track your contacts, and possiblysend and receive short text messages; not really the “Swiss army knives” of technology they are today.Even as late as 2002, cell phones with cameras were not commonly found in the hands of consumers.By 1997, small applications such as calculators and games (Tetris, for example) crept their way ontocell phones, but the overwhelming function was still that of a phone dialer itself. Cell phones had not yetbecome the multiuse, multifunction personal tools they are today. No one yet saw the need for Internetbrowsing, MP3 playing, or any of the multitudes of functions we are accustomed to using today. It ispossible that the cell phone manufacturers of 1997 did not fully perceive the need consumers would havefor an all-in-one device. However, even if the need was present, a lack of device memory and storagecapacity was an even bigger obstacle to overcome. More people may have wanted their devices to be all-in-one tools, but manufacturers still had to climb the memory hurdle.To put the problem simply, it takes memory to store and run applications on any device, cell phones included. Cell phones, as a device, until recently did not have the amount of memory available to them thatwould facilitate the inclusion of “extra” programs. Within the last two years, the price of memory hasreached very low levels. Device manufacturers now have the ability to include more memory at lowerprices. Many cell phones now have more standard memory than the average PC had in the mid-1990s. So,now that we have the need, and the memory, we can all jump in and develop cool applications for cellphones around the world, right? Not exactly.Device manufacturers still closely guard the operating systems that run on their devices. While a fewhave opened up to the point where they will allow some Java-based applications to run within a smallenvironment on the phone, many do not allow this. Even the systems that do allow some Java apps to rundo not allow the kind of access to the “core” system that standard desktop developers are accustomed to having.1.3 Open Handset Alliance and AndroidThis barrier to application development began to crumble in November of 2007 when Google, under theOpen Handset Alliance, released Android. The Open Handset Alliance is a group of hardware and softwaredevelopers, including Google, NTT DoCoMo, Sprint Nextel, and HTC, whose goal is to create a more opencell phone environment. The first product to be released under the alliance is the mobile device operatingsystem, Android.With the release of Android, Google made available a host of development tools and tutorials to aid would-be developers onto the new system. Help files, the platform software development kit (SDK), and even a developers’ community can be found at Google’s Android website, This site should be your starting point, and I highly encourage you to visit the site.NOTE ：Google, in promoting the new Android operating system, even went as far as to create a $10million contest looking for new and exciting Android applications.While cell phones running Linux, Windows, and even PalmOS are easy to find, as of this writing, nohardware platforms have been announced for Android to run on. HTC, LG Electronics, Motorola, andSamsung are members of the Open Handset Alliance, under which Android has been released, so we canonly hope that they have plans for a few Android-based devices in the near future. With its release inNovember 2007, the system itself is still in a software-only beta. This is good news for developers because it gives us a rare advance look at a future system and a chance to begin developing applications that willrun as soon as the hardware is released.NOTE：This strategy clearly gives the Open Handset Alliance a big advantage over other cell phone operating system developers, because there could be an uncountable number of applications available immediately for the first devices released to run Android.Introduction to AndroidAndroid, as a system, is a Java-based operating system that runs on the Linux 2.6 kernel. The system is very lightweight and full featured. Android applications are developed using Java and can be ported rather easily to the new platform. If you have not yet downloaded Java or are unsure about which version you need, I detail the installation of the development environment in Chapter 2. Other features of Android include an accelerated 3-D graphics engine (based on hardware support), database support powered by SQLite, and an integrated web browser.If you are familiar with Java programming or are an OOP developer of any sort, you are likely used to programmatic user interface (UI) development—that is, UI placement which is handled directly within the program code. Android, while recognizing and allowing for programmatic UI development, also supports the newer, XML-based UI layout. XML UI layout is a fairly new concept to the average desktop developer. I will cover both the XML UI layout and the programmatic UI development in the supporting chapters of this book.One of the more exciting and compelling features of Android is that, because of its architecture, third-partyapplications—including those that are “home grown”—are executed with the same system priority as those that are bundled with the core system. This is a major departure from most systems, which give embeddedsystem apps a greater execution priority than the thread priority available to apps created by third-partydevelopers. Also, each application is executed within its own thread using a very lightweight virtualmachine.Aside from the very generous SDK and the well-formed libraries that are available to us to develop with,the most exciting feature for Android developers is that we now have access to anything the operatingsystem has access to. In other words, if you want to create an application that dials the phone, you haveaccess to the phone’s dialer; if you want to create an application that utilizes the phone’s internal GPS (ifequipped), you have access to it. The potential for developers to create dynamic and intriguing applicationsis now wide open.On top of all the features that are available from the Android side of the equation, Google has thrown insome very tantalizing features of its own. Developers of Android applications will be able to tie their applications into existing Google offerings such as Google Maps and the omnipresent Google Search.Suppose you want to write an application that pulls up a Google map of where an incoming call isemanating from, or you want to be able to store common search results with your contacts; the doors ofpossibility have been flung wide open with Android.Chapter 2 begins your journey to Android development. You will learn the how’s and why’s of usingspecific development environments or integrated development environments (IDE), and you will downloadand install the Java IDE Eclipse.2 Application: Hello World2.1 Key Skills & Concepts● Creating new Android projects● Working with Views● Using a TextView● Modifying the main.xml file● Running applications on the Android EmulatorIn this chapter, you will be creating your first Android Activity. This chapter examines theapplication-building process from start to finish. I will show you how to create an Android project inEclipse, add code to the initial files, and run the finished application in the Android Emulator. The resultingapplication will be a fully functioning program running in an Android environment.Actually, as you move through this chapter, you will be creating more than one Android Activity.Computer programming tradition dictates that your first application be the typical Hello World! application,so in the first section you will create a standard Hello World! application with just a blank background andthe “Hello World!” text. Then, for the sake of enabling you to get to know the language better, the next section explains in detail the files automatically created by Android for your Hello World! application. You will create two iterations of this Activity, each using different techniques for displaying information to the screen. You will also create two different versions of a Hello World! application that will display an image that delivers the “Hello World!” message. This will give you a good introduction to the controls and inner workings of Android.NOTE：You will often see “application” and “Activity” used interchangeably. The difference between the two is that an application can be composed of multiple Activities, but one application must have at leastone Activity. Each “window” or screen of your application is a separate Activity. Therefore, if you create a fairly simple application with only one screen of data (like the Hello World! application in this chapter),that will be one Activity. In future chapters you will create applications with multiple Activities.To make sure that you get a good overall look at programming in Android, in Chapter 6 you will createboth of these applications in the Android SDK command-line environment for Microsoft Windows andLinux. In other words, this chapter covers the creation process in Eclipse, and Chapter 6 covers the creationprocess using the command-line tools. Therefore, before continuing, you should check that your Eclipseenvironment is correctly configured. Review the steps in Chapter 3 for setting the PATH statement for theAndroid SDK. You should also ensure that the JRE is correctly in your PATH statement.TIP：If you have configuration-related issues while attempting to work with any of the command-lineexamples, try referring to the configuration steps in Chapters 2 and 3; and look at the Android SDK documentation.2.2 Creating Your First Android Project in EclipseTo start your first Android project, open Eclipse. When you open Eclipse for the first time, it opens toan empty development environment (see Figure 5-1), which is where you want to begin. Your first task isto set up and name the workspace for your application. Choose File | New | Android Project, which willlaunch the New Android Project wizard.CAUTION Do not select Java Project from the New menu. While Android applications are written in Java, and you are doing all of your development in Java projects, this option will create a standard Java application. Selecting Android Project enables you to create Android-specific applications.If you do not see the option for Android Project, this indicates that the Android plugin for Eclipse was not fully or correctly installed. Review the procedure in Chapter 3 for installing the Android plugin for Eclipse to correct this.2.3 The New Android Project wizard creates two things for youA shell application that ties into the Android SDK, using the android.jar file, and ties the project intothe Android Emulator. This allows you to code using all of the Android libraries and packages, and alsolets you debug your applications in the proper environment.Your first shell files for the new project. These shell files contain some of the vital application blocksupon which you will be building your programs. In much the same way as creating a Microsoft .NETapplication in Visual Studio generates some Windows-created program code in your files, using the Android Project wizard in Eclipse generates your initial program files and some Android-created code. Inaddition, the New Android Project wizard contains a few options, shown next, that you must set to initiate your Android project. For the Project Name field, for purposes of this example, use the titleHelloWorldText. This name sufficiently distinguishes this Hello World! project from the others that youwill be creating in this chapter.In the Contents area, keep the default selections: the Create New Project inWorkspace radio button should be selected and the Use Default Location check box should be checked.This will allow Eclipse to create your project in your default workspace directory. The advantage ofkeeping the default options is that your projects are kept in a central location, which makes ordering,managing, and finding these projects quite easy. For example, if you are working in a Unix-basedenvironment, this path points to your $HOME directory.If you are working in a Microsoft Windows environment, the workspace path will beC:/Users/<username>/workspace, as shown in the previous illustration. However, for any number of reasons, you may want to uncheck the Use Default Location check box and select a different location for your project. One reason you may want to specify a different location here is simply if you want to choose a location for this specific project that is separate from other Android projects. For example, you may want to keep the projects that you create in this book in a different location from projects that you create in the future on your own. If so, simply override the Location option to specify your own custom location directory for this project.3 Application FundamentalsAndroid applications are written in the Java programming language. The compiled Java code — along with any data and resource files required by the application — is bundled by the aapt tool into an Androidpackage, an archive file marked by an .apk suffix. This file is the vehicle for distributing the application and installing it on mobile devices; it's the file users download to their devices. All the code in a single .apk file is considered to be one application.In many ways, each Android application lives in its own world:1. By default, every application runs in its own Linux process. Android starts the process when any of the application's code needs to be executed, and shuts down the process when it's no longer needed and system resources are required by other applications.2. Each process has its own virtual machine (VM), so application code runs in isolation from the code of all other applications.3. By default, each application is assigned a unique Linux user ID. Permissions are set so that the application's files are visible only to that user and only to the application itself — although there are ways to export them to other applications as well.It's possible to arrange for two applications to share the same user ID, in which case they will be able to see each other's files. To conserve system resources, applications with the same ID can also arrange to run in the same Linux process, sharing the same VM.3.1 Application ComponentsA central feature of Android is that one application can make use of elements of other applications (provided those applications permit it). For example, if your application needs to display a scrolling list of images and another application has developed a suitable scroller and made it available to others, you can call upon that scroller to do the work, rather than develop your own. Application have four types of components:(1)ActivitiesAn activity presents a visual user interface for one focused endeavor the user can undertake. For example, an activity might present a list of menu items users can choose from or it might display photographs along with their captions. A text messaging application might have one activity that shows a list of contacts to send messages to, a second activity to write the message to the chosen contact, and other activities to review old messages or change settings. Though they work together to form a cohesive user interface, each activity is independent of the others. Each one is implemented as a subclass of the Activity base class.An application might consist of just one activity or, like the text messaging application just mentioned, it may contain several. What the activities are, and how many there are depends, of course, on the application and its design. Typically, one of the activities is marked as the first one that should be presented to the user when the application is launched. Moving from one activity to another is accomplished by having the current activity start the next one.Each activity is given a default window to draw in. Typically, the window fills the screen, but it might be smaller than the screen and float on top of other windows. An activity can also make use of additional windows —— for example, a pop-up dialog that calls for a user response in the midst of the activity, or a windowswindow that presents users with vital information when they select a particular item on-screen.The visual content of the window is provided by a hierarchy of views — objects derived from the base View class. Each view controls a particular rectangular space within the window. Parent views contain and organize the layout of their children. Leaf views (those at the bottom of the hierarchy) draw in the rectangles they control and respond to user actions directed at that space. Thus, views are where the activity's interaction with the user takes place.For example, a view might display a small image and initiate an action when the user taps that image. Android has a number of ready-made views that you can use — including buttons, text fields, scroll bars, menu items, check boxes, and more.A view hierarchy is placed within an activity's window by the Activity.setContentView() method. The content view is the View object at the root of the hierarchy. (See the separate User Interface document for more information on views and the hierarchy.)(2)ServicesA service doesn't have a visual user interface, but rather runs in the background for an indefinite period of time. For example, a service might play background music as the user attends to other matters, or it might fetch data over the network or calculate something and provide the result to activities that need it. Each service extends the Service base class.A prime example is a media player playing songs from a play list. The player application would probably have one or more activities that allow the user to choose songs and start playing them. However, the musicplayback itself would not be handled by an activity because users will expect the music to keep playing even after they leave the player and begin something different. To keep the music going, the media player activity could start a service to run in the background. The system would then keep the music playback service running even after the activity that started it leaves the screen.It's possible to connect to (bind to) an ongoing service (and start the service if it's not already running). While connected, you can communicate with the service through an interface that the service exposes. For the music service, this interface might allow users to pause, rewind, stop, and restart the playback.Like activities and the other components, services run in the main thread of the application process. So that they won't block other components or the user interface, they often spawn another thread for time-consuming tasks (like music playback). See Processes and Threads, later.(3)Broadcast receiversA broadcast receiver is a component that does nothing but receive and react to broadcast announcements. Many broadcasts originate in system code — for example, announcements that the timezone has changed, that the battery is low, that a picture has been taken, or that the user changed a language preference. Applications can also initiate broadcasts — for example, to let other applications know that some data has been downloaded to the device and is available for them to use.An application can have any number of broadcast receivers to respond to any announcements it considers important. All receivers extend the BroadcastReceiver base class.Broadcast receivers do not display a user interface. However, they may start an activity in response to the information they receive, or they may use the NotificationManager to alert the user. Notifications can get the user's attention in various ways —— flashing the backlight, vibrating the device, playing a sound, and so the user's attention in various wayson. They typically place a persistent icon in the status bar, which users can open to get the message.(4)Content providersA content provider makes a specific set of the application's data available to other applications. The data can be stored in the file system, in an SQLite database, or in any other manner that makes sense. The content provider extends the ContentProvider base class to implement a standard set of methods that enable other applications to retrieve and store data of the type it controls. However, applications do not call these methods directly. Rather they use a ContentResolver object and call its methods instead. A ContentResolver can talk to any content provider; it cooperates with the provider to manage any interprocess communication that's involved.See the separate Content Providers document for more information on using content providers. Whenever there's a request that should be handled by a particular component, Android makes sure that the application process of the component is running, starting it if necessary, and that an appropriate instance of the component is available, creating the instance if necessary.3.2 Activating components: intentsContent providers are activated when they're targeted by a request from a ContentResolver. The other three components — activities, services, and broadcast receivers — are activated by asynchronous messages called intents. An intent is an Intent object that holds the content of the message. For activities and services, it names the action being requested and specifies the URI of the data to act on, among other things. For example, it might convey a request for an activity to present an image to the user or let the user edit some text. For broadcast receivers, theIntent object names the action being announced. For example, it might announce to interested parties that the camera button has been pressed.。
翻译应用程序软件作文英语
翻译应用程序软件作文英语Title: The Role and Impact of Translation Applications in Modern Software。
Translation applications have become an indispensable tool in today's interconnected world, facilitating communication across language barriers and enabling seamless interaction between individuals and cultures. These software solutions play a pivotal role in breaking down language barriers and fostering global collaboration. In this essay, we will explore the significance of translation applications in modern software and their impact on various aspects of society.One of the primary functions of translationapplications is to bridge the gap between people who speak different languages. In a globalized society where communication is key, these applications empowerindividuals to overcome linguistic obstacles and engage with others regardless of their native tongue. Whether it'stranslating text messages, emails, or social media posts, these applications enable users to communicate effectively across languages, thereby promoting cross-cultural understanding and cooperation.Moreover, translation applications have revolutionized the way businesses operate in the international market. With the rise of e-commerce and online platforms, companies are expanding their reach beyond borders, catering to a diverse global audience. Translation software allows businesses to localize their content, making it accessible and relevant to customers in different regions. From website localization to product descriptions and customer support, these applications facilitate multilingual communication, helping businesses to connect with customers worldwide and drive growth.In addition to facilitating communication, translation applications also play a crucial role in knowledge dissemination and accessibility. In an era where information is abundant but language barriers persist, these applications serve as tools for knowledge exchangeand learning. Whether it's translating educational resources, research papers, or literature, these applications enable individuals to access information in their native language, regardless of its original source. This democratization of information promotes education and cultural exchange on a global scale, enriching societies and empowering individuals with diverse perspectives and insights.Furthermore, translation applications have significant implications for diplomacy and international relations. In an increasingly interconnected world, effective communication between nations is paramount for addressing global challenges and fostering cooperation. Translation software facilitates diplomatic communication by ensuring accurate and timely translation of diplomatic documents, speeches, and negotiations. By removing language barriers, these applications promote dialogue and understanding among nations, contributing to peace, stability, and mutual cooperation on the world stage.However, despite their numerous benefits, translationapplications are not without challenges and limitations. One of the primary concerns is the issue of accuracy and quality. While advancements in machine learning and artificial intelligence have improved the performance of translation algorithms, they may still struggle with nuances, idiomatic expressions, and context-specific meanings. As a result, mistranslations or misinterpretations can occur, leading to misunderstandings or even cultural insensitivity.Another challenge is the preservation of linguistic diversity. While translation applications facilitate communication across languages, they may inadvertently contribute to the dominance of certain languages at the expense of others. As users rely on these applications for translation, there is a risk of language loss or erosion, particularly for smaller or less widely spoken languages. Therefore, efforts must be made to promote linguistic diversity and support the preservation of endangered languages in the digital age.In conclusion, translation applications have becomeindispensable tools in modern software, enabling communication, facilitating business transactions, promoting education, and fostering international cooperation. Despite their challenges and limitations, these applications have revolutionized the way we interact with one another in an increasingly globalized world. As technology continues to evolve, translation applications will play an increasingly important role in bridging linguistic and cultural divides, shaping a more connected and inclusive society.。
英语作文介绍软件的使用
英语作文介绍软件的使用Title: Exploring the Utility of Software Applications。
In our contemporary digital age, software applications have become indispensable tools in various facets of life, ranging from education and business to entertainment and personal organization. In this essay, we will delve into the multifaceted realm of software applications, exploring their diverse functionalities and the profound impact they have on our daily lives.To begin with, software applications facilitate efficiency and productivity in academic endeavors. Take, for instance, educational software designed for students and educators. Programs like Microsoft Office Suite and Google Workspace offer a plethora of tools such as Word, Excel, PowerPoint, and Google Docs, which streamline tasks like document creation, data analysis, and presentation development. These applications not only enhance the quality of academic work but also foster collaborationamong peers and educators through features like real-time editing and commenting.Moreover, software applications play a pivotal role in the realm of business and commerce. Enterprise resource planning (ERP) software, such as SAP and Oracle, revolutionizes the way organizations manage their resources, from finances and human capital to supply chain operations. With integrated modules for accounting, HR management, inventory control, and customer relationship management (CRM), ERP systems optimize business processes, enhance decision-making, and drive organizational growth and profitability.In addition to their practical utility, software applications cater to our entertainment and leisure needs. Gaming enthusiasts are treated to a vast array of gaming software that spans various genres, platforms, and gaming experiences. From immersive role-playing games (RPGs) to adrenaline-pumping action games and intellectually stimulating puzzle games, the gaming industry thrives on innovative software development that pushes the boundariesof imagination and technology.Furthermore, software applications empower individuals to organize and manage their personal lives more effectively. Task management applications like Todoist and Trello enable users to create to-do lists, set reminders, and prioritize tasks, thereby enhancing productivity and time management skills. Additionally, lifestyleapplications such as fitness trackers, meditation apps, and recipe organizers promote holistic well-being byfacilitating exercise regimes, mindfulness practices, and healthy eating habits.It is worth noting that the utility of software applications extends beyond conventional realms to encompass emerging fields such as artificial intelligence (AI), virtual reality (VR), and blockchain technology. AI-powered applications like virtual assistants and language translation tools redefine human-computer interaction, making tasks like scheduling appointments and language learning more seamless and efficient. Similarly, VR applications transport users to immersive virtualenvironments, revolutionizing industries like gaming, education, and architecture. Meanwhile, blockchain-based applications offer decentralized solutions for secure transactions, digital identity verification, and transparent supply chain management.In conclusion, software applications serve as indispensable tools that permeate various aspects of our lives, from education and business to entertainment and personal organization. With their diverse functionalities and transformative impact, software applications continue to shape the way we work, learn, communicate, and entertain ourselves in the digital age. As technology continues to evolve, the landscape of software applications will undoubtedly evolve as well, opening up new possibilities and opportunities for innovation and progress.。
软件工程毕业论文文献翻译中英文对照
软件工程毕业论文文献翻译中英文对照学生毕业设计(论文)外文译文学生姓名: 学号专业名称:软件工程译文标题(中英文):Qt Creator白皮书(Qt Creator Whitepaper)译文出处:Qt network 指导教师审阅签名: 外文译文正文:Qt Creator白皮书Qt Creator是一个完整的集成开发环境(IDE)，用于创建Qt应用程序框架的应用。
Qt是专为应用程序和用户界面，一次开发和部署跨多个桌面和移动操作系统。
本文提供了一个推出的Qt Creator和提供Qt开发人员在应用开发生命周期的特点。
Qt Creator的简介Qt Creator的主要优点之一是它允许一个开发团队共享一个项目不同的开发平台(微软Windows?的Mac OS X?和Linux?)共同为开发和调试工具。
Qt Creator的主要目标是满足Qt开发人员正在寻找简单，易用性，生产力，可扩展性和开放的发展需要，而旨在降低进入新来乍到Qt的屏障。
Qt Creator 的主要功能，让开发商完成以下任务: , 快速，轻松地开始使用Qt应用开发项目向导，快速访问最近的项目和会议。
, 设计Qt物件为基础的应用与集成的编辑器的用户界面，Qt Designer中。
, 开发与应用的先进的C + +代码编辑器，提供新的强大的功能完成的代码片段，重构代码，查看文件的轮廓(即，象征着一个文件层次)。
, 建立，运行和部署Qt项目，目标多个桌面和移动平台，如微软Windows，Mac OS X中，Linux的，诺基亚的MeeGo，和Maemo。
, GNU和CDB使用Qt类结构的认识，增加了图形用户界面的调试器的调试。
, 使用代码分析工具，以检查你的应用程序中的内存管理问题。
, 应用程序部署到移动设备的MeeGo，为Symbian和Maemo设备创建应用程序安装包，可以在Ovi商店和其他渠道发布的。
, 轻松地访问信息集成的上下文敏感的Qt帮助系统。
安卓应用基础中英文对照外文翻译文献
中英文对照外文翻译(文档含英文原文和中文翻译)Android Application FundamentalsAndroid applications are written in the Java programming language. The Android SDK tools compile the code—along with any data and resource files—into an Android package, an archive file with an .apk suffix. All the code in a single .apk file is considered to be one application and is the file that Android-powered devices use to install the application.Once installed on a device, each Android application lives in its own security sandbox:The Android operating system is a multi-user Linux system in which each application is a different user.By default, the system assigns each application a unique Linux user ID (the ID is used only by the system and is unknown to the application). The system sets permissions for all the files in an application so that only the user ID assigned to that application can access them.Each process has its own virtual machine (VM), so an application's code runs in isolation from other applications.By default, every application runs in its own Linux process. Android starts the process when any of the application's components need to be executed, then shuts down the process when it's no longer needed or when the system must recover memory for other applications. In this way, the Android system implements the principle of least privilege. That is, each application, by default, has access only to the components that it requires to do its work and no more. This creates a very secure environment in which an application cannot access parts of the system for which it is not given permission.However, there are ways for an application to share data with other applications and for an application to access system services:It's possible to arrange for two applications to share the same Linux user ID, in which case they are able to access each other's files. To conserve system resources, applications with the same user ID can also arrange to run in the same Linux process and share the same VM (the applications must also be signed with the same certificate).An application can request permission to access device data such as the user's contacts, SMS messages, the mountable storage (SD card), camera, Bluetooth, and more. All application permissions must be granted by the user at install time.That covers the basics regarding how an Android application exists within the system. The rest of this document introduces you to:1、The core framework components that define your application.2、The manifest file in which you declare components and required device features for your application.3、Resources that are separate from the application code and allow your application to gracefully optimize its behavior for a variety of device configurations.Application ComponentsApplication components are the essential building blocks of an Android application. Each component is a different point through which the system can enter your application. Not all components are actual entry points for the user and some depend on each other, but each oneexists as its own entity and plays a specific role—each one is a unique building block that helps define your application's overall behavior.There are four different types of application components. Each type serves a distinct purpose and has a distinct lifecycle that defines how the component is created and destroyed.Here are the four types of application components:ActivitiesAn activity represents a single screen with a user interface. For example, an email application might have one activity that shows a list of new emails, another activity to compose an email, and another activity for reading emails. Although the activities work together to form a cohesive user experience in the email application, each one is independent of the others. As such, a different application can start any one of these activities (if the email application allows it). For example, a camera application can start the activity in the email application that composes new mail, in order for the user to share a picture.An activity is implemented as a subclass of Activity and you can learn more about it in the Activities developer guide.ServicesA service is a component that runs in the background to perform long-running operations or to perform work for remote processes. A service does not provide a user interface. For example, a service might play music in the background while the user is in a different application, or it might fetch data over the network without blocking user interaction with an activity. Another component, such as an activity, can start the service and let it run or bind to it in order to interact with it.A service is implemented as a subclass of Service and you can learn more about it in the Services developer guide.Content providersA content provider manages a shared set of application data. You can store the data in the file system, an SQLite database, on the web, or any other persistent storage location your application can access. Through the content provider, other applications can query or evenmodify the data (if the content provider allows it). For example, the Android system provides a content provider that manages the user's contact information. As such, any application with the proper permissions can query part of the content provider (such as ContactsContract.Data) to read and write information about a particular person.Content providers are also useful for reading and writing data that is private to your application and not shared. For example, the Note Pad sample application uses a content provider to save notes.A content provider is implemented as a subclass of ContentProvider and must implement a standard set of APIs that enable other applications to perform transactions. For more information, see the Content Providers developer guide.Broadcast receiversA broadcast receiver is a component that responds to system-wide broadcast announcements. Many broadcasts originate from the system—for example, a broadcast announcing that the screen has turned off, the battery is low, or a picture was captured. Applications can also initiate broadcasts—for example, to let other applications know that some data has been downloaded to the device and is available for them to use. Although broadcast receivers don't display a user interface, they may create a status bar notification to alert the user when a broadcast event occurs. More commonly, though, a broadcast receiver is just a "gateway" to other components and is intended to do a very minimal amount of work. For instance, it might initiate a service to perform some work based on the event.A broadcast receiver is implemented as a subclass of BroadcastReceiver and each broadcast is delivered as an Intent object. For more information, see the BroadcastReceiver class.A unique aspect of the Android system design is that any application can start another application’s component. For example, if you want the user to capture a photo with the device camera, there's probably another application that does that and your application can use it, instead of developing an activity to capture a photo yourself. You don't need to incorporate or even link to the code from the camera application. Instead, you can simply start the activity in the camera application that captures a photo. When complete, the photo is even returned to your application so you can use it. To the user, it seems as if the camera is actually a part of your application.When the system starts a component, it starts the process for that application (if it's not already running) and instantiates the classes needed for the component. For example, if your application starts the activity in the camera application that captures a photo, that activity runs in the process that belongs to the camera application, not in your application's process. Therefore, unlike applications on most other systems, Android applications don't have a single entry point (there's no main()function, for example).Because the system runs each application in a separate process with file permissions that restrict access to other applications, your application cannot directly activate a component from another application. The Android system, however, can. So, to activate a component in another application, you must deliver a message to the system that specifies your intent to start a particular component. The system then activates the component for you.Activating ComponentsThree of the four component types—activities, services, and broadcast receivers—are activated by an asynchronous message called an intent. Intents bind individual components to each other at runtime (you can think of them as the messengers that request an action from other components), whether the component belongs to your application or another.An intent is created with an Intent object, which defines a message to activate either a specific component or a specific type of component—an intent can be either explicit or implicit, respectively.For activities and services, an intent defines the action to perform (for example, to "view" or "send" something) and may specify the URI of the data to act on (among other things that the component being started might need to know). For example, an intent might convey a request for an activity to show an image or to open a web page. In some cases, you can start an activity to receive a result, in which case, the activity also returns the result in an Intent (for example, you can issue an intent to let the user pick a personal contact and have it returned to you—the return intent includes a URI pointing to the chosen contact).For broadcast receivers, the intent simply defines the announcement being broadcast (for example, a broadcast to indicate the device battery is low includes only a known action string that indicates "battery is low").The other component type, content provider, is not activated by intents. Rather, it is activated when targeted by a request from a ContentResolver. T he content resolver handles all direct transactions with the content provider so that the component that's performing transactions with the provider doesn't need to and instead calls methods onthe ContentResolver object. This leaves a layer of abstraction between the content provider and the component requesting information (for security).There are separate methods for activating each type of component:You can start an activity (or give it something new to do) by passingan Intent to startActivity() or startActivityForResult() (when you want the activity to return a result).You can start a service (or give new instructions to an ongoing service) by passingan Intent to startService(). Or you can bind to the service by passing an Intent to bindService().You can initiate a broadcast by passing an Intent to methodslike sendBroadcast(), sendOrderedBroadcast(), or sendStickyBroadcast().You can perform a query to a content provider by calling query() on a ContentResolver.For more information about using intents, see the Intents and Intent Filters document. More information about activating specific components is also provided in the following documents: Activities, Services, BroadcastReceiver and Content Providers.Declaring componentsThe primary task of the manifest is to inform the system about the application's components. For example, a manifest file can declare an activity as follows:In the <application> element, the android:icon attribute points to resources for an icon that identifies the application.In the <activity> element, the android:name at tribute specifies the fu lly qualified class name of the Activity subclass and the android:label attributes specifies a string to use as the user-visible label for the activity.You must declare all application components this way:1、<activity>elements for activities2、<service> elements for services3、<receiver>elements for broadcast receivers4、<provider>elements for content providersActivities, services, and content providers that you include in your source but do not declare in the manifest are not visible to the system and, consequently, can never run. However, broadcast receivers can be either declared in the manifest or created dynamically in code (as BroadcastReceiver objects) and registered with the system bycalling registerReceiver().Declaring component capabilitiesAs discussed above, in Activating Components, you can use an Intent to start activities, services, and broadcast receivers. You can do so by explicitly naming the target component (using the component class name) in the intent. However, the real power of intents lies in the concept of intent actions. With intent actions, you simply describe the type of action you want to perform (and optionally, the data upon which you’d like to perform the action) and allow the system to find a component on the device that can perform the action and start it. If there are multiple components that can perform the action described by the intent, then the user selects which one to use.The way the system identifies the components that can respond to an intent is by comparing the intent received to the intent filters provided in the manifest file of other applications on the device.When you declare a component in your application's manifest, you can optionally include intent filters that declare the capabilities of the component so it can respond to intents from other applications. You can declare an intent filter for your component by addingan <intent-filter>element as a child of the component's declaration element.For example, an email application with an activity for composing a new email might declare an intent filter in its manifest entry to respond to "send" intents (in order to send email). An activity in your application can then create an intent with the “send” action (ACTION_SEND), which the system matches to the email application’s “send” activity and launches it when you invoke the intent with startActivity().For more about creating intent filters, see the Intents and Intent Filters document.Declaring application requirementsThere are a variety of devices powered by Android and not all of them provide the same features and capabilities. In order to prevent your application from being installed on devices that lack features needed by your application, it's important that you clearly define a profile for the types of devices your application supports by declaring device and software requirements in your manifest file. Most of these declarations are informational only and the system does not read them, but external services such as Google Play do read them in order to provide filtering for users when they search for applications from their device.For example, if your application requires a camera and uses APIs introduced in Android 2.1 (API Level7), you should declare these as requirements in your manifest file. That way, devices that do not have a camera and have an Android version lower than 2.1 cannot install your application from Google Play.However, you can also declare that your application uses the camera, but doesnot require it. In that case, your application must perform a check at runtime to determine if the device has a camera and disable any features that use the camera if one is not available.Here are some of the important device characteristics that you should consider as you design and develop your application:Screen size and densityIn order to categorize devices by their screen type, Android defines two characteristics for each device: screen size (the physical dimensions of the screen) and screen density (the physical density of the pixels on the screen, or dpi—dots per inch). To simplify all the different types of screen configurations, the Android system generalizes them into select groups that make them easier to target.The screen sizes are: small, normal, large, and extra large.The screen densities are: low density, medium density, high density, and extra high density.By default, your application is compatible with all screen sizes and densities, because the Android system makes the appropriate adjustments to your UI layout and image resources. However, you should create specialized layouts for certain screen sizes and provide specialized images for certain densities, using alternative layout resources, and by declaring in your manifest exactly which screen sizes your application supports withthe <supports-screens> element.For more information, see the Supporting Multiple Screens document.Input configurationsMany devices provide a different type of user input mechanism, such as a hardware keyboard, a trackball, or a five-way navigation pad. If your application requires a particular kind of input hardware, then you should declare it in your manifest with the <uses-configuration> element. However, it is rare that an application should require a certain input configuration.Device featuresThere are many hardware and software features that may or may not exist on a given Android-powered device, such as a camera, a light sensor, bluetooth, a certain version of OpenGL, or the fidelity of the touchscreen. You should never assume that a certain feature is available on all Android-powered devices (other than the availability of the standard Android library), so you should declare any features used by your application withthe <uses-feature> element.Platform VersionDifferent Android-powered devices often run different versions of the Android platform, such as Android 1.6 or Android 2.3. Each successive version often includes additional APIs not available in the previous version. In order to indicate which set of APIs are available, each platform version specifies an API Level (for example, Android 1.0 is API Level 1 and Android 2.3 is API Level 9). If you use any APIs that were added to the platform after version 1.0, you should declare the minimum API Level in which those APIs were introduced using the <uses-sdk> element.It's important that you declare all such requirements for your application, because, when you distribute your application on Google Play, the store uses these declarations to filter which applications are available on each device. As such, your application should be available only to devices that meet all your application requirements.For more information about how Google Play filters applications based on these (and other) requirements, see the Filters on Google Play document.Application ResourcesAn Android application is composed of more than just code—it requires resources that are separate from the source code, such as images, audio files, and anything relating to the visual presentation of the application. For example, you should define animations, menus, styles, colors, and the layout of activity user interfaces with XML files. Using application resources makes it easy to update various characteristics of your application without modifying code and—by providing sets of alternative resources—enables you to optimize your application for a variety of device configurations (such as different languages and screen sizes).For every resource that you include in your Android project, the SDK build tools define a unique integer ID, which you can use to reference the resource from your application code or from other resources defined in XML. For example, if your application c ontains an image file named logo.png (saved in the res/drawable/ directory), the SDK tools generate a resource IDnamed R.drawable.logo, which you can use to reference the image and insert it in your user interface.One of the most important aspects of providing resources separate from your source code is the ability for you to provide alternative resources for different device configurations. For example, by defining UI strings in XML, you can translate the strings into other languages and save those strings in separate files. Then, based on a language qualifier that you append to the resource directory's name (such as res/values-fr/ for French string values) and the user's language setting, the Android system applies the appropriate language strings to your UI.Android supports many different qualifiers for your alternative resources. The qualifier is a short string that you include in the name of your resource directories in order to define the device configuration for which those resources should be used. As another example, you should often create different layouts for your activities, depending on the device's screen orientation and size. For example, when the device screen is in portrait orientation (tall), you might want a layout with buttons to be vertical, but when the screen is in landscape orientation (wide), the buttons should be aligned horizontally. To change the layout depending on the orientation, you can define two different layouts and apply the appropriate qualifier to each layout's directory name. Then, the system automatically applies the appropriate layout depending on the current device orientation.For more about the different kinds of resources you can include in your application and how to create alternative resources for various device configurations, see theApplication Resources developer guide.安卓应用基础在Java编程语言编写的Android应用程序的Android的SDK工具编译代码以及与任何数据和到一个Android的包，一个归档文件档案资源的.apk后缀，所有的在一个单一的代码.apk文件被认为是一个应用程序，是Android的文件，供电设备来安装应用程序。
计算机工程专业用于信息安全实践教育的安卓手机应用软件大学毕业论文外文文献翻译及原文
毕业设计（论文）外文文献翻译文献、资料中文题目：用于信息安全实践教育的安卓手机应用软件文献、资料英文题目：文献、资料来源：文献、资料发表（出版）日期：院（部）：专业：计算机信息工程班级：姓名：学号：指导教师：翻译日期： 2017.02.14毕业设计外文文献翻译院系：计算机与信息工程学院年级专业：姓名：学号：附件：Android based mobile apps forinformation security hands-on education用于信息安全实践教育的安卓手机应用软件Zouheir Trabelsi1·Mohammed Al Matrooshi1·Saeed Al Bairaq1·Walid Ibrahim1·Mohammad M. Masud1【摘要】随着移动设备在学生群体中变得越来越流行，新的教育活动和工具，以及学习方法便能够发展到这一流行的移动设备（如可流动性和贴近学生的日常生活）中并从中获益。
特别是，信息安全教育应该反映当前计算机平台远离桌面倾向移动设备的趋势。
本文讨论一个关于学习方法的案例，其目的在于利用移动设备的优点和采取学习信息安全的最佳做法，以及促进学生的兴趣，提高他们的自我效能感。
学习的方法是使用两款Android学习软件，在传统实验室以外，即现实环境中的任何时间，任何地点，通过实施网络流量过滤，提高学生在防火墙过滤规则方面的动手能力。
实际上，这两个Android应用程序，一个是防火墙的应用程序，一个是数据包生成器应用程序。
在谷歌Play商店中，这两个应用程序是免费的。
根据谷歌Play商店的统计数据，约一年半的时间里，数据包生成器应用程序很受欢迎，世界各地的总下载量高达20000次，用户好评达3.75分。
将现有的各种Android防火墙应用程序从建议和突出意义的角度进行分析和对比。
同时，对Android应用程序在实现课程效果的影响进行了讨论。
计算机网络中英文对照外文翻译文献
中英文资料外文翻译计算机网络计算机网络，通常简单的被称作是一种网络，是一家集电脑和设备为一体的沟通渠道，便于用户之间的沟通交流和资源共享。
网络可以根据其多种特点来分类。
计算机网络允许资源和信息在互联设备中共享。
一．历史早期的计算机网络通信始于20世纪50年代末，包括军事雷达系统、半自动地面防空系统及其相关的商业航空订票系统、半自动商业研究环境。
1957年俄罗斯向太空发射人造卫星。
十八个月后，美国开始设立高级研究计划局(ARPA)并第一次发射人造卫星。
然后用阿帕网上的另外一台计算机分享了这个信息。
这一切的负责者是美国博士莱德里尔克。
阿帕网于来于自印度，1969年印度将其名字改为因特网。
上世纪60年代，高级研究计划局(ARPA)开始为美国国防部资助并设计高级研究计划局网(阿帕网)。
因特网的发展始于1969年，20世纪60年代起开始在此基础上设计开发，由此，阿帕网演变成现代互联网。
二．目的计算机网络可以被用于各种用途:为通信提供便利:使用网络，人们很容易通过电子邮件、即时信息、聊天室、电话、视频电话和视频会议来进行沟通和交流。
共享硬件:在网络环境下，每台计算机可以获取和使用网络硬件资源，例如打印一份文件可以通过网络打印机。
共享文件：数据和信息: 在网络环境中，授权用户可以访问存储在其他计算机上的网络数据和信息。
提供进入数据和信息共享存储设备的能力是许多网络的一个重要特征。
共享软件:用户可以连接到远程计算机的网络应用程序。
信息保存。
安全保证。
三．网络分类下面的列表显示用于网络分类：3．1连接方式计算机网络可以据硬件和软件技术分为用来连接个人设备的网络，如：光纤、局域网、无线局域网、家用网络设备、电缆通讯和G.hn（有线家庭网络标准）等等。
以太网的定义，它是由IEEE 802标准，并利用各种媒介，使设备之间进行通信的网络。
经常部署的设备包括网络集线器、交换机、网桥、路由器。
无线局域网技术是使用无线设备进行连接的。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
桌面应用程序中英文资料外文翻译文献Binding Beans and Data in a Desktop Application This guide is an introduction to the support in NetBeans IDE 6.0 for beans binding and data binding in Java desktop applications.Software and Files Needed for the TutorialFor this tutorial you need to have the following software installed on your computer:NetBeans IDE 6.0 (download).Java Standard Development Kit (JDK) version 5.0 or 6.0 (download)Introduction: Beans Binding in NetBeans IDE 6.0Until the release of the beans binding library, it was somewhat cumbersome to connect UI components to databases or to keep values of component properties in sync. For example, displaying data from a standard database in a JTable required the manual creation of utility classes to handle the connection between the database and the JTable. And keeping values of different bean properties in sync (such as the value of a JTextField with the rendering of a visual bean) required hand-coding of listeners and event handlers.The beans binding library simplifies and standardizes all of this. You can merely write a few lines of code to establish which properties of which components need to be kept in sync, and the beans binding library handles the rest. In the NetBeans IDE, beans binding features are integrated in the GUI Builder, so you can quickly get the behavior of your application coded soon after you have established the visual design.This guide is an overview of the main aspects of beans binding in the IDE. For aconcrete example of many of these features, you can try the Building a Java Desktop Database Application tutorial.Binding Properties to Other PropertiesAt its most basic, beans binding is a way to connect bean properties without using event listening and handling code.To illustrate the concept of beans binding and how the IDE supports it, we will do a simple example where a user can adjust a slider to change a numerical value in a text field.To set up the example:In the IDE, choose, File > New Project.Select the Java category and select the Java Application template. Click Next.In the Name and Location page of the wizard, perform the following operations: Type NumberSlider as the project name.Leave the Set As Main Project checkbox selected.Clear the Create Main Class checkbox.Click Finish to exit the wizard and set up the project.In the Projects window, right-click the NumberSlider project node and choose New > JFrame Form.(If JFrame Form is not available in the New menu, choose Other. Then in theNew File wizard, select the Swing GUI Forms category and select the JFrame Form template.)In the Name and Location page of the wizard, perform the following operations: Type NumberSliderFrame for the class name.Type numberslider for the package name.Click Finish to exit the wizard and create the form.NumberSliderForm.java should open in design mode in the editing area.From the Swing Controls section of the Palette, drag a slider component into the design area. (If the Palette window is not open, choose Window > Palette.) From the Palette, drag a text field component to the design area.The resulting form might look something like the screenshot below. However, positioning is not important for purposes of this example.Source and TargetNow that we have set up the example, we are ready to create the binding. However, first we need to determine which component will be the source of the binding and which will be the target. The binding source component is where a value for the property first originates.When binding in the GUI Editor, you initiate a binding on the target and then you declare the source in the Bind dialog box.In this case, since the JSlider comes with a default range of values, we will use it as the source.Note: Bindings can be two-way (read/write), so that changes in the target are automatically reflected in the source. However, the direction of the initial binding is always from the source to the target. See the information on Update Mode in the Advanced Binding Configuration section.To bind the slider to the text field:Right-click the text field component and choose Bind > text to open the Bind dialog box.From the Binding Source combo box, select jSlider1.From the Binding Expression combo box, select value int as shown in the image below.Click OK.You have just bound the value bean property of the slider to the text value of the text field.In the design area, the text field should show the value 50. This value reflects the fact that the slider is in the middle position and the default range of values for the slider is from 0 to 100.You can now run the application and see the binding in action.To run the project:Choose Run > Run Main Project.In the Run Project dialog box, click OK to accept numberslider.NumberSliderForm as the main class.The applications should start in a separate window. Adjust the slider in the running application and watch the value change in the text field.Advanced Binding ConfigurationThe example above shows a straightforward binding with some default behaviors. But sometimes you might want or need to configure your binding differently. If that is the case, you can use the Advanced tab of the Binding dialog box.The Advanced tab of the dialog box contains the following fields:Name. Enables you to create a name for the binding, which gives you more flexibility for managing your bindings. The name is added to the constructor of the binding and can be referenced with the binding's getName() method.Update Mode. Specifies the way that the properties are kept synchronized. The possible values are:Always sync (read/write). Whenever a change is made to either the source or the target, the other is updated.Only read from source (read only). The target is only updated the first time the source value is set. Changes that are made to the source are updated in the target. Changes made to the target are not updated in the source.Read from source once (read once). The target is only updated when the target and source are initially bound.Update Source When (available only to the text property of JTextField and JTextArea components). Enables you to select the frequency with which the properties are synchronized.Ignore Adjusting (available to the value property of JSlider; to the selectedElement property of JTable and JList; and to the selectedElements property ofJTable and JList). If this checkbox is selected, any changes made to one property are not propagated to the other property until the user is finished making the change. For example, when the application's user drags a slider, the value of the property to which the slider's value property is bound is only updated once the user releases the mouse button.Converter. If your binding involves properties with different data types, you can specify code that converts values between the types. The beans binding library handles many commonly needed conversions, but you might need to provide your own converters for other combinations of property types. Such converters need to extend the org.jdesktop.beansbinding.Converter class.The Converter drop-down list is populated with any converters that have been added as beans to your form. You can also add the conversion code directly by clicking the ellipsis (...) button, and selecting Custom Code from the Select Converter Property Using drop-down list.Validator. Enables you to specify code to validate a change in the target property value before propagating that change back to the source property. For example, you can use a validator to make sure that an integer property value is within a specific range.Validators need to extend the org.jdesktop.beansbinding.Validator class.The Validator drop-down list is populated with any validators that have been added as beans to your form. You can also add the validation code directly by clicking the ellipsis (...) button, and selecting Custom Code from the Select Validator Property Using drop-down list.Null Source Value. Enables you to specify a different value to use if the source property has a null value when the binding is attempted. This field corresponds with the setSourceNullValue() method of the org.jdesktop.beansbinding.Binding class.Unreadable Source Value. Enables you to specify a different value to use if the binding expression cannot be resolved when the binding is attempted. This field corresponds with the setSourceUnreadableValue() method of the org.jdesktop.beansbinding.Binding class.Note: To better understand the classes and methods mentioned above, you can access the beans binding Javadoc documentation directly from the IDE. Choose Help > Javadoc References > Beans Binding. In the browser window that opens, click the org.jdesktop.beansbinding link to access documentation for those classes.Binding Data to ComponentsOnce you have created a new Java form and added components to the form, you can generate code to bind those components to data. The IDE makes it easy to bind data to Swing JTable, JList, and JComboBox components.Before binding a component to data from a database, you need to have done the following things:Connected to a database in the IDE.Added the component to a form in the GUI Builder.Created classes that represent the database tables to which you want to bind. Steps on creating the entity classes for binding data to a component are given below.Creating Entity ClassesTo create entity classes to represent the database that is to be bound to the JTable: In the Projects window, right-click your project and choose New > Other, select the Persistence category, and select the Entity Classes from Database template.In the Database Tables page of the wizard, select the database connection.Once the Available Tables column is populated, select the tables that you want to use in your application and click Add to move them to the Selected Tables column. Click Next.In the Entity Classes page of the wizard, make sure the Generate Named QueryAnnotations for Persistent Fields dialog box is selected.Make any customizations that you want to make to the names of the generated classes and their location.Click Create Persistence Unit.In the Create Persistence Unit dialog box, make sure of the following things:That the selected Persistence Library is TopLink.That the selected Table Generation Strategy is "None".Click Finish.You should see nodes for the entity classes in the Projects window.Binding Components to the Beans That Represent the DataTo bind the data to a JTable component:Right-click the component in the GUI Builder and choose Bind > elements.Click Import Data to Form. From the Import Data to Form dialog box, select the database table to which you want to bind your components. Click OK.From the Binding Source combo box, select the item that represents the result list of the entity class. For example, if the entity class is called, Customer.java, the list object would be generated as customerList.Leave the Binding Expression value as null.If there are any database columns that you want to appear in the JTable, select those columns in the Selected list and move them to the Available list.Select the Advanced tab to further configure the binding. For example, you can specify a validator or converter, or you can specify behavior if the binding source is null or unreadable.Click OK.To bind the data to a JList component:Right-click the component in the GUI Builder and choose Bind > elements.Click Import Data to Form. From the Import Data to Form dialog box, select the database table to which you want to bind your components. Click OK.From the Binding Source combo box, select the item that represents the result list of the entity class. For example, if the entity class is called, Customer.java, the list object would be generated as customerList.Leave the Binding Expression value as null.In the Display Expression drop-down list, select the property that represents the database column that contains the values that you want to display in the list.Select the Advanced tab to further configure the binding.Click OK.Note: You can also use the New Java Desktop Application wizard to quickly create a whole working application that has CRUD (create, read, update, and delete) features. However, it is better to generate all the entity classes in advance to ensure that all relations among the entities are correctly covered by the generated classes.Special Binding PropertiesWhere necessary, the beans binding library provides special synthetic properties for some Swing components that are missing from the components themselves. Theseproperties represent things, such as a table's selected row, that are useful to bind to other properties.在桌面应用程序中Bean和数据的绑定这个向导是一个在java桌面应用程序中对于NetBeans IDE 6.0中支持bean 绑定以及数据绑定的介绍。