java原型设计代码 java项目原型图

请设计一个GUI界面，参考如下界面原型实现。求大神用JAVA

import java.awt.Color;

成都创新互联公司-专业网站定制、快速模板网站建设、高性价比宁化网站开发、企业建站全套包干低至880元,成熟完善的模板库,直接使用。一站式宁化网站制作公司更省心,省钱,快速模板网站建设找我们，业务覆盖宁化地区。费用合理售后完善，10多年实体公司更值得信赖。

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import java.util.Random;

import javax.swing.JButton;

import javax.swing.JFrame;

import javax.swing.JPanel;

public class MyPanel extends JFrame {

private JButton[] btns = new JButton[7];

private Random rn = new Random();

private boolean[] flags = new boolean[33];// 用来判别重复

public MyPanel() {

init();

}

private void init() {

setTitle("MyPanel....");

setSize(540, 250);

setContentPane(createPane());

}

private JPanel createPane() {

JPanel pane = new JPanel(null);

pane.setBackground(Color.YELLOW);

for (int i = 0; i  btns.length; i++) {

btns[i] = new JButton("0");

btns[i].setBounds(20 + (i * 70), 30, 54, 24);

btns[i].setBackground(Color.PINK);

pane.add(btns[i]);

btns[i].addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

while (true) {

int n = rn.nextInt(34);

// 如果数字被使用，或为 33 34 就重新选数字

if (n == 0 || n  33 || flags[n - 1]) {

 continue;

}

// 把使用了的数字设置为true，即已使用

flags[n - 1] = true;

// 把不用了的数字设置成未使用状态

if (Integer.parseInt(((JButton) e.getSource())

  .getText()) != 0) {

 flags[Integer.parseInt(((JButton) e.getSource())

   .getText()) - 1] = false;

}

((JButton) e.getSource()).setText(String.valueOf(n));

break;

}

}

});

}

JButton creNum = new JButton("创建数字");

creNum.setBounds(50, 150, 100, 30);

creNum.addActionListener(new ActionListener() {

@Override

public void actionPerformed(ActionEvent e) {

for (int i = 0; i  btns.length; i++) {

while (true) {

int n = rn.nextInt(34);

// 如果数字被使用，或为 33 34 就重新选数字

if (n == 0 || n  33 || flags[n - 1]) {

 continue;

}

// 把使用了的数字设置为true，即已使用

flags[n - 1] = true;

// 把不用了的数字设置成未使用状态

if (Integer.parseInt(btns[i].getText()) != 0) {

 flags[Integer.parseInt(btns[i].getText()) - 1] = false;

}

btns[i].setText(String.valueOf(n));

break;

}

}

}

});

pane.add(creNum);

JButton sort = new JButton("排序");

sort.setBounds(200, 150, 100, 30);

sort.addActionListener(new ActionListener() {

@Override

public void actionPerformed(ActionEvent e) {

// 排序

String[] strs = new String[7];

// 把按钮上面的数字拿出来

for (int i = 0; i  btns.length; i++) {

strs[i] = btns[i].getText();

}

// 开始排序

for (int i = strs.length - 1; i  0; i--) {

for (int j = 0; j  i; j++) {

if (Integer.parseInt(strs[i])  Integer

  .parseInt(strs[j])) {

 String temp;

 temp = strs[i];

 strs[i] = strs[j];

 strs[j] = temp;

}

}

}

// 排好，在显示到按钮上

for (int j = 0; j  strs.length; j++) {

btns[j].setText(strs[j]);

}

}

});

pane.add(sort);

JButton reset = new JButton("重置");

reset.setBounds(350, 150, 100, 30);

reset.addActionListener(new ActionListener() {

@Override

public void actionPerformed(ActionEvent e) {

flags = new boolean[33];

for (int i = 0; i  btns.length; i++) {

btns[i].setText("0");

}

}

});

pane.add(reset);

return pane;

}

public static void main(String[] args) {

MyPanel mp = new MyPanel();

mp.setVisible(true);

}

}

根据你的要求，数字不会重复，用的是冒泡排序

希望对你有帮助

如图：

java 有原型链吗

1.原型链

原型链是JavaScript中继承的主要方法。

每个构造函数都拥有一个原型对象，原型对象都包含一个指向构造函数的指针(constructor)，实例都包含一个指向原型对象的内部指针(__proto__)。

假如，原型对象(Son.prototype)等于另一个类型(Pserson)的实例(person1),那么此时的原型对象(Son.prototype)将包含一个指向另一个原型(Person.prototype)的指针,相应的，另有一个原型(Person.prototype)中也包含着一个指向另一个构造函数(Person())的指针。

再如，另一个原型(Person.prototype)又是另一个类型（Person）的实例（person1）,那么上述关系依旧成立，如此层层递进，就构成了实例与原型的链条，这就是所谓的原型链。

function SuperType(){     this.property=true;     }     SuperType.prototype.getSuperValue=function(){     return this.property;     }     function SubType(){     this.subproperty=false;     }         //继承了SuperType SubType.prototype=new SuperType ();     SubType.prototype.getSubValue=function(){     return this.subproperty;     }     var instance=new Son(); alert(instance.getSuperValue());      //true     alert(instanceinstanceof Object);    //true alert(instanceinstanceof SuperType); //true alert(instanceinstanceof SubType);   //true

以上代码定义了两个类型：SuperType和SubType。每个类型分别有一个属性和方法。它们主要区别就是SubType继承了SuperType,而这继承是通过创建SuperType新实例，并将这个新实例赋给SubType.prototype实现的。实现的本质就是重写原型对象，代之以新类型的实例。

instance指向Subtyoe.prototype,SubType.prototype又指向了SuperType.prototype。getSuperValue()方法仍然还在SuperType。prototype中，但property则位于SubType.prototype中。这是因为property是一个实例属性，而getSyoerValue()则是一个原型方法。既然SubType.prototype现在是SuperType的实例，那么property当然位于该实例中。此外，要注意instance.constrcutor现在指向的是SuperType，这是因为原来SubType.propertype中的constructor被重写了的缘故。

注：SubType.propertype中的constructor不被重写了的缘故，而是SubType的原型指向了另一个对象——SuperType的原型，而这个原型对象的constructor是指向SuperType的。

通过实现原型链，本质上就是扩展了原型搜索机制。

2.别忘了默认的原型

事实上，我们的原型链还少了一环，所有引用类型默认继承了Object类型，而这个继承也是通过原型链实现的。我们要记住，所有函数的默认原型都是Object的实例，因此默认原型都会包含一个内部指针，指向Object.prototype。这也正式自定义类型能使用toString()等默认方法的原因。

一句话，SubType集成了SuperType，而SuperType继承了Object。当调用instance.toSring()时，实际调用的是保存在Object.prototype中的那个方法。

3.确定原型和实例的关系

可以使用instanceof操作符来测试实例与原型链中出点过的构造函数。

alert(instanceinstanceof Object);    //truealert(instanceinstanceof SuperType); //truealert(instanceinstanceof SubType);   //true  

4.谨慎的定义方法

子类型有时需要重写父类型中的某个方法，或者需要添加父类型中不穿在的某个方法，但不管怎么，给原型添加的代码一定要放在替换原型的语句之后。

function SuperType(){    this.property=true;    }  SuperType.prototype.getSuperValue=function(){    return this.property;    }  function SubType(){    this.subproperty=false;    }      //继承了SuperTypeSubType.prototype=new SuperType();  //添加新方法SubType.prototype.getSubValue=function(){    return this.subproperty;    }  //重写父类型中的方法SubType.prototype.getSuperValue=function(){    return this.subproperty;    }  var instance=new SubType();alert(instance.getSuperValue());        //false

注意，在通过原型链实现继承时，不能使用对象字面量创建原型对象，这样会重写原型链。

function SuperType(){    this.property=true;    }  SuperType.prototype.getSuperValue=function(){    return this.property;    }  function SubType(){    this.subproperty=false;    }      //继承了SuperTypeSubType.prototype=new SuperType();  //使用字面量添加新方法，会导致上一行代码无效SubType.prototype={    getSubValue:function(){        return this.subproperty;        },    someOtherMethod:function(){        return false;        }              }var instance=new SubType();alert(instance.getSuperValue());        //error

由于现在的原型包含的是一个Object的实例，而非SuperType的实例，因此我们设想中的原型链已经别切断——SubType和SuperType已经没关系了。

5.原型链的问题

原型链最主要的问题还是来支援引用类型的原型，我们以前说过包含引用类型值的原型属性会被所有实例共享，这也是为什么要在构造函数中定义属性，而不是在原型中定义属性的原因了。在通过原型来实现继承时，原型实际上会被变成另一个类型的实例。

function SuperType(){    this.colors=["red","blue","green"];    }      function SubType(){}  //继承了SuperTypeSubType.prototype=new SuperType();  var instance=new SubType();instance.colors.push("black");  //"red","blue","green","black"alert(instance.colors);  var instance2=new SubType();alert(instance2.colors);         //"red","blue","green","black"

原型的第二个问题：在创建子类的实例时，不能向父类型的构造函数传递参数，所以实践中很少单独用到原型链。

试编写一个java应用程序，要求输入一个圆的半径，输出其面积

代码为：

Scanner scanner=new Scanner(System.in);

System.out.println("请输入圆的半径：");

int r=Integer.parseInt(scanner.next()); //获取半径

System.out.println("圆的面积为:"+Math.PI*r*r);

扩展资料：

java所具有的特性：

1.简单性

Java看起来设计得很像C++，但是为了使语言小和容易熟悉，设计者们把C++语言中许多可用的特征去掉了，这些特征是一般程序员很少使用的。例如，Java不支持go to语句，代之以提供break和continue语句以及异常处理。Java还剔除了C++的操作符过载（overload）和多继承特征，并且不使用主文件，免去了预处理程序。

因为Java没有结构，数组和串都是对象，所以不需要指针。Java能够自动处理对象的引用和间接引用，实现自动的无用单元收集，使用户不必为存储管理问题烦恼，能更多的时间和精力花在研发上。

2.面向对象

Java是一个面向对象的语言。对程序员来说，这意味着要注意应中的数据和操纵数据的方法（method），而不是严格地用过程来思考。在一个面向对象的系统中，类（class）是数据和操作数据的方法的集合。

数据和方法一起描述对象（object）的状态和行为。每一对象是其状态和行为的封装。类是按一定体系和层次安排的，使得子类可以从超类继承行为。在这个类层次体系中有一个根类，它是具有一般行为的类。Java程序是用类来组织的。

Java还包括一个类的扩展集合，分别组成各种程序包（Package），用户可以在自己的程序中使用。例如，Java提供产生图形用户接口部件的类（java.awt包），这里awt是抽象窗口工具集（abstract windowing toolkit）的缩写，处理输入输出的类（java.io包）和支持网络功能的类（java点虐 包）。

3.分布性

Java设计成支持在网络上应用，它是分布式语言。Java既支持各种层次的网络连接，又以Socket类支持可靠的流（stream）网络连接，所以用户可以产生分布式的客户机和服务器。

网络变成软件应用的分布运载工具。Java程序只要编写一次，就可到处运行。

4.编译和解释性

Java编译程序生成字节码（byte-code），而不是通常的机器码。Java字节码提供对体系结构中性的目标文件格式，代码设计成可有效地传送程序到多个平台。Java程序可以在任何实现了Java解释程序和运行系统（run-time system）的系统上运行。

在一个解释性的环境中，程序开发的标准“链接”阶段大大消失了。如果说Java还有一个链接阶段，它只是把新类装进环境的过程，它是增量式的、轻量级的过程。因此，Java支持快速原型和容易试验，它将导致快速程序开发。这是一个与传统的、耗时的“编译、链接和测试”形成鲜明对比的精巧的开发过程。

5.稳健性

Java原来是用作编写消费类家用电子产品软件的语言，所以它是被设计成写高可靠和稳健软件的。Java消除了某些编程错误，使得用它写可靠软件相当容易。

Java是一个强类型语言，它允许扩展编译时检查潜在类型不匹配问题的功能。Java要求显式的方法声明，它不支持C风格的隐式声明。这些严格的要求保证编译程序能捕捉调用错误，这就导致更可靠的程序。

可靠性方面最重要的增强之一是Java的存储模型。Java不支持指针，它消除重写存储和讹误数据的可能性。类似地，Java自动的“无用单元收集”预防存储漏泄和其它有关动态存储分配和解除分配的有害错误。Java解释程序也执行许多运行时的检查，诸如验证所有数组和串访问是否在界限之内。

异常处理是Java中使得程序更稳健的另一个特征。异常是某种类似于错误的异常条件出现的信号。使用try/catch/finally语句，程序员可以找到出错的处理代码，这就简化了出错处理和恢复的任务。

6.安全性

Java的存储分配模型是它防御恶意代码的主要方法之一。Java没有指针，所以程序员不能得到隐蔽起来的内幕和伪造指针去指向存储器

。更重要的是，Java编译程序不处理存储安排决策，所以程序员不能通过查看声明去猜测类的实际存储安排。编译的Java代码中的存储引用在运行时由Java解释程序决定实际存储地址。

Java运行系统使用字节码验证过程来保证装载到网络上的代码不违背任何Java语言限制。这个安全机制部分包括类如何从网上装载。例如，装载的类是放在分开的名字空间而不是局部类，预防恶意的小应用程序用它自己的版本来代替标准Java类。

7.可移植性

Java使得语言声明不依赖于实现的方面。例如，Java显式说明每个基本数据类型的大小和它的运算行为（这些数据类型由Java语法描述）。

Java环境本身对新的硬件平台和操作系统是可移植的。Java编译程序也用Java编写，而Java运行系统用ANSIC语言编写。

8.高性能

Java是一种先编译后解释的语言，所以它不如全编译性语言快。但是有些情况下性能是很要紧的，为了支持这些情况，Java设计者制作了“及时”编译程序，它能在运行时把Java字节码翻译成特定CPU（中央处理器）的机器代码，也就是实现全编译了。

Java字节码格式设计时考虑到这些“及时”编译程序的需要，所以生成机器代码的过程相当简单，它能产生相当好的代码。

9.多线索性

Java是多线索语言，它提供支持多线索的执行（也称为轻便过程），能处理不同任务，使具有线索的程序设计很容易。Java的lang包提供一个Thread类，它支持开始线索、运行线索、停止线索和检查线索状态的方法。

Java的线索支持也包括一组同步原语。这些原语是基于监督程序和条件变量风范，由C.A.R.Haore开发的广泛使用的同步化方案。用关键词synchronized，程序员可以说明某些方法在一个类中不能并发地运行。这些方法在监督程序控制之下，确保变量维持在一个一致的状态。

10.动态性

Java语言设计成适应于变化的环境，它是一个动态的语言。例如，Java中的类是根据需要载入的，甚至有些是通过网络获取的。

参考资料：百度百科-Java

java怎么根据原型图设计接口开发

大家好，又见面了，我是你们的朋友全栈君。

java web开发(一) 环境搭建讲解了如何搭建一个Java Web项目，如果你还没了解，建议先浏览下！今天这篇文章主要讲解的就是接口开发，打算使用比较古老的或者说比较原始方法实现的接口。

一.数据库设计。

假设要做一个简单的学生信息管理系统，数据库名为students_manage，并且先设计一张学生表，表名为student。

1.打开Sqlyog工具，如果还没创建连接，可以点击新建，输入名称，点击确定即可，然后在保存的连接中选择，刚刚新建的连接，只需要在密码输入框中输入，安装数据库时的设置的密码，点击连接，其他的默认即可，