正文
小黄鸭java代码教程 小黄鸭程序调试法
提示：扫一扫查出行【扫一扫了解最新限行尾号】
复制提示
java中如果把下拉菜单用鼠标选中的值添加到文本框里面？
需要小黄鸭java代码教程的组件:
下拉菜单 是 JComboBox组件
文本框 是 JTextField组件
设置下拉菜单小黄鸭java代码教程的内容
常用的主要有三种方法
使用添加模型的方式,来添加内容
JComboBox jcb = new JComboBox();
jcb.setModel(new DefaultComboBoxModelString(new String[] {"一","二"}))
使用数组参数的构造器,来添加内容
String[] ss = {"选项一","选项二"};
JComboBox jcb = new JComboBox(ss);
3. 使用链表参数的构造器,来添加内容
VectorString ve = new VectorString();
ve.add("选项一");ve.add("选项二");
JComboBox jcb = new JComboBox(ve); //把单链表作为参数,来构造一个下拉菜单
事件响应器的设置
当鼠标选择菜单的选项后, 会触发一个事件ActionEvent, 该事件的处理代码里, 可以实现把选择的值添加到文本框.
需要给JComboBox 添加 一个ActionListener 就能实现对事件的响应
效果图
参考代码如下 jdk 1.8
import java.awt.event.*;
import java.util.*;
import javax.swing.*;
import java.awt.*;
public class JCBDemo extends JFrame implements ActionListener {
private static final long serialVersionUID = 1L;
//组件的定义
private final JTextField jtf1;
private final JTextField jtf2;
private final JTextField jtf3;
private final JComboBoxString jcb2;
private final JComboBoxString jcb1;
private final JComboBoxString jcb3;
public static void main(String[] args) {
new JCBDemo().setVisible(true);
}
public JCBDemo() {
setLayout(new GridLayout(3, 3, 0, 0));
//给JComboBox 添加数据的方式一 setModel的方法
JLabel jl1 = new JLabel("选择小黄鸭java代码教程你喜欢的水果");
jcb1 = new JComboBoxString();
jcb1.setModel(new DefaultComboBoxModelString(new String[] { "苹果", "鸭梨", "香蕉", "山楂", "蜜桃" }));
jtf1 = new JTextField();
jtf1.setColumns(10);
jtf1.setText((String) jcb1.getSelectedItem());//设置文本框的值
//给JComboBox 添加数据的方式二 使用带数组作为参数的构造方法
JLabel jl2 = new JLabel("选择小黄鸭java代码教程你喜欢的电影");
String[] move = { "英雄本色", "神奇四侠", "复仇者联盟" };
jcb2 = new JComboBoxString(move);
jcb2.addItem("星球大战");
jtf2 = new JTextField();
jtf2.setText((String) jcb2.getSelectedItem());
jtf2.setColumns(10);
//给JComboBox 添加数据的方式三 使用带Vector链表作为参数的构造方法
JLabel jl3 = new JLabel("选择小黄鸭java代码教程你喜欢的书籍");
VectorString list = new VectorString();
list.add("货币战争");
list.add("格林童话");
jcb3 = new JComboBoxString(list);
jtf3 = new JTextField();
jtf3.setColumns(10);
jtf3.setText((String) jcb3.getSelectedItem());
add(jl1);add(jcb1);add(jtf1);
add(jl2);add(jcb2);add(jtf2);
add(jl3);add(jcb3);add(jtf3);
jcb1.setActionCommand("1");//设置动作命令
jcb1.addActionListener(this);//设置事件响应器
jcb2.setActionCommand("2");
jcb2.addActionListener(this);
jcb3.setActionCommand("3");
jcb3.addActionListener(this);
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setSize(350, 139);//设置窗口大小
setLocationRelativeTo(null);//设置窗口居中
setTitle("下拉菜单示范");
}
public void actionPerformed(ActionEvent e) {//当鼠标选择下拉菜单的值时
String comd =e.getActionCommand();//得到动作命令
if(comd.equals("1")){
jtf1.setText((String) jcb1.getSelectedItem());//设置文本框的内容
}else if(comd.equals("2")){
jtf2.setText((String) jcb2.getSelectedItem());
}else if(comd.equals("3")){
jtf3.setText((String) jcb3.getSelectedItem());
}
}
}
相关问答
Q1: 一道Java程序题，关于Scanner类与字符串分解
public static void main(String args[]) {
String menu = "北京烤鸭：189元 西芹炒肉：12.9元 酸菜鱼：69元 铁板牛柳：32元";
Scanner scanner = new Scanner(menu);// Scanner类创建scanner，将menu传递给构造方法的参数
String regex = "[^0123456789.]+";
// scanner调用useDelimiter（String regex），将regex传递给该方法的参数
scanner.useDelimiter(regex);
double sum = 0;
while (scanner.hasNext()) {
try {
double price = scanner.nextDouble();// scanner调用nextDouble（）返回数字单词
sum = sum + price;
System.out.println(price);
} catch (InputMismatchException exp) {
String t = scanner.next();
}
}
System.out.println("菜单总价格：" + sum + "元");
}
Q2: 软件设计模式鸭子模拟器
假设我们需要设计出各种各样的鸭子，一边游泳戏水， 一边呱呱叫。很明显这时我们需要设计了一个鸭子超类（Superclass），并让各种鸭子继承此超类。
public abstract class Duck {
public void Swim() {
//会游泳
}
public abstract display();//各种外观不一样，所以为抽象
public void Quack() {
//会叫
}
}
每一只鸭子就继承Duck类
public class MallardDuck extends Duck {
public void display() {
// 外观是绿色的
}
}
public class RedheadDuck extends Duck{
public void display(){
// 外观是红色的
}
}
好了，我们完成这些后，但是发现我们需要有一些鸭子是会飞的，应该怎么修改呢？
也许你要说这很简单，在Duck类里面直接加入一个fly()方法，不就可以了。
public abstract class Duck {
public void Swim() {
//会游泳
}
public abstract display();//各种外观不一样，所以为抽象
public void Quack() {
//会叫
}
public void fly(){
//会飞
}
}
这时你会发现所有的鸭子都变成了会飞的,很明显这是不对了，例如橡皮鸭显然就不是了。
你也许想到了另一种方法，在会飞的鸭子类里才添加该方法不就可以了嘛，
public class MallardDuck extend Duck{
public void display(){
// 外观是绿色的
}
public void fly(){
//会飞
}
}
这个方法看起来是很不错，可是有很多种鸭子都会飞的时候，代码的复用性很明显是不够好的,你不得不在
每一个会飞的鸭子类里去写上同一个fly()方法,这可不是个好主意.
可能你又想到另一个方法：采用继承和覆盖，在Duck类里实现fly()方法，在子类里如果不会飞的就覆盖它
public abstract class Duck {
public void Swim() {
//会游泳
}
public abstract display();//各种外观不一样，所以为抽象
public void Quack(){
//会叫
}
public void fly(){
//会飞
}
}
//橡皮鸭吱吱叫，不会飞
public class RubberDuck extend Duck{
public void quack(){
//覆盖成吱吱叫
}
public void display{
//外观是橡皮鸭
}
public void fly{
//什么也不做
}
}
这样我们真实现了确实能飞的鸭子才可以飞起来了，看起来主意不错！问题到这儿似乎得到了解决
但我们现在有了一种新的鸭子，诱铒鸭(不会飞也不会叫),看来需要这样来写
public class DecoyDuck extend Duck{
public void quack(){
//覆盖，变成什么也不做
}
public void display(){
//诱饵鸭
}
public void fly(){
//覆盖，变成什么也不做
}
}
每当有新的鸭子子类出现或者鸭子新的特性出现，就不得不被迫在Duck类里添加并在所有子类里检查可能需要覆盖fly()和quark()...这简直是无穷尽的恶梦。所以，我们需要一个更清晰的方法，让某些（而不是全部）鸭子类型可飞或可叫。让鸭子的特性能有更好的扩展性。
用一下接口的方式把fly()取出来，放进一个Flyable接口中，这样只有会飞的鸭子才实现这个接口，当然我们也可以照此来设计一个Quackbable接口，因为不是所有的鸭子都会叫,也只让会叫的鸭子才去实现这个接口.
但这个方法和上面提到的在子类里去实现fly一样笨，如果几十种都可以飞，你得在几十个鸭子里去写上一样的fly(),如果一旦这个fly有所变更，你将不得不找到这几十个鸭子去一个一个改它们的fly()方法。
因为改变鸭子的行为会影响所有种类的鸭子，而这并不恰当。Flyable与Quackable接口一开始似乎还挺不错， 解决了问题（ 只有会飞的鸭子才继承Flyable） ， 但是Java的接口不具有实现代码， 所以继承接口无法达到代码的复用。这意味着：无论何时你需要修改某个行为，你必须得往下追踪并修改每一个定义此行为的类。
策略模式的第一原则：找出应用中可能需要变化之处，把它们独立出来，不要和那些不需要变化的代码混在一起。 好吧，回头看一下这个Duck类，就我们目前所知，除了fly()和quack()的问题之外，Duck类还算一切正常，主要是鸭子的行为总是可能变化的，让我们头痛就在于这些行为的变化，那我们就把这些行为独立出来。
为了要把这两个行为从Duck 类中分开， 我们将把它们自Duck 类中取出，建立一组新类代表每个行为。我们建立两组类（完全远离Duck类），一个是「fly」相关的，一个是「quack」相关的，每一组类将实现各自 的动作。比方说，我们可能有一个类实现「呱呱叫」，另一个类实现「吱吱叫」，另一个类实现「安静」。我们利用接口代表每组行为，比方说， FlyBehavior来代表飞的行为，QuackBehavior代表叫的行为，而让每一种行为具体类来实现该行为接口。
在此，我们有两个接口，FlyBehavior和QuackBehavior，还有它们对应的类，负责实现具体的行为：
public interface FlyBehavior {
public void fly();
}
public class FlyWithWings implements FlyBehavior{
public void fly{}{
//实现鸭子飞行
}
}
public class FlyNoWay implements FlyBehavior{
public void fly{}{
//什么也不做，不会飞
}
}
public interface QuackBehavior{
public void quack();
}
public class Quack implements QuackBehavior{
public void quack(){
//实现鸭子呱呱叫
}
}
public class Squeak implements QuackBehavior{
public void quack(){
//实现鸭子吱吱叫
}
}
public class MuteQuack implements QuackBehavior{
public void quack(){
//什么也不做，不会叫
}
}
实际上这样的设计，我们已经可以让飞行和呱呱叫的动作被其他的对象复用，因为这些行为已经与鸭子类无关了。如果我们新增一些行为，也不会影响到既有的行为类，也不会影响有已经使用到飞行行为的鸭子类。
好了，我们设计好鸭子的易于变化的行为部分后，该到了整合鸭子行为的时候了。
这时我们该想到策略模式的另一个原则了：
针对接口编程，而不是针对实现编程。
首先， 在鸭子中加入两个实例变量，分别为「flyBehavior」与「quackBehavior」，声明为接口类型（ 而不是具体类实现类型）， 每个变量会利用多态的方式在运行时引用正确的行为类型（ 例如：FlyWithWings 、Squeak...等）。我们也必须将Duck类与其所有子类中的fly()与quack()移除，因为这些行为已经被搬移到FlyBehavior与 Quackehavior类中了，用performFly()和performQuack()取代Duck类中的fly()与quack()。
public abstract class Duck(){
FlyBehavior flyBehavior;
QuackBehavior quackBehavior;
public void swim(){
//会游泳
}
public abstract void display();//各种外观不一样，所以为抽象
public void performQuack(){
quackBehavior.quack();
}
public void performFly(){
flyBehavior.fly();
}
}
很容易，是吧？想进行呱呱叫的动作，Duck对象只要叫quackBehavior对象
去呱呱叫就可以了。在这部分的代码中，我们不在乎QuackBehavior 接口的对象到底是什么，我们只关心该对象
知道如何进行呱呱叫就够了。
好吧！ 现在来关心如何设定flyBehavior 与quackBehavior的实例变量。
看看MallardDuck类：
public class MallardDuck extends Duck {
public MallardDuck() {
\\绿头鸭使用Quack类处理呱呱叫，所以当performQuack() 被调用，就把责任委托给Quack对象进行真正的呱呱叫。
quackBehavior = new Quack();
\\使用FlyWithWings作为其FlyBehavior类型。
flyBehavior = new FlyWithWings();
}
}
所以，绿头鸭会真的『呱呱叫』，而不是『吱吱叫』，或『叫不出声』。这是怎么办到的？当MallardDuck实例化时，它的构造器会
把继承来的quackBehavior实例变量初始化成Quack类型的新实例（Quack是QuackBehavior的具体实现类）。同样的处理方式也可以用在飞行行为上： MallardDuck 的构造器将flyBehavior 实例变量初始化成FlyWithWings 类型的实例（
FlyWithWings是FlyBehavior的具体实现类）。
输入下面的Duck类（Duck.java） 以及MallardDuck 类MallardDuck.java），并编译之。
public abstract class Duck {
//为行为接口类型声明两个引用变量， 所有鸭子子类（在同一个packge）都继承它们。
FlyBehavior flyBehavior;
QuackBehavior quackBehavior;
public Duck() {
}
public abstract void display();
public void performFly() {
flyBehavior.fly();//委托给行为类
}
public void performQuack() {
quackBehavior.quack();//委托给行为类
}
public void swim() {
System.out.println("All ducksfloat, even decoys!");
}
}
public class MallardDuck extends Duck {
public MallardDuck() {
quackBehavior = newQuack();
flyBehavior = newFlyWithWings();
}
public void display() {
System.out.println("I’m a real Mallard duck");
}
}
输入FlyBehavior接口（FlyBehavior.java）与两个行为实现类（FlyWithWings.java与FlyNoWay.java），并编译之。
public interface FlyBehavior {//所有飞行行为类必须实现的接口
public void fly();
}
public class FlyWithWings implements FlyBehavior {//这是飞行行为的实现， 给「真会」飞的鸭子用 .. .
public void fly() {
System.out.println("I’m flying!!");
}
}
public class FlyNoWay implements FlyBehavior {//这是飞行行为的实现， 给「不会」飞的鸭子用（ 包括橡皮鸭和诱饵鸭）
public void fly() {
System.out.println("I can’t fly");
}
}
输入QuackBehavior接口（QuackBehavior.java)及其三个实现类（Quack.java、MuteQuack.java、Squeak.java），并编译之。
public interface QuackBehavior {
public void quack();
}
public class Quack implements QuackBehavior {
public void quack() {
System.out.println(“Quack”);
}
}
public class MuteQuack implements QuackBehavior {
public void quack() {
System.out.println(“ Silence ”);
}
}
public class Squeak implements QuackBehavior {
public void quack() {
System.out.println(“Squeak”);
}
}
输入并编译测试类（MiniDuckSimulator.java）
public class MiniDuckSimulator {
public static void main(String[] args) {
Duck mallard = new MallardDuck();
mallard.display();
//这会调用MallardDuck继承来的performQuack() ，进而委托给该对象的QuackBehavior对象处理。（也就是说，调用继承来的quackBehavior的quack()）
mallard.performQuack();
//至于performFly() ，也是一样的道理。
mallard.performFly();
}
}
运行结果：
I’m a real Mallard duck
Quack
I’m flying!!
虽然我们把行为设定成具体的类（通过实例化类似Quack 或FlyWithWings的行为类， 并指定到行为引
用变量中），但是还是可以在运行时轻易地改变该行为。
所以，目前的作法还是很有弹性的，只是初始化实例变量的作法不够弹性罢了。
我们希望一切能有弹性，毕竟，正是因为一开始的设计的鸭子行为没有弹性，才让我们走到现在这条路。
我们还想能够「指定」行为到鸭子的实例， 比方说， 想要产生绿头鸭实例，并指定特定「类型」的飞行
行为给它。干脆顺便让鸭子的行为可以动态地改变好了。换句话说，我们应该在鸭子类中包含设定行为的方法。
因为quackBehavior实例变量是一个接口类型，所以我们是能够在运行时，透过多态动态地指定不同的QuickBehavior实现类给它。
我们在鸭子子类透过设定方法（settermethod）设定鸭子的行为，而不是在鸭子的构造器内实例化。
在Duck类中，加入两个新方法：从此以后，我们可以「随时」调用这两个方法改变鸭子的行为。
public strate class Duck(){
FlyBehavior flyBehavior;
QuackBehavior quackBehavior;
public void setFlyBehavior(FlyBehavior fb) {
flyBehavior = fb;
}
public void setQuackBehavior(QuackBehavior qb) {
quackBehavior = qb;
}
}
好了，让我们再制造一个新的鸭子类型：模型鸭（ModelDuck.java）
public class ModelDuck extends Duck {
public ModelDuck() {
flyBehavior = new FlyNoWay();//初始状态，我们的模型鸭是不会飞的。
quackBehavior = new Quack();//初始状态，我们的模型鸭是可以叫的.
}
public void display() {
System.out.println("I’m a modelduck");
}
}
建立一个新的FlyBehavior类型（FlyRocketPowered.java）
public class FlyRocketPowered implements FlyBehavior {
// 我们建立一个利用火箭动力的飞行行为。
public void fly() {
System.out.println("I’m flying with arocket!");
}
}
改变测试类（MiniDuckSimulator.java），加上模型鸭，并使模型鸭具有火箭动力。
public class MiniDuckSimulator {
public static void main(String[] args) {
Duck mallard = new MallardDuck();
mallard.performQuack();
mallard.performFly();
Duck model = new ModelDuck();
//第一次调用performFly() 会被委托给flyBehavior对象（也就是FlyNoWay对象），该对象是在模型鸭构造器中设置的。
model.performFly();
//这会调用继承来的setter 方法，把火箭动力飞行的行为设定到模型鸭中。哇咧！ 模型鸭突然具有火箭动力飞行能力。
model.setFlyBehavior(new FlyRocketPowered());
//如果成功了， 就意味着模型鸭动态地改变行为。如果把行为的实现绑死在鸭子类中， 可就无法做到这样。
model.performFly();
}
}
运行一下，看下结果
I’m a real Mallard duck
Quack
I’m flying!!
I’m a model duck
I can’t fly
I’m flying with a rocket!
如同本例一般，当你将两个类结合起来使用，这就是组合（composition）。这种作法和『继承』不同的地方在于，
鸭子的行为不是继承而来，而是和适当的行为对象『组合』而来。
这是一个很重要的技巧。其实是使用了策略模式中的第三个设计原则， 多用组合，少用继承。
现在来总结一下，鸭子的行为被放在分开的类中，此类专门提供某行为的实现。
这样，鸭子类就不再需要知道行为的实现细节。
鸭子类不会负责实现Flyable与Quackable接口，反而是由其他类专门实现FlyBehavior与QuackBehavior，
这就称为「行为」类。由行为类实现行为接口，而不是由Duck类实现行为接口。
这样的作法迥异于以往，行为不再是由继承Duck超类的具体实现而来， 或是继承某个接口并由子类自行实现而来。
(这两种作法都是依赖于「实现」， 我们被实现绑得死死的， 没办法更改行为,除非写更多代码)。
在我们的新设计中， 鸭子的子类使用接口（ FlyBehavior与QuackBehavior）所表示的行为，所以实际的实现不会被
绑死在鸭子的子类中。（ 换句话说， 特定的实现代码位于实现FlyBehavior与QuakcBehavior的特定类中）,这样我们就获得了更大的灵活性和可扩展性。
Q3: 高中生想成为JAVA软件编程高手要怎样做？
高中生如何成为JAVA软件编程高手?做为一名高中生，以前从未接触过计算机JAVA软件编程小黄鸭java代码教程的内容，以前在学校时除了铺天盖地的试卷，就还是试卷，几乎很少接触到计算机软件编程的内容。高中毕业后落榜了，孩子们都想拥有一个好的出路，想学习一门专业的技术，那么高中生怎么样才能学好软件开发技术呢?其实成为编程高手没有捷径，多么简单的一句话啊，但是有多少人能够了解它呢。关键是你知道怎样才能成为真正的编程高手吗?
北大青鸟java课程软件工程师课程，专门针对高中生开设，零基础学习，把高中生培养成高薪的软件工程师人才。学校以企业真实项目实训的方式培养学员软件开发技术，提升学员学习兴趣，增强学员项目开发经验，引领学员轻松踏入IT行业。入学即签订就业协议，让中等及以上学历者经过一年的努力实现软件工程师梦想!
北大青鸟针对学员如何成为JAVA软件编程高手，总结了一些经验，供学员参考。
1.一门语言的语法，SDK的常用API，算法与数据结构有了上面的知识，再加上一点实践，再从网上找一些笔试题做几套，基本可以过笔试这一关。
2.编码规范、高性能编码经验技巧。要成为一个职业化的、专业化的程序员，首先要养成良好的习惯，良好的习惯从规范化的点滴日常工作开始。
3.熟练掌握IDE、常用工具的使用工具可以提高生产力，用一把小刀去砍树很困难，用电锯立刻变得很简单。
4.面向对象的原则。这里重点掌握面向对象的原则，比如：单一职责原则SRP、开放-封闭原则、替换原则LSP、依赖倒置原则DIP等，明白了这些原则，对后面内容理解的深入会有很大的帮助。其实这才是根本，不了解这些原则去学设计模式有种空中楼阁、头重脚轻的感觉。根基不牢上层建筑就好像浮云一样。
5.重构。重构就是在不改变软件功能的前提下改善代码的设计以提高可维护性。修改别人的代码或者优化自己的代码都需要用到重构技术。
6.设计模式。基于一些常用的模式来学习如何使用设计模式。设计模式对于做框架开发的程序员比较有帮助。小黄鸭java代码教程我们会选择一些常用的来讲解。
7.最重要、最难，看上去却最简单的功夫：修改代码的艺术。对公司来讲，一个没经验的人修改了一个bug，可能会引出几个问题，然后再去修改，如此恶性循环。对于员工来讲，赶鸭子上架，不了解代码的逻辑、针对表象简单粗暴的修改，有时小黄鸭java代码教程我看了真的很是心痛。对程序员本身的能力提高也是缓慢的。其实修改别人的代码开始是功夫，之后就是艺术。就好像你要给一个人治病，你要成为医生，先要掌握人体基本结构、各个脏器的特点、各种药物的功能、常用的诊治方法等等，医院不会让一个医学院毕业的学生去给病人看病，总要有段实习，由经验丰富的医生带一段时间。然后从难度较低的做起。
8.架构设计。架构设计在程序设计中是相当关键的一步，需不断摸索和研究，总结出自己的方法。
9.软件工程。开发软件的过程，我经历过公司从CMM到敏捷的转变，我个人是比较推崇敏捷开发的，这里想与大家站在工程的角度聊一聊软件开发。
10.质量管理。越往后其实越偏向管理了，开始是个人修炼，后面是站在组织、站在公司的角度来看软件。质量是说得多、做得少，尤其在软件领域，我一直觉得很邪门的事情是不懂软件开发的人甚至被淘汰出去的人去从事软件行业的质量管理，真是令人担忧。质量管理中有很多很好的理论和工具，是值得我们学习的，不只可以应用到软件开发上，生活中也很有用的。
Q4: java解析json字符串 放到数组中
java解析json字符串时将大括号中小黄鸭java代码教程的对应为一个类小黄鸭java代码教程，里面的数据对应为类的属性，最后用数组接受即可。
示例关键代码如下小黄鸭java代码教程：
//导入 net.sf.json.JSONArray和net.sf.json.JSONObject 两个jar 包
String str = "[{name:'a',value:'aa'},{name:'b',value:'bb'},{name:'c',value:'cc'},{name:'d',value:'dd'}]" ; // 一个未转化的字符串
JSONArray json = JSONArray.fromObject(str ); // 首先把字符串转成 JSONArray 对象
if(json.size()0){
for(int i=0;ijson.size();i++){
JSONObject job = json.getJSONObject(i); // 遍历 jsonarray 数组，把每一个对象转成 json 对象
System.out.println(job.get("name")+"=") ; // 得到 每个对象中的属性值
}
}
小黄鸭java代码教程的介绍就聊到这里吧，感谢你花时间阅读本站内容，更多关于小黄鸭程序调试法、小黄鸭java代码教程的信息别忘了在本站进行查找喔。
