毕业设计论文外文中英文翻译讲解

本科毕业设计（论文）外文参考文献译文及原文

学院计算机学院

专业网络工程

年级班别2008级（3）班

学号3108007132

学生姓名廖杰发

指导教师黄益民

2012 年 5 月

目录

1 对象的创建和存在时间 (1)

1.1 对象的创建及破坏方式 (1)

1.2 内存池中动态创建对象 (1)

1.3 对象的生命周期 (1)

1.4 其它内容 (2)

1.4.1 集合与继承器 (2)

1.4.2 单根结构 (4)

1.4.3 集合库与方便使用集合 (5)

2Object landscapes and lifetimes (7)

2.1objects created and destroyed (7)

2.2objects created dynamically (7)

2.3Objects’ Lifetime (8)

2.4Other section (8)

2.4.1 Collections and iterators (8)

2.4.2 The singly rooted hierarchy (10)

2.4.3 Collection libraries and support for easy collection use (11)

1对象的创建和存在时间

从技术角度说，OOP（面向对象程序设计）只是涉及抽象的数据类型、继承以及多形性，但另一些问题也可能显得非常重要。本节将就这些问题进行探讨。

1.1对象的创建及破坏方式

对象需要的数据位于哪儿，如何控制对象的“存在时间”呢？针对这个问题，解决的方案是各异其趣的。C++认为程序的执行效率是最重要的一个问题，所以它允许程序员作出选择。为获得最快的运行速度，存储以及存在时间可在编写程序时决定，只需将对象放置在堆栈（有时也叫作自动或定域变量）或者静态存储区域即可。这样便为存储空间的分配和释放提供了一个优先级。某些情况下，这种优先级的控制是非常有价值的。然而，我们同时也牺牲了灵活性，因为在编写程序时，必须知道对象的准确的数量、存在时间、以及类型。如果要解决的是一个较常规的问题，如计算机辅助设计、仓储管理或者空中交通控制，这一方法就显得太局限了。

1.2内存池中动态创建对象

第二个方法是在一个内存池中动态创建对象，该内存池亦叫“堆”或者“内存堆”。若采用这种方式，除非进入运行期，否则根本不知道到底需要多少个对象，也不知道它们的存在时间有多长，以及准确的类型是什么。这些参数都在程序正式运行时才决定的。若需一个新对象，只需在需要它的时候在内存堆里简单地创建它即可。由于存储空间的管理是运行期间动态进行的，所以在内存堆里分配存储空间的时间比在堆栈里创建的时间长得多（在堆栈里创建存储空间一般只需要一个简单的指令，将堆栈指针向下或向下移动即可）。由于动态创建方法使对象本来就倾向于复杂，所以查找存储空间以及释放它所需的额外开销不会为对象的创建造成明显的影响。除此以外，更大的灵活性对于常规编程问题的解决是至关重要的。

C++允许我们决定是在写程序时创建对象，还是在运行期间创建，这种控制方法更加灵活。大家或许认为既然它如此灵活，那么无论如何都应在内存堆里创建对象，而不是在堆栈中创建。

1.3对象的生命周期

但还要考虑另外一个问题，亦即对象的“存在时间”或者“生存时间”

1

（Lifetime）。若在堆栈或者静态存储空间里创建一个对象，编译器会判断对象的持续时间有多长，到时会自动“破坏”或者“清除”它。程序员可用两种方法来破坏一个对象：用程序化的方式决定何时破坏对象，或者利用由运行环境提供的一种“垃圾收集器”特性，自动寻找那些不再使用的对象，并将其清除。当然，垃圾收集器显得方便得多，但要求所有应用程序都必须容忍垃圾收集器的存在，并能默许随垃圾收集带来的额外开销。但这并不符合C++语言的设计宗旨，所以未能包括到C++里。但Java确实提供了一个垃圾收集器（Smalltalk也有这样的设计；尽管Delphi默认为没有垃圾收集器，但可选择安装；而C++亦可使用一些由其他公司开发的垃圾收集产品）。

1.4其它内容

本节剩下的部分将讨论操纵对象时要考虑的另一些因素。

1.4.1集合与继承器

针对一个特定问题的解决，如果事先不知道需要多少个对象，或者它们的持续时间有多长，那么也不知道如何保存那些对象。既然如此，怎样才能知道那些对象要求多少空间呢？事先上根本无法提前知道，除非进入运行期。

在面向对象的设计中，大多数问题的解决办法似乎都有些轻率——只是简单地创建另一种类型的对象。用于解决特定问题的新型对象容纳了指向其他对象的句柄。当然，也可以用数组来做同样的事情，那是大多数语言都具有的一种功能。但不能只看到这一点。这种新对象通常叫作“集合”（亦叫作一个“容器”，但AWT在不同的场合应用了这个术语，所以本书将一直沿用“集合”的称呼。在需要的时候，集合会自动扩充自己，以便适应我们在其中置入的任何东西。所以我们事先不必知道要在一个集合里容下多少东西。只需创建一个集合，以后的工作让它自己负责好了。

幸运的是，设计优良的OOP语言都配套提供了一系列集合。在C++中，它们是以“标准模板库”（STL）的形式提供的。Object Pascal用自己的“可视组件库”（VCL）提供集合。Smalltalk提供了一套非常完整的集合。而Java也用自己的标准库提供了集合。在某些库中，一个常规集合便可满足人们的大多数要求；而在另一些库中（特别是C++的库），则面向不同的需求提供了不同类型的集合。例如，可以用一个矢量统一对所有元素的访问方式；一个链接列表则用于保证所有元素的插入统一。所以我们能根据自己的需要选择适当的类型。其中包括集、队列、散列表、树、堆栈等等。

所有集合都提供了相应的读写功能。将某样东西置入集合时，采用的方式是十分明2

显的。有一个叫作“推”（Push）、“添加”（Add）或其他类似名字的函数用于做这件事情。但将数据从集合中取出的时候，方式却并不总是那么明显。如果是一个数组形式的实体，比如一个矢量（Vector），那么也许能用索引运算符或函数。但在许多情况下，这样做往往会无功而返。此外，单选定函数的功能是非常有限的。如果想对集合中的一系列元素进行操纵或比较，而不是仅仅面向一个，这时又该怎么办呢？

办法就是使用一个“继续器”（Iterator），它属于一种对象，负责选择集合内的元素，并把它们提供给继承器的用户。作为一个类，它也提供了一级抽象。利用这一级抽象，可将集合细节与用于访问那个集合的代码隔离开。通过继承器的作用，集合被抽象成一个简单的序列。继承器允许我们遍历那个序列，同时毋需关心基础结构是什么——换言之，不管它是一个矢量、一个链接列表、一个堆栈，还是其他什么东西。这样一来，我们就可以灵活地改变基础数据，不会对程序里的代码造成干扰。Java最开始（在1.0和1.1版中）提供的是一个标准继承器，名为Enumeration（枚举），为它的所有集合类提供服务。Java 1.2新增一个更复杂的集合库，其中包含了一个名为Iterator的继承器，可以做比老式的Enumeration更多的事情。

从设计角度出发，我们需要的是一个全功能的序列。通过对它的操纵，应该能解决自己的问题。如果一种类型的序列即可满足我们的所有要求，那么完全没有必要再换用不同的类型。有两方面的原因促使我们需要对集合作出选择。首先，集合提供了不同的接口类型以及外部行为。堆栈的接口与行为与队列的不同，而队列的接口与行为又与一个集（Set）或列表的不同。利用这个特征，我们解决问题时便有更大的灵活性。

其次，不同的集合在进行特定操作时往往有不同的效率。最好的例子便是矢量（Vector）和列表（List）的区别。它们都属于简单的序列，拥有完全一致的接口和外部行为。但在执行一些特定的任务时，需要的开销却是完全不同的。对矢量内的元素进行的随机访问（存取）是一种常时操作；无论我们选择的选择是什么，需要的时间量都是相同的。但在一个链接列表中，若想到处移动，并随机挑选一个元素，就需付出“惨重”的代价。而且假设某个元素位于列表较远的地方，找到它所需的时间也会长许多。但在另一方面，如果想在序列中部插入一个元素，用列表就比用矢量划算得多。这些以及其他操作都有不同的执行效率，具体取决于序列的基础结构是什么。在设计阶段，我们可以先从一个列表开始。最后调整性能的时候，再根据情况把它换成矢量。由于抽象是通过继承器进行的，所以能在两者方便地切换，对代码的影响则显得微不足道。

3

最后，记住集合只是一个用来放置对象的储藏所。如果那个储藏所能满足我们的所有需要，就完全没必要关心它具体是如何实现的（这是大多数类型对象的一个基本概念）。如果在一个编程环境中工作，它由于其他因素（比如在Windows下运行，或者由垃圾收集器带来了开销）产生了内在的开销，那么矢量和链接列表之间在系统开销上的差异就或许不是一个大问题。我们可能只需要一种类型的序列。甚至可以想象有一个“完美”的集合抽象，它能根据自己的使用方式自动改变基层的实现方式。

1.4.2单根结构

在面向对象的程序设计中，由于C++的引入而显得尤为突出的一个问题是：所有类最终是否都应从单独一个基础类继承。在Java中（与其他几乎所有OOP语言一样），对这个问题的答案都是肯定的，而且这个终级基础类的名字很简单，就是一个“Object”。这种“单根结构”具有许多方面的优点。

单根结构中的所有对象都有一个通用接口，所以它们最终都属于相同的类型。另一种方案（就象C++那样）是我们不能保证所有东西都属于相同的基本类型。从向后兼容的角度看，这一方案可与C模型更好地配合，而且可以认为它的限制更少一些。但假期我们想进行纯粹的面向对象编程，那么必须构建自己的结构，以期获得与内建到其他OOP 语言里的同样的便利。需添加我们要用到的各种新类库，还要使用另一些不兼容的接口。理所当然地，这也需要付出额外的精力使新接口与自己的设计方案配合（可能还需要多重继承）。为得到C++额外的“灵活性”，付出这样的代价值得吗？当然，如果真的需要——如果早已是C专家，如果对C有难舍的情结——那么就真的很值得。但假如你是一名新手，首次接触这类设计，象Java那样的替换方案也许会更省事一些。

单根结构中的所有对象（比如所有Java对象）都可以保证拥有一些特定的功能。在自己的系统中，我们知道对每个对象都能进行一些基本操作。一个单根结构，加上所有对象都在内存堆中创建，可以极大简化参数的传递（这在C++里是一个复杂的概念）。

利用单根结构，我们可以更方便地实现一个垃圾收集器。与此有关的必要支持可安装于基础类中，而垃圾收集器可将适当的消息发给系统内的任何对象。如果没有这种单根结构，而且系统通过一个句柄来操纵对象，那么实现垃圾收集器的途径会有很大的不同，而且会面临许多障碍。

由于运行期的类型信息肯定存在于所有对象中，所以永远不会遇到判断不出一个对象的类型的情况。这对系统级的操作来说显得特别重要，比如违例控制；而且也能在程

4

序设计时获得更大的灵活性。

1.4.3集合库与方便使用集合

由于集合是我们经常都要用到的一种工具，所以一个集合库是十分必要的，它应该可以方便地重复使用。这样一来，我们就可以方便地取用各种集合，将其插入自己的程序。Java提供了这样的一个库，尽管它在Java 1.0和1.1中都显得非常有限（Java 1.2的集合库则无疑是一个杰作）。

下溯造型与模板／通用性

为了使这些集合能够重复使用，或者“再生”，Java提供了一种通用类型，以前曾把它叫作“Object”。单根结构意味着、所有东西归根结底都是一个对象”！所以容纳了Object的一个集合实际可以容纳任何东西。这使我们对它的重复使用变得非常简便。

为使用这样的一个集合，只需添加指向它的对象句柄即可，以后可以通过句柄重新使用对象。但由于集合只能容纳Object，所以在我们向集合里添加对象句柄时，它会上溯造型成Object，这样便丢失了它的身份或者标识信息。再次使用它的时候，会得到一个Object句柄，而非指向我们早先置入的那个类型的句柄。所以怎样才能归还它的本来面貌，调用早先置入集合的那个对象的有用接口呢？

在这里，我们再次用到了造型（Cast）。但这一次不是在分级结构中上溯造型成一种更“通用”的类型。而是下溯造型成一种更“特殊”的类型。这种造型方法叫作“下溯造型”（Downcasting）。举个例子来说，我们知道在上溯造型的时候，Circle（圆）属于Shape（几何形状）的一种类型，所以上溯造型是安全的。但我们不知道一个Object 到底是Circle还是Shape，所以很难保证下溯造型的安全进行，除非确切地知道自己要操作的是什么。

但这也不是绝对危险的，因为假如下溯造型成错误的东西，会得到我们称为“违例”（Exception）的一种运行期错误。我们稍后即会对此进行解释。但在从一个集合提取对象句柄时，必须用某种方式准确地记住它们是什么，以保证下溯造型的正确进行。

下溯造型和运行期检查都要求花额外的时间来运行程序，而且程序员必须付出额外的精力。既然如此，我们能不能创建一个“智能”集合，令其知道自己容纳的类型呢？这样做可消除下溯造型的必要以及潜在的错误。答案是肯定的，我们可以采用“参数化类型”，它们是编译器能自动定制的类，可与特定的类型配合。例如，通过使用一个参数化集合，编译器可对那个集合进行定制，使其只接受Shape，而且只提取Shape。

5

参数化类型是C++一个重要的组成部分，这部分是C++没有单根结构的缘故。在C++中，用于实现参数化类型的关键字是template（模板）。Java目前尚未提供参数化类型，因为由于使用的是单根结构，所以使用它显得有些笨拙。但这并不能保证以后的版本不会实现，因为“generic”这个词已被Java“保留到将来实现”（在Ada语言中，“generic”被用来实现它的模板）。Java采取的这种关键字保留机制其实经常让人摸不着头脑，很难断定以后会发生什么事情。

6

2Object landscapes and lifetimes

Technically, OOP is just about abstract data typing, inheritance, and polymorphism, but other issues can be at least as important. The remainder of this section will cover these issues.

2.1objects created and destroyed

Where is the data for an object and how is the lifetime of the object controlled? There are different philosophies at work here. C++ takes the approach that control of efficiency is the most important issue, so it gives the programmer a choice. For maximum run-time speed, the storage and lifetime can be determined while the program is being written, by placing the objects on the stack (these are sometimes called automatic or scoped variables) or in the static storage area. This places a priority on the speed of storage allocation and release, and control of these can be very valuable in some situations. However, you sacrifice flexibility because you must know the exact quantity, lifetime, and type of objects while you're writing the program. If you are trying to solve a more general problem such as computer-aided design, warehouse management, or air-traffic control, this is too restrictive.

2.2objects created dynamically

The second approach is to create objects dynamically in a pool of memory called the heap. In this approach, you don't know until run-time how many objects you need, what their lifetime is, or what their exact type is. Those are determined at the spur of the moment while the program is running. If you need a new object, you simply make it on the heap at the point that you need it. Because the storage is managed dynamically, at run-time, the amount of time required to allocate storage on the heap is significantly longer than the time to create storage on the stack. (Creating storage on the stack is often a single assembly instruction to move the stack pointer down, and another to move it back up.) The dynamic approach makes the generally logical assumption that objects tend to be complicated, so the extra overhead of finding storage and releasing that storage will not have an important impact on the creation of an object. In addition, the greater flexibility is essential to solve the general programming problem.

Java uses the second approach, exclusively]. Every time you want to create an object,

7

you use the new keyword to build a dynamic instance of that object.

2.3Objects’ Lifetime

There's another issue, however, and that's the lifetime of an object. With languages that allow objects to be created on the stack, the compiler determines how long the object lasts and can automatically destroy it. However, if you create it on the heap the compiler has no knowledge of its lifetime. In a language like C++, you must determine programmatically when to destroy the object, which can lead to memory leaks if you don’t do it correctly (and this is a common problem in C++ programs). Java provides a feature called a garbage collector that automatically discovers when an object is no longer in use and destroys it. A garbage collector is much more convenient because it reduces the number of issues that you must track and the code you must write. More important, the garbage collector provides a much higher level of insurance against the insidious problem of memory leaks (which has brought many a C++ project to its knees).

2.4Other section

The rest of this section looks at additional factors concerning object lifetimes and landscapes.

2.4.1Collections and iterators

If you don’t know how many objects you’re goi ng to need to solve a particular problem, or how long they will last, you also don’t know how to store those objects. How can you know how much space to create for those objects? You can’t, since that information isn’t known until run-time.

The solution to most problems in object-oriented design seems flippant: you create another type of object. The new type of object that solves this particular problem holds references to other objects. Of course, you can do the same thing with an array, which is available in most languages. But there’s more. This new object, generally called a container (also called a collection, but the Java library uses that term in a different sense so this book will use “container”), will expand itself whenever necessary to accommodate everything you place inside it. So you don’t need to know how many objects you’re going to hold in a container. Just create a container object and let it take care of the details.

8

Fortunately, a good OOP language comes with a set of containers as part of the package. In C++, it’s part of the Standard C++ Library and is sometimes called the Standard Template Library (STL). Object Pascal has containers in its Visual Component Library (VCL). Smalltalk has a very complete set of containers. Java also has containers in its standard library. In some libraries, a generic container is considered good enough for all needs, and in others (Java, for example) the library has different types of containers for different needs: a vector (called an ArrayList in Java) for consistent access to all elements, and a linked list for consistent insertion at all elements, for example, so you can choose the particular type that fits your needs. Container libraries may also include sets, queues, hash tables, trees, stacks, etc.

All containers have some way to put things in and get things out; there are usually functions to add elements to a container, and others to fetch those elements back out. But fetching elements can be more problematic, because a single-selection function is restrictive. What if you want to manipulate or compare a set of elements in the container instead of just one?

The solution is an iterator, which is an object whose job is to select the elements within a container and present them to the user of the iterator. As a class, it also provides a level of abstraction. This abstraction can be used to separate the details of the container from the code that’s accessing that container. The container, via the iterator, is abstracted to be simply a sequence. The iterator allows you to traverse that sequence without worrying about the underlying structure—that is, whether it’s an ArrayList, a LinkedList, a Stack, or something else. This gives you the flexibility to easily change the underlying data structure without disturbing the code in your program. Java began (in version 1.0 and 1.1) with a standard iterator, called Enumeration, for all of its container classes. Java 2 has added a much more complete container library that contains an iterator called Iterator that does more than the older Enumeration.

From a design standpoint, all you really want is a sequence that can be manipulated to solve your problem. If a single type of sequence satisfied all of your needs, there’d be no reason to have different kinds. There are two reasons that you need a choice of containers. First, containers provide different types of interfaces and external behavior. A stack has a

9

different interface and behavior than that of a queue, which is different from that of a set or a list. One of these might provide a more flexible solution to your problem than the other. Second, different containers have different efficiencies for certain operations. The best example is an ArrayList and a LinkedList. Both are simple sequences that can have identical interfaces and external behaviors. But certain operations can have radically different costs. Randomly accessing elements in an ArrayList is a constant-time operation; it takes the same amount of time regardless of the element you select. However, in a LinkedList it is expensive to move through the list to randomly select an element, and it takes longer to find an element that is further down the list. On the other hand, if you want to insert an element in the middle of a sequence, it’s much cheaper in a LinkedList than in an ArrayList. These and other operations have different efficiencies depending on the underlying structure of the sequence. In the design phase, you might start with a LinkedList and, when tuning for performance, change to an ArrayList. Because of the abstraction via iterators, you can change from one to the other with minimal impact on your code.

In the end, remember that a container is only a storage cabinet to put objects in. If that cabinet solves al l of your needs, it doesn’t really matter how it is implemented (a basic concept with most types of objects). If you’re working in a programming environment that has built-in overhead due to other factors, then the cost difference between an ArrayList and a LinkedList might not matter. You might need only one type of sequence. You can even imagine the “perfect” container abstraction, which can automatically change its underlying implementation according to the way it is used.

2.4.2The singly rooted hierarchy

One of the issues in OOP that has become especially prominent since the introduction of C++ is whether all classes should ultimately be inherited from a single base class. In Java (as with virtually all other OOP languages) the answer is “yes” and the name of this ultimate base class is simply Object. It turns out that the benefits of the singly rooted hierarchy are many.

All objects in a singly rooted hierarchy have an interface in common, so they are all ultimately the same type. The alternative (provided by C++) is that you don’t know that everything is the same fundamental type. From a backward-compatibility standpoint this fits

10

the model of C better and can be thought of as less restrictive, but when you want to do full-on object-oriented programming you must then build your own hierarchy to provide the same convenience that’s built into other OOP languages. And in any new class library you acquire, some other incompatible interface will be used. It requires effort (and possibly multiple inheritance) to work the new interface into your design. Is the extra “flexibility” of C++ worth it? If you need it—if you have a large investment in C—it’s quite valuable. If you’re starting from scratch, other alternatives such as Java can often be more productive.

All objects in a singly rooted hierarchy (such as Java provides) can be guaranteed to have certain functionality. You know you can perform certain basic operations on every object in your system. A singly rooted hierarchy, along with creating all objects on the heap, greatly simplifies argument passing (one of the more complex topics in C++).

A singly rooted hierarchy makes it much easier to implement a garbage collector (which is conveniently built into Java). The necessary support can be installed in the base class, and the garbage collector can thus send the appropriate messages to every object in the system. Without a singly rooted hierarchy and a system to manipulate an object via a reference, it is difficult to implement a garbage collector.

Since run-time type information i s guaranteed to be in all objects, you’ll never end up with an object whose type you cannot determine. This is especially important with system level operations, such as exception handling, and to allow greater flexibility in programming.

2.4.3Collection libraries and support for easy collection use

Because a container is a tool that you’ll use frequently, it makes sense to have a library of containers that are built in a reusable fashion, so you can take one off the shelf Because a container is a tool that you’ll use frequently, it makes sense to have a library of containers that are built in a reusable fashion, so you can take one off the shelf and plug it into your program. Java provides such a library, which should satisfy most needs.

Downcasting vs. templates/generics

To make these containers reusable, they hold the one universal type in Java that was previously mentioned: Object. The singly rooted hierarchy means that everything is an Object,

11

so a container that holds Objects can hold anything. This makes containers easy to reuse.

To use such a container, you simply add object references to it, and later ask for them back. But, since the container holds only Objects, when you add your object reference into the container it is upcast to Object, thus losing its identity. When you fetch it back, you get an Object reference, and not a reference to the type that you put in. So how do you turn it back into something that has the useful interface of the object that you put into the container?

Here, the cast is used again, but this time you’re not casting up the inheritance hierarchy to a more general type, you cast down the hierarchy to a more specific type. This manner of casting is called downcasting. With upcasting, you know, for example, that a Circle is a type of Shape so it’s safe to upcast, but you don’t know that an Object is necessarily a Circle or a Shape so it’s hardly safe to downcast unless you know that’s what you’re dealing with.

It’s not completely dangerous, however, because if you downcast to the wrong thing you’ll get a run-time error called an exception, which will be described shortly. When you fetch object references from a container, though, you must have some way to remember exactly what they are so you can perform a proper downcast.

Downcasting and the run-time checks require extra time for the running program, and extra effort from the programmer. Wouldn’t it make sense to somehow create the c ontainer so that it knows the types that it holds, eliminating the need for the downcast and a possible mistake? The solution is parameterized types, which are classes that the compiler can automatically customize to work with particular types. For example, with a parameterized container, the compiler could customize that container so that it would accept only Shapes and fetch only Shapes.

Parameterized types are an important part of C++, partly because C++ has no singly rooted hierarchy. In C++, the keywo rd that implements parameterized types is “template.” Java currently has no parameterized types since it is possible for it to get by—however awkwardly—using the singly rooted hierarchy. However, a current proposal for parameterized types uses a syntax that is strikingly similar to C++ templates.

12

毕业设计外文翻译资料

外文出处： 《Exploiting Software How to Break Code》By Greg Hoglund, Gary McGraw Publisher : Addison Wesley Pub Date : February 17, 2004 ISBN : 0-201-78695-8 译文标题： JDBC接口技术 译文： JDBC是一种可用于执行SQL语句的JavaAPI（ApplicationProgrammingInterface应用程序设计接口）。它由一些Java语言编写的类和界面组成。JDBC为数据库应用开发人员、数据库前台工具开发人员提供了一种标准的应用程序设计接口，使开发人员可以用纯Java语言编写完整的数据库应用程序。 一、ODBC到JDBC的发展历程 说到JDBC，很容易让人联想到另一个十分熟悉的字眼“ODBC”。它们之间有没有联系呢？如果有，那么它们之间又是怎样的关系呢？ ODBC是OpenDatabaseConnectivity的英文简写。它是一种用来在相关或不相关的数据库管理系统（DBMS）中存取数据的，用C语言实现的，标准应用程序数据接口。通过ODBCAPI，应用程序可以存取保存在多种不同数据库管理系统（DBMS）中的数据，而不论每个DBMS使用了何种数据存储格式和编程接口。 1．ODBC的结构模型 ODBC的结构包括四个主要部分：应用程序接口、驱动器管理器、数据库驱动器和数据源。应用程序接口：屏蔽不同的ODBC数据库驱动器之间函数调用的差别，为用户提供统一的SQL编程接口。 驱动器管理器：为应用程序装载数据库驱动器。 数据库驱动器：实现ODBC的函数调用，提供对特定数据源的SQL请求。如果需要，数据库驱动器将修改应用程序的请求，使得请求符合相关的DBMS所支持的文法。 数据源：由用户想要存取的数据以及与它相关的操作系统、DBMS和用于访问DBMS的网络平台组成。 虽然ODBC驱动器管理器的主要目的是加载数据库驱动器，以便ODBC函数调用，但是数据库驱动器本身也执行ODBC函数调用，并与数据库相互配合。因此当应用系统发出调用与数据源进行连接时，数据库驱动器能管理通信协议。当建立起与数据源的连接时，数据库驱动器便能处理应用系统向DBMS发出的请求，对分析或发自数据源的设计进行必要的翻译，并将结果返回给应用系统。 2．JDBC的诞生 自从Java语言于1995年5月正式公布以来，Java风靡全球。出现大量的用java语言编写的程序，其中也包括数据库应用程序。由于没有一个Java语言的API，编程人员不得不在Java程序中加入C语言的ODBC函数调用。这就使很多Java的优秀特性无法充分发挥，比如平台无关性、面向对象特性等。随着越来越多的编程人员对Java语言的日益喜爱，越来越多的公司在Java程序开发上投入的精力日益增加，对java语言接口的访问数据库的API 的要求越来越强烈。也由于ODBC的有其不足之处，比如它并不容易使用，没有面向对象的特性等等，SUN公司决定开发一Java语言为接口的数据库应用程序开发接口。在JDK1．x 版本中，JDBC只是一个可选部件，到了JDK1．1公布时，SQL类包（也就是JDBCAPI）

软件开发概念和设计方法大学毕业论文外文文献翻译及原文

毕业设计（论文）外文文献翻译 文献、资料中文题目：软件开发概念和设计方法文献、资料英文题目： 文献、资料来源： 文献、资料发表（出版）日期： 院（部）： 专业： 班级： 姓名： 学号： 指导教师： 翻译日期： 2017.02.14

外文资料原文 Software Development Concepts and Design Methodologies During the 1960s, ma inframes and higher level programming languages were applied to man y problems including human resource s yste ms,reservation s yste ms, and manufacturing s yste ms. Computers and software were seen as the cure all for man y bu siness issues were some times applied blindly. S yste ms sometimes failed to solve the problem for which the y were designed for man y reasons including: ?Inability to sufficiently understand complex problems ?Not sufficiently taking into account end-u ser needs, the organizational environ ment, and performance tradeoffs ?Inability to accurately estimate development time and operational costs ?Lack of framework for consistent and regular customer communications At this time, the concept of structured programming, top-down design, stepwise refinement，and modularity e merged. Structured programming is still the most dominant approach to software engineering and is still evo lving. These failures led to the concept of "software engineering" based upon the idea that an engineering-like discipl ine could be applied to software design and develop ment. Software design is a process where the software designer applies techniques and principles to produce a conceptual model that de scribes and defines a solution to a problem. In the beginning, this des ign process has not been well structured and the model does not alwa ys accurately represent the problem of software development. However,design methodologies have been evolving to accommo date changes in technolog y coupled with our increased understanding of development processes. Whereas early desig n methods addressed specific aspects of the

毕业设计外文翻译附原文

外文翻译 专业机械设计制造及其自动化学生姓名刘链柱 班级机制111 学号1110101102 指导教师葛友华

外文资料名称： Design and performance evaluation of vacuum cleaners using cyclone technology 外文资料出处：Korean J. Chem. Eng., 23(6), (用外文写) 925-930 (2006) 附件： 1.外文资料翻译译文 2.外文原文

应用旋风技术真空吸尘器的设计和性能介绍 吉尔泰金，洪城铱昌，宰瑾李， 刘链柱译 摘要：旋风型分离器技术用于真空吸尘器 - 轴向进流旋风和切向进气道流旋风有效地收集粉尘和降低压力降已被实验研究。优化设计等因素作为集尘效率，压降，并切成尺寸被粒度对应于分级收集的50％的效率进行了研究。颗粒切成大小降低入口面积，体直径，减小涡取景器直径的旋风。切向入口的双流量气旋具有良好的性能考虑的350毫米汞柱的低压降和为1.5μm的质量中位直径在1米3的流量的截止尺寸。一使用切向入口的双流量旋风吸尘器示出了势是一种有效的方法，用于收集在家庭中产生的粉尘。 摘要及关键词：吸尘器; 粉尘; 旋风分离器 引言 我们这个时代的很大一部分都花在了房子，工作场所，或其他建筑，因此，室内空间应该是既舒适情绪和卫生。但室内空气中含有超过室外空气因气密性的二次污染物，毒物，食品气味。这是通过使用产生在建筑中的新材料和设备。真空吸尘器为代表的家电去除有害物质从地板到地毯所用的商用真空吸尘器房子由纸过滤，预过滤器和排气过滤器通过洁净的空气排放到大气中。虽然真空吸尘器是方便在使用中，吸入压力下降说唱空转成比例地清洗的时间，以及纸过滤器也应定期更换，由于压力下降，气味和细菌通过纸过滤器内的残留粉尘。 图1示出了大气气溶胶的粒度分布通常是双峰形，在粗颗粒（>2.0微米）模式为主要的外部来源，如风吹尘，海盐喷雾，火山，从工厂直接排放和车辆废气排放，以及那些在细颗粒模式包括燃烧或光化学反应。表1显示模式，典型的大气航空的直径和质量浓度溶胶被许多研究者测量。精细模式在0.18?0.36 在5.7到25微米尺寸范围微米尺寸范围。质量浓度为2?205微克，可直接在大气气溶胶和 3.85至36.3μg/m3柴油气溶胶。

本科毕业设计方案外文翻译范本

I / 11 本科毕业设计外文翻译 <2018届） 论文题目基于WEB 的J2EE 的信息系统的方法研究 作者姓名[单击此处输入姓名] 指导教师[单击此处输入姓名] 学科(专业 > 所在学院计算机科学与技术学院 提交日期[时间 ]

基于WEB的J2EE的信息系统的方法研究 摘要：本文介绍基于工程的Java开发框架背后的概念，并介绍它如何用于IT 工程开发。因为有许多相同设计和开发工作在不同的方式下重复，而且并不总是符合最佳实践，所以许多开发框架建立了。我们已经定义了共同关注的问题和应用模式，代表有效解决办法的工具。开发框架提供：<1）从用户界面到数据集成的应用程序开发堆栈；<2）一个架构，基本环境及他们的相关技术，这些技术用来使用其他一些框架。架构定义了一个开发方法，其目的是协助客户开发工程。 关键词：J2EE 框架WEB开发 一、引言 软件工具包用来进行复杂的空间动态系统的非线性分析越来越多地使用基于Web的网络平台，以实现他们的用户界面，科学分析，分布仿真结果和科学家之间的信息交流。对于许多应用系统基于Web访问的非线性分析模拟软件成为一个重要组成部分。网络硬件和软件方面的密集技术变革[1]提供了比过去更多的自由选择机会[2]。因此，WEB平台的合理选择和发展对整个地区的非线性分析及其众多的应用程序具有越来越重要的意义。现阶段的WEB发展的特点是出现了大量的开源框架。框架将Web开发提到一个更高的水平，使基本功能的重复使用成为可能和从而提高了开发的生产力。 在某些情况下，开源框架没有提供常见问题的一个解决方案。出于这个原因，开发在开源框架的基础上建立自己的工程发展框架。本文旨在描述是一个基于Java的框架，该框架利用了开源框架并有助于开发基于Web的应用。通过分析现有的开源框架，本文提出了新的架构，基本环境及他们用来提高和利用其他一些框架的相关技术。架构定义了自己开发方法，其目的是协助客户开发和事例工程。 应用程序设计应该关注在工程中的重复利用。即使有独特的功能要求，也

毕业设计外文翻译-中文版

本科生毕业设计（论文）外文科技文献译文 译文题目(外文题目)学院(系)Socket网络编程的设计与实现A Design and Implementation of Active Network Socket Programming 机械与能源工程学院 专学业 号 机械设计制造及其自动化 071895 学生姓名李杰林 日期2012年5月27日指导教师签名日期

摘要：编程节点和活跃网络的概念将可编程性引入到通信网络中，并且代码和数据可以在发送过程中进行修改。最近，多个研究小组已经设计和实现了自己的设计平台。每个设计都有其自己的优点和缺点，但是在不同平台之间都存在着互操作性问题。因此，我们引入一个类似网络socket编程的概念。我们建立一组针对应用程序进行编程的简单接口，这组被称为活跃网络Socket编程（ANSP）的接口，将在所有执行环境下工作。因此，ANSP 提供一个类似于“一次性编写，无限制运行”的开放编程模型，它可以工作在所有的可执行环境下。它解决了活跃网络中的异构性，当应用程序需要访问异构网络内的所有地区，在临界点部署特殊服务或监视整个网络的性能时显得相当重要。我们的方案是在现有的环境中，所有应用程序可以很容易地安装上一个薄薄的透明层而不是引入一个新的平台。 关键词：活跃网络；应用程序编程接口；活跃网络socket编程

1 导言 1990年，为了在互联网上引入新的网络协议，克拉克和藤农豪斯[1]提出了一种新的设 计框架。自公布这一标志性文件，活跃网络设计框架[2，3，10]已经慢慢在20世纪90 年代末成形。活跃网络允许程序代码和数据可以同时在互联网上提供积极的网络范式，此外，他们可以在传送到目的地的过程中得到执行和修改。ABone作为一个全球性的骨干网络，开 始进行活跃网络实验。除执行平台的不成熟，商业上活跃网络在互联网上的部署也成为主要障碍。例如，一个供应商可能不乐意让网络路由器运行一些可能影响其预期路由性能的未知程序，。因此，作为替代提出了允许活跃网络在互联网上运作的概念，如欧洲研究课题组提出的应用层活跃网络（ALAN）项目[4]。 在ALAN项目中，活跃服务器系统位于网络的不同地址，并且这些应用程序都可以运行在活跃系统的网络应用层上。另一个潜在的方法是网络服务提供商提供更优质的活跃网络服务类。这个服务类应该提供最优质的服务质量（QOS），并允许路由器对计算机的访问。通过这种方法，网络服务提供商可以创建一个新的收入来源。 对活跃网络的研究已取得稳步进展。由于活跃网络在互联网上推出了可编程性，相应 地应建立供应用程序工作的可执行平台。这些操作系统平台执行环境（EES），其中一些已 被创建，例如，活跃信号协议（ASP）[12]和活跃网络传输系统（ANTS）[11]。因此，不 同的应用程序可以实现对活跃网络概念的测试。 在这些EES 环境下，已经开展了一系列验证活跃网络概念的实验，例如，移动网络[5]，网页代理[6]，多播路由器[7]。活跃网络引进了很多在网络上兼有灵活性和可扩展性的方案。几个研究小组已经提出了各种可通过路由器进行网络计算的可执行环境。他们的成果和现有基础设施的潜在好处正在被评估[8，9]。不幸的是，他们很少关心互操作性问题，活跃网络由多个执行环境组成，例如，在ABone 中存在三个EES，专为一个EES编写的应用程序不能在其他平台上运行。这就出现了一种资源划分为不同运行环境的问题。此外，总是有一些关键的网络应用需要跨环境运行，如信息收集和关键点部署监测网络的服务。 在本文中，被称为活跃网络Socket编程（ANSP）的框架模型，可以在所有EES下运行。它提供了以下主要目标： ??通过单一编程接口编写应用程序。 由于ANSP提供的编程接口，使得EES的设计与ANSP 独立。这使得未来执行环境的发展和提高更加透明。

毕业设计外文翻译原文.

Optimum blank design of an automobile sub-frame Jong-Yop Kim a ,Naksoo Kim a,*,Man-Sung Huh b a Department of Mechanical Engineering,Sogang University,Shinsu-dong 1,Mapo-ku,Seoul 121-742,South Korea b Hwa-shin Corporation,Young-chun,Kyung-buk,770-140,South Korea Received 17July 1998 Abstract A roll-back method is proposed to predict the optimum initial blank shape in the sheet metal forming process.The method takes the difference between the ?nal deformed shape and the target contour shape into account.Based on the method,a computer program composed of a blank design module,an FE-analysis program and a mesh generation module is developed.The roll-back method is applied to the drawing of a square cup with the ˉange of uniform size around its periphery,to con?rm its validity.Good agreement is recognized between the numerical results and the published results for initial blank shape and thickness strain distribution.The optimum blank shapes for two parts of an automobile sub-frame are designed.Both the thickness distribution and the level of punch load are improved with the designed blank.Also,the method is applied to design the weld line in a tailor-welded blank.It is concluded that the roll-back method is an effective and convenient method for an optimum blank shape design.#2000Elsevier Science S.A.All rights reserved. Keywords:Blank design;Sheet metal forming;Finite element method;Roll-back method

毕业设计外文翻译

毕业设计（论文） 外文翻译 题目西安市水源工程中的 水电站设计 专业水利水电工程 班级 学生 指导教师 2016年

研究钢弧形闸门的动态稳定性 牛志国 河海大学水利水电工程学院，中国南京，邮编210098 nzg_197901@https://www.sodocs.net/doc/f411921597.html,，niuzhiguo@https://www.sodocs.net/doc/f411921597.html, 李同春 河海大学水利水电工程学院，中国南京，邮编210098 ltchhu@https://www.sodocs.net/doc/f411921597.html, 摘要 由于钢弧形闸门的结构特征和弹力，调查对参数共振的弧形闸门的臂一直是研究领域的热点话题弧形弧形闸门的动力稳定性。在这个论文中，简化空间框架作为分析模型，根据弹性体薄壁结构的扰动方程和梁单元模型和薄壁结构的梁单元模型，动态不稳定区域的弧形闸门可以通过有限元的方法，应用有限元的方法计算动态不稳定性的主要区域的弧形弧形闸门工作。此外，结合物理和数值模型，对识别新方法的参数共振钢弧形闸门提出了调查，本文不仅是重要的改进弧形闸门的参数振动的计算方法，但也为进一步研究弧形弧形闸门结构的动态稳定性打下了坚实的基础。 简介 低举升力，没有门槽，好流型，和操作方便等优点，使钢弧形闸门已经广泛应用于水工建筑物。弧形闸门的结构特点是液压完全作用于弧形闸门，通过门叶和主大梁，所以弧形闸门臂是主要的组件确保弧形闸门安全操作。如果周期性轴向载荷作用于手臂，手臂的不稳定是在一定条件下可能发生。调查指出:在弧形闸门的20次事故中，除了极特殊的破坏情况下，弧形闸门的破坏的原因是弧形闸门臂的不稳定;此外，明显的动态作用下发生破坏。例如:张山闸，位于中国的江苏省，包括36个弧形闸门。当一个弧形闸门打开放水时，门被破坏了，而其他弧形闸门则关闭，受到静态静水压力仍然是一样的，很明显，一个动态的加载是造成的弧形闸门破坏一个主要因素。因此弧形闸门臂的动态不稳定是造成弧形闸门(特别是低水头的弧形闸门)破坏的主要原是毫无疑问。

本科毕业设计外文翻译

Section 3 Design philosophy, design method and earth pressures 3.1 Design philosophy 3.1.1 General The design of earth retaining structures requires consideration of the interaction between the ground and the structure. It requires the performance of two sets of calculations: 1）a set of equilibrium calculations to determine the overall proportions and the geometry of the structure necessary to achieve equilibrium under the relevant earth pressures and forces; 2）structural design calculations to determine the size and properties of thestructural sections necessary to resist the bending moments and shear forces determined from the equilibrium calculations. Both sets of calculations are carried out for specific design situations (see 3.2.2) in accordance with the principles of limit state design. The selected design situations should be sufficiently Severe and varied so as to encompass all reasonable conditions which can be foreseen during the period of construction and the life of the retaining wall. 3.1.2 Limit state design This code of practice adopts the philosophy of limit state design. This philosophy does not impose upon the designer any special requirements as to the manner in which the safety and stability of the retaining wall may be achieved, whether by overall factors of safety, or partial factors of safety, or by other measures. Limit states (see 1.3.13) are classified into: a) ultimate limit states (see 3.1.3); b) serviceability limit states (see 3.1.4). Typical ultimate limit states are depicted in figure 3. Rupture states which are reached before collapse occurs are, for simplicity, also classified and

毕业设计外文翻译原文

编号： 毕业设计(论文)外文翻译 （原文） 院（系）：应用科技学院 专业：机械设计制造及其自动化 学生姓名：邓瑜 学号：0501120501 指导教师单位：应用科技学院 姓名：黄小能 职称： 2009年 5 月20 日

The Injection Molding The Introduction of Molds The mold is at the core of a plastic manufacturing process because its cavity gives a part its shape. This makes the mold at least as critical-and many cases more so-for the quality of the end product as, for example, the plasticiting unit or other components of the processing equipment. Mold Material Depending on the processing parameters for the various processing methods as well as the length of the production run, the number of finished products to be produced, molds for plastics processing must satisfy a great variety of requirements. It is therefore not surprising that molds can be made from a very broad spectrum of materials, including-from a technical standpoint-such exotic materials as paper matched and plaster. However, because most processes require high pressures, often combined with high temperatures, metals still represent by far the most important material group, with steel being the predominant metal. It is interesting in this regard that, in many cases, the selection of the mold material is not only a question of material properties and an optimum price-to-performance ratio but also that the methods used to produce the mold, and thus the entire design, can be influenced. A typical example can be seen in the choice between cast metal molds, with their very different cooling systems, compared to machined molds. In addition, the production technique can also have an effect; for instance, it is often reported that, for the sake of simplicity, a prototype mold is frequently machined from solid stock with the aid of the latest technology such as computer-aided (CAD) and computer-integrated manufacturing (CIM). In contrast to the previously used methods based on the use of patterns, the use of CAD and CAM often represents the more economical solution today, not only because this production capability is available pin-house but also because with any other technique an order would have to be placed with an outside supplier. Overall, although high-grade materials are often used, as a rule standard materials are used in mold making. New, state-of-the art (high-performance) materials, such as ceramics, for instance, are almost completely absent. This may be related to the fact that their desirable characteristics, such as constant properties up to very high temperatures, are not required on molds, whereas their negative characteristics, e. g. low tensile strength and poor thermal conductivity, have a clearly related to ceramics, such as sintered material, is found in mild making only to a limited degree. This refers less to the modern materials and components

抛光瓷砖毕业设计外文文献翻译

毕业设计外文资料翻译 题目POLISHING OF CERAMIC TILES 抛光瓷砖 学院材料科学与工程 专业复合材料与工程 班级 学生 学号 指导教师 二〇一二年三月二十八日

MATERIALS AND MANUFACTURING PROCESSES, 17(3), 401–413 (2002) POLISHING OF CERAMIC TILES C. Y. Wang,* X. Wei, and H. Yuan Institute of Manufacturing Technology, Guangdong University ofTechnology, Guangzhou 510090, P.R. China ABSTRACT Grinding and polishing are important steps in the production of decorative vitreous ceramic tiles. Different combinations of finishing wheels and polishing wheels are tested to optimize their selection. The results show that the surface glossiness depends not only on the surface quality before machining, but also on the characteristics of the ceramic tiles as well as the performance of grinding and polishing wheels. The performance of the polishing wheel is the key for a good final surface quality. The surface glossiness after finishing must be above 208 in order to get higher polishing quality because finishing will limit the maximum surface glossiness by polishing. The optimized combination of grinding and polishing wheels for all the steps will achieve shorter machining times and better surface quality. No obvious relationships are found between the hardness of ceramic tiles and surface quality or the wear of grinding wheels; therefore, the hardness of the ceramic tile cannot be used for evaluating its machinability. Key Words: Ceramic tiles; Grinding wheel; Polishing wheel

毕业设计外文资料翻译译文

附件1：外文资料翻译译文 包装对食品发展的影响 一个消费者对某个产品的第一印象来说包装是至关重要的，包括沟通的可取性，可接受性，健康饮食形象等。食品能够提供广泛的产品和包装组合，传达自己加工的形象感知给消费者，例如新鲜包装/准备，冷藏，冷冻，超高温无菌，消毒（灭菌），烘干产品。 食物的最重要的质量属性之一，是它的味道，其影响人类的感官知觉，即味觉和嗅觉。味道可以很大程度作退化的处理和/或扩展存储。其他质量属性，也可能受到影响，包括颜色，质地和营养成分。食品质量不仅取决于原材料，添加剂，加工和包装的方法，而且其预期的货架寿命（保质期）过程中遇到的分布和储存条件的质量。越来越多的竞争当中，食品生产商，零售商和供应商；和质量审核供应商有显着提高食品质量以及急剧增加包装食品的选择。这些改进也得益于严格的冷藏链中的温度控制和越来越挑剔的消费者。 保质期的一个定义是：在食品加工和包装组合下，在食品的容器和条件，在销售点分布在特定系统的时间能保持令人满意的食味品质。保质期，可以用来作为一个新鲜的概念，促进营销的工具。延期或保质期长的产品，还提供产品的使用时间，方便以及减少浪费食物的风险，消费者和/或零售商。包装产品的质量和保质期的主题是在第3章中详细讨论。 包装为消费者提供有关产品的重要信息，在许多情况下，使用的包装和/或产品，包括事实信息如重量，体积，配料，制造商的细节，营养价值，烹饪和开放的指示，除了法律准则的最小尺寸的文字和数字，有定义的各类产品。消费者寻求更详细的产品信息，同时，许多标签已经成为多语种。标签的可读性是为视障人士的问题，这很可能成为一个对越来越多的老年人口越来越重要的问题。 食物的选择和包装创新的一个主要驱动力是为了方便消费者的需求。这里有许多方便的现代包装所提供的属性，这些措施包括易于接入和开放，处置和处理，产品的知名度，再密封性能，微波加热性，延长保质期等。在英国和其他发达经济体显示出生率下降和快速增长的一个相对富裕的老人人口趋势，伴随着更加苛

毕业设计外文翻译

毕业设计（论文） 外文文献翻译 题目：A new constructing auxiliary function method for global optimization 学院： 专业名称： 学号： 学生姓名： 指导教师： 2014年2月14日

一个新的辅助函数的构造方法的全局优化 Jiang-She Zhang，Yong-Jun Wang https://www.sodocs.net/doc/f411921597.html,/10.1016/j.mcm.2007.08.007 非线性函数优化问题中具有许多局部极小，在他们的搜索空间中的应用，如工程设计，分子生物学是广泛的，和神经网络训练．虽然现有的传统的方法，如最速下降方法，牛顿法，拟牛顿方法，信赖域方法，共轭梯度法，收敛迅速，可以找到解决方案，为高精度的连续可微函数，这在很大程度上依赖于初始点和最终的全局解的质量很难保证．在全局优化中存在的困难阻碍了许多学科的进一步发展．因此，全局优化通常成为一个具有挑战性的计算任务的研究． 一般来说，设计一个全局优化算法是由两个原因造成的困难：一是如何确定所得到的最小是全球性的（当时全球最小的是事先不知道），和其他的是，如何从中获得一个更好的最小跳．对第一个问题，一个停止规则称为贝叶斯终止条件已被报道．许多最近提出的算法的目标是在处理第二个问题．一般来说，这些方法可以被类?主要分两大类，即：（一）确定的方法，及（ii）的随机方法．随机的方法是基于生物或统计物理学，它跳到当地的最低使用基于概率的方法．这些方法包括遗传算法（GA），模拟退火法（SA）和粒子群优化算法（PSO）．虽然这些方法有其用途，它们往往收敛速度慢和寻找更高精度的解决方案是耗费时间．他们更容易实现和解决组合优化问题．然而，确定性方法如填充函数法，盾构法，等，收敛迅速，具有较高的精度，通常可以找到一个解决方案．这些方法往往依赖于修改目标函数的函数“少”或“低”局部极小，比原来的目标函数，并设计算法来减少该?ED功能逃离局部极小更好的发现． 引用确定性算法中，扩散方程法，有效能量的方法，和积分变换方法近似的原始目标函数的粗结构由一组平滑函数的极小的“少”．这些方法通过修改目标函数的原始目标函数的积分．这样的集成是实现太贵，和辅助功能的最终解决必须追溯到

本科毕业设计外文文献翻译

（ 本科毕业设计外文文献翻译 学校代码： 10128 学 号： 题 目：Shear wall structural design of high-level framework 学生姓名： 学 院：土木工程学院 系 别：建筑工程系 专 业：土木工程专业（建筑工程方向） 班 级：土木08-（5）班 指导教师： (副教授)

Shear wall structural design of high-level framework Wu Jicheng Abstract: In this paper the basic concepts of manpower from the frame shear wall structure, analysis of the structural design of the content of the frame shear wall, including the seismic wall shear span ratio design, and a concrete structure in the most commonly used frame shear wall structure the design of points to note. Keywords: concrete; frame shear wall structure; high-rise buildings The wall is a modern high-rise buildings is an important building content, the size of the frame shear wall must comply with building regulations. The principle is that the larger size but the thickness must be smaller geometric features should be presented to the plate, the force is close to cylindrical. The wall shear wall structure is a flat component. Its exposure to the force along the plane level of the role of shear and moment, must also take into account the vertical pressure. Operate under the combined action of bending moments and axial force and shear force by the cantilever deep beam under the action of the force level to look into the bottom mounted on the basis of. Shear wall is divided into a whole wall and the associated shear wall in the actual project, a whole wall for example, such as general housing construction in the gable or fish bone structure film walls and small openings wall. Coupled Shear walls are connected by the coupling beam shear wall. But because the