这里有一个很菜的问题，答上来给100分！！！谢谢！！！

以前有人發過類似的貼子,你search一下調用之類的等等,很多的.

解决方案 »

  1.   

    声明frm2为全局变量
    frm1.textbox1.text=frm2.textbox1.text
      

  2.   

    总是看到有人问这样的问题！OOP没用好给一篇哦以前的文章，包你解决问题。100分该给我了！
    初吻OOP
    ——xlfancy   2003.05.21OOP，对于任何一个玩IT的人（特别是程序员）来说，那可是个挂在嘴边显水平好东东啊。因此呢，有事没事你总她挂在嘴边就对啦！
    所谓OOP，就是Object Oriented Programming，用书上的话来说也叫“面向对象的程序设计”。正因如此,哦不敢大言，只是轻轻地
    吻了她一下！就我的肤浅理解，只要把程序、以及程序中所有一切的一切，都看成是对象就好啦。下面哦就把初吻的滋味，和大家分享分享！假定我要用C#写这样一个程序：
    程序有3个窗体组成（F1、F2、F3，记住这是对象），其中有2个数据（d、d12）。对数据的访问要求，d可由F1、F2、F3任意访问；
    d12只能由F1、F2访问，但F3不能访问。这是个很简单的程序，用面向过程的程序设计来说，只要建立3个窗体，1个全局变量，1个局部变量，搞定！可想玩OOP，那就不是这么回事了。（不过个人觉得OOP还更好玩野），别急哈，慢慢来首先，我们把程序看成是一个对象（注意：OOP开始啦），并命名为Test，如下：class Test
    {}嘿嘿，玩过C++的会说，这是什么对象？没错，在C#中，这就是对象！只不过是个空的对象。C#中类可以不必显式声明构造函数、
    析造函数，C#会替你加上一个默认的构造函数、析造函数。如果是必需，也可以显式声明构造函数、析造函数，这将取代默认的
    构造函数、析造函数。当然要使编译通过，我们还得指定程序的入口点，C#中程序入口和终止由方法Main()指定。并且Main()方法
    只能是static方法。好啦，那就加上方法Main()吧！如下：class Test
    {
    //public Test(){}
    static void Main()
    { }
    }以上就是我们程序的完整的对象。然后，我们再把其他对象分别加入，由于F1、F2具有相同的特性（都能访问d12），不妨把它们看成
    从属于同一个对象F。如下：class Test
    {
    class F
    {
    class F1
    {}
    class F2
    {}
    }
       
    class F3
    {} static void Main()
    { }
    }对啦，还有数据d，d12。d可以作为 Test的字段（C++称为成员），而d12只能作为F的字段，再加上修饰符就成下面的样子：public class Test
    {
    private static String d="全局变量";
    public class F
    {
    private static String d12="局部变量";
    public class F1
    {}
    public class F2
    {}
    } public class F3
    {} static void Main()
    { }
    }搞定！OOP就这么好玩哦明白了吧？从OOP的角度来看，全局变量、局部变量只不过是对象的一个字段罢了，所不同的只是它们的作用域和访问属性。有人说啦，你这就叫搞定？窗体在那呢？别急呀，别忘了对象的一大利器--继承，对呀，就是继承！我们可以让F1、F2、F3分别从3个窗体中继承不就结啦。
    好，下面我们开始从VS.NET的IDE中来继续完成这个程序。
    第一步：创建一个C#空项目，用默认名Project1，然后从项目菜单中选择菜单添加类，取名为Test,并把它作为我们程序的总对象。
    这样，C#就为我们生成如下代码：（为使架构清晰，删除了注释）using System;namespace Project1
    {
    public class Test
    {
    public Test()
    {
    }
    }
    }
    第二步：把Main()方法加上，然后把前面介绍的架构补全，就成下面这个样子：using System;namespace Project1
    {
    public class Test
    {
    private static String d="全局变量";
    public class F
    {
    private static String d12="局部变量";
    public class F1
    {}
    public class F2
    {}
    } public class F3
    {} static void Main()
    { }
    }
    }试着编译一下，通过！只是有两个警告：
    f:\winapp\project1\test.cs(10,25): warning CS0169: 私有字段“Project1.Test.d”从未使用过
    f:\winapp\project1\test.cs(13,26): warning CS0169: 私有字段“Project1.Test.F.d12”从未使用过不管它，继续我们的OOP。现在开始玩继承了。注意哈，继承开始啦
    第三步：现在我们来创建一个窗体Form1，并把它们分别作为F1、F2、F3的基类。同时在Form1中加个按钮button1，
    这样C#为我们生成的Form1代码如下：using System;
    using System.Drawing;
    using System.Collections;
    using System.ComponentModel;
    using System.Windows.Forms;namespace Project1
    {
    public class Form1 : System.Windows.Forms.Form
    {
    private System.Windows.Forms.Button button1;
    private System.ComponentModel.Container components = null; public Form1()
    {
    InitializeComponent();
    } protected override void Dispose( bool disposing )
    {
    if( disposing )
    {
    if(components != null)
    {
    components.Dispose();
    }
    }
    base.Dispose( disposing );
    } private void InitializeComponent()
    {
    this.button1 = new System.Windows.Forms.Button();
    this.SuspendLayout();
    // 
    // button1
    // 
    this.button1.Location = new System.Drawing.Point(192, 40);
    this.button1.Name = "button1";
    this.button1.TabIndex = 0;
    this.button1.Text = "button1";
    // 
    // Form1
    // 
    this.AutoScaleBaseSize = new System.Drawing.Size(6, 14);
    this.ClientSize = new System.Drawing.Size(292, 273);
    this.Controls.Add(this.button1);
    this.Name = "Form1";
    this.Text = "Form1";
    this.ResumeLayout(false);
    }
    }
    }现在我们给Form1窗体上的button1添加个单击事件（只要在button1上双击一下，C#就会自动为我们加上），如下：private void button1_Click(object sender, System.EventArgs e)
    {}上面的方法是属于class Form1的，为了能在F1中得到继承和重写，我们要稍作修改，如下：protected virtual void button1_Click(object sender, System.EventArgs e)
    {
          
    }注意关键字 protected virtual 使我们能够在class F1中重写这个方法。class Form1中的button1_Click方法
    就让它保持为空好啦。我们将在稍后重写这个方法。好啦，F1、F2、F3就可以从这个Form1继承啦。这样我们的代码就成下面这个样子：using System;namespace Project1
    {
    public class Test
    {
    private static String d="全局变量";
    public class F
    {
    private static String d12="局部变量";
    public class F1:Form1   //注意此处从Form1继承
    {}
    public class F2:Form1   //注意此处从Form1继承
    {}
    } public class F3:Form1   //注意此处从Form1继承
    {} static void Main()
    { }
    }
    }
    第四步：在class F1中重写button1_Click方法，如下：protected override void button1_Click(object sender, System.EventArgs e)
    {
    MessageBox.Show(d+" 和 "+d12);
    d12="全局变量和局部变量只不过是个字段而已";
    F2 f2=new F2();
    f2.Show();
    }在class F2中重写button1_Click方法，如下：
    protected override void button1_Click(object sender, System.EventArgs e)
    {
    MessageBox.Show(d12);
    F3 f3=new F3();
    f3.Show();
    }在class F3中重写button1_Click方法，如下：
    protected override void button1_Click(object sender, System.EventArgs e)
    {
    MessageBox.Show(d);
    }这样我们得到如下完整的代码：using System;
    using System.Windows.Forms;   //注意此处添加的引用namespace Project1
    {
    public class Test
    {
    private static String d="全局变量";
    public class F
    {
    private static String d12="局部变量";
    public class F1:Form1   //注意此处从Form1继承
    {
    protected override void button1_Click(object sender, System.EventArgs e)
    {
    MessageBox.Show(d+" 和 "+d12);
    d12="全局变量和局部变量只不过是个字段而已";
    F2 f2=new F2();
    f2.Show();
    } }
    public class F2:Form1   //注意此处从Form1继承
    {
    protected override void button1_Click(object sender, System.EventArgs e)
    {
    MessageBox.Show(d12);
    F3 f3=new F3();
    f3.Show();
    }
    }
    } public class F3:Form1   //注意此处从Form1继承
    {
    protected override void button1_Click(object sender, System.EventArgs e)
    {
    MessageBox.Show(d);
    }
    } static void Main()
    {
    Application.Run(new F.F1());
    }
    }
    }请注意第二行多了个using System.Windows.Forms; 这是由于Application驻留在此命名空间。好啦，编译运行看看，怎么样？咦？怎么有个DOS窗口呢？请注意了：这是因为我们还没告诉编译器要编译成Windows应用程序（空项目默认是控制台应用程序），
    现在请点击项目菜单中的属性菜单，在弹出的属性对话窗中将输出类型改为Windows应用程序，点击确定钮关闭属性对话窗。
    以上就是设空定项目类型的方法。如果你熟悉了，可以在完成了第一步后就进行定项目类型的设定。再次编译运行，哈哈！搞定赛！怎么样？OOP就是爽吧！
      

  3.   

    总是看到有人问这样的问题！OOP没用好给一篇哦以前的文章，包你解决问题。100分该给我了！
    初吻OOP
    ——xlfancy   2003.05.21OOP，对于任何一个玩IT的人（特别是程序员）来说，那可是个挂在嘴边显水平好东东啊。因此呢，有事没事你总她挂在嘴边就对啦！
    所谓OOP，就是Object Oriented Programming，用书上的话来说也叫“面向对象的程序设计”。正因如此,哦不敢大言，只是轻轻地
    吻了她一下！就我的肤浅理解，只要把程序、以及程序中所有一切的一切，都看成是对象就好啦。下面哦就把初吻的滋味，和大家分享分享！假定我要用C#写这样一个程序：
    程序有3个窗体组成（F1、F2、F3，记住这是对象），其中有2个数据（d、d12）。对数据的访问要求，d可由F1、F2、F3任意访问；
    d12只能由F1、F2访问，但F3不能访问。这是个很简单的程序，用面向过程的程序设计来说，只要建立3个窗体，1个全局变量，1个局部变量，搞定！可想玩OOP，那就不是这么回事了。（不过个人觉得OOP还更好玩野），别急哈，慢慢来首先，我们把程序看成是一个对象（注意：OOP开始啦），并命名为Test，如下：class Test
    {}嘿嘿，玩过C++的会说，这是什么对象？没错，在C#中，这就是对象！只不过是个空的对象。C#中类可以不必显式声明构造函数、
    析造函数，C#会替你加上一个默认的构造函数、析造函数。如果是必需，也可以显式声明构造函数、析造函数，这将取代默认的
    构造函数、析造函数。当然要使编译通过，我们还得指定程序的入口点，C#中程序入口和终止由方法Main()指定。并且Main()方法
    只能是static方法。好啦，那就加上方法Main()吧！如下：class Test
    {
    //public Test(){}
    static void Main()
    { }
    }以上就是我们程序的完整的对象。然后，我们再把其他对象分别加入，由于F1、F2具有相同的特性（都能访问d12），不妨把它们看成
    从属于同一个对象F。如下：class Test
    {
    class F
    {
    class F1
    {}
    class F2
    {}
    }
       
    class F3
    {} static void Main()
    { }
    }对啦，还有数据d，d12。d可以作为 Test的字段（C++称为成员），而d12只能作为F的字段，再加上修饰符就成下面的样子：public class Test
    {
    private static String d="全局变量";
    public class F
    {
    private static String d12="局部变量";
    public class F1
    {}
    public class F2
    {}
    } public class F3
    {} static void Main()
    { }
    }搞定！OOP就这么好玩哦明白了吧？从OOP的角度来看，全局变量、局部变量只不过是对象的一个字段罢了，所不同的只是它们的作用域和访问属性。有人说啦，你这就叫搞定？窗体在那呢？别急呀，别忘了对象的一大利器--继承，对呀，就是继承！我们可以让F1、F2、F3分别从3个窗体中继承不就结啦。
    好，下面我们开始从VS.NET的IDE中来继续完成这个程序。
    第一步：创建一个C#空项目，用默认名Project1，然后从项目菜单中选择菜单添加类，取名为Test,并把它作为我们程序的总对象。
    这样，C#就为我们生成如下代码：（为使架构清晰，删除了注释）using System;namespace Project1
    {
    public class Test
    {
    public Test()
    {
    }
    }
    }
    第二步：把Main()方法加上，然后把前面介绍的架构补全，就成下面这个样子：using System;namespace Project1
    {
    public class Test
    {
    private static String d="全局变量";
    public class F
    {
    private static String d12="局部变量";
    public class F1
    {}
    public class F2
    {}
    } public class F3
    {} static void Main()
    { }
    }
    }试着编译一下，通过！只是有两个警告：
    f:\winapp\project1\test.cs(10,25): warning CS0169: 私有字段“Project1.Test.d”从未使用过
    f:\winapp\project1\test.cs(13,26): warning CS0169: 私有字段“Project1.Test.F.d12”从未使用过不管它，继续我们的OOP。现在开始玩继承了。注意哈，继承开始啦
    第三步：现在我们来创建一个窗体Form1，并把它们分别作为F1、F2、F3的基类。同时在Form1中加个按钮button1，
    这样C#为我们生成的Form1代码如下：using System;
    using System.Drawing;
    using System.Collections;
    using System.ComponentModel;
    using System.Windows.Forms;namespace Project1
    {
    public class Form1 : System.Windows.Forms.Form
    {
    private System.Windows.Forms.Button button1;
    private System.ComponentModel.Container components = null; public Form1()
    {
    InitializeComponent();
    } protected override void Dispose( bool disposing )
    {
    if( disposing )
    {
    if(components != null)
    {
    components.Dispose();
    }
    }
    base.Dispose( disposing );
    } private void InitializeComponent()
    {
    this.button1 = new System.Windows.Forms.Button();
    this.SuspendLayout();
    // 
    // button1
    // 
    this.button1.Location = new System.Drawing.Point(192, 40);
    this.button1.Name = "button1";
    this.button1.TabIndex = 0;
    this.button1.Text = "button1";
    // 
    // Form1
    // 
    this.AutoScaleBaseSize = new System.Drawing.Size(6, 14);
    this.ClientSize = new System.Drawing.Size(292, 273);
    this.Controls.Add(this.button1);
    this.Name = "Form1";
    this.Text = "Form1";
    this.ResumeLayout(false);
    }
    }
    }现在我们给Form1窗体上的button1添加个单击事件（只要在button1上双击一下，C#就会自动为我们加上），如下：private void button1_Click(object sender, System.EventArgs e)
    {}上面的方法是属于class Form1的，为了能在F1中得到继承和重写，我们要稍作修改，如下：protected virtual void button1_Click(object sender, System.EventArgs e)
    {
          
    }注意关键字 protected virtual 使我们能够在class F1中重写这个方法。class Form1中的button1_Click方法
    就让它保持为空好啦。我们将在稍后重写这个方法。好啦，F1、F2、F3就可以从这个Form1继承啦。这样我们的代码就成下面这个样子：using System;namespace Project1
    {
    public class Test
    {
    private static String d="全局变量";
    public class F
    {
    private static String d12="局部变量";
    public class F1:Form1   //注意此处从Form1继承
    {}
    public class F2:Form1   //注意此处从Form1继承
    {}
    } public class F3:Form1   //注意此处从Form1继承
    {} static void Main()
    { }
    }
    }
    第四步：在class F1中重写button1_Click方法，如下：protected override void button1_Click(object sender, System.EventArgs e)
    {
    MessageBox.Show(d+" 和 "+d12);
    d12="全局变量和局部变量只不过是个字段而已";
    F2 f2=new F2();
    f2.Show();
    }在class F2中重写button1_Click方法，如下：
    protected override void button1_Click(object sender, System.EventArgs e)
    {
    MessageBox.Show(d12);
    F3 f3=new F3();
    f3.Show();
    }在class F3中重写button1_Click方法，如下：
    protected override void button1_Click(object sender, System.EventArgs e)
    {
    MessageBox.Show(d);
    }这样我们得到如下完整的代码：using System;
    using System.Windows.Forms;   //注意此处添加的引用namespace Project1
    {
    public class Test
    {
    private static String d="全局变量";
    public class F
    {
    private static String d12="局部变量";
    public class F1:Form1   //注意此处从Form1继承
    {
    protected override void button1_Click(object sender, System.EventArgs e)
    {
    MessageBox.Show(d+" 和 "+d12);
    d12="全局变量和局部变量只不过是个字段而已";
    F2 f2=new F2();
    f2.Show();
    } }
    public class F2:Form1   //注意此处从Form1继承
    {
    protected override void button1_Click(object sender, System.EventArgs e)
    {
    MessageBox.Show(d12);
    F3 f3=new F3();
    f3.Show();
    }
    }
    } public class F3:Form1   //注意此处从Form1继承
    {
    protected override void button1_Click(object sender, System.EventArgs e)
    {
    MessageBox.Show(d);
    }
    } static void Main()
    {
    Application.Run(new F.F1());
    }
    }
    }请注意第二行多了个using System.Windows.Forms; 这是由于Application驻留在此命名空间。好啦，编译运行看看，怎么样？咦？怎么有个DOS窗口呢？请注意了：这是因为我们还没告诉编译器要编译成Windows应用程序（空项目默认是控制台应用程序），
    现在请点击项目菜单中的属性菜单，在弹出的属性对话窗中将输出类型改为Windows应用程序，点击确定钮关闭属性对话窗。
    以上就是设空定项目类型的方法。如果你熟悉了，可以在完成了第一步后就进行定项目类型的设定。再次编译运行，哈哈！搞定赛！怎么样？OOP就是爽吧！
      

  4.   

    看这个贴，里面有N个好办法：http://expert.csdn.net/Expert/topic/2265/2265063.xml?temp=.5568659
      

  5.   

    将textbox1设为public 
    frm1.textbox1.text=frm2.textbox1.text
      

  6.   

    form1form2 fm2 = new form2();
    form2.fm1 = this;
    fm2.show();form2public form1 fm1 = new form1();fm1.就可以访问form1所有属性与控件了
      

  7.   

    又是同样的问题,我已经回答了N次了!
    在第一个窗体Form1中用:
    public Text originaltext;//要记得把private 改成public
    Form2 frm2=new Form2(this);
    frm2.show();第二个Form2:
    private Form1 frm1
    private 
    public Form2(Form1 frm)//构造函数
    {
        this.frm1=frm;   
        
    }
      

  8.   

    在From2中加入一个成员变量Public From1 myfrom1;
    重载Form2类的构造函数,加入一个参数ref From1
    如:
    From2(ref From1 from1)
    {
    myfrom1 = from1;
    }
    这样在代码中修改如下:
    //我在myform中打开另一个窗口：
    //button1 cliked event ->
      Form2 myform2 = new Form2(ref this);
      myform2.show();就可以在myfrom2中调用myfrom2.myfrom1的函数了!
    this is very good!