插入算法用面向对象来写

A. 如何用C#并用面向对象的方式写冒泡算法

public void BubbleSort(int[] R)
{
int i,j,temp;
//交换标志
bool exchange;
//最多做R.Length-1趟排序
for(i=0; i<R.Length; i++)
{
//本趟排序开始前，交换标志应为假
exchange=false;
for(j=R.Length-2; j>=i; j--)
{
//交换条件
if(R[j+1]<R[j])
{
temp=R[j+1];
R[j+1]=R[j];
R[j]=temp;
//发生了交换，故将交换标志置为真
exchange=true;
}
}
//本趟排序未发生交换，提前终止算法
if(!exchange)
{
break;
}
}
}

B. 面向对象的实现

（一）程序设计语言
⒈选择面向对象语言
采用面向对象方法开发软件的基本目的和主要优点是通过重用提高软件的生产率。因此，应该优先选用能够最完善、最准确地表达问题域语义的面向对象语言。
在选择编程语言时，应该考虑的其他因素还有：对用户学习面向对象分析、设计和编码技术所能提供的培训操作；在使用这个面向对象语言期间能提供的技术支持；能提供给开发人员使用的开发工具、开发平台，对机器性能和内存的需求，集成已有软件的容易程度。
⒉程序设计风格
⑴提高重用性。
⑵提高可扩充性。
⑶提高健壮性。
（二）类的实现
在开发过程中，类的实现是核心问题。在用面向对象风格所写的系统中，所有的数据都被封装在类的实例中。而整个程序则被封装在一个更高级的类中。在使用既存部件的面向对象系统中，可以只花费少量时间和工作量来实现软件。只要增加类的实例，开发少量的新类和实现各个对象之间互相通信的操作，就能建立需要的软件。
一种方案是先开发一个比较小、比较简单的来，作为开发比较大、比较复杂的类的基础。
⑴“原封不动”重用。
⑵进化性重用。
一个能够完全符合要求特性的类可能并不存在。
⑶“废弃性”开发。
不用任何重用来开发一个新类。
⑷错误处理。
一个类应是自主的，有责任定位和报告错误。
（三）应用系统的实现
应用系统的实现是在所有的类都被实现之后的事。实现一个系统是一个比用过程性方法更简单、更简短的过程。有些实例将在其他类的初始化过程中使用。而其余的则必须用某种主过程显式地加以说明，或者当作系统最高层的类的表示的一部分。
在C++和C中有一个main（）函数，可以使用这个过程来说明构成系统主要对象的那些类的实例。
（四）面向对象测试
⑴算法层。
⑵类层。
测试封装在同一个类中的所有方法和属性之间的相互作用。
⑶模板层。
测试一组协同工作的类之间的相互作用。
⑷系统层。
把各个子系统组装成完整的面向对象软件系统，在组装过程中同时进行测试。

C. 如何用面向对象编写数据结构与算法

《面向对象数据结构（C++版）》全面介绍了面向对象数据结构的基础理论、算法设计方法和具体应用，包括数据结构及算法设计的基本概念、线性表、串、栈和队列、数组和广义表、树和二叉树、图、查找、排序等内容，力求满足计算机及相关专业本科教学的基本要求及培养目标。《面向对象数据结构（C++版）》采用面向对象C++语言描述数据结构和算法，涉及内容全面丰富，重点突出，理论讲述难度适中，算法实践浅显易懂，例题习题丰富。《面向对象数据结构（C++版）》可作为高等院校计算机及相关专业本科及研究生面向对象数据结构课程教材，也可供从事计算机软件开发和工程应用的技术人员参考。

D. 算法,面向对象:二者有关系吗我感觉编写算法程序用得大多是面向过程的思想,面向对象很少用到

算法大部分是为了提高程序的效率，或者避免漏洞而设计的！C++本来就是面向对象的。感觉不到是因为接触的太少了。什么样的算法和是面向对象还是面向过程，是没有什么关系的。

E. 老师要求小菜使用面向对象的思想编写一个计算器，可以实现两个数的加、减、乘、除运算

第二天。

小菜问道：“你说计算器这样的小程序还可以用到面向对象三大特性？继承和多态怎么可能用得上，我实在不能理解。”

大鸟：“小菜很有钻研精神嘛，好，今天我让你功力加深一级。你先要考虑一下，你昨天写的这个代码，能否做到很灵活的可修改和扩展呢？”

小菜：“我已经把业务和界面分离了呀，这不是很灵活了吗？”

大鸟：“那我问你，现在如果我希望增加一个开根（sqrt）运算，你如何改？”

小菜：“那只需要改Operation类就行了，在switch中加一个分支就行了。”

大鸟：“问题是你要加一个平方根运算，却需要让加减乘除的运算都得来参与编译，如果你一不小心，把加法运算改成了减法，这岂不是大大的糟糕。打个比方，如果现在公司要求你为公司的薪资管理系统做维护，原来只有技术人员（月薪），市场销售人员（底薪+提成），经理（年薪+股份）三种运算算法，现在要增加兼职工作人员（时薪）的算法，但按照你昨天的程序写法，公司就必须要把包含原三种算法的运算类给你，让你修改，你如果心中小算盘一打，‘TMD，公司给我的工资这么低，我真是郁闷，这下有机会了’，于是你除了增加了兼职算法以外，在技术人员（月薪）算法中写了一句

if (员工是小菜)

{

salary = salary * 1.1;

}

那就意味着，你的月薪每月都会增加10%（小心被抓去坐牢），本来是让你加一个功能，却使得原有的运行良好的功能代码产生了变化，这个风险太大了。你明白了吗？”

小菜：“哦，你的意思是，我应该把加减乘除等运算分离，修改其中一个不影响另外的几个，增加运算算法也不影响其他代码，是这样吗？”

大鸟：“自己想去吧，如何用继承和多态，你应该有感觉了。”

小菜：“OK，我马上去写。”

Operation运算类

public class Operation

{

private double _numberA = 0;

private double _numberB = 0;

public double NumberA

{

get { return _numberA; }

set { _numberA = value; }

}

public double NumberB

{

get { return _numberB; }

set { _numberB = value; }

}

public virtual double GetResult()

{

double result = 0;

return result;

}

}

加减乘除类

class OperationAdd : Operation

{

public override double GetResult()

{

double result = 0;

result = NumberA + NumberB;

return result;

}

}

class OperationSub : Operation

{

public override double GetResult()

{

double result = 0;

result = NumberA - NumberB;

return result;

}

}

class OperationMul : Operation

{

public override double GetResult()

{

double result = 0;

result = NumberA * NumberB;

return result;

}

}

class OperationDiv : Operation

{

public override double GetResult()

{

double result = 0;

if (NumberB==0)

throw new Exception("除数不能为0。");

result = NumberA / NumberB;

return result;

}

}

小菜：“大鸟哥，我按照你说的方法写出来了一部分，首先是一个运算类，它有两个Number属性，主要用于计算器的前后数，然后有一个虚方法GetResult()，用于得到结果，然后我把加减乘除都写成了运算类的子类，继承它后，重写了GetResult()方法，这样如果要修改任何一个算法，就不需要提供其他算法的代码了。但问题来了，我如何让计算器知道我是希望用哪一个算法呢？”

F. java 使用面向对象编写计算器

做法相当的 多```

用简单工厂模式做。

把加、减、乘、除运算 之类的逻辑放到接口中，
在客户来具体实列化那一个工厂，把所有的判断全部写在 借口的实现类中去`````

G. JAVA怎么用面向对象思想写计算器

//frame版程序源代码如下，疏漏之处，望批评指正。
//数字分组没有编写，科学型计算器没有编写，其他已经完善。
import java.awt.*;
import java.lang.*;
import javax.swing.*;
import javax.swing.event.*;
import java.awt.event.*;
import java.text.DecimalFormat;public class Calculator implements ActionListener { // 导入动作监听接口
// 设计面板中的单位
JFrame frame; JTextField textAnswer; JPanel panel, panel1, panel2, panel3; JMenuBar mainMenu; JTextField textMemory; JLabel labelMemSpace; // labelMemSpace单纯做摆设，控制面板的形状 JButton buttonBk, buttonCe, buttonC; JButton button[]; JButton buttonMC, buttonMR, buttonMS, buttonMAdd; JButton buttonDot, buttonAddAndSub, buttonAdd, buttonSub, buttonMul,
buttonDiv, buttonMod; JButton buttonSqrt, buttonDao, buttonEqual; JMenu editMenu, viewMenu, helpMenu; JMenuItem Item, pasteItem, tItem, sItem, numberGroup, topHelp,
aboutCal; DecimalFormat df; // 设置数据输出精度 boolean clickable; // 控制当前能否按键 double memoryd; // 使用内存中存储的数字 int memoryi; double vard, answerd; // 用来保存double型数据的中间值(vard)和最后结果(answerd) short key = -1, prekey = -1; // key用来保存当前进行何种运算,prekey用来保存前次进行何种运算 String ; // 做复制用 JTextArea help; // 帮助 JScrollPane scrollHelp; // 构造函数
public Calculator() {
clickable = true;
answerd = 0;
frame = new JFrame("计算器");
df = new DecimalFormat("0.##############"); // 设置数据输出精度(对于double型值)
textAnswer = new JTextField(15);
textAnswer.setText("");
textAnswer.setEditable(false);
textAnswer.setBackground(new Color(255, 255, 255));
panel = new JPanel();
frame.getContentPane().add(panel);
panel1 = new JPanel();
panel2 = new JPanel();
panel.setLayout(new BorderLayout());
// 设计整个面板
mainMenu = new JMenuBar();
editMenu = new JMenu("编辑(E)");
viewMenu = new JMenu("查看(V)");
helpMenu = new JMenu("帮助(H)");
Item = new JMenuItem(" 复制(C) Ctrl+C");
Item.addActionListener(this);
pasteItem = new JMenuItem(" 粘贴(V) Ctrl+V");
pasteItem.addActionListener(this);
editMenu.add(Item);
editMenu.add(pasteItem);
tItem = new JMenuItem("●标准型(T)");
tItem.addActionListener(this);
sItem = new JMenuItem(" 科学型(S)");
sItem.addActionListener(this);
numberGroup = new JMenuItem(" 数字分组(I)");
numberGroup.addActionListener(this);
viewMenu.add(tItem);
viewMenu.add(sItem);
viewMenu.add(numberGroup);
topHelp = new JMenuItem(" 帮助主题(H)");
topHelp.addActionListener(this);
help = new JTextArea(5, 20);
scrollHelp = new JScrollPane(help);
help.setEditable(false);
help.append("执行简单计算\n");
help.append("1. 键入计算的第一个数字。\n");
help.append("2. 单击“+”执行加、“-”执行减、“*”执行乘或“/”执行除。\n");
help.append("3. 键入计算的下一个数字。\n");
help.append("4. 输入所有剩余的运算符和数字。\n");
help.append("5. 单击“=”。\n");
aboutCal = new JMenuItem(" 关于计算器(A)");
aboutCal.addActionListener(this);
helpMenu.add(topHelp);
helpMenu.add(aboutCal);
mainMenu.add(editMenu);
mainMenu.add(viewMenu);
mainMenu.add(helpMenu);
panel.add(mainMenu, BorderLayout.NORTH);
panel.add(textAnswer, BorderLayout.CENTER);
panel.add(panel1, BorderLayout.SOUTH);
panel1.setLayout(new BorderLayout());
textMemory = new JTextField(3);
textMemory.setEditable(false);
textMemory.setBackground(new Color(217, 217, 217));
labelMemSpace = new JLabel(" ");
buttonBk = new JButton("Backspace");
buttonBk.setForeground(new Color(255, 0, 0));
buttonCe = new JButton("CE");
buttonCe.setForeground(new Color(255, 0, 0));
buttonC = new JButton("C");
buttonC.setForeground(new Color(255, 0, 0));
buttonBk.addActionListener(this);
buttonCe.addActionListener(this);
buttonC.addActionListener(this);
panel1.add(panel2, BorderLayout.NORTH);
panel2.setLayout(new FlowLayout(FlowLayout.RIGHT));
panel2.add(textMemory);
panel2.add(labelMemSpace);
panel2.add(buttonBk);
panel2.add(buttonCe);
panel2.add(buttonC);
panel3 = new JPanel();
panel1.add(panel3, BorderLayout.CENTER);
button = new JButton[10];
for (int i = 0; i < button.length; i++) {
button[i] = new JButton(Integer.toString(i));
button[i].setForeground(new Color(0, 0, 255));
}
buttonMC = new JButton("MC");
buttonMC.setForeground(new Color(255, 0, 0));
buttonMR = new JButton("MR");
buttonMR.setForeground(new Color(255, 0, 0));
buttonMS = new JButton("MS");
buttonMS.setForeground(new Color(255, 0, 0));
buttonMAdd = new JButton("M+");
buttonMAdd.setForeground(new Color(255, 0, 0));
buttonDot = new JButton(".");
buttonDot.setForeground(new Color(0, 0, 255));
buttonAddAndSub = new JButton("+/-");
buttonAddAndSub.setForeground(new Color(0, 0, 255));
buttonAdd = new JButton("+");
buttonAdd.setForeground(new Color(255, 0, 0));
buttonSub = new JButton("-");
buttonSub.setForeground(new Color(255, 0, 0));
buttonMul = new JButton("*");
buttonMul.setForeground(new Color(255, 0, 0));
buttonDiv = new JButton("/");
buttonDiv.setForeground(new Color(255, 0, 0));
buttonMod = new JButton("%");
buttonMod.setForeground(new Color(0, 0, 255));
buttonSqrt = new JButton("sqrt");
buttonSqrt.setForeground(new Color(0, 0, 255));
buttonDao = new JButton("1/x");
buttonDao.setForeground(new Color(0, 0, 255));
buttonEqual = new JButton("=");
buttonEqual.setForeground(new Color(255, 0, 0));
// 将所有行为与监听绑定
panel3.setLayout(new GridLayout(4, 6));
panel3.add(buttonMC);
buttonMC.addActionListener(this);
panel3.add(button[7]);
button[7].addActionListener(this);
panel3.add(button[8]);
button[8].addActionListener(this);
panel3.add(button[9]);
button[9].addActionListener(this);
panel3.add(buttonDiv);
buttonDiv.addActionListener(this);
panel3.add(buttonSqrt);
buttonSqrt.addActionListener(this);
panel3.add(buttonMR);
buttonMR.addActionListener(this);
panel3.add(button[4]);
button[4].addActionListener(this);
panel3.add(button[5]);
button[5].addActionListener(this);
panel3.add(button[6]);
button[6].addActionListener(this);
panel3.add(buttonMul);
buttonMul.addActionListener(this);
panel3.add(buttonMod);
buttonMod.addActionListener(this);
panel3.add(buttonMS);
buttonMS.addActionListener(this);
panel3.add(button[1]);
button[1].addActionListener(this);
panel3.add(button[2]);
button[2].addActionListener(this);
panel3.add(button[3]);
button[3].addActionListener(this);
panel3.add(buttonSub);
buttonSub.addActionListener(this);
panel3.add(buttonDao);
buttonDao.addActionListener(this);
panel3.add(buttonMAdd);
buttonMAdd.addActionListener(this);
panel3.add(button[0]);
button[0].addActionListener(this);
panel3.add(buttonAddAndSub);
buttonAddAndSub.addActionListener(this);
panel3.add(buttonDot);
buttonDot.addActionListener(this);
panel3.add(buttonAdd);
buttonAdd.addActionListener(this);
panel3.add(buttonEqual);
buttonEqual.addActionListener(this);
frame.setDefaultCloseOperation(frame.EXIT_ON_CLOSE);
frame.pack();
frame.show();
} // 设置各个按钮行为
public void actionPerformed(ActionEvent event) {
boolean sign = false; // 判断是否是double型数参与运算，是为true，不是为false
Object temp = event.getSource();
try {
// 如果按下数据按钮，将按下的按钮代表的数据插入的当前文本框字符串之后
for (int i = 0; i <= 9; i++)
if (temp == button[i] && clickable == true)
textAnswer.setText(textAnswer.getText()
+ Integer.toString(i));
// 按下'.'按钮时，判断当前文本框内字符串中含不含'.'，如果已含，则不允许再插入'.'
if (temp == buttonDot && clickable == true) {
boolean isDot = false;
if (textAnswer.getText().length() == 0)
isDot = true;
for (int i = 0; i < textAnswer.getText().length(); i++)
if ('.' == textAnswer.getText().charAt(i)) {
isDot = true;
break;
}
if (isDot == false)
textAnswer.setText(textAnswer.getText() + ".");
}
if ((temp == buttonAdd || temp == buttonSub || temp == buttonMul || temp == buttonDiv)
&& clickable == true) {
// '+'操作
if (temp == buttonAdd) {
switch (prekey) {
case 0:
answerd += Double.parseDouble(textAnswer.getText());
break;
case 1:
answerd -= Double.parseDouble(textAnswer.getText());
break;
case 2:
answerd *= Double.parseDouble(textAnswer.getText());
break;
case 3:
if (Double.parseDouble(textAnswer.getText()) == 0) {
textAnswer.setText("除数不能为零");
clickable = false;
} else
answerd /= Double.parseDouble(textAnswer.getText());
break;
default:
answerd = Double.parseDouble(textAnswer.getText());
}
textAnswer.setText("");
prekey = key = 0;
}
// '-'操作
if (temp == buttonSub) {
switch (prekey) {
case 0:
answerd += Double.parseDouble(textAnswer.getText());
break;
case 1:
answerd -= Double.parseDouble(textAnswer.getText());
break;
case 2:
answerd *= Double.parseDouble(textAnswer.getText());
break;
case 3:
if (Double.parseDouble(textAnswer.getText()) == 0) {
textAnswer.setText("除数不能为零");
clickable = false;
} else
answerd /= Double.parseDouble(textAnswer.getText());
break;
default:
answerd = Double.parseDouble(textAnswer.getText());
}
textAnswer.setText("");
prekey = key = 1;
}
// '*'操作
if (temp == buttonMul) {
switch (prekey) {
case 0:
answerd += Double.parseDouble(textAnswer.getText());
break;
case 1:
answerd -= Double.parseDouble(textAnswer.getText());
break;
case 2:
answerd *= Double.parseDouble(textAnswer.getText());
break;
case 3:
if (Double.parseDouble(textAnswer.getText()) == 0) {
textAnswer.setText("除数不能为零");
clickable = false;
} else
answerd /= Double.parseDouble(textAnswer.getText());
break;
default:
answerd = Double.parseDouble(textAnswer.getText());
}
textAnswer.setText("");
prekey = key = 2;
}
// '/'操作
if (temp == buttonDiv) {
switch (prekey) {
case 0:
answerd += Double.parseDouble(textAnswer.getText());
break;
case 1:

H. c++面向对象

只要是复杂的程序，用c++写总会比c写清晰很多，但是如果程序简单，用c++会要多写很多代码。

不过合法的c程序也是合法的c++程序，c++本来就包括和完全兼容c，c++当然可以代替c

I. 请问用java语言写的项目,毕业论文可以按面向过程的结构来写吗

按面向过程写的话，需求不能有大的改动，要不然可能牵一发动全身，因为面向过程的耦合度太高了；也就是说需求要一开始就比较明确；

既然用Java写项目，还是用面向对象好一些，毕竟Java在面向对象编程方面有优势；面向对象可读性较高，好修改和维护；

J. 最通俗地解释面向对象

面向对象(Object Oriented,OO)是软件开发方法。面向对象的概念和应用已超越了程序设计和软件开发，扩展到如数据库系统、交互式界面、应用结构、应用平台、分布式系统、网络管理结构、CAD技术、人工智能等领域。面向对象是一种对现实世界理解和抽象的方法，是计算机编程技术发展到一定阶段后的产物。

概念

1. 对象。

   对象是人们要进行研究的任何事物，从最简单的整数到复杂的飞机等均可看作对象，它不仅能表示具体的事物，还能表示抽象的规则、计划或事件。

2. 对象的状态和行为。

   对象具有状态，一个对象用数据值来描述它的状态。

   对象还有操作，用于改变对象的状态，对象及其操作就是对象的行为。

   对象实现了数据和操作的结合，使数据和操作封装于对象的统一体中。

3. 类。

   具有相同特性（数据元素）和行为（功能）的对象的抽象就是类。因此，对象的抽象是类，类的具体化就是对象，也可以说类的实例是对象，类实际上就是一种数据类型。

   类具有属性，它是对象的状态的抽象，用数据结构来描述类的属性。

   类具有操作，它是对象的行为的抽象，用操作名和实现该操作的方法来描述。

4. 类的结构。

   在客观世界中有若干类，这些类之间有一定的结构关系。通常有两种主要的结构关系，即一般--具体结构关系，整体--部分结构关系。

   ①一般--具体结构称为分类结构，也可以说是“或”关系，或者是“is a”关系。

   ②整体--部分结构称为组装结构，它们之间的关系是一种“与”关系，或者是“has a”关系。

5. 消息和方法。

   对象之间进行通信的结构叫做消息。在对象的操作中，当一个消息发送给某个对象时，消息包含接收对象去执行某种操作的信息。发送一条消息至少要包括说明接受消息的对象名、发送给该对象的消息名（即对象名、方法名）。一般还要对参数加以说明，参数可以是认识该消息的对象所知道的变量名，或者是所有对象都知道的全局变量名。

   类中操作的实现过程叫做方法，一个方法有方法名、返回值、参数、方法体。

特征

1. 对象唯一性。

   每个对象都有自身唯一的标识，通过这种标识，可找到相应的对象。在对象的整个生命期中，它的标识都不改变，不同的对象不能有相同的标识。

2. 抽象性。

   抽象性是指将具有一致的数据结构（属性）和行为（操作）的对象抽象成类。一个类就是这样一种抽象，它反映了与应用有关的重要性质，而忽略其他一些无关内容。任何类的划分都是主观的，但必须与具体的应用有关。

3. 继承性。

   继承性是子类自动共享父类数据结构和方法的机制，这是类之间的一种关系。在定义和实现一个类的时候，可以在一个已经存在的类的基础之上来进行，把这个已经存在的类所定义的内容作为自己的内容，并加入若干新的内容。

   继承性是面向对象程序设计语言不同于其它语言的最重要的特点，是其他语言所没有的。

   在类层次中，子类只继承一个父类的数据结构和方法，则称为单重继承。在类层次中，子类继承了多个父类的数据结构和方法，则称为多重继承。

   多重继承，JAVA、VB、NET、Objective-C均仅支持单继承，注意在C++多重继承时，需小心二义性。

   在软件开发中，类的继承性使所建立的软件具有开放性、可扩充性，这是信息组织与分类的行之有效的方法，它简化了对象、类的创建工作量，增加了代码的可重用性。

   采用继承性，提供了类的规范的等级结构。通过类的继承关系，使公共的特性能够共享，提高了软件的重用性。

4. 多态性（多形性）

   多态性是指相同的操作或函数、过程可作用于多种类型的对象上并获得不同的结果。不同的对象，收到同一消息可以产生不同的结果，这种现象称为多态性。

   多态性允许每个对象以适合自身的方式去响应共同的消息。

   多态性增强了软件的灵活性和重用性。