当前位置：文档库 › Microsoft Word - MFC消息循环和消息路由

Microsoft Word - MFC消息循环和消息路由

MFC消息循环和消息泵

首先，应该清楚MFC的消息循环(::GetMessage,::PeekMessage)，消息泵(CWinThread::PumpMessage)和MFC的消息在窗口之间的路由是两件不同的事情。在MFC的应用程序中(应用程序类基于CWinThread继承)，必须要有一个消息循环，他的作用是从应用程序的消息队列中读取消息，并把它派送出去(::DispatchMessage)。而消息路由是指消息派送出去之后，系统(USER32.DLL)把消息投递到哪个窗口，以及以后消息在窗口之间的传递是怎样的。

消息分为队列消息(进入线程的消息队列)和非队列消息(不进入线程的消息队列)。对于队列消息，最常见的是鼠标和键盘触发的消息，例如WM_MOUSERMOVE,WM_CHAR等消息；还有例如：WM_PAINT、WM_TIMER和WM_QUIT。当鼠标、键盘事件被触发后，相应的鼠标或键盘驱动程序就会把这些事件转换成相应的消息，然后输送到系统消息队列，由Windows系统负责把消息加入到相应线程的消息队列中，于是就有了消息循环(从消息队列中读取并派送消息)。还有一种是非队列消息，他绕过系统队列和消息队列，直接将消息发送到窗口过程。例如,当用户激活一个窗口系统发送WM_ACTIVATE, WM_SETFOCUS, and WM_SETCURSOR。创建窗口时发送WM_CREATE消息。在后面你将看到，MS这么设计是很有道理的，以及他的整套实现机制。

这里讲述MFC的消息循环，消息泵。先看看程序启动时，怎么进入消息循环的：

_tWinMain ->AfxWinMain ->AfxWinInit ->CWinThread::InitApplication

->CWinThread::InitInstance ->CWinThread::Run

非对话框程序的消息循环的事情都从这CWinThread的一Run开始...

第一部分：非对话框程序的消息循环机制

//thrdcore.cpp

// main running routine until thread exits

int CWinThread::Run()

{

ASSERT_VALID(this);

// for tracking the idle time state

BOOL bIdle = TRUE;

LONG lIdleCount = 0;

// acquire and dispatch messages until a WM_QUIT message is receive

for (;;)

{

// phase1: check to see if we can do idle work

while (bIdle && !::PeekMessage(&m_msgCur, NULL, NULL, NULL, PM_NOREMO VE))

{

// call OnIdle while in bIdle state

if (!OnIdle(lIdleCount++))

bIdle = FALSE; // assume "no idle" state

}

// phase2: pump messages while available

{

// pump message, but quit on WM_QUIT

if (!PumpMessage())

return ExitInstance();

// reset "no idle" state after pumping "normal" message

if (IsIdleMessage(&m_msgCur))

{

bIdle = TRUE;

lIdleCount = 0;

}

} while (::PeekMessage(&m_msgCur, NULL, NULL, NULL, PM_NOREMOVE));

} //无限循环，退出条件是收到WM_QUIT消息。

ASSERT(FALSE); // not reachable

}

这是一个无限循环，他的退出条件是收到WM_QUIT消息：

if (!PumpMessage())

return ExitInstance();

在PumpMessage中，如果收到WM_QUIT消息，那么返回FALSE,所以ExitInstance()函数执行，跳出循环，返回程序的退出代码。所以，一个程序要退出，只用在代码中调用函数

VOID PostQuitMessage( int nExitCode )。指定退出代码nExitCode就可以退出程序。下面讨论一下这个函数Run的流程，分两步：

1,第一个内循环phase1。bIdle代表程序是否空闲。他的意思就是，如果程序是空闲并且消息队列中没有要处理的消息，那么调用虚函数OnIdle进行空闲处理。在这个处理中将更新UI界面(比如工具栏按钮的enable和disable状态)，删除临时对象(比如用FromHandle得到的对象指针。由于这个原因，在函数之间传递由FromHandle得到的对象指针是不安全的，因为他没有持久性)。OnIdle是可以重载的，你可以重载他并返回TRUE 使消息循环继续处于空闲状态。

NOTE：MS用临时对象是出于效率上的考虑，使内存有效利用，并能够在空闲时自动撤销资源。关于由句柄转换成对象，可以有若干种方法。一般是先申明一个对象obj,然后使用obj.Attatch来和一个句柄绑定。这样产生的对象是永久的，你必须用obj.Detach来释放对象。

2，第二个内循环phase2。在这个循环内先启动消息泵(PumpMessage),如果不是

WM_QUIT消息，消息泵将消息发送出去(::DispatchMessage)。消息的目的地是消息结构中的hwnd字段所对应的窗口。

//thrdcore.cpp

BOOL CWinThread::PumpMessage()

{

ASSERT_VALID(this);

//如果是WM_QUIT就退出函数(return FALSE)，这将导致程序结束.

if (!::GetMessage(&m_msgCur, NULL, NULL, NULL)) {

#ifdef _DEBUG

if (afxTraceFlags & traceAppMsg)

TRACE0("CWinThread::PumpMessage - Received WM_QUIT.n");

m_nDisablePumpCount++; // application must die

// Note: prevents calling message loop things in 'ExitInstance'

// will never be decremented

#endif

return FALSE;

}

#ifdef _DEBUG

if (m_nDisablePumpCount != 0)

{

TRACE0("Error: CWinThread::PumpMessage called when not permitted.n ");

ASSERT(FALSE);

}

#endif

#ifdef _DEBUG

if (afxTraceFlags & traceAppMsg)

_AfxTraceMsg(_T("PumpMessage"), &m_msgCur);

#endif

// process this message

if (m_msgCur.message != WM_KICKIDLE && !PreTranslateMessage(&m_msgCu r))

{

::TranslateMessage(&m_msgCur); //键转换

::DispatchMessage(&m_msgCur); //派送消息

}

return TRUE;

}

在这一步有一个特别重要的函数大家一定认识：PreTranslateMessage。这个函数在::DispatchMessage发送消息到窗口之前，进行对消息的预处理。

PreTranslateMessage函数是CWinThread的成员函数，大家重载的时候都是在View 类或者主窗口类中，那么，它是怎么进入别的类的呢？代码如下：

//thrdcore.cpp

BOOL CWinThread::PreTranslateMessage(MSG* pMsg)

{

ASSERT_VALID(this);

// 如果是线程消息，那么将会调用线程消息的处理函数

if (pMsg->hwnd == NULL && DispatchThreadMessageEx(pMsg))

return TRUE;

// walk from target to main window

CWnd* pMainWnd = AfxGetMainWnd();

if (CWnd::WalkPreTranslateTree(pMainWnd->GetSafeHwnd(), pMsg))

return TRUE;

// in case of modeless dialogs, last chance route through main

// window's accelerator table

if (pMainWnd != NULL)

{

CWnd* pWnd = CWnd::FromHandle(pMsg->hwnd);

if (pWnd->GetTopLevelParent() != pMainWnd)

return pMainWnd->PreTranslateMessage(pMsg);

}

return FALSE; // no special processing

}

由上面这个函数可以看出：

第一，如果(pMsg->hwnd == NULL),说明这是一个线程消息。调用CWinThread::DispatchThreadMessageEx到消息映射表找到消息入口，然后调用消息处理函数。

NOTE: 一般用PostThreadMessage函数发送线程之间的消息，他和窗口消息不同，需要指定线程id,消息激被系统放入到目标线程的消息队列中；用

ON_THREAD_MESSAGE( message, memberFxn )宏可以映射线程消息和他的处理函数。这个宏必须在应用程序类(从CWinThread继承)中，因为只有应用程序类才处理线程消息。如果你在别的类(比如视图类)中用这个宏，线程消息的消息处理函数将得不到线程消息。

第二，消息的目标窗口的PreTranslateMessage函数首先得到消息处理权，如果函数返回FALSE，那么他的父窗口将得到消息的处理权，直到主窗口；如果函数返回TRUE(表示消息已经被处理了)，那么就不需要调用父类的PreTranslateMessage函数。这样，保证了消息的目标窗口以及他的父窗口都可以有机会调用PreTranslateMessage--在消息发送到窗口之前进行预处理(如果自己处理完然后返回FALSE的话-_-b),如果你想要消息不传递给父类进行处理的话，返回TRUE就行了。

第三，如果消息的目标窗口和主窗口没有父子关系，那么再调用主窗口的PreTranslateMessage函数。为什么这样？由第二步知道，一个窗口的父窗口不是主窗口的话，尽管它的PreTranslateMessage返回FALSE，主窗口也没有机会调用

PreTranslateMessage函数。我们知道，加速键的转换一般在框架窗口的PreTranslateMessage函数中。我找遍了MFC中关于加速键转换的处理，只有CFrameWnd,CMDIFrameWnd，CMDIChildWnd等窗口类有。所以，第三步的意思是，如果消息的目标窗口(他的父窗口不是主窗口，比如一个这样的非模式对话框)使消息的预处理继续漫游的话(他的PreTranslateMessage返回FALSE)，那么给一次机会给主窗口调用PreTranslateMessage(万一他是某个加速键消息呢？)，这样能够保证在有非模式对话框的情况下还能保证主窗口的加速键好使。

我做了一个小例子，在对话框类的PreTranslateMessage中，返回FALSE。在主窗口显示这个非模式对话框，在对话框拥有焦点的时候，仍然能够激活主窗口的快捷键。

总之，整个框架就是让每个消息的目标窗口(包括他的父窗口)都有机会参与消息到来之前的处理。呵呵~

至此，非对话框的消息循环和消息泵的机制就差不多了。这个机制在一个无限循环中，不断地从消息队列中获取消息，并且保证了程序的线程消息能够得到机会处理，窗口消息在预处理之后被发送到相应的窗口处理过程。那么，还有一点疑问，为什么要一会儿调

用::PeekMessage,一会儿调用::GetMessage呢，他们有什么区别？

NOTE：一般来说，GetMessage被设计用来高效地从消息队列获取消息。如果队列中没有消息，那么函数GetMessage将导致线程休眠(让出CPU时间)。而PeekMessage是判断消息队列中如果没有消息，它马上返回0，不会导致线程处于睡眠状态。

在上面的phase1第一个内循环中用到了PeekMessage，它的参数PM_NOREMOVE表示并不从消息队列中移走消息，而是一个检测查询，如果消息队列中没有消息他立刻返回0，如果这时线程空闲的话将会引起消息循环调用OnIdle处理过程(上面讲到了这个函数的重要性)。如果将::PeekMessage改成::GetMessage(***),那么如果消息队列中没有消息，线程将休眠，直到线程下一次获得CPU时间并且有消息出现才可能继续执行，这样，消息循环的空闲时间没有得到应用，OnIdle也将得不到执行。这就是为什么既要

用::PeekMessage(查询),又要用::GetMessage(做实际的工作)的缘故。

第二部分: 对话框程序的消息循环机制

基于对话框的MFC工程和上面的消息循环机制不一样。实际上MFC的对话框工程程序就是模式对话框。他和上面讲到的非对话框程序的不同之处，主要在于应用程序对象的InitInstance()不一样。

//dlg_5Dlg.cpp

BOOL CDlg_5App::InitInstance()

{

AfxEnableControlContainer();

#ifdef _AFXDLL

Enable3dControls(); // Call this when using MFC in a shared DLL

#else

Enable3dControlsStatic(); // Call this when linking to MFC staticall

#endif

CDlg_5Dlg dlg; //定义一个对话框对象

m_pMainWnd = &dlg;

int nResponse = dlg.DoModal(); //对话框的消息循环在这里面开始

if (nResponse == IDOK)

{

// TODO: Place code here to handle when the dialog is

// dismissed with OK

}

else if (nResponse == IDCANCEL)

{

// TODO: Place code here to handle when the dialog is

// dismissed with Cancel

}

// Since the dialog has been closed, return FALSE so that we exit th e

// application, rather than start the application's message pump. return FALSE;

}

NOTE: InitInstance函数返回FALSE，由最上面程序启动流程可以看出，CWinThread:: Run是不会得到执行的。也就是说，上面第一部分说的消息循环在对话框中是不能执行的。实际上，对话框也有消息循环，她的消息循环在CDialog::DoModal()虚函数中的一个RunMo dalLoop函数中。

这个函数的实现体在CWnd类中：

int CWnd::RunModalLoop(DWORD dwFlags)

{

ASSERT(::IsWindow(m_hWnd)); // window must be created

ASSERT(!(m_nFlags & WF_MODALLOOP)); // window must not already be i

n modal state

// for tracking the idle time state

BOOL bIdle = TRUE;

LONG lIdleCount = 0;

BOOL bShowIdle = (dwFlags & MLF_SHOWONIDLE) && !(GetStyle() & WS_VISI BLE);

HWND hWndParent = ::GetParent(m_hWnd);

m_nFlags |= (WF_MODALLOOP|WF_CONTINUEMODAL);

MSG* pMsg = &AfxGetThread()->m_msgCur;

// acquire and dispatch messages until the modal state is done

for (;;)

{

ASSERT(ContinueModal());

// phase1: check to see if we can do idle work

while (bIdle && !::PeekMessage(pMsg, NULL, NULL, NULL, PM_NOREMOVE)) {

ASSERT(ContinueModal());

// show the dialog when the message queue goes idle

if (bShowIdle)

{

ShowWindow(SW_SHOWNORMAL);

UpdateWindow();

bShowIdle = FALSE;

}

// call OnIdle while in bIdle state

if (!(dwFlags & MLF_NOIDLEMSG) && hWndParent != NULL && lIdleCount =

= 0)

{

// send WM_ENTERIDLE to the parent

::SendMessage(hWndParent, WM_ENTERIDLE, MSGF_DIALOGBOX, (LPARAM)m_hWn d);

}

if ((dwFlags & MLF_NOKICKIDLE) || !SendMessage(WM_KICKIDLE, MSGF_DIAL OGBOX, lIdleCount++))

{

// stop idle processing next time

bIdle = FALSE;

}

// phase2: pump messages while available

{

ASSERT(ContinueModal());

// pump message, but quit on WM_QUIT

//PumpMessage(消息泵)的实现和上面讲的差不多。都是派送消息到窗口。

if (!AfxGetThread()->PumpMessage())

{

AfxPostQuitMessage(0);

return -1;

}

// show the window when certain special messages rec'd

if (bShowIdle && (pMsg->message == 0x118 || pMsg->message == WM_SYSKE YDOWN))

{

ShowWindow(SW_SHOWNORMAL);

UpdateWindow();

bShowIdle = FALSE;

}

if (!ContinueModal())

goto ExitModal;

// reset "no idle" state after pumping "normal" message

if (AfxGetThread()->IsIdleMessage(pMsg))

{

bIdle = TRUE;

lIdleCount = 0;

}

} while (::PeekMessage(pMsg, NULL, NULL, NULL, PM_NOREMOVE));

} //无限循环

ExitModal:

m_nFlags &= ~(WF_MODALLOOP|WF_CONTINUEMODAL);

return m_nModalResult;

}

先说说怎么退出这个无限循环，在代码中：

if (!ContinueModal())

goto ExitModal;

决定是否退出循环，消息循环函数返回也就是快要结束结束程序了。

BOOL CWnd::ContinueModal()

{

return m_nFlags & WF_CONTINUEMODAL;

}

NOTE: CWnd::ContinueModal()函数检查对话框是否继续模式。返回TRUE,表示现在是模式的；返回FALSE，表示对话框已经不是模式(将要结束)。

如果要结束对话框，在内部最终会调用函数CWnd::EndModalLoop，它取消m_nFlags 的模式标志(消息循环中的ContinueModal函数将返回FALSE，消息循环将结束，程序将退出)；然后激发消息循环读取消息。也就是说，结束模式对话框是一个标志，改变这个标志就可以了。他的代码是：

//wincore.cpp

void CWnd::EndModalLoop(int nResult)

{

ASSERT(::IsWindow(m_hWnd));

// this result will be returned from CWnd::RunModalLoop

m_nModalResult = nResult;

// make sure a message goes through to exit the modal loop

if (m_nFlags & WF_CONTINUEMODAL)

{

m_nFlags &= ~WF_CONTINUEMODAL;

PostMessage(WM_NULL);

}

NOTE: PostMessage(NULL)是有用的。如果消息队列中没有消息的话，可能消息循环中的ContinueModal()不会马上执行，发送一个空消息是激发消息循环马上工作。

下面说一下CWnd::RunModalLoop函数中的消息循环究竟干了些什么事情:

1,第一个内循环。首先从消息队列中查询消息，如果对话框空闲，而且消息队列中没有消息，他做三件事情，大家应到都能从字面上明白什么意思。最重要的是发送WM_KICKIDLE消息。为什么呢？第一部分讲到了，非对话框程序用OnIdle来更新用户界面(UI)，比如工具栏，状态栏。那么，如果对话框中也有工具栏和状态栏呢，在哪里更新(网上有很多这样的程序)？可以处理WM_KICKIDLE消息：

LRESULT CDlg_5Dlg::OnKickIdle(WPARAM w,LPARAM l)

{

//调用CWnd::UpdateDialogControls更新用户界面

UpdateDialogControls(this, TRUE);

return 0;

}

NOTE: CWnd::UpdateDialog函数发送CN_UPDATE_COMMAND_UI消息给所有的用户界面对话框控件。

2,第二个内循环。最重要的还是PumpMessage派送消息到目标窗口。其他的，像第二个if语句，0x118消息好像是WM_SYSTIMER消息(系统用来通知光标跳动的一个消息)。也就是说，如果消息为WM_SYSTIMER或者WM_SYSKEYDOWN,并且空闲显示标志为真的话，就显示窗口并通知窗口立刻重绘。

总之，对话框的消息循环机制和非对话框(比如SDI,MDI)还是类似的，仅仅侧重点不同。模式对话框是模式显示，自然有他的特点。下面部分讨论一下模式对话框和非模式对话框的区别。因为模式对话框有自己的特殊消息循环；而非模式对话框，共用程序的消息循环，和普通的窗口已经没有什么大的区别了。

第三部分：模式对话框和非模式对话框的区别

这个话题已经有很多人讨论，我说说我所理解的意思。

在MFC框架中，一个对话框对象DoModal一下就能产生一个模式对话框，Create一下就能产生一个非模式对话框。实际上，无论是模式对话框还是非模式对话框，在MFC内部都是调用::CreateDialogIndirect(***)函数来创建非模式对话框。只是模式对话框作了更多的工作，包括使父窗口无效，然后进入自己的消息循环等

等。::CreateDialogIndirect(***)函数最终调用CreateWindowEx函数通知系统创建窗体并返回句柄，他内部没有实现自己的消息循环。

非模式对话框创建之后立即返回，并且和主程序共用一个消息循环。非模式对话框要等对话框结束之后才返回，自己有消息循环。比如下面的代码：

CMyDlg* pdlg = new CMyDlg;

pdlg ->Create(IDD_DIALOG1);

pdlg->ShowWindow(SW_SHOW);

MessageBox("abc");

非模式对话框和消息框MessageBox几乎是同时弹出来。而如果将Create改成DoModal，那么，只能弹出模式对话框，在关闭了对话框之后(模式对话框自己的消息循环结束)，消息框才弹出来。

NOTE：可以在模式对话框中调用GetParent()->EnableWindow(true);这样，主窗口的菜单，工具栏又激活了，能用了。MFC使用非模式对话框来模拟模式对话框，而在win32 SDK程序中，模式对话框激发他的父窗口Enable操作是没有效果的。

关于消息循环总结：

1，我们站在一个什么高度看消息循环？消息循环其实没有什么深奥的道理。如果一个邮递员要不断在一个城市中送信，我们要求他做什么？要求他来回跑，但他一次只能在一个地方出现。如果我们的应用程序只有一个线程的话，我们要他不断地为窗口传递消息，我们怎么做？在一个循环中不断的检测消息，并将他发送到适当的窗口。窗口可以有很多个，但消息循环只有一个，而且每时每刻最多只有一个地方在执行代码。为什么？看第二点。

2，因为是单线程的(程序进程启动的时候，只有而且有一个线程，我们称他为主线程),所以就像邮递员一样，每次只能在某一个地方干活。什么意思呢？举个例子，

用::DiapatchMessage派送消息，在窗口处理过程(WinProc,窗口函数)返回之前，他是阻塞的,不会立即返回，也就是消息循环此时不能再从消息队列中读取消息，直

到::DispatchMessage返回。如果你在窗口函数中执行一个死循环操作，就算你用PostQuitMessage函数退出，程序也会down掉。

while(1)

{

PostQuitMessage(0); //程序照样down.

}

所以，当窗口函数处理没有返回的时候，消息循环是不会从消息队列中读取消息的。这也是为什么在模式对话框中要自己用无限循环来继续消息循环，因为这个无限循环阻塞了原来的消息循环，所以，在这个无限循环中要用GetMessage,PeekMessage,DispatchMessage 来从消息队列中读取消息并派送消息了。要不然程序就不会响应了，这不是我们所希望的。以说，消息循环放在程序的什么的地方都基本上是过的去的，比如放在DLL里面。但是，最好在任何时候，只有一个消息循环在工作(其他的都被阻塞了)。然后，我们要作好的一件事情，就是怎么从消息循环中退出！当然用WM_QUIT是可以拉~(PostThreadMessage 也是个好主意)，这个消息循环退出后，可能程序退出，也可能会激活另外一个被阻塞的消息循环，程序继续运行。这要看你怎么想，怎么去做。最后一个消息循环结束的时候，也许就是程序快结束的时候，因为主线程的执行代码也快要完了(除非BT的再作个死循环)。NOTE: 让windows系统知道创建一个线程的唯一方法是调用API CreatThread函数(__beginthreadex之类的都要在内部调用他创建新线程)。好像windows核心编程说，在win2000下，系统用CreateRemoteThread函数来创建线程，CreateThread在内部

调用CreateRemoteThread。不过这不是争论的焦点，至少win98下CreateRemoteThread并不能正常工作，还是CreateThread主持大局。

3，在整个消息循环的机制中，还必须谈到窗口函数的可重入性。什么意思？就是窗口函数(他是个回调函数)的代码什么时候都可以被系统(调用者一般是user32模块)调用。比如在窗口过程中，向自己的窗口SendMessage(***);那么执行过程是怎样的？

我们知道，SendMessage是要等到消息发送并被目标窗口执行完之后才返回的。那么窗口在处理消息，然后又等待刚才发送到本窗口的消息被处理后之后(SendMessage返回)才继续往下执行，程序不就互相死锁了吗？

其实是不会的。windows设计一套适合SendMessage的算法，他判断如果发送的消息是属于本线程创建的窗口的，那么直接由user32模块调用窗口函数(可能就有窗口重入)，并将消息的处理结果结果返回。这样做体现了窗口重入。上面的例子，我们调用SendMessage(***)发送消息到本窗口，那么窗口过程再次被调用，处理完消息之后将结果返回，然后SendMessage之后的程序接着执行。对于非队列消息，如果没有窗口重入，不知道会是什么样子。

NOTE: 由于窗口的可重入性。在win32 SDK程序中应尽量少用全局变量和静态变量，因为在窗口函数执行过程中可能窗口重入，如果重入后将这些变量改了，但你的程序在窗口重入返回之后继续执行，可能就是使用已经改变的全局或静态变量。在MFC中(所有窗口的窗口函数基本上都是AfxWndProc)，按照类的思想进行了组织，一般变量都是类中的，好管理的多。

4,MFC中窗口类(比如C**View,CFrameWnd等)中的MessageBox函数，以及AfxMessageBox函数都是阻塞原有的消息循环的。由消息框内部的一个消息循环来从消息队列中读取消息，并派送消息(和模式对话框类似)。实际上，这些消息函数最终调用的是::MessageBox，它在消息框内部实现了一个消息循环(原有的主程序消息循环被阻塞了)。论坛中碰到过几次关于计时器和消息框的问题，看下面的代码：

void CTest_recalclayoutView::OnTimer(UINT nIDEvent)

{

// TODO: Add your message handler code here and/or call default MessageBox("abc");

while(1); //设计一个死循环

CView::OnTimer(nIDEvent);

}

咱让OnTimer大约5秒钟弹出一个消息框。那么，消息框不断的被弹出来，只要消息框不被关闭，那么程序就不会进入死循环。实际上，每次弹出对话框，都是最上层的那个消息框掌握着消息循环，其他的消息循环被阻塞了。只要不关闭最上面的消息框，while(1);就得不到执行。如果点了关闭，程序就进入了死循环，只能用ctrl+alt+del来解决问题了。5，消息循环在很多地方都有应用。比如应用在线程池中。一个线程的执行周期一般在线程函数返回之后结束，那么怎么延长线程的生命周期呢？一种方法就是按照消息循环的思想，在线程中加入消息循环，不断地从线程队列读取消息，并处理消息，线程的生命周期就保持着直到这个消息循环的退出。

NOTE：只要线程有界面元素或者调用GetMessage,或者有线程消息发送过来，系统就会为线程创建一个消息队列。

6,在单线程程序中，如果要执行一个长时间的复杂操作而且界面要有相应的话，可以考虑用自己的消息泵。比如，可以将一个阻塞等待操作放在一个循环中，并将超时值设置得比较小，然后每个等待的片段中用消息泵继续消息循环，使界面能够响应用户操作。等等之类，都可以应用消息泵(调用一个类似这样的函数)：

BOOL CChildView::PeekAndPump()

{

MSG msg;

while(::PeekMessage(&msg,NULL,0,0,PM_NOREMOVE))

{

if(!AfxGetApp()->PumpMessage())

{

::PostQuitMessage(0);

return false;

}

return true;

}

其实，用多线程也能解决复杂运算时的界面问题，但是没有这么方便，而且一般要加入线程通信和同步，考虑的事情更多一点。

综上所述，MFC消息循环就那么回事，主要思想还是和SDK中差不多。这种思想主要的特点表现在迎合MFC整个框架上，为整个框架服务，为应用和功能服务。

几个消息循环中的常用函数进行对比

1 PostMessage 与SendMessage 函数对比

SendMessage把消息直接发送到窗口，并调用此窗口的相应消息处理函数，等消息处理函数结束后SendMessage才返回!SendMessage发送的消息不进入系统的消息队列;SendMessage函数有返回值

PostMessage将消息发送到与创建窗口的线程相关联的消息队列后立即返

回;PostMessage函数没有返回值;

2 GetMessage 与PeekMessage函数的对比

GetMessage(LPMSG lpMsg, HWND hWnd, UINT wMsgFilterMin, UINT wMsgFilterMax)

PeekMessage(LPMSG lpMsg, HWND hWnd, UINT wMsgFilterMin, UINT wMsgFilterMax,UINT wRemoveMsg)

根据参数可以看出以上2个函数的区别，参数wRemoveMsg的作用是指定消息获取的方式，如果设为PM_NOREMOVE,那么消息将不会从消息队列中被移出，如果设为

PM_REMOVE，那么消息将会从消息队列中被移出;

还有区别：

他们如果没有捕获到消息，程序的主线程会被操作系统挂起。当操作系统再次回来照顾此线程时，发现消息队列中仍然没有消息可取，此时两个函数的行为就不同了：GetMessage : 过门不入，操作系统再次挂起此线程，去照顾别的线程;

PeekMessage: 取回控制权，使程序执行一段时间，等待可能的消息进入消息队列并将其捕获;这时程序进入空闲时间阶段;

补：

一．SDK下的消息机制实现

一般来说，Windows的消息都是和线程相对应的。即Windows会把消息发送给和该消息相对应的线程。

Win32程序的主体

WinMain(…)

{

MSG msg;

RegisterClass(…); // 注册窗口类

CreateWindow(…); // 创建窗口

ShowWindow(…); // 显示窗口

UpdateWindow(…);

While(GetMessage(&msg,…)){ // 消息循环

TranslateMessage(…); // 把虚键消息翻译成字符消息并放到响应的消息队列里面

DispatchMessage(…); // 消息分发到相关的窗口过程

}

在SDK的模式下，程序是通过GetMessage函数从和某个线程相对应的消息队列里面把消息取出来并放到一个特殊的结构里面，一个消息的结构是一个如下的structure。

typedef struct tagMSG {

HWND hwnd; // 表示和窗口过程相关的窗口的句柄

UINT message; // 消息的ID号

WPARAM wParam; // 和消息相关的参数

LPARAM lParam; // 和消息相关的参数

DWORD time; // 消息发送的时间

POINT pt; // 示消息发送时的鼠标的位置

}MSG;

在SDK编程过程中，用户需要在窗口过程中分析消息的类型和跟消息一起的参数的含义，做不同的处理，也就是通过一个巨大的switch/case结构进行不同的消息处理，相对比较麻烦，而MFC把消息调用的过程给封装起来，使用户能够通过ClassWizard方便地使用和处理Windows的各种消息，甚至在弄清楚MFC的消息机制后，用户完全可以添加自己的消息命令以及消息响应函数。

二．MFC的消息实现机制

我们可以看到，在MFC的框架结构下，可以进行消息处理的类的头文件里面都会含有DECLARE_MESSAGE_MAP()宏,这里主要进行消息映射和消息处理函数的声明。

#define DECLARE_MESSAGE_MAP () \

private: \

static const AFX_MESSAGE_ENTRY _messageEntries[]; \

protected: \

static AFX_DATA const AFX_MSGMAP messageMap; \

virtual const AFX_MSGMAP* GetMessageMap() const; \

可以进行消息处理的类的实现文件里一般都含有如下的结构。

BEGIN_MESSAGE_MAP(CInheritClass, CBaseClass)

//{{AFX_MSG_MAP(CInheritClass)

//}}AFX_MSG_MAP

END_MESSAGE_MAP()

这里主要进行消息映射的实现和消息处理函数的实现。

其中BEGIN_MESSAGE_MAP宏的定义如下：

#ifdef _AFXDLL

#define BEGIN_MESSAGE_MAP(theClass, baseClass) \

const AFX_MSGMAP* PASCAL theClass::_GetBaseMessageMap() \

{ return &baseClass::messageMap; } \

const AFX_MSGMAP* theClass::GetMessageMap() const \

{ return &theClass::messageMap; } \

AFX_DATADEF const AFX_MSGMAP theClass::messageMap = \

{ &theClass::_GetBaseMessageMap, &theClass::_messageEntries[0] }; \ const AFX_MSGMAP_ENTRY theClass::_messageEntries[] = \

{ \

#else

#define BEGIN_MESSAGE_MAP(theClass, baseClass) \

const AFX_MSGMAP* theClass::GetMessageMap() const \

{ return &theClass::messageMap; } \

AFX_DATADEF const AFX_MSGMAP theClass::messageMap = \

{ &baseClass::messageMap, &theClass::_messageEntries[0] }; \

const AFX_MSGMAP_ENTRY theClass::_messageEntries[] = \

{ \

#endif

#define END_MESSAGE_MAP() \

{0, 0, 0, 0, AfxSig_end, (AFX_PMSG)0 } \

}; \

可见，BEGIN_MESSAGE_MAP（）定义了两套宏，分别用于静态编译和动态编译。

相应的，END_MESSAGE_MAP()宏定义如下：

#define END_MESSAGE_MAP() \

{0, 0, 0, 0, AfxSig_end, (AFX_PMSG)0 } \

}; \

在这里粘贴宏的具体定义只是为了让你更好的理解，并没有必要将它们熟记。不要被它们的样子吓坏，宏做的工作始终只是替换，你拿两个具体的类名称替换掉

BEGIN_MESSAGE_MAP()宏中的两个参数，你就可以发现这个宏的具体功能和运行方式。所有能够进行消息处理的类都是基于CCmdTarget类的，也就是说CCmdTarget类是所有可以进行消息处理类的父类。CCmdTarget类是MFC处理命令消息的基础和核心。

同时MFC定义了下面的两个主要结构:

AFX_MSGMAP_ENTRY

struct AFX_MSGMAP_ENTRY

{

UINT nMessage; // windows message

UINT nCode; // control code or WM_NOTIFY code

UINT nID;

// control ID (or 0 for windows messages)

UINT nLastID;

// used for entries specifying a range of control id's

UINT nSig;

// signature type (action) or pointer to message #

AFX_PMSG pfn; // routine to call (or special value)

};

其中AFX_MSGMAP_ENTRY结构包含了一个消息的所有相关信息,其中nMessage为Windows消息的ID号

nCode为控制消息的通知码

nID为Windows控制消息的ID

nLastID表示如果是一个指定范围的消息被映射的话，nLastID用来表示它的范围。nSig表示消息的动作标识。

AFX_PMSG pfn 它实际上是一个指向和该消息相应的执行函数的指针。

和AFX_MSGMAP

struct AFX_MSGMAP

{

#ifdef _AFXDLL

const AFX_MSGMAP* (PASCAL* pfnGetBaseMap)();

#else

const AFX_MSGMAP* pBaseMap;

#endif

const AFX_MSGMAP_ENTRY* lpEntries;

};

而AFX_MSGMAP主要作用是两个，一：用来得到基类的消息映射入口地址。二：得到本身的消息映射入口地址。

实际上，MFC把所有的消息一条条填入到AFX_MSGMAP_ENTRY结构中去，形成一个数组，该数组存放了所有的消息和与它们相关的参数。同时通过AFX_MSGMAP能得到该数组的首地址，同时得到基类的消息映射入口地址，这是为了当本身对该消息不响应的时候，就调用其基类的消息响应。

现在我们来分析MFC是如何让窗口过程来处理消息的。用MFC向导生成的MFC AppWizard（exe）应用程序通常会自动生成五个类：CDocument，CView，CApp，CMainFrame和CAbout。这些类除了CApp都是继承自CWnd，也就是说他们都有各自的消息循环队列和消息处理函数，所以按照SDK编程经验，Windows应该把消息发送到特定的类，由那些特定的类的消息处理函数进行处理，但是实际上所有MFC的窗口类都通过钩子函数_AfxCbtFilterHook截获消息，并且在钩子函数_AfxCbtFilterHook中把窗口过程设定为AfxWndProc。原来的窗口过程保存在成员变量m_pfnSuper中。这样做的原因，一是为了提高消息分发效率，而是为了能很好的兼容MFC2.4以及之前的版本。

所谓钩子函数hook，是Windows程序设计中的一种高级技术。通常消息都是停留在消息队列中等待被所隶属的窗口抓取，如果你设立了hook，就可以更早一步抓取消息，并且可以抓取不属于你的消息，送往你设定的一个所谓的“滤网函数（filter）”。

所以在MFC框架下，一般一个消息的处理过程是这样的。

(1) 函数AfxWndProc接收Windows操作系统发送的消息。

(2) 函数AfxWndProc调用函数AfxCallWndProc进行消息处理，这里一个进步是把对句柄的操作转换成对CWnd对象的操作。

(3) 函数AfxCallWndProc调用CWnd类的方法WindowProc进行消息处理。注意AfxWndProc和AfxCallWndProc都是AFX的API函数。而WindowProc已经是CWnd 的一个方法。所以可以注意到在WindowProc中已经没有关于句柄或者是CWnd的参数了。

(4) 方法WindowProc调用方法OnWndMsg进行正式的消息处理，即把消息派送到相关的方法中去处理。

消息是如何派送的呢？实际上在CWnd类中都保存了一个AFX_MSGMAP的结构，而在AFX_MSGMAP结构中保存有所有我们用ClassWizard生成的消息的数组的入口，我们把传给OnWndMsg的message和数组中的所有的message进行比较，找到匹配的那一个消息。实际上系统是通过函数AfxFindMessageEntry来实现的。找到了那个message，实际上我们就得到一个AFX_MSGMAP_ENTRY结构，而我们在上面已经提到

AFX_MSGMAP_ENTRY保存了和该消息相关的所有信息，其中主要的是消息的动作标识和跟消息相关的执行函数。然后我们就可以根据消息的动作标识调用相关的执行函数，而这个执行函数实际上就是通过ClassWizard在类实现中定义的一个方法。这样就把消息的处理转化到类中的一个方法的实现上。

举一个简单的例子，比如在View中对WM_LButtonDown消息的处理就转化成对如下一个方法的操作。

void CInheritView::OnLButtonDown(UINT nFlags, CPoint point)

{

// TODO: Add your message

handler code here and/or call default

CView::OnLButtonDown(nFlags, point);

}

注意这里CView::OnLButtonDown(nFlags, point)实际上就是调用CWnd的Default()方法。而Default()方法所做的工作就是调用DefWindowProc对消息进行处理。这实际上是调用原来的窗口过程进行缺省的消息处理。

如果OnWndMsg方法没有对消息进行处理的话，就调用DefWindowProc对消息进行处理。这是实际上是调用原来的窗口过程进行缺省的消息处理。

所以如果正常的消息处理的话，MFC窗口类是完全脱离了原来的窗口过程，用自己的一套体系结构实现消息的映射和处理。即先调用MFC窗口类挂上去的窗口过程，再调用原先的窗口过程。并且用户面对和消息相关的参数不再是死板的wParam和lParam,而是和消息类型具体相关的参数。比如和消息WM_LbuttonDown相对应的方法OnLButtonDown

的两个参数是nFlags和point。nFlags表示在按下鼠标左键的时候是否有其他虚键按下，point更简单，就是表示鼠标的位置。

同时MFC窗口类消息传递中还提供了两个函数，分别为WalkPreTranslateTree和PreTranslateMessage。我们知道利用MFC框架生成的程序，都是从CWinApp开始执行的，而CWinapp实际继承了CWinThread类。在CWinThread的运行过程中会调用窗口类中的WalkPreTranslateTree方法。而WalkPreTranslateTree方法实际上就是从当前窗口开始查找愿意进行消息翻译的类，直到找到窗口没有父类为止。在WalkPreTranslateTree方法中调用了PreTranslateMessage方法。实际上PreTranslateMessage最大的好处是我们在消息处理前可以在这个方法里面先做一些事情。举一个简单的例子，比如我们希望在一个CEdit对象里，把所有的输入的字母都以大写的形式出现。我们只需要在PreTranslateMessage方法中判断message是否为

WM_CHAR,如果是的话，把wParam(表示键值)由小写字母的值该为大写字母的值就实现了这个功能。

继续上面的例子，根据我们对MFC消息机制的分析，我们很容易得到除了上面的方法，我们至少还可以在另外两个地方进行操作。

1、在消息的处理方法里面即OnChar中，当然最后我们不再调用CEdit::OnChar(nChar, nRepCnt, nFlags)，而是直接调用DefWindowProc(WM_CHAR,nChar,MAKELPARAM (nRepCnt,nFlags))。因为从我们上面的分析可以知道CEdit::OnChar(nChar, nRepCnt, nFlags)实际上也就是对DefWindowProc方法的调用。

2、我们可以直接重载DefWindowProc方法,对message类型等于WM_CHAR的，直接修改nChar的值即可。

三．添加自定义消息

首先弄清楚两点：

（1）谁要发送这个消息（2）谁要接受这个消息。

用一个简单的例子来说明。对象A向B（也可以就是A到A）发送消息。

1、发送消息

首先在A的头文件中定义这个消息：

#define WM_USERMESSAGE WM_USER+30

所有自定义消息都是以WM_USER消息为基础加上一个任意的自然数来表示的。A是向外发送消息的对象，因此在A的某个方法（函数）里就会调用用来发消息的函数

B::SendMessage()/B::PostMessage()，因为是B接受消息，因此是如上的形式。

2、接受消息

对象接受一个消息，应该有三部分：在头文件中有该消息的处理函数的原型；在实现文件中有接受消息映射的宏；以及该消息的处理函数的具体实现。

2.1、头文件中加上自定义消息的处理函数原型

在DECLARE_MESSAGE_MAP（）语句之前，一对AFX_MSG之间加上如下形式的函数原型：

afx_msg LRESULT OnProcName( WPARAM wParam, LPARAM lParam )；

对Win32来说，wParam, lParam是传递消息最常用的手段。

2.2、在实现文件中加上接受消息映射的宏

在cpp文件里，BEGIN_MESSAGE_MAP语句之后，在一对AFX_MSG_MAP之间，增加如下形式的代码：

ON_MESSAGE(WM_USERMESSAGE, OnProcName)

上面是不用分号结尾的。

2.3、在实现文件中给出消息处理函数的具体实现。

实验三 MFC 消息映射编程实验

实验三MFC 消息映射编程实验一、实验目的 (1) 熟悉Visual Studio 开发环境； (2) 掌握消息映射机制的基本原理和手工添加消息映射的方法； (3) 熟练掌握在Visual Studio 开发环境调试程序的方法。二、实验内容设计MFC 应用程序，手工添加消息映射，实现下面的功能： (1) 按下CTRL 键，拖动鼠标绘制矩形； (2) 按下SHIFT 键，拖动鼠标绘制椭圆。三、实验结果 (1)总结手工添加消息映射的基本步骤； 1、在BEGIN_MESSAGE_MAP 和END_MESSAGE_MAP 之间添加消息映射宏； BEGIN_MESSAGE_MAP(CDemoView, CView) ON_MESSAGE（WM_KEYDOWN, OnKeyDown） ON_COMMAND(ID_OPER_TEST, OnOperTest) END_MESSAGE_MAP( ) 2 、在类声明中声明成员函数； 3、在类的实现部分实现成员函数。列出鼠标绘图功能的实现代码； (2)列出鼠标绘图功能的实现代码；头文件： #include "afxwin.h" class CDemoWnd:public CFrameWnd { public: CDemoWnd(); ~CDemoWnd(); public: LRESULT OnPaint(WPARAM wParam,LPARAM lParam); LRESULT OnLButtonDown(WPARAM wParam,LPARAM lParam); LRESULT OnMouseMove(WPARAM wParam,LPARAM lParam); DECLARE_MESSAGE_MAP() public: int m_nX0; int m_nY0; int m_nX1;

java期末考试知识点总结

java知识点总结应同学要求，特意写了一个知识点总结，因比较匆忙，可能归纳不是很准确，重点是面向对象的部分。 java有三个版本：JAVA SE 标准版\JAVA ME移动版\JAVA EE企业版 java常用命令：java, javac, appletview java程序文件名：.java, .class java的两类程序：applet, application; 特点，区别，这两类程序如何运行 java的主方法，主类，共有类；其特征 java的数据类型，注意与C++的不同，如字符型，引用型，初值 java与C++的不同之处，期中已总结 java标记符的命名规则 1）标识符有大小写字母、下划线、数字和$符号组成。 2）开头可以是大小写字母，下划线，和$符号（不能用数字开头） 3）标识符长度没有限制 4）标识符不能使关键字和保留字面向对象的四大特征抽象、封装、继承、多态封装，类、对象，类与对象的关系，创建对象，对象实例变量构造函数，默认构造函数，派生类的构造函数，构造函数的作用，初始化的顺序，构造方法的重载构造函数：创建对象的同时将调用这个对象的构造函数完成对象的初始化工作。把若干个赋初值语句组合成一个方法在创建对象时一次性同时执行，这个方法就是构造函数。是与类同名的方法，创建对象的语句用new算符开辟了新建对象的内存空间之后，将调用构造函数初始化这个新建对象。构造函数是类的特殊方法：构造函数的方法名与类名相同。构造函数没有返回类型。构造函数的主要作用是完成对类对象的初始化工作。构造函数一般不能由编程人员显式地直接调用。在创建一个类的新对象的同时，系统会自动调用该类的构造函数为新对象初始化。类的修饰符：public类VS 默认; abstract类; final类; 1）类的访问控制符只有一个：public，即公共的。公共类表明它可以被所有其他类访问和引用。若一个类没有访问控制符，说明它有默认访问控制特性，规定该类智能被同一个包中的类访问引用（包访问控制）。 2）abstract类：用abstract修饰符修饰的类被称为抽象类，抽象类是没有具体对象的概念类，抽象类是它所有子类的公共属性集合，用抽象类可以充分利用这些公共属性来提高开发和维护效率。 3）final类：被final修饰符修饰限定的，说明这个类不能再有子类。所以abstract与final 不能同时修饰一个类。域和方法的定义 1)域：定义一个类时，需要定义一组称之为“域”或“属性”的变量，保存类或对象的数据。

消息映射编程实验

MFC 消息映射编程实验实验报告姓名：杨培培班级：电气12级3班 12053307

【预备知识】 1、消息映射消息映射本质上就是一个数组，MFC 使用消息映射建立消息和类的成员函数的对应关系。消息映射数组中存储的信息 (1) 所处理的消息； (2) 消息应用的控件ID，或者ID 范围； (3) 消息所传递的参数； (4) 消息所期望的返回值。 2、消息映射宏下面介绍常用的两个消息映射宏： (1)ON_MESSAGE：处理任意消息语法规则： ON_MESSAGE(ID,func) LRESULT func(WPARAM wParam, LPARAM lParam); 举例：映射鼠标左键按下消息 ON_MESSAGE（WM_LBUTTONDOWN, OnLButtonDown） LRESULT OnLButtonDown(WPARAM wParam, LPARAM lParam); (2)ON_COMMAND：处理WM_COMMAND 消息语法规则： ON_COMMAND(ID,func) void func( ); 举例：映射菜单项命令消息

ON_COMMAND(ID_OPER_TEST, OnOperTest) void OnOperTest ( ); 3、消息映射步骤 MFC 中手工添加消息映射按照如下步骤进行： (1)在BEGIN_MESSAGE_MAP 和END_MESSAGE_MAP 之间添加消息映射宏； BEGIN_MESSAGE_MAP(CDemoView, CView) ON_MESSAGE（WM_KEYDOWN, OnKeyDown） ON_COMMAND(ID_OPER_TEST, OnOperTest) END_MESSAGE_MAP( ) (2) 在类声明中声明成员函数； (3) 在类的实现部分实现成员函数。【实验目的】 (1) 熟悉Visual Studio 开发环境； (2) 掌握消息映射机制的基本原理和手工添加消息映射的方法； (3) 熟练掌握在Visual Studio 开发环境调试程序的方法。【实验内容】设计 MFC 应用程序，手工添加消息映射，实现下面的功能： (1) 按下CTRL 键，拖动鼠标绘制矩形； (2) 按下SHIFT 键，拖动鼠标绘制椭圆。【实验报告】 (1) 总结手工添加消息映射的基本步骤；

java中常用关键字总结

Java中的关键字总结 final 关键字 1、用final修饰的类不能被继承，没有子类； 2、用final修饰的方法，方法不能被重写； 3、用final修饰变量，变量的值不能被修改，表示常量，(书写规范：全部字母都要大写；多个单词，可以使用下划线（_）分开；) 注意：如果被final修饰的变量是一个引用类型的数据，那么通过这个引用改变堆空间中的数据，不会报错；如果被final修饰的变量是一个引用类型的数据，那么通过这个引用改变堆空间中的数据，不会报错； 4、final用于成员变量表示该成员变量为常量，不能被修改，必须在变量定义时赋值。 5、final用于局部变量表示该局部变量为常量，不能被修改，可以在变量定义时赋值，也可以先定义变量后赋值。什么时候用final关键字? 有的时候不想别人重写我的方法就使用final关键字修饰该方法； static关键字 1、static用于成员变量表示该变量只有一份，也就是说静态成员变量属于类而不属于某个具体的类实例对象，所有的类实例对象共享这个静态成员变量；静态函数是不需要对象的，直接可以使用类名来调用； 2、非静态函数可以调用静态函数；静态函数不能调用非静态函数（非静态函数都是通过对象调用的）；静态函数不能使用非静态成员变量，但可以使用静态成员变量； 3、静态函数调用时不需要对象的，所以不能使用和对象有关的关键字；(this；super；) 4、构造函数不能使用static修饰(构造函数是创建对象，开辟空间，给所有成员变量赋默认值之后，有JVM调用进栈，用来给对象的成员变量赋初始值的) static用于类，这里指的是内部类，那么在别的地方就可以通过外部类名来引用这个静态的内部类。 5、static还可以用于类的代码块，叫做静态代码块，静态代码块在类加载的时候就执行完毕，而类只加载一次；是在类中独立于类成员的static语句块，可以有多个，位置可以随便放，它不在任何的方法体内，JVM加载类时会执行这些静态的代码块，如果static代码块有多个，JVM将按照它们在类中出现的先

MFC的运行机制和消息响应机制

MFC的类层次结构与运行机制 MFC的类层次结构如图所示（子类指向父类）：其中： CObject：是MFC提供的绝大多数类的基类。该类完成动态空间的分配与回收，支持一般的诊断、出错信息处理和文档序列化等。 CCmdTarget：主要负责将系统事件（消息）和窗口事件（消息）发送给响应这些事件的对象，完成消息发送、等待和派遣调度等工作，实现应用程序的对象之间的协调运行。 CWinApp：是应用程序的主线程类，它是从CWinThread类派生而来的。CWinThread类用来完成对线程的控制，包括线程的创建、运行、终止和挂起等。 CDocument：是文档类，包含了应用程序在运行期间所用到的数据。 CWnd：是一个通用的窗口类，用来提供Windows中的所有通用特性、对话框和控件。 CFrameWnd是从CWnd类继承来的，并实现了标准的框架应用程序。 CDialog类用来控制对话框窗口。 CView：用于让用户通过窗口来访问文档。 CMDIFrameWnd和CMDIChildWnd：分别用于多文档应用程序的主框架窗口和文档子窗口的显示和管理。CMiniFrameWnd类是一种简化的框架窗口，它没有最大化和最小化窗口按钮，也没有窗口系统菜单，一般很少用到它。 MFC运行机制在程序中，当定义一个类对象时，它会自动调用相应的构造函数。所谓"类对象"，就是用该类定义的"变量"，这个"变量"又称为类的一个实例。例如，theApp就是类CSimpApp的一个对象。 MFC正是利用类的这种"自动调用相应的构造函数"特性，使得WinMain()函数的调用变成了应用程序框架内部的调用，所以我们在代码中看不到每个Windows程序所必须有的WinMain()函数。当应用程序运行到"CSimpApp theApp;"时，系统就会先调用基类CWinApp构造函数，进行一系列的内部初始化操作，然后自动调用CSimpApp的虚函数InitInstance()，该函数会进一步调用相应的函数来完成主窗口的构造和显示工作。下面来看看上述程序中InitInstance的执行过程。首先执行的是： m_pMainWnd = new CMainFrame; 该语句用来创建从CFrameWnd类派生而来的用户框架窗口CMainFrame类对象，继而调用该类的构造函数，使得Create函数被调用，完成了窗口创建工作。

Java关键字final使用总结

Java关键字final使用总结一、final 根据程序上下文环境，Java关键字final有“这是无法改变的”或者“终态的”含义，它可以修饰非抽象类、非抽象类成员方法和变量。你可能出于两种理解而需要阻止改变：设计或效率。 final类不能被继承，没有子类，final类中的方法默认是final的。 final方法不能被子类的方法覆盖，但可以被继承。 final成员变量表示常量，只能被赋值一次，赋值后值不再改变。 final不能用于修饰构造方法。注意：父类的private成员方法是不能被子类方法覆盖的，因此private 类型的方法默认是final类型的。 1、final类 final类不能被继承，因此final类的成员方法没有机会被覆盖，默认都是final的。在设计类时候，如果这个类不需要有子类，类的实现细节不允许改变，并且确信这个类不会载被扩展，那么就设计为final类。 2、final方法如果一个类不允许其子类覆盖某个方法，则可以把这个方法声明为final 方法。使用final方法的原因有二：第一、把方法锁定，防止任何继承类修改它的意义和实现。第二、高效。编译器在遇到调用final方法时候会转入内嵌机制，大大提高执行效率。例如：

3、final变量（常量）用final修饰的成员变量表示常量，值一旦给定就无法改变！ final修饰的变量有三种：静态变量、实例变量和局部变量，分别表示三种类型的常量。从下面的例子中可以看出，一旦给final变量初值后，值就不能再改变了。另外，final变量定义的时候，可以先声明，而不给初值，这中变量也称为final空白，无论什么情况，编译器都确保空白final在使用之前必须被初始化。但是，final空白在final关键字final的使用上提供了更大的灵活性，为此，一个类中的final 数据成员就可以实现依对象而有所不同，却有保持其恒定不变的特征。

MFC消息映射机制

由于工作需要，这几天学了一点MFC，在AFX里看到很多熟悉的东西，如类型信息，序列化，窗口封装和消息分派。几乎每个界面库都必须提供这些基础服务，但提供的手法却千差万别。MFC大量地借用了宏，映射表来实现，而VCL则更多的在语言级别上给与支持。这其实是很容易理解的，因为C++是一个标准，不会因某个应用而随便扩展语言；相反Delphi完全由一个公司掌握，因此每支持一项新技术，变化最大的往往是语言本身。学习MFC的代码，再对照VCL的实现，这真是一个很有意思的过程，其中可以看到两个框架在一些设计思想上是殊途同归的，所不同的是表现手法，以及封装的程度。我计划将这段时间阅读MFC的心得写成一系列文章，其中可能会穿插与VCL的对比，不管你熟悉VCL还是MFC，通过这些文章或许可从另一个角度来看待自己熟悉的框架。这是第一篇：消息分派。消息处理函数表 MFC和VCL在对消息进行封装的时候，都没有使用虚函数机制。原因是虚函数带来了不必要的空间开销。那么它们用什么来代替虚函数，即可减少空间浪费，也可实现类似虚函数的多态呢？让我们从一个例子开始。假设父类ParentWnd处理了100个消息，并且将这100个处理函数声明为虚函数；此时有一个子类ChildWnd它只需要处理2个消息，另外98个交由ParentWnd默认处理，但是ChildWnd的虚表仍然占有100个函数指针，其中2个指向自己的实现，另外98个指向父类的实现，情况大概像下面这样：指向父类实现的函数指针浪费了空间，当控件类非常多的时候，这种浪费就非常明显。因此必须走另一条路，将不必要的函数指针去掉，如下图所示：

ChildWnd去掉函数指针之后，当有一个消息需要Fun100处理时，ChildWnd就束手无策了。需要一个方法让ChildWnd能够找到父类的表，我们再对这个数据结构进行改进如下：现在看来好多了，如果ChildWnd有一个消息需要Fun1处理，则查找ChildWnd的MsgHandlers，找到Fun1函数指针调用之；如果需要Fun100处理，发现ChildWnd的MsgHandlers没有Fun100，则通过ParentTable找到父类的MsgHandlers继续查找。如此一直查找，到最后再找不到，就调用DefWindowProc作默认处理。 MFC和VCL都是通过类似的方法实现消息分派的。只是VCL有编译器的支持，直接将这个表放到VMT中，因此实现起来非常简单，只需在控件类里作如下声明： procedure WMMButtonDown(var Message: TWMMButtonDown); message WM_MBUTTONDOWN; TObject.Dispatch会将WM_MBUTTONDOWN正确分派到WMMButtonDown。

常用java技巧总结

面向对象的思想特点 A:是一种更符合我们思想习惯的思想 B:可以将复杂的事情简单化 C:将我们从执行者变成了指挥者面向对象：我们怎么才能更符合面向对象思想呢? A:有哪些类呢? B:每个类有哪些东西呢? C:类与类直接的关系是什么呢? 开发，设计，特征面向对象开发就是不断的创建对象，使用对象，指挥对象做事情。面向对象设计其实就是在管理和维护对象之间的关系。面向对象特征封装(encapsulation) 继承(inheritance) 多态(polymorphism) 继承：把多个类中相同的成员给提取出来定义到一个独立的类中。然后让这多个类和该独立的类产生一个关系，这多个类就具备了这些内容。这个关系叫继承。继承的好处： A:提高了代码的复用性 B:提高了代码的维护性 C:让类与类产生了一个关系，是多态的前提继承的弊端： A:让类的耦合性增强。这样某个类的改变，就会影响其他和该类相关的类。原则：低耦合，高内聚。耦合：类与类的关系内聚：自己完成某件事情的能力 B:打破了封装性 Java中继承的特点 A:Java中类只支持单继承 B:Java中可以多层(重)继承(继承体系) 继承的注意事项： A:子类不能继承父类的私有成员 B:子类不能继承父类的构造方法，但是可以通过super去访问 C:不要为了部分功能而去继承

多态：同一个对象在不同时刻体现出来的不同状态。多态前提： A:有继承或者实现关系。 B:有方法重写。 C:有父类或者父接口引用指向子类对象。多态中的成员访问特点 A:成员变量编译看左边，运行看左边 B:构造方法子类的构造都会默认访问父类构造 C:成员方法编译看左边，运行看右边 D:静态方法编译看左边，运行看左边多态的好处提高了程序的维护性(由继承保证) 提高了程序的扩展性(由多态保证) 多态的弊端不能访问子类特有功能静态的特点： A:随着类的加载而加载 B:优先与对象存在 C:被类的所有对象共享这其实也是我们判断该不该使用静态的依据。 D:可以通过类名调用静态变量和成员变量的区别 A:所属不同静态变量：属于类，类变量成员变量：属于对象，对象变量，实例变量 B:内存位置不同静态变量：方法区的静态区成员变量：堆内存 C:生命周期不同静态变量：静态变量是随着类的加载而加载，随着类的消失而消失成员变量：成员变量是随着对象的创建而存在，随着对象的消失而消失D:调用不同静态变量：可以通过对象名调用，也可以通过类名调用成员变量：只能通过对象名调用

Java期末知识点整理总结

Java期末知识点整理总结计科2班苏锐师编号47 学号201330551464 第一章 Java语言概述 1. Java语言发展历史和现状及前景 2. Java语言的特点：简单、面向对象、分布式、健壮性、结构中立、安全性、可移植、解释的、高性能、多线程、多态性 3. Java虚拟机概念（JVM），Java程序的执行过程 4. Java应用程序分类：Application和Applet 5. Java程序的开发环境：JDK，IDE 第二章 Java数据类型及其运算 1. 标识符与保留字 1.2 标识符命名语法规则与Java推荐的标识符命名规则 1.3 Java中的关键字 2. 数据类型byte, short, int long, char, float, double, boolean 注意点：Java中所有数据类型是确定的，与平台无关，没有sizeof操作，其中特别注意char 类型是2字节Unicode编码，与C++ 不同；知道基本类型都有对应的默认值。整型数的十进制、八进制、十六进制值的表示。实型数的十进制、十六进制与科学计数法表示，注意实型常量默认类型为double型。 3. 运算符与表达式算术运算符： + - * / % ++ -- 关系运算符：> >= < <= == != 逻辑运算符：&& || ！& | 注意短路计算与非短路计算的差别位运算符： >> << >>> & | ^ ~ 要认识异或(^)与按位取反(~)运算符赋值运算符： += -= *= /= %= &= |= ^= <<= >>= >>>= 要注意赋值运算符中包含了强制转换：若： int k = 1; k += 44.232D; 则相当于： k = (int) ( k + 44.232D); 条件运算符：exp ？stat1 ：stat2 要注意stat1与stat2要求类型相兼容且不能为void类型。运算符的优先级：算术运算 > 关系运算> 逻辑运算

MFC消息映射机制如何运用ClassWizard

M F C消息映射机制如何运用C l a s s W i z a r d The Standardization Office was revised on the afternoon of December 13, 2020

画图的基本应用： Point的应用，在mfc中的很多的位置都要用到。只是当前点的信息，xy坐标，MoveToEx 移动位置函数The MoveToEx function updates the current position to the specified point and optionally returns the previous position. LineTo 画直线的函数 CDC类，作图相关的操作 GetDC，cwnd：：getdc 以及cdc的释放（区别hdc），两者的范围不同，调用方式不同 CClientDC 不需要显示地调用getdc和releasedc，只需要声明类的定义和类的调用。 Cliendc对象里利用view指针构造，但是调用的时候用的是对象的点调用方式。 Cwnd：：getparent 获得父窗口的指针，view的父窗口是frame。注意区别view 和framework的客户区域。 Cwindowdc类和clientdc一样自动调用getdc和releasedc。了解他的访问客户区的范围。 Getdesktopwindow 获得桌面窗口。创建画笔： CPen 类，设置画笔的属性，包括一些类型宽度，颜色。 CDC：：SelectObject 用的过程中要保存原来的画笔指针。创建一个阴影线的笔只能是1或更小。（其他的注意情况看msdn）。

JAVA重点知识总结

CoreJava部分 1简述下java基本数据类型及所占位数，java基本数据类型：4类8种整数类型：byte(1byte),short(2byte),int(4byte),long(8byte) 浮点类型：float(4byte),double(8byte) 字符类型：char(2byte) 逻辑类型：boolean(false/true1byte) 2说出5个启动时异常 ------RunTimeException ------NullPointerException ------ArrayIndexOutOfBoundsException ------ClassCastException ------NumberFormatException 3HashMap和HashTable的区别： 1HashMap允许空键值对，HashTable不允许 2HashMap不是线程安全的，HashTable是 3HashMap直接实现Map接口，HashTable继承Dictionary类 4.ArrayList,Vector,LinkedList存储性能和区别它们都实现了List接口 ArrayList和Vector都是基于数组实现的 LinkedList基于双向循环链表（查找效率低，添加删除容易） ArrayList不是线程安全的而Vector是线程安全的，所有速度上ArrayList高于Vector 5.Collection和Collections的区别 Collection是集合类的上级接口，继承与他的接口主要有Set和List Collections是针对集合类的一个帮助类，他提供一系列静态方法实现对各种集合的搜索、排序、线程安全等操作。 6List、Map、Set三个接口，存取元素时，各有什么特点？ List以特定次序来持有元素，可有重复元素。 Set无法持有重复元素，内部排序 Map保存key-value值，value可多值。 7final,finally,finalize的区别 Final用于声明属性，方法和类，分别表示属性不可变，方法不可覆盖，类不可继承Finally是异常处理语句结构的一部分，表示总是执行 Finalize是Object类的一个方法，在垃圾收集时的其他资源回收，例如关闭文件等。8Overload和Override的区别。Overload的方法是否可以改变返回值的类型？方法的重写Override和重载Overload是Java多态的不同表现。重写Overriding是父类与子类之间多态的一种表现，方法名，参数列表返回值类型都得与父类的方法一致。重载Overloading是一种类中多态的一种表现。重载的方法是可以改变返回值类型的。9用一句话总结一下冒泡排序依次比较相邻的两个数，将小数放在前面，大数放在后面。 10实现线程安全的两种方式 1）synchronized方法：通过在方法声明加入synchronized关键字来声明synchronized方法

JAVA编程关键字和常用单词

Java基础常见英语词汇(共70个) OO: object-oriented ,面向对象 OOP: object-oriented programming,面向对象编程 JDK:Java development kit, java开发工具包 JVM:java virtual machine ,java虚拟机 Compile:编绎 Run:运行 Class:类 Object:对象 System:系统 out:输出 print:打印 line:行 variable:变量 type:类型 operation:操作,运算 array:数组 parameter:参数 method:方法 function:函数 member-variable:成员变量 member-function:成员函数 get:得到 set:设置 public:公有的 private:私有的 protected:受保护的 default:默认 access:访问 package:包 import:导入 static:静态的 void:无(返回类型) extends:继承 parent class:父类 base class:基类 super class:超类 child class:子类

derived class:派生类 override:重写,覆盖 overload:重载 final:最终的,不能改变的 abstract:抽象 interface:接口 implements:实现 exception:异常 Runtime:运行时 ArithmeticException:算术异常ArrayIndexOutOfBoundsException:数组下标越界异常NullPointerException:空引用异常ClassNotFoundException:类没有发现异常NumberFormatException:数字格式异常(字符串不能转化为数字) Catch:捕捉 Finally:最后 Throw:抛出 Throws: (投掷)表示强制异常处理 Throwable:(可抛出的)表示所有异常类的祖先类 Lang:language,语言 Util:工具 Display:显示 Random:随机 Collection:集合 ArrayList:(数组列表)表示动态数组 HashMap: 散列表,哈希表 Swing:轻巧的 Awt:abstract window toolkit:抽象窗口工具包 Frame:窗体 Size:尺寸 Title:标题 Add:添加 Panel:面板 Layout:布局 Scroll:滚动 Vertical:垂直 Horizonatal:水平 Label:标签 TextField:文本框 TextArea:文本域 Button:按钮

mfc原理和消息映射

MFC思想 win32程序中创建一个窗口的过程：设计窗口阶段(由WNDCLASS结构描述部分)、窗口的注册及创建显示过程、消息循环部分。win32用标准的C语言代码实现，是面向过程的。在MFC中采用了面向对象的思想，即用面向对象的C++思想对以上代码进行了封装，也就是说将一些对窗口进行操作的API的函数封装到了一个类中，以下我将用简短的代码来演示一下这个过程： class CWnd { public: HWND m_hWnd; BOOL Create(); BOOL ShowWindow(); }; BOOL CWnd::Create() { WNDCLASS wndClass; wndClass.style=CS_HREDRAW; wndClass.lpfnWndProc=(WNDPROC)DefWndProc; wndClass.cbClsExtra=0; wndClass.cbWndExtra=0; wndClass.hInstance=hInstance; wndClass.hIcon=LoadIcon(hInstance,MAKEINTRESOURCE(IDI_ICON1)); wndClass.hCursor=LoadCursor(hInstance,MAKEINTRESOURCE(IDC_CURSOR1)); LOGBRUSH lgbr; lgbr.lbStyle=BS_SOLID; lgbr.lbColor=RGB(192,192,0); lgbr.lbHatch=0; wndClass.hbrBackground=CreateBrushIndirect(&lgbr); wndClass.lpszMenuName=NULL; wndClass.lpszClassName="mycls"; RegisterClass(&wndClass); HWND hWnd; m_hWnd=CreateWindow("mycls","窗口标题", WS_OVERLAPPEDWINDOW,0,NULL,NULL,hInstance,NULL); if(m_hWnd!=NULL) return true; else return false; } BOOL CWnd::ShowWindow() { return ShowWindow(hWnd,nCmdShow); } 为了保证代码和以前的执行方式一样，Winmain()函数可以写成如下形式：

MFC消息映射

消息映射的实现 Windows消息概述 Windows应用程序的输入由Windows系统以消息的形式发送给应用程序的窗口。这些窗口通过窗口过程来接收和处理消息，然后把控制返还给Windows。消息的分类队列消息和非队列消息从消息的发送途径上看，消息分两种：队列消息和非队列消息。队列消息送到系统消息队列，然后到线程消息队列；非队列消息直接送给目的窗口过程。这里，对消息队列阐述如下： Windows维护一个系统消息队列（System message queue），每个GUI线程有一个线程消息队列（Thread message queue）。鼠标、键盘事件由鼠标或键盘驱动程序转换成输入消息并把消息放进系统消息队列，例如 WM_MOUSEMOVE、WM_LBUTTONUP、WM_KEYDOWN、WM_CHAR等等。Windows每次从系统消息队列移走一个消息，确定它是送给哪个窗口的和这个窗口是由哪个线程创建的，然后，把它放进窗口创建线程的线程消息队列。线程消息队列接收送给该线程所创建窗口的消息。线程从消息队列取出消息，通过Windows把它送给适当的窗口过程来处理。除了键盘、鼠标消息以外，队列消息还有WM_PAINT、WM_TIMER和WM_QUIT。这些队列消息以外的绝大多数消息是非队列消息。系统消息和应用程序消息从消息的来源来看，可以分为：系统定义的消息和应用程序定义的消息。系统消息ID的范围是从0到WM_USER-1，或0X80000到0XBFFFF；应用程序消息从WM_USER （0X0400）到0X7FFF，或0XC000到0XFFFF；WM_USER到0X7FFF范围的消息由应用程序自己使用；0XC000到0XFFFF范围的消息用来和其他应用程序通信，为了ID的唯一性，使用::RegisterWindowMessage来得到该范围的消息ID。消息结构和消息处理消息的结构为了从消息队列获取消息信息，需要使用MSG结构。例如，::GetMessage函数（从消息队列得到消息并从队列中移走）和::PeekMessage函数(从消息队列得到消息但是可以不移走)都使用了该结构来保存获得的消息信息。 MSG结构的定义如下： typedef struct tagMSG { // msg HWND hwnd; UINT message; WPARAM wParam; LPARAM lParam; DWORD time; POINT pt; } MSG; 该结构包括了六个成员，用来描述消息的有关属性：接收消息的窗口句柄、消息标识（ID）、第一个消息参数、第二个消息参数、消息产生的时间、消息产生时鼠标的位置。应用程序通过窗口过程来处理消息如前所述，每个“窗口类”都要登记一个如下形式的窗口过程： LRESULT CALLBACK MainWndProc (

4.MFC消息映射机制如何运用ClassWizard

. 画图的基本应用： Point的应用，在mfc中的很多的位置都要用到。只是当前点的信息，xy坐标，MoveToEx 移动位置函数The MoveToEx function updates the current position to the specified point and optionally returns the previous position. LineTo 画直线的函数 CDC类，作图相关的操作 GetDC，cwnd：：getdc 以及cdc的释放（区别hdc），两者的范围不同，调用方式不同CClientDC 不需要显示地调用getdc和releasedc，只需要声明类的定义和类的调用。Cliendc对象里利用view指针构造，但是调用的时候用的是对象的点调用方式。Cwnd：：getparent 获得父窗口的指针，view的父窗口是frame。注意区别view和framework 的客户区域。 Cwindowdc类和clientdc一样自动调用getdc和releasedc。了解他的访问客户区的范围。Getdesktopwindow 获得桌面窗口。创建画笔： CPen 类，设置画笔的属性，包括一些类型宽度，颜色。 CDC：：SelectObject 用的过程中要保存原来的画笔指针。创建一个阴影线的笔只能是1或更小。（其他的注意情况看msdn）。创建画刷： CBrush 类的方法 FillRect填充矩形的区域。 CRect类，几种不同的方法。用位图填充画刷。CBitmap 的构造函数，没有参数。调用之前必需初始化。透明画刷的创建： dc.Rectangle(); 画出矩形。空画刷：GetStockObject CBrush::FromeHandle 空画刷的实现方法： CBrush *brush=CBrush::FromHandle((HBRUSH)GetStockObject(NULL_BRUSH)); CBrush *oldbrush=dc.SelectObject(brush); dc.Rectangle(CRect(org,point)); dc.SelectObject(oldbrush); 理解消息响应的知识： MouseMove 如有侵权请联系告知删除，感谢你们的配合！精品

何小伟-高手总结java常用API

Java常用API的运用，效率及技巧 1. Java面向对象基本概念 2. System 3. String, StringBuffer 4. 数值，字符，布尔对象与简单类型的操作 5. Class, ClassLoader 6. Java IO系统 7. Java集合类 8. ResourceBundle, Properties 9. Exceptions 10. JDBC类库 11. 常用设计模式 1. Java面向对象基本概念 Java基本上是面向对象的程序设计语言，除了一些简单类型(primitive)的变量以外，一切都是对象，程序是对象的组合，每个对象都有自己的空间，并且每个对象都有一种类型，同一类所有对象都能接受相同的消息。下面只对Java中对象的结构作简单的说明：类（class）: class是定义类的关键字，类中包含类变量，方法，内部类，内部接口等。由class可以生成类的实例，即一个个对象。如果一个类的成员被定义成static的，则这个成员不专属于任何对象，而是属于这个类，所有的对象共享这个成员。抽象类(abstract class): 抽象类不能直接生成一个实例，抽象类中必需有方法是abstract的，抽象类的意思就是它实现了一部分的方法，而定义为abstract的方法则需要在它的字类中去实现。接口(interface): 接口可以理解为纯抽象的类，它的每个方法都是未实现的，它可以有成员变量，但必须是static的。一个类如果从这个接口继承（implements）则它必须实现这个接口的所有方法。继承类用关键字：extends，继承接口用关键字：implements。一个类只能从一个类继承下来，但可以从多个接口继承（类似于C++的多重继承）。字类可以覆盖父类的方法(method)，但不能覆盖父类的成员变量(field)。如果父类的方法为final或static的则不能被覆盖。类的初始化顺序是，如果有父类，则先初始化父类的field，然后执行父类的构造函数，如果子类没有显式的去调父类的构造函数则缺省的会去调父类的无参数构造函数。然后是子类的field 与构造函数的初始化。 public interface SuperInterface { public staitc String SOME_FLAG = “1”; public void someMethod(); } public Class SuperClass { { System.out.println(“init SuperClass field”);} public SuperClass() {System.out.println(“init SuperClass Constructor”); } public void runMethod() { System.out.println(“run SuperClass runMethod()”); } }

java中常用关键字总结

Java中的关键字总结 final关键字 1、用final修饰的类不能被继承，没有子类； 2、用final修饰的方法，方法不能被重写； 3、用final修饰变量，变量的值不能被修改，表示常量，(书写规范：全部字母都要大写；多个单词，可以使用下划线（_）分开；) 注意：如果被final修饰的变量是一个引用类型的数据，那么通过这个引用改变堆空间中的数据，不会报错；如果被final修饰的变量是一个引用类型的数据，那么通过这个引用改变堆空间中的数据，不会报错； 4、final用于成员变量表示该成员变量为常量，不能被修改，必须在变量定义时赋值。 5、final用于局部变量表示该局部变量为常量，不能被修改，可以在变量定义时赋值，也可以先定义变量后赋值。什么时候用final关键字? 有的时候不想别人重写我的方法就使用final关键字修饰该方法； static关键字 1、static用于成员变量表示该变量只有一份，也就是说静态成员变量属于类而不属于某个具体的类实例对象，所有的类实例对象共享这个静态成员变量；静态函数是不需要对象的，直接可以使用类名来调用； 2、非静态函数可以调用静态函数；静态函数不能调用非静态函数（非静态函数都是通过对象调用的）；静态函数不能使用非静态成员变量，但可以使用静态成员变量； 3、静态函数调用时不需要对象的，所以不能使用和对象有关的关键字；(this；super；) 4、构造函数不能使用static修饰(构造函数是创建对象，开辟空间，给所有成员变量赋默认值之后，有JVM调用进栈，用来给对象的成员变量赋初始值的) static用于类，这里指的是内部类，那么在别的地方就可以通过外部类名来引用这个静态的内部类。 5、static还可以用于类的代码块，叫做静态代码块，静态代码块在类加载的时候就执行完毕，而类只加载一次；是在类中独立于类成员的static语句块，可以有多个，位置可以随便放，它不在任何的方法体内，JVM加载类时会执行这些静态的代码块，如果static代码块有多个，JVM将按照它们在类中出现的先

Java常见关键字及用法总结

Java常见关键字及用法总结关键字目录 abstract - 1 - boolean - 2 - break - 2 - byte - 2 - case - 3 - catch - 3 - char - 4 - class - 4 - continue - 5 - default - 5 - do - 6 - double - 6 - else - 6 - extends - 6 - false - 7 - final - 7 - finally - 7 - float - 8 - for - 8 - if - 8 - implements - 9 - import - 9 - instanceof - 9 - int - 9 - interface - 10 - long - 10 - native - 10 -

new - 11 - null - 11 - package - 11 - private - 11 - protected - 12 - public - 12 - return - 13 - short - 13 - static - 13 - super - 14 - switch - 14 - synchronized - 15 - this - 16 - throw - 16 - throws - 16 - transient - 17 - try - 17 - true - 18 - void - 18 - volatile - 18 - while - 18 - 1.abstract abstract 关键字可以修改类或方法。 abstract 类可以扩展（增加子类），但不能直接实例化。 abstract 方法不在声明它的类中实现，但必须在某个子类中重写。-示例- public abstract class MyClass{ } public abstract String myMethod();