鼠标右键菜单.Ponit座标与OBject所在CRECT不对应..

zyug 2009-05-21 03:51:44

我要通过鼠标右键来确定鼠标在哪个OBJECT上面，然后弹出相应的右键菜单.....
每一个OBJect对应一个绘图区Crect,如果鼠标的point在这个Crect内就调用相应的菜单

可是现在,我分明在Crect上点击右键，却告诉我

---------------------------
POINT x:257 y:302 字体所在矩形 left:60 right:272 ,top:60 bottom:84
---------------------------

下面是代码



void CNewPrintView::OnContextMenu(CWnd* /*pWnd*/, CPoint point)

{

	// TODO: 在此处添加消息处理程序代码

	/*;



	*/

	CString s ;

	s.Format(_T("POINT x:%d y:%d 字体所在矩形 left:%d right:%d ,top:%d bottom:%d"),point.x,point.y,ctt.m_nRect.left,ctt.m_nRect.right,ctt.m_nRect.top,ctt.m_nRect.bottom);

	AfxMessageBox(s);



	if(ctt.IsInRect(point))

	{

		CMenu menu;

		menu.LoadMenu(IDR_SETUP);

		CMenu * pMenu;

		pMenu = menu.GetSubMenu(0);

		pMenu->TrackPopupMenu(TPM_RIGHTBUTTON|TPM_LEFTALIGN,point.x,point.y,this,NULL);

		menu.DestroyMenu();

	}

}

什么道理,point的值也是随鼠标变化而变化.但是总差那么一点，难道要转化么？

...全文

113 3 打赏收藏转发到动态举报

写回复

用AI写文章

3 条回复

切换为时间正序

请发表友善的回复…

发表回复

zyug 2009-05-21

打赏
举报

谢谢你
screentoclient好像得到的是负数，
不知道为什么，
改成这样就好了

CRect rec;

	GetWindowRect(&rec); 

	CPoint newPoint;

	newPoint.x = point.x - rec.left;

	newPoint.y = point.y - rec.top;

通过newPoint进行比较就行了

finetawe 2009-05-21

打赏
举报

如1楼所说，要把point做下转换

lvbajiao 2009-05-21

打赏
举报

当然要转换了。screentoclient和clienttoscreen

using System; using System.Collections.Generic; using System.Linq; using System.Web; using System.Web.UI; using System.Web.UI.WebControls; using InfoSoftGlobal; using System.Text; using System.Data.SqlClient; using System.Data; namespace MYASP { ///

/// Author:jilongliang ///

public partial class index : System.Web.UI.Page { protected void Page_Load (object sender, EventArgs e) { } ///

/// 直接在控件加载出来 ///

/// /// protected void Literal1_Load (object sender, EventArgs e) { Literal1.Text = FusionCharts.RenderChart("swf/ScrollCombiDY2D.swf", "fusioncharts.xml", "", "fusioncharts1", "500", "500", false, true); } ///

/// 用户输入显示的图形fusioncharts ///

/// /// protected void btnSubmit_Click (object sender, EventArgs e) { //Request.Form() //Label1.Text = Request["ponit1"]; StringBuilder xmlData = new StringBuilder(); xmlData.Append(""); xmlData.AppendFormat("", txtPoint1.Text); //txtPoint1.Text xmlData.AppendFormat("", txtPoint2.Text); xmlData.AppendFormat("", txtPoint3.Text); xmlData.AppendFormat("", txtPoint4.Text); xmlData.Append(""); Literal1.Text = FusionCharts.RenderChart("swf/Pie3D.swf", "", xmlData.ToString(), "fusioncharts2", "800", "500", false, false); } ///

/// 从数据库读数据 ///

/// /// protected void Literal2_Load (object sender, EventArgs e) { string query = "select Team ,Points from tb_charts"; StringBuilder xmlData = new StringBuilder(); using(SqlDataReader dr = SQLDBHelper.ExecuteReader(CommandType.Text, query, null)) { // xmlData.AppendFormat(""); while(dr.Read()) { xmlData.AppendFormat("", dr ["Team"].ToString(), dr ["Points"].ToString()); } xmlData.AppendFormat(""); Literal2.Text = FusionCharts.RenderChart("swf/Column3D.swf", "", xmlData.ToString(), "testChart", "500", "500", false, true); } } ///

/// ///

/// /// protected void test2_Click (object sender, EventArgs e) { string str1=Request ["ponit1"]; Label1.Text=str1; StringBuilder xmlData = new StringBuilder(); xmlData.Append(""); xmlData.AppendFormat("", txtPoint1.Text); //txtPoint1.Text xmlData.AppendFormat("", txtPoint2.Text); xmlData.AppendFormat("", txtPoint3.Text); xmlData.AppendFormat("", txtPoint4.Text); xmlData.Append(""); Literal1.Text = FusionCharts.RenderChart("swf/Pie3D.swf", "", xmlData.ToString(), "fusioncharts2", "800", "500", false, false); } protected void test2_Click1 (object sender, EventArgs e) { } } }

面向对象编程的基础要了解面向对象编程（OOP）的基本概念，需要理解 OOP 的三个主要概念，它们撑起了整个 OOP 的框架。这三个概念是：封装、继承性和多态性。除此以外，还需了解对象、类、消息、接口、及抽象等概念。 2.2.1 对象现实世界中的对象具两个特征：状态和行为。例如：自行车有状态（传动装置、步度、两个车轮和齿轮的数目等）和行为（刹车、加速、减速和换档等）。其次，我们再来看看软件对象。软件对象是现实世界对象的模式化产物，他们也有状态和行为。软件对象把状态用数据表示并存放在变量里，而行为则用方法实现。实际上，软件对象还包括了数据结构和使用这些数据结构的代码。因此也可以说：软件对象是现实世界客观事务的软件化模拟，是变量（数据和数据结构）和相关方法（对数据操作和对象管理的程序）的软件组合。在面向对象的程序设计中，你可以用软件对象表示现实世界的对象，而这些软件对象和现实世界对象是相对应的。例如：如果你正在建立一个帐户管理系统，那么你的对象就是帐户、欠款、信用卡、月收入、贷款、交易等等。如果你设计一个电子实习交通工具系统，那么你的对象就是汽车、摩托车、自行车等等。就自行车的软件对象而言，表示该对象的状态和行为应为与变量和方法相对应。自行车的状态：数度是 10mp（每小时 10 米），步度是 90rpm （每分钟 90 转），当前传动装置是第 5 个齿轮。再面向对象的程序设计中，这些数据应放在变量中。自行车的行为：刹车，改变步度和换档。在面向对象的程序设计中，这些行为用方法实现。在 OOP 技术中，对象充当了一个很重要的角色。对象的数据是组成对象的核心，而方法则环绕这个核心并隐藏在对象之中。 2.2.2 封装 "封装"是 OOP 语言的优点之一。把一个对象的数据加以包装并置于其方法的保护之下称为封装。所谓封装就是对数据的隐藏。封装实现了把数据和操作这些数据的代码包装成为一个对象（即离散的部件），而数据和操作细节（方法）隐藏起来。如果增加某些限制，使得对数据的访问可按照统一的方式进行，那些能比较容易地产生更为强壮的代码。 OOP 语言提出一种（或称为协议），以保证对数据进行统一的操作。通常的做法是：程序和对象数据的交互作用通过一个公开的接口进行，而不直接进行操作。由于把数据封装在对象中，所以，访问对象中的数据只有一种途径，那就是利用一个公开的接口。实际上，封装在程序和数据之间设置了一道栅栏，它可以阻止一部分的设计错误，不至于涉足应用程序其他部分的数据。 2.2.3 消息一个单独的对象一般不十分有用，而作为一员出现在包含有许多其他对象的大程序或应用程序之中，通过这些对象的相互作用，程序员可实现高层次的操作和更负责的功能。某此对象通过向其他对象发送消息与其他对象进行交互作用和通信。消息是以参数的形式传递给某方法的。一个消息通常由三部分组成： 1. 消息传送到对象的名称。 2. 要执行的方法的名称。 3. 方法需要的任意参数。 2.2.4 类类是一个蓝图或样板，定义了某种类型的所有对象的变量和方法。在 java 语言中，Java 程序的基本单位是类，也就是说：一个 Java 程序是由多个类组成的。定义一个类与定义一个数据类型是有区别的。在程序设计语言中，把定义数据类型的能力作为一种很重要的能力来对待。在面向对象的语言中，类的功能更强大，这是因为类不仅含有定义数据类型的功能，而且还包含了对方法的定义。对象实际是类中的一个实例。生成实例的过程叫做把"一个对象实例化"。一个实例化的对象实际上是由若干个实例变量和实例方法组成的。当你创建出一个类的实例时，系统将为实例变量指定内存，然后你就可以利用实例方法去做某些事情。 2.2.5 继承继承是指建立子类的能力。子类继承了父亲的特征和功能。类的层次结构类似于一棵数的结构，也像一个家庭谱系。它显示了根和它的导出类之间的关系。子类从它先辈类那里继承了代码和数据，这样，它就可以执行先辈类的功能和访问先辈类的数据。一个纯面向对象程序设计的语言将具有严格的继承性。通过对象、类，我们实现了封装，通过子类我们可以实现继承。例如，公共汽车、出租车、货车等都是汽车，但它们是不同的汽车，除了具有汽车的共性外，它们还具有自己的特点(如不同的操作方法，不同的用途等)。这时我们可以把它们作为汽车的子类来实现，它们继承父类(汽车)的所有状态和行为，同时增加自己的状态和行为。通过父类和子类，我们实现了类的的层次，可以从最一般的类开始，逐步特殊化，定义一系列的子类。同时，通过继承也实现了代码的复用，使程序的复杂性线性地增长，而不是呈几何级数增长。 2.2.6 抽象面向对象的程序设计系统鼓励充分利用"抽象"。在现实世界中，人们正是通过抽象来理解复杂的事务。例如：人们并没有把汽车当作成百上千的零件组成来认识，而是把它当作具有自己特定行为的对象。人们可以忽略发动机、液压传输、刹车系统等如何工作的细节，而习惯于把汽车当作一个整体来认识。包含通用对象类的库叫作类库。 2.2.7 多态型面向对象程序的最后一个概念是多态性。凭借多态性，你可以创建一个新的对象，它具有与基对象相同的功能，但是这些功能中的一个或多个是通过不同的方式完成的。例如：在 Java 中你可以凭借多态性，通过一个画圆的对象，来创建一个画椭圆或矩形的对象。不管是画圆，画椭圆还是画矩形的方法，它们都有一个相同的方法名，但以不同的方式完成他们的画圆的功能。 1.8 类和对象 1.8.1 类类是组成 Java 程序的基本要素。它封装了一类对象的状态和方法，是这一类对象的原型。定义一个类，实际上就是指定该类所包含的数据和对数据进行操作的代码。类通过关键字 class 来定义，一般格式为：【类说明修饰符】class 类名【extends 子句】【implements 子句】 type instance-varable1; type instance-varable2; type instance-varable3; the methodname1(parameter-list){method-body;} the methodname2(parameter-list){method-body;} the methodnameN (parameter-list){method-body;} 下面将类定义格式的项目说明如下：（1） class 是类说明关键字。（2）类名是由程序员自己定义的 Java 标识符，每个类说明必须有 class 和类名。（3）类说明修饰符包括：  abstract 说明一个类为抽象类，抽象类是指不能直接实例化对象的类。  final 说明一个类为最终类，即改类不能再有子类。  public 说明类为公共类，该类可以被当前包以外的类和对象使用。  private 说明类为私有类。（4） extends 子句用于说明类的直接超类。（5） implements 子句用于说明类中将实现哪些接口，接口是 Java 的一种引用类型。（6）类体包含了变量和方法。在类体中定义的数据、变量和方法称为类的成员，或称为实例变量和实例方法。（7）例如：下例定义了一个 Point 类 ,并且声明了它的两个变量 x、y 坐标 ,同时实现 init()方法对 x、y 赋初值。 class Ponit { int x,y; void init(int ix, int iy){ x=ix; y=iy; } } 类中所定义的变量和方法都是类的成员。对类的成员可以设定访问权限，来限定其它对象对它的访问，访问权限所以有以下几种:private, protected, public, friendly。 1.8.2 对象把类实例化,我们可以生成多个对象,这些对象通过消息传递来进行交互(消息传递即激活指定的某个对象的方法以改变其状态或让它产生一定的行为),最终完成复杂的任务。一个对象的生命期包括三个阶段:创建对象、对象的引用和释放对象。 1.8.3 创建对象创建对象包括声明、实例化和初始化三方面的内容。通常的格式为 : 1. 声明对象对象声明实际上是给对象命名，也称定义一个实例变量。对象声明的一般格式为： type name 其中，type 是一个类的类名，用它声明的对象将属于改类；name 是对象名。例如： Date today； Rectangle myRectangle; 第一条语句说明了对象 today 属于 Date 类，第二条语句说明了对象 myRectangle 属于 Rectangle 类。对象说明并没有体现一个具体的对象，只有通过实例化后的对象才能被使用。 2. 实例化对象实例化对象就是创建一个对象。实例化对象意味着给对象分配必要的存储空间，用来保存对象的数据和代码。实例化后的每个对象均占有自己的一块内存区域，实例化时，每个对象分配有一个"引用"（reference）保存到一个实例变量中。"引用" 实际上是一个指针，此指针指向对象所占有的内存区域。因此，对象名（变量）实际上存放的是一个被实例化之后的对象所占有的内存区域的指针。例如： type objectName = new type ( [paramlist] ); 运算符 new 为对象分配内存空间 ,实例化一个对象。new 调用对象的构造方法,返回对该对象的一个引用(即该对象所在的内存地址)。用 new 可以为一个类实例化，多个不同的对象。这些对象分别占用不同的内存空间，因此改变其中一个对象的状态不会影响其它对象的状态。 3．初始化对象生成对象的最后一步是执行构造方法,进行初始化。由于对构造方法可以进行重写，所以通过给出不同个数或类型的参数会分别调用不同的构造方法。例子：以类 Rectangle 为例,我们生成类 Rectangle 的对象: Rectangle p1=new Rectangle (); Rectangle p2=new Rectangle (30，40); 这里，我们为类 Rectangle 生成了两个对象 p1、p2,它们分别调用不同的构造方法， p1 调用缺省的构造方法(即没有参数)，p2 则调用带参数的构造方法。p1、p2 分别对应于不同的内存空间，它们的值是不同的,可以完全独立地分别对它们进行操作。虽然 new 运算符返回对一个对象的引用，但与 C、C++中的指针不同,对象的引用是指向一个中间的数据结构，它存储有关数据类型的信息以及当前对象所在的堆的地址，而对于对象所在的实际的内存地址是不可操作的,这就保证了安全性。 1.8.4 对象的引用对象的使用包括引用对象的成员变量和方法,通过运算符·可以实现对变量的访问和方法的调用,变量和方法可以通过设定一定的访问权限(见下面的例子)来允许或禁止其它对象对它的访问。我们先定义一个类 Point。例子： class Point{ int x,y; String name = "a point"; Point(){ x = 0; y = 0; } Point( int x, int y, String name ){ this.x = x; this.y = y; this.name = name; } int getX(){ return x; } int getY(){ return y; } void move( int newX, int newY ){ x = newX; y = newY; } Point newPoint( String name ){ Point newP = new Point( -x, -y, name ); return newP; } boolean equal( int x, int y ){ if( this.x==x && this.y==y ) return true; else return false; } void print(){ System.out.println(name+" : x = "+x+" y = "+y); } } public class UsingObject{ public static void main( String args[] ){ Point p = new Point(); p.print(); //call method of an object p.move( 50, 50 ); System.out.println("** after moving **"); System.out.println("Get x and y directly"); System.out.println("x = "+p.x+" y = "+p.y); //access variabl es of an object System.out.println("or Get x and y by calling method"); System.out.println("x = "+p.getY()+" y = "+p.getY()); if( p.equal(50,50) ) System.out.println("I like this point!!!! "); else System.out.println("I hate it!!!!! "); p.newPoint( "a new point" ).print(); new Point( 10, 15, "another new point" ).print(); } } 运行结果为: C:\java UsingObject a point : x = 0 y = 0 **** after moving ***** Get x and y directly x = 50 y = 50 or Get x and y by calling method x = 50 y = 50 I like this point!!!! a new point : x = -50 y = -50 another new point : x = 10 y = 15 1.引用对象的变量要访问对象的某个变量,其格式为: objectReference.variable 其中 objectReference 是对象的一个引用,它可以是一个已生成的对象,也可以是能够生成对象引用的表达式。例如:我们用 Point p=newPoint();生成了类 Point 的对象 p 后,可以用 p.x,p.y 来访问该点的 x、y 坐标,如 p.x = 10; p.y = 20; 或者用 new 生成对象的引用,然后直接访问,如: tx=new point().x; 2.调用对象的方法要调用对象的某个方法,其格式为: objectReference.methodName ( [paramlist] ); 例如我们要移动类 Point 的对象 p,可以用 p.move(30,20); 虽然我们可以直接访问对象的变量 p.x、p.y 来改变点 p 的坐标,但是通过方法调用的方式来实现能更好地体现面向对象的特点,建议在可能的情况下尽可能使用方法调用。同样,也可以用 new 生成对象的引用,然后直接调用它的方法,如 new point(). move (30,20); 前面已经讲过,在对象的方法执行完后,通常会返回指定类型的值,我们可以合法地使用这个值,如:例子中类 Point 的方法 equal 返回布尔值,我们可以用它来作为判断条件分别执行不同的分支。如: if (p.equal (20,30)){ ...... //statements when equal }else { ...... //statements when unequal } 另外,类 Point 的方法 newPoint 返回该点关于原点的对称点,返回值也是一个 Point 类型,我们可以访问它的变量或调用它的方法,如: px = p.newPoint().x 或 px = p.newPoint(). getX(); 1.8.5 成员变量对象具有状态和行为，而对象的状态则是用变量或数据来描述的。在一个类中，对象的状态是以变量或数据的形式定义的。例如： "盒子"的体积的状态主要是宽度、高度、和深度。因此在类定义"盒子"对象时，只将这三个属性作为其主要的状态，并用变量的形式来描述，这些变量称为成员变量。而在对象实例化后，这些变量称为实例变量。 1.8.6 成员变量定义格式成员变量定义的一般格式为：【Modifer】type variablelist；其中， type 指定变量的类型，它可以时 Java 的任意一种类型。 variablelist 是一组逗号隔开的变量名（变量列表），每个变量都可带有自己的初始化的表达式。例如： xint ，z； aint ，b＝2，c＝3； Modifer 是定义变量的修饰符，它说明了变量的访问权限和某些使用规则。变量修饰符可以是关键字 public、protected、private、final、static、transient 和 volatile 的组合。 1.8.7 成员变量的初始化当成员变量含有自己的初始化表达式时，可以创建实例的方式使成员变量实例化。例如： class Box{ double width = 10; double height= 15; double depth= } 变量 width、height、depth 是成员变量。在执行 Box myBox1 ＝ new Box（）语句之后， new 运算符就创建了一个实例，并将变量分别赋初值为 10、15、20。在此时的变量 width、 height、depth 称为实例变量。注意：在初始化表达式中，不能包含成员变量本身或同类的其他成员变量。例如，下面的用法式错误的： class Test{ int int t =j; int } 错误有两个：一个式变量 k 的初始化涉及对 k 自身的访问；二式对 t 进行初始化时含有对 j 的访问，而 j 的说明在其后。 1.8.8 成员变量的访问权限成员变量或方法的访问权限是用访问权限修饰符来指定的。Java 的访问权限修饰符包括四种显示方式修饰符和一种隐含方式修饰符，即： 1. 公用变量用 public 说明的变量是公有变量。访问权限：允许任何包中的任何类的变量访问。例如：下面的代码中，在类 Alpha 中说明了一个公用变量 i_public，而在另一个类 Beta 中可以访问该变量。 class Alpha{ public int i_public ; } class Beta{ void accessmethod() { Alphaa= newAlpha(); a.i_public=10; } } 2. 私有变量 //说明公用变量 i_public //访问公用变量 i_public 用 private 说明的变量是私有变量。访问权限：只能被定义它的类的变量访问。例如：下面的代码中，在类 Alpha 中说明了一个私有变量 i_private，其他类不允许访问。正确的访问格式： class Alpha{ 3. 保护变量 } public int i_private ; void accessmethod() { Alphaa= newAlpha(); a.i_private=10; } //说明私有变量 i_private //访问私有变量 i_private 用 protected 说明的变量是保护变量。访问权限：允许类自身、子类以及在同一个包中的所有类的变量访问。例如：假定某个包 Geek 中含有两个成员类 Alpha 和 Beta，若在类 Alpha 中说明了一个保护变量 i_protected,则在另外一个类 Beta 中可以访问该变量。 class Alpha{ public int i_protected; void accessmethod() } class Beta { void accessmethod() { Alpha a= new Alpha(); a.i_protected=10; } } 4. 私有保护变量 //说明保护变量 i_protected //访问保护变量 i_protected 用 private protected 说明的变量是私有保护变量。访问权限：允许类自身以及它的子类变量访问。例如：下面的两种访问方式是可行的。（1）在类中访问私有保护变量例如： class Alpha{ private protected int i_pri_prot ; void accessmethod() { Alphaa= newAlpha(); } } a. i_pri_prot =10; //访问私有保护变量 i_pri_prot （2）在子类中访问私有保护变量例如： class Alpha{ private protected int i_pri_prot＝10 ; } class Beta extends Alpha { void accessmethod() { Alphaa= newAlpha(); } } a. i_pri_prot =30; //访问私有保护变量 i_pri_prot 在程序执行时，变量 i_pri_prot 的值是 30，而不是 10； 5. 友好变量如果一个变量没有显示地设置访问权限，则该变量为友好变量。访问权限：允许类自身以及在同一个包中地所有类地变量访问。例如：下面的类中定义了一个友好变量： class Alpha{ int i_friendly ; void accessmethod() { Alphaa= newAlpha(); } } a. i_friendly=10; //访问友好变量 i_friendly 在了解了成员变量的访问权限之后，那么在说明每一个成员变量时，都可以按访问权限给变量提供适当的保护措施，这样就加强了变量的安全性。名称公用私有保护私有保护访问权限修饰 public private protected private protected 类 √ √ √ √ 子类 √ √ √ 包 √ * 所有类 √ √ 友好 friendly √ √ 注：表中√的为可选，打*的说明有特殊限制。*号是针对子类访问保护变量而言，即一个子类只有与超类在同一个包中，才可以访问超类对象的保护变量。 1.8.9 静态变量用 static 说明的变量是静态变量。静态变量与其他成员变量有区别：其他成员变量必须通过类的对象来访问，每个对象都有这些变量的备份；而静态变量独立于改类中的任何对象，它在类的实例中只有一个备份，可以直接使用，而不必通过类的对象去访问，它一直属于定义它的类，因此也称为类变量。类的所有对象都共享 static 变量。static 变量通常也称为全局变量。例如：静态变量的定义和引用。首先在类 MyDemo 中定义了 static 变量 x，y 然后在类 MyStaticDemo 中输入变量 x 和 y 的值。 import java.awt.Graphics; class MyDemo { static int x=80; static int y=120; } class MyStaticDemo extends java.applet.Applet { public void paint(Graphics g) { g.drawString("x="+MyDemo.x+"y="+MyDemo.y,25,50); } } 程序运行结果： x＝80 y＝120 在上面的程序中，在访问的静态变量 x 和 y 时，是通过类名 MyDemo 直接访问的。 static 也可以说明方法。用 static 说明的方法是静态方法或类方法，在实例中只有一个备份。该方法具有以下约束： a) b) c) 它们仅可以调用其他 static 方法。它们仅可以访问 static 变量。它们不能参考 this 或 super。如果类的成员被定义为 static，则可以通过下面形式引用：类名，成员名这里，类名是定义 static 成员所属的类。Java 通过这样的方式，实现了全局方法和变量。 1.8.10 final 变量用 final 说明的变量可以当作一个常量使用，不得对其进行任何修改。若某此变量为了防止被修改，则定义变量时必须初始化一个 final 变量。在这一点上，final 与 C\C＋＋的 const 相似。比如： final int MONDAY=1; final int TUSDAY=2; final int WEDNESDAY=3; ...... 以后程序可以把上述变量当作常量来使用，而不用担心其被修改。 final 变量用大写字母来表示，这是一种习惯约定。final 变量不占内存空间，实际上也就是一个常数。 1.9 方法 1.9.1 方法的定义方法也是类的一个成员，定义方法时在定义类的同时进行的。其一般格式为： type name(parameter -list) { //方法体 } 格式说明：（1） type 指定方法的返回类型，简称方法的类型，它可以是任何有效的类型，包括类类型。方法的返回或带值返回都由 return 语句实现，当一个方法没有返回值时，其 type 必须为 void，且 return 语句可以省略。（2） name 指定方法名，方法名可以是合适的 Java 标识符。（3） parameter-list 指定方法的参数列表，参数包括参数的类型和参数名，每个参数用逗号隔开。在定义方法时，其参数将作为形参；在调用方法时，其参数被称为实参。调用时是把实参的值传递给形参。入过方法没有参数，参数列表为空，但括号"（）"不能省略。（4）方法体包含了一组代码，它用于对数据处理。方法体用以对大括号"{}"括起来。例如：Box 类封装"盒子"的状态和行为，即数据变量和方法，用方法 volume 计算 Box 对象的体积。 import java.awt.Graphics； class Box { double width; double height; double depth; void setDemo(double w,double h,double d) { width=w; height=h; depth=d; } } double volume() { return width*height*depth; } class BoxDemo extends java.applet.Applet { public void paint(Graphics g) { double d_volume; Box myBox = new Box(); myBox.setDemo(10,20,30); //调用方法 setDemo 给变量赋值 d_volumn = myBox.volume(); //计算体积 g.drawString("myBox 的体积是："+ d_volumn,25,50); } } 程序运行的结果如下： myBox 的体积是：6000 1.9.2 方法的访问权限方法同成员变量一样，可以在定义时说明方法的访问权限，其说明格式和访问机制与成员变量完全一样。例如：私有方法、私有保护方法只能被同一个类中的方法调用，公用方法可以被其他类的方法调用。 import java.awt.Graphics; class Alpah1 { pivateint i_private() { int x=10; int y=20; return x+y; } public int i_public1() { return i_private(); } } class Alpah2 { public public int x,y; private protected int i_protected(int a,int h) { x=a; y=b; return x+y; } public void i_public2(int i,int j) { k=i_protected(i,j); } } class Test extends java.applet.Applet { public void paint(Graphics g) { int p1; Alpah1 ap1= newAlpah1(); Alpah2 ap2= newAlpah2(); p1=ap1.i_public1(); ap2. i_public2(50,50); g.drawString("i_public1()的返回值是："+p1,25,50); g.drawString("i_public2()的返回值是："＋ap2.k,25,50); } } 程序运行的结果如下：方法 i_public1()的返回值是:30 方法 i_public2()的返回值是:100 程序说明：（1）在类 Alpah1 中，方法 i_private()是私有的，它只能被同类的方法 i_public1()调用。而方法 i_public1()是公有的，它可以被另一类 Demo 中的方法 paint（）调用。（2）在类 Alpah2 中，方法 i_protected()是私有保护性的，它不能被其他类的方法调用，而只能被同类（或子类）的方法 i_public2()调用。同样，方法 i_public2()也是公有的，它可以被另一类 Test 中的方法 paint（）调用。（3）在方法 i_public1()中，语句 return i_private()执行的顺序为：先调用，后返回。其返回值是 x+y 的和。（4）在方法 i_public2(int i,int j)中，将形参 i 和 j 作为调用方法中的实参。如：k=i_protected(i,j); (5) 在类 Alpha2 中，定义了成员变量 k、x 和 y。其中 k 是公有的，它可被类 Test 中的方法引用，其格式为：ap2.k；而变量 x 和 y 是私有的。它只能被同一类的方法引用。（6）在类 Alpah1 方法 i_private（）中，定义的变量 x 和 y 是局部变量。局部变量作用域是：只能在定义它的方法中有效，即使同一类中的方法也不能引用。例如：方法 i_public()是不能访问局部变量 x 和 y 的。 1.9.3 对象作为参数例：给定两个数，按大小顺序输出。 import java.awt.Graphics; class Test1 { public int a,b; void mov(int i,int j) { a=i; b=j; } } class Test2 { void max(Test1 test1) { int c; if(test1.aObject 描述：公用类。此类中包含了一组在 Swing 工具包中使用的帮助器方法常用类方法： void paintComponent(Graphics g,Component c,Container p,int x,int y,int w,int h); void paintComponent(Graphics g,Component c,Container p,Rectangle r); void invokeLate(Runnable doRun); boolean isEventDispatchThread(); Component getRoot(Component c); JRootPane getRootPane(Component c);

在Draw工具中 draw-end(画图结束后想地图添加图形) 发现第一次添加一个图形,第二次添加两个图形,第三次添加三个图形,依次递增 //新增图形 function addLifeBoundary(){ alert("新增图形"); lifeFeatureLayer.clearSelection(); lifeFeatureLayer.refresh(); ...

function setPlace(dd){ var add="福建省福州市"+$("#sendDistrict").val(); map.clearOverlays(); //清除地图上所有覆盖物 function myFun(){ console.log(local.getResults().getPoi(0).ad...

VC/MFC

16,472

社区成员

421,732

社区内容

发帖

与我相关

我的任务

社区管理员

加入社区

近7日
近30日
至今

加载中

查看更多榜单

社区公告

VC/MFC社区版块或许是CSDN最“古老”的版块了，记忆之中，与CSDN的年龄几乎差不多。随着时间的推移，MFC技术渐渐的偏离了开发主流，若干年之后的今天，当我们面对着微软的这个经典之笔，内心充满着敬意，那些曾经的记忆，可以说代表着二十年前曾经的辉煌……
向经典致敬，或许是老一代程序员内心里面难以释怀的感受。互联网大行其道的今天，我们期待着MFC技术能够恢复其曾经的辉煌，或许这个期待会永远成为一种“梦想”，或许一切皆有可能……
我们希望这个版块可以很好的适配Web时代，期待更好的互联网技术能够使得MFC技术框架得以重现活力，……

试试用AI创作助手写篇文章吧

+ 用AI写文章