Delphi中静态方法重载还是覆盖的讨论新人学习Delphi的时候,容易搞不懂的一个问题,当子类方法和基类方法同名，并且参数也一样的时候，叫做什么呢？是覆盖，还是重载呢？&答案是隐藏父类方法。&一般我们的理解重载是同名，不同参数的同一个类里面实现，或者父类和子类方法同名，参数不同，子类必须有overide关键字，表示重载方法。&也就是说重载必须有overload修饰；&覆盖呢？覆盖必须有override修改；&否则同名，同参数就是隐藏方法。=================================================================下面是笔者自己的程序，您可以尝试一下。&program&Project2;&{$APPTYPE&CONSOLE}&uses&&SysU&&&type&tclassa=class&&&&&private&&&&&&&age&:I&&&&&public&&&&&&&function&getage:&&&//静态方法&&&&&&&function&getDat:&&//静态方法&&&&&&&&&&&&&&&tclassb=class(tclassa)&&&&&&&private&&&&&&&&&&public&&&&&&&&&&&function&getdat:&&//隐藏静态方法&&&&&&&&&&&function&getage:I&//隐藏静态方法&&&&&&&&&&&&{&tclassa&}&function&tclassa.getage:&begin&&age&:=&1;&&result&:=&&function&tclassa.getDat:&begin&&result&:=&3;&{&tclassb&}&function&tclassb.getage:&Ibegin&&Result&:=&1+&inherited&getage();&var&a:&&&b:function&tclassb.getdat:&begin&&result&:=&1&+&inherited&getdat();&begin&&a&:=&tclassa.C&&b&:=&tclassb.C&&&Writeln(a.getage());&&Writeln(b.getage());&&Writeln(a.getdat());&&Writeln(b.getdat());&//&调用的是子类的隐藏后的静态方法&&&&&&&&&a.&&b.&&&{&TODO&-oUser&-cConsole&Main&:&Insert&code&here&}end.&我们可以看到隐藏了父类方法之后，还是可以调用父类同名方法的。这就和覆盖是相似的。&&参考资料=================================&Delphi面向对象方法的分类以及覆盖隐藏和重载&6&&方法的分类&&按用途分&普通方法,构造方法,析构方法,&类方法,消息处理方法&&按运行绑定机制分:静态方法,虚方法,动态方法,[注意此处的静态方法不是所谓的class&method&而是普通的方法&,静态是指静态编译]&&关于析构方法,最好是用名字destroy&,这样可以使用Free方法,而不要直接调用destroy方法.&&Free方法会先判断对象变量是否为nil.&&procedure&TObject.F&&begin&&&&if&Self&&&&nil&then&&&&&&D&&&&&&消息处理方法的例子:&&procedure&WMChar(var&message:TWMChar);message&WM_CHAR;&&问题来了.为什么在一个Control中声明了消息处理方法,就能调用此消息处理方法呢,这里涉及到&&TObject&中Dispatch方法的秘密,我暂时没有看懂.留作以后继续学习&&先给出Dispatch的源码.&&procedure&TObject.Dispatch(var&Message);&&asm&&&&&&PUSH&&&&ESI&&&&&&MOV&&&&&SI,[EDX]&&&&&&OR&&&&&&SI,SI&&&&&&JE&&&&&&@@default&&&&&&CMP&&&&&SI,0C000H&&&&&&JAE&&&&&@@default&&&&&&PUSH&&&&EAX&&&&&&MOV&&&&&EAX,[EAX]&&&&&&CALL&&&&GetDynaMethod&&&&&&POP&&&&&EAX&&&&&&JE&&&&&&@@default&&&&&&MOV&&&&&ECX,ESI&&&&&&POP&&&&&ESI&&&&&&JMP&&&&&ECX&&&&@@default:&&&&&&POP&&&&&ESI&&&&&&MOV&&&&&ECX,[EAX]&&&&&&JMP&&&&&DWORD&PTR&[ECX]&+&VMTOFFSET&TObject.DefaultHandler&&&&&&GetDynaMethod的方法源码如下&&procedure&&&&&&&GetDynaM&&asm&&&&&&&&&&{&-&&&&&EAX&&&&&vmt&of&class&&&&&&&&&&&&}&&&&&&&&&&{&&&&&&&SI&&&&&&dynamic&method&index&&&&}&&&&&&&&&&{&&-&&&&ESI&pointer&to&routine&&}&&&&&&&&&&{&&&&&&&ZF&=&0&if&found&&&&&&&&&}&&&&&&&&&&{&&&&&&&trashes:&EAX,&ECX&&&&&&&&&&&&&&&}&&&&&&&&&&&&PUSH&&&&EDI&&&&&&&&&&XCHG&&&&EAX,ESI&&&&&&&&&&JMP&&&&&@@haveVMT&&@@outerLoop:&&&&&&&&&&MOV&&&&&ESI,[ESI]&&@@haveVMT:&&&&&&&&&&MOV&&&&&EDI,[ESI].vmtDynamicTable&&&&&&&&&&TEST&&&&EDI,EDI&&&&&&&&&&JE&&&&&&@parent&&&&&&&&&&MOVZX&&&ECX,word&ptr&[EDI]&&&&&&&&&&PUSH&&&&ECX&&&&&&&&&&ADD&&&&&EDI,2&&&&&&&&&&REPNE&&&SCASW&&&&&&&&&&JE&&&&&&@@found&&&&&&&&&&POP&&&&&ECX&&@parent:&&&&&&&&&&MOV&&&&&ESI,[ESI].vmtParent&&&&&&&&&&TEST&&&&ESI,ESI&&&&&&&&&&JNE&&&&&@@outerLoop&&&&&&&&&&JMP&&&&&@@exit&&&&@@found:&&&&&&&&&&POP&&&&&EAX&&&&&&&&&&ADD&&&&&EAX,EAX&&&&&&&&&&SUB&&&&&EAX,ECX&&&&&&&&&{&this&will&always&clear&the&Z-flag&!&}&&&&&&&&&&MOV&&&&&ESI,[EDI+EAX*2-4]&&&&@@exit:&&&&&&&&&&POP&&&&&EDI&&&&&7&&方法的覆盖,隐藏和重载&&&&覆盖是override&,重载是&&隐藏是子类中的方法和父类的方法同名,而且参数相同,没有override修饰符,则子类的方法就隐藏父类的方法.&&Example:&&&...&&&&TChineseMan&=&class(TMan)&&&&&&procedure&SayHello(words:string);&//打招呼&&&&&&&&&....&&&procedure&TChineseMan.SayHello(words:&string);&&&begin&&&&&ShowMessage('TChinese&Man&SayHello&'+words);&&&&&&...&&&&procedure&TForm1.Button1Click(Sender:&TObject);&&&&var&&&&&APerson:TM&&&&&AChinesePerson:TChineseP&&&&begin&&&&&APerson:=TChineseMan.C&&&&&APerson.SayHello('是一名中国人');&&&&&&//注意了此处调用的是父类的TMan.Sayhello方法&&&&&//&&&&&ChinesePerson:=TChinesePerson.C&&&&&ChinesePerson.SayHello('是一名中国人');&//此时调用的是TChineseMan.sayHello&&&&&&&&&&//如果想要APerson调用TChineseMan.sayHello方法&应该采取强制类型转换,强制类型转换其实就是对象框架的范围调整&&&&&TChinesePerson(APerson).SayHello('是一名中国人');&//此时调用的是TChineseMan.sayHello&&&&&&&&&&&&&&8&&&可见性&&Delphi中四种类成员的保护方式:published,public,protected,&&&&&published,public&是可以最大访问,protected是对之类是可见的,private是对子类不可见&&另外对象变量如果与其类的声明在同一个单元中,则private,protected失去作用,全部都是public&&有点类似C++中友元的概念&&Example&&类TMan和此函数在同一个单元&&procedure&TForm1.Button1Click(Sender:&TObject);&&var&&&&APerson:TM&&begin&&&&TMan.S&&&&&APerson.FAge:=10;//虽然FAge是private&,但是此处确可以访问&&&&&&APerson:=TMan.C&&&&APerson.Name:='小李';&&&&APerson.SayHello('&是一名中国人');&&&&&Delphi面向对象编程&&读书笔记之二&1&什么是对象&A.对象是一组相关代码和数据的组合.面向对象程序设计中,过程(函数)被成为方法,数据被称做属性(注意此处的属性和类中property不是一回事)&B.对象之间可以通过发送消息请求而互相联系,一个消息通常由三部分组成:接收对象的名字,对象成员的名字(方法和property),对象成员的参数&C.对象是有类型的,不同的对象是属于不同的类型.&
最新教程周点击榜
微信扫一扫Java 属性覆盖，静态方法覆盖,方法重写的JVM相关实现 - 开源中国社区
当前访客身份：游客 [
当前位置：
发布于 日 15时,
Java&属性覆盖，静态方法覆盖，方法重写。JVM是如何实现这种特性的？大体涉及两个方面：1.静态链接和动态链接区别&。2..java源文件编译成.class文件后，.class中的JVM指令是不同的。具体涉及到&&invokestatic，invokevirtual，getfield三个指令。invokestatic针对静态方法，invokevirtual针对实例方法，getfield针对属性。理解不对之处，请各位老爷指正。
代码片段(4)
1.&[代码]Person类，父类&&&&
package com.demo1;
public class Person {
public String getName() {
return this.
public static void sayHello() {
System.out.println("Person");
2.&[代码]Student类，子类，继承Person&&&&
package com.demo1;
public class Student extends Person {
public Student(String name) {
super.name = "Rose";
this.name =
public String getName() {
return this.
public static void sayHello() {
System.out.println("Student");
3.&[代码]main方法&&&&
package com.demo1;
public class Test1 {
public static void main(String[] args) {
Student t = new Student("Jack");
Person p =
System.out.println(t.name);
System.out.println(p.name);
System.out.println(t.getName());
System.out.println(p.getName());
t.sayHello();
p.sayHello();
4.&[代码]输出结果&&&&
开源中国-程序员在线工具：
相关的代码(218)
回去把书看清楚吧
2楼：青木河 发表于
引用来自“winktj”的评论回去把书看清楚吧呵呵，一看阁下就不是“格物致知”的人。
3楼：winktj 发表于
引用来自“winktj”的评论回去把书看清楚吧引用来自“青木河”的评论呵呵，一看阁下就不是“格物致知”的人。一看你就是不认真看书的人,基本概念都没弄清楚. 还格物致知呢.
4楼：青木河 发表于
引用来自“winktj”的评论回去把书看清楚吧引用来自“青木河”的评论呵呵，一看阁下就不是“格物致知”的人。引用来自“winktj”的评论一看你就是不认真看书的人,基本概念都没弄清楚. 还格物致知呢.这代码是用来JVM的继承实现原理的。需要运行后用javap命令反编译出JVM指令，然后找出“invokevirtual”指令、“invokestatic”指令，“getfield”指令三个指令。这三个指令逻辑的不同，导致了示例代码输出结果的不同。呵呵，请大侠指教“基本概念”是指什么？
5楼：一只小桃子 发表于
属性是覆盖吗？没注意过，super.xxx也不能访问？
6楼：xiaolei123 发表于
奥 & 这个 啊 ，这个就是 & 看你的类型是什么类型 ，
如果 & &&&&&person p &那么就输出person的值。
如果是 &&&&student p &那么就输出student的值、
跟那个近 & 就输出哪个的值、
7楼：青木河 发表于
引用来自“xiaolei123”的评论奥 & 这个 啊 ，这个就是 & 看你的类型是什么类型 ，
如果 & &&&&&person p &那么就输出person的值。
如果是 &&&&student p &那么就输出student的值、
跟那个近 & 就输出哪个的值、实例方法重载，根据运行时对象的实际类型，决定运行哪个方法； 静态方法和属性就是像你说的，根据源码时的类型决定是哪个静态方法和属性。 涉及静态链接和动态连接的概念。
8楼：青木河 发表于
引用来自“孤独小桃子”的评论属性是覆盖吗？没注意过，super.xxx也不能访问？属性是覆盖，静态方法也是覆盖。实例方法(非final类型的函数)，就是重写，不是覆盖。super是在子类代码里用吧。这里主要是用在main函数里时，覆盖和重写有什么不同。
9楼：wenhaoran 发表于
引用来自“winktj”的评论回去把书看清楚吧引用来自“青木河”的评论呵呵，一看阁下就不是“格物致知”的人。引用来自“winktj”的评论一看你就是不认真看书的人,基本概念都没弄清楚. 还格物致知呢.引用来自“青木河”的评论这代码是用来JVM的继承实现原理的。需要运行后用javap命令反编译出JVM指令，然后找出“invokevirtual”指令、“invokestatic”指令，“getfield”指令三个指令。这三个指令逻辑的不同，导致了示例代码输出结果的不同。呵呵，请大侠指教“基本概念”是指什么？三个指令逻辑是什么大神?
10楼：8enet 发表于
区分this 和 super关键字啊，this是本类，new的是哪个子类就是哪个值，动态绑定的，静态方法是静态绑定的 就算
Person p =也可以调p.sayHello(); 和继承没关系
11楼：青木河 发表于
引用来自“winktj”的评论回去把书看清楚吧引用来自“青木河”的评论呵呵，一看阁下就不是“格物致知”的人。引用来自“winktj”的评论一看你就是不认真看书的人,基本概念都没弄清楚. 还格物致知呢.引用来自“青木河”的评论这代码是用来JVM的继承实现原理的。需要运行后用javap命令反编译出JVM指令，然后找出“invokevirtual”指令、“invokestatic”指令，“getfield”指令三个指令。这三个指令逻辑的不同，导致了示例代码输出结果的不同。呵呵，请大侠指教“基本概念”是指什么？引用来自“wenhaoran”的评论三个指令逻辑是什么大神?简单说吧：invokestatic是针对静态方法的指令，它的一般逻辑就是静态连接，在加载class文件后，解析连接时，就把静态方法的方法名引用替换为实际地址，所以com.demo1.Person.sayHello()被替换为Person类的sayHello地址，com.demo1.Student.sayHello()被替换为Student类的sayHello地址。这两个地址的不同，造成了t.sayHello(); p.sayHello();输出结果的不同。
12楼：青木河 发表于
引用来自“winktj”的评论回去把书看清楚吧引用来自“青木河”的评论呵呵，一看阁下就不是“格物致知”的人。引用来自“winktj”的评论一看你就是不认真看书的人,基本概念都没弄清楚. 还格物致知呢.引用来自“青木河”的评论这代码是用来JVM的继承实现原理的。需要运行后用javap命令反编译出JVM指令，然后找出“invokevirtual”指令、“invokestatic”指令，“getfield”指令三个指令。这三个指令逻辑的不同，导致了示例代码输出结果的不同。呵呵，请大侠指教“基本概念”是指什么？引用来自“wenhaoran”的评论三个指令逻辑是什么大神?invokevirtual是针对实例方法的，invokevirtual指令是动态绑定，类加载后，在解析连接时，不会绑定地址，而是在运行时，先获取实例的实际类型，然后去方法表里查询方法的地址，至于方法区里方法表是怎样产生的，你可以再研究，反正实现的逻辑就是实际类型没有该方法，就去父类找。因为最先获取的是实际类型，所以，这也是实现方法重写的本质。
13楼：青木河 发表于
引用来自“winktj”的评论回去把书看清楚吧引用来自“青木河”的评论呵呵，一看阁下就不是“格物致知”的人。引用来自“winktj”的评论一看你就是不认真看书的人,基本概念都没弄清楚. 还格物致知呢.引用来自“青木河”的评论这代码是用来JVM的继承实现原理的。需要运行后用javap命令反编译出JVM指令，然后找出“invokevirtual”指令、“invokestatic”指令，“getfield”指令三个指令。这三个指令逻辑的不同，导致了示例代码输出结果的不同。呵呵，请大侠指教“基本概念”是指什么？引用来自“wenhaoran”的评论三个指令逻辑是什么大神?至于getfield指令，没有细研究，要么跟invokestatic一样是静态绑定，要么就是运行时，不去获取实例的实际类型，而是直接用引用类型。不会有重写逻辑，自然就是覆盖了。
14楼：青木河 发表于
引用来自“winktj”的评论回去把书看清楚吧引用来自“青木河”的评论呵呵，一看阁下就不是“格物致知”的人。引用来自“winktj”的评论一看你就是不认真看书的人,基本概念都没弄清楚. 还格物致知呢.引用来自“青木河”的评论这代码是用来JVM的继承实现原理的。需要运行后用javap命令反编译出JVM指令，然后找出“invokevirtual”指令、“invokestatic”指令，“getfield”指令三个指令。这三个指令逻辑的不同，导致了示例代码输出结果的不同。呵呵，请大侠指教“基本概念”是指什么？引用来自“wenhaoran”的评论三个指令逻辑是什么大神?具体的实际逻辑可以参考虚拟机规范：/javase/specs/jvms/se7/html/
15楼：wenhaoran 发表于
引用来自“孤独小桃子”的评论属性是覆盖吗？没注意过，super.xxx也不能访问？引用来自“青木河”的评论属性是覆盖，静态方法也是覆盖。实例方法(非final类型的函数)，就是重写，不是覆盖。super是在子类代码里用吧。这里主要是用在main函数里时，覆盖和重写有什么不同。我一直想纠正大家一个问题 什么是属性 你没有搞明白 就拿你定义的 Person 类有多少个属性 你能正确回答
16楼：青木河 发表于
引用来自“8enet”的评论区分this 和 super关键字啊，this是本类，new的是哪个子类就是哪个值，动态绑定的，静态方法是静态绑定的 就算
Person p =也可以调p.sayHello(); 和继承没关系哈哈哈，这里是分析输出结果为什么会这样，目的是为了找出造成这种现象的本质。 不是在分析语法。只有在继承这种场景下，才会有方法重写，所以是和继承有关系的。
17楼：青木河 发表于
引用来自“孤独小桃子”的评论属性是覆盖吗？没注意过，super.xxx也不能访问？引用来自“青木河”的评论属性是覆盖，静态方法也是覆盖。实例方法(非final类型的函数)，就是重写，不是覆盖。super是在子类代码里用吧。这里主要是用在main函数里时，覆盖和重写有什么不同。引用来自“wenhaoran”的评论我一直想纠正大家一个问题 什么是属性 你没有搞明白 就拿你定义的 Person 类有多少个属性 你能正确回答Person类只有1个属性，com.demo1.Person.name 。Student有2个属性：com.demo1.Person.name，com.demo1.Student.name 。回答完毕。
18楼：wenhaoran 发表于
引用来自“孤独小桃子”的评论属性是覆盖吗？没注意过，super.xxx也不能访问？引用来自“青木河”的评论属性是覆盖，静态方法也是覆盖。实例方法(非final类型的函数)，就是重写，不是覆盖。super是在子类代码里用吧。这里主要是用在main函数里时，覆盖和重写有什么不同。引用来自“wenhaoran”的评论我一直想纠正大家一个问题 什么是属性 你没有搞明白 就拿你定义的 Person 类有多少个属性 你能正确回答引用来自“青木河”的评论Person类只有1个属性，com.demo1.Person.name 。Student有2个属性：com.demo1.Person.name，com.demo1.Student.name 。回答完毕。回答错误 属性和成员变量（字段）是有点区别的 回去查查资料
19楼：青木河 发表于
引用来自“孤独小桃子”的评论属性是覆盖吗？没注意过，super.xxx也不能访问？引用来自“青木河”的评论属性是覆盖，静态方法也是覆盖。实例方法(非final类型的函数)，就是重写，不是覆盖。super是在子类代码里用吧。这里主要是用在main函数里时，覆盖和重写有什么不同。引用来自“wenhaoran”的评论我一直想纠正大家一个问题 什么是属性 你没有搞明白 就拿你定义的 Person 类有多少个属性 你能正确回答引用来自“青木河”的评论Person类只有1个属性，com.demo1.Person.name 。Student有2个属性：com.demo1.Person.name，com.demo1.Student.name 。回答完毕。引用来自“wenhaoran”的评论回答错误 属性和成员变量（字段）是有点区别的 回去查查资料哈哈，你还是现在就告诉我吧，属性和成员变量有什么不同。别告诉我是C#那种解释.
20楼：xiaolei123 发表于
讨论这么专业、、
开源从代码分享开始
青木河的其它代码面向对象、类与对象、成员与局部变量、封装、private、构造函数、this、static、extends、super、final、abstract、interface、多态、内部类、异常【5】
时间： 01:37:36
&&&& 阅读：87
&&&& 评论：
&&&& 收藏：0
本文原创作者：本文原创出处： 本文版权归作者和博客园共有，未经作者同意必须保留此段声明，且在文章页面明显位置给出原文连接 ，否则保留追究法律责任的权利。
面向对象概念
理解面向对象
面向对象是相对面向过程而言
面向对象和面向过程都是一种思想
　　&强调的是功能行为
　　&将功能封装进对象，强调具备了功能的对象。
面向对象是基于面向过程的。
& 　　在一个结构体中定义窗口的大小，位置，颜色，背景等属性，对窗口操作的函数与窗口本身的定义没有任何关系，
如HideWindow，MoveWindow，MinimizeWindow，这些函数都需要接受一个代表要被操作的窗口参数 ，
是一种谓语与宾语的关系 。
&&&&　&定义窗口时，除了要指定在面向过程中规定的那些属性，如大小，位置，颜色，背景等外，还要指定该窗口可能具有的动作 ，
如隐藏，移动，最小化等。这些函数被调用时，都是以某个窗口要隐藏，某个窗口要移动的语法格式来使用的 ，
这是一种主语与谓语的关系。
面向过程的思想和面向对象的思想
　　面向对象和面向过程的思想有着本质上的区别,&作为面向对象的思维来说，当你拿到一个问题时，
你分析这个问题不再是第一步先做什么，
第二步再做什么，这是面向过程的思维，你应该分析这个问题里面有哪些类和对象，这是第一点，
然后再分析这些类和对象应该具有哪些属性和
方法。这是第二点。最后分析类和类之间具体有什么关系，这是第三点。
&&&&&&面向对象有一个非常重要的设计思维：合适的方法应该出现在合适的类里面
面向对象的设计思想
　　面向对象的基本思想是，从现实世界中客观存在的事物出发来构造软件系统，并在系统的构造中尽可能运用人类的自然思维方式。
　　面向对象更加强调运用人类在日常生活的逻辑思维中经常采用的思想方法与原则，如抽象、分类，继承、聚合、多态等。
　　人在思考的时候，首先眼睛里看到的是一个一个的对象。
面向对象的特点&
是一种符合人们思考习惯的思想
可以将复杂的事情简单化
将程序员从执行者转换成了指挥者
完成需求时：
　　& 先要去找具有所需的功能的对象来用。
　　& 如果该对象不存在，那么创建一个具有所需功能的对象。
　　&&这样简化开发并提高复用。
面向对象开发，设计，特征
开发的过程：其实就是不断的创建对象，使用对象，指挥对象做事情。
设计的过程：其实就是在管理和维护对象之间的关系。
面向对象的特征：
　　&封装(encapsulation)
　　&继承(inheritance)
　　&多态(polymorphism)
面向对象还支持如下几个功能：
&&&& 1）对象是面向对象方法中最基本的概念，它的基本特点是：标识唯一性、分类性、多态性、封装性、模块独立性好。
&&&& 2）类是具有共同属性、共同方法的一类事物。类是对象的抽象；对象则是类的实例。
　　　而类是整个软件系统最小的程序单元，类的封装性将各种信息细节隐藏起来，并通过公用方法来暴露该类对所提供的功能，
　　　从而提高了类的内聚性，降低了对象之间的耦合性。
&&&& 3）对象间的这种相互合作需要一个机制协助进行，这样的机制称为&消息&。消息是一个实例与另一个实例之间相互通信的机制。
&&&& 4）在面向对象方法中，类之间共享属性和操作的机制称为继承。继承具有传递性。
　　　继承可分为单继承（一个继承只允许有一个直接父类，即类等级为树形结构）与多继承（一个类允许有多个直接父类），
　　　但Java不支持多继承。
在Java语言中除了8个基本数据类型值之外，一切都是对象，而对象就是面向对象程序设计的中心。
对象具有状态，一个对象用数据值来描述它的状态。Java通过对对象定义Field（以前常被称为属性，现在也称字段）来描述对象的状态；
对象还有操作，这些操作可以改变对象的状态，
对象的操作也被称为对象的行为，Java通过为对象定义方法来描述对象的行为。
&&&&&& 对象是Java程序的核心，所以在Java里的对象具有唯一性，每个对象都有一个标识来引用它，
如果某个对象失去了标识，这个对象将变成垃圾，只能等着系统垃圾回收机制来回收它。Java语言不允许直接访问对象，
而是通过对对象的引用来操作对象。
在Java语言使用class关键字定义类，定义类时可使用Field来描述该类对象的数据，可使用方法来描述该类对象的行为特征。
Java语言使用extends关键字来表示继承关系。
Java使用new关键字来创建指定类的对象，每个类可以创建任意多个对象，多个对象的Field值可以不同。
类与对象的关系
使用计算机语言就是不断的在描述现实生活中的事物。
java中描述事物通过类的形式体现，类是具体事物的抽象，概念上的定义。
对象即是该类事物实实在在存在的个体。
类是对某一类事物的描述，是抽象的、概念上的定义；对象是实际存在的该类事物的每个个体，因而也称实例(instance)。&
　　　　类与对象的关系如图
可以理解为：
　　&类就是图纸
　　&汽车就是堆内存中的对象
对于同一类事物可以抽取它们的共性的内容，定义在类中。
如生活中的汽车，每一台车都有轮胎数和颜色。
那么在通过java描述汽车这类事物时，就可以将这两个共性属性作为类中的属性进行定义。
通过该类建立的每一个汽车实体都具有该属性，并可以有对象特有的属性值。
生活中描述事物无非就是描述事物的属性和行为。
　　&如：人有身高，体重等属性，有说话，打球等行为。
Java中用类class来描述事物也是如此
　　&属性：对应类中的成员变量。
　　&行为：对应类中的成员函数。
定义类其实在定义类中的成员(成员变量和成员函数)。
每一个JAVA里面的class（类）都对应了我们现实生活中某一类事物的一个抽象。
成员变量和局部变量的区别？
成员变量：
　　&成员变量定义在类中，在整个类中都可以被访问。
　　&成员变量随着对象的建立而建立，存在于对象所在的堆内存中。
　　&成员变量有默认初始化值。
局部变量：
　　&局部变量只定义在局部范围内，如：函数内，语句内等。
　　&局部变量存在于栈内存中。
　　&作用的范围结束，变量空间会自动释放。
　　&局部变量没有默认初始化值。
方法体中局部变量若与成员变量同名，局部变量将屏蔽成员变量。
class Variable {
int x = 0, y = 0, z = 0; // 类的成员变量
void init(int x, int y) {
int z = 5; // 局部变量
System.out.println("** in init**");
System.out.println("x = " + x + "y = " + y + "z = " + z);
public class VariableTest {
public static void main(String args[]) {
Variable v = new Variable();
System.out.println("** before init **");
System.out.println("x = " + v.x + "y = " + v.y + "z = " + v.z);
v.init(20, 30);
System.out.println("** after init **");
System.out.println("x = " + v.x + "y = " + v.y + "z = " + v.z);
创建对象，使用对象
class Car//对Car这类事物进行描述
String color = "red";
int num = 4;
void show()
System.out.println("color="+color+"..num="+num);
1 class CarDemo
public static void main(String[] args)
Car c = new Car();//建立对象
c.color = "black";//对对象的属性进行修改
c.show();//使用对象的功能。
&对象内存结构
Car c1 = new Car();　　c1.color="blue";
Car c2 = new Car();
只要是用new操作符定义的实体就在会堆内存中开辟一个新的空间。
并每一个对象中都有一份属于自己的属性。
通过 对象.对象成员 的方式操作对象中的成员，
对其中一个对象的成员进行了修改。和另一个对象没有关系。
匿名对象是对象的简化形式
匿名对象两种使用情况
　　&当对对象方法仅进行一次调用时
　　&匿名对象可以作为实际参数进行传递
封装(Encapsulation)
封装：是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。
　　&将变化隔离。
　　&便于使用。
　　&提高重用性。
　　&提高安全性。
封装原则：
　　&将不需要对外提供的内容都隐藏起来。
　　&把属性都隐藏，提供公共方法对其访问。
　　　　　要求使对象之外的部分不能随意存取对象的内部数据，从而有效避免了错误对它的&交叉感染&，使软件错误能局部化，降低排错难度
封装是把过程和数据包围起来，对数据的访问只能通过已定义的界面。面向对象计算始于这个基本概念，
即现实世界可以被描绘成一系列完全自治、封装的对象，这些对象通过一个受保护的接口访问其他对象。封装隐藏了类的内部实现机制，
从而可以在不影响使用者的前提下改变类的内部结构，同时保护了数据。
&private(私有)关键字
private关键字：
　　&是一个权限修饰符。
　　&用于修饰成员(成员变量和成员函数)
　　&被私有化的成员只在本类中有效。
常用之一：
　　&将成员变量私有化，对外提供对应的set ，get方法对其进行访问。提高对数据访问的安全性。
　　1.函数名与类名相同
　　2.不用定义返回值类型
　　3.没有具体的返回值。
　　给对象进行初始化。
　　1.默认构造函数的特点。
　　2.多个构造函数是以重载的形式存在的。
this关键字
特点：this代表其所在函数所属对象的引用。
换言之：this代本类对象的引用。
什么时候使用this关键字呢？
当在函数内需要用到调用该函数的对象时，就用this。
&static(静态)关键字
static关键字：
　　&用于修饰成员（成员变量和成员函数）
被修饰后的成员具备以下特点：
　　随着类的加载而加载
　　优先于对象存在
　　被所有对象所共享
　　可以直接被类名调用
　　静态方法只能访问静态成员
　　静态方法中不可以写this，super关键字
　　主函数是静态的
继承的概述
多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么多个类无需再定义这些属性和行为，只要继那个类即可。
多个类可以称为子类，单独这个类称为父类或者超类。
子类可以直接访问父类中的非私有的属性和行为。
通过 extends 关键字让类与类之间产生继承关系。
　　&class SubDemo extends Demo{}
继承的出现提高了代码的复用性。
继承的出现让类与类之间产生了关系，提供了多态的前提。
注意：子类不可以具备父类中私有的内容。
父类怎么来的？共性不断向上抽取而来的。
继承关系封装了这样一种逻辑：&XX是一种XX&，只要能说通，就可以考虑用继承关系来封装它。
继承的特点
Java只支持单继承，不支持多继承。
　　&一个类只能有一个父类，不可以有多个父类。
　　&class SubDemo extends Demo{} //ok
　　&class SubDemo extends Demo1,Demo2...//error
Java支持多层继承(继承体系)
　　&class A{}
　　&class B extends A{}
　　&class C extends B{}
定义继承需要注意：
　　&不要仅为了获取其他类中某个功能而去继承
　　&类与类之间要有所属( " is a " )关系，xx1是xx2的一种。
注意：因为多继承容易出现问题。
两个父类中有相同的方法。子类到底要执行哪一个是不确定的。
所以java不支持多继承，但将这种机制换了另一个种安全的方式来体现，多实现。
多次继承出现的继承体系中，通常看父类中的功能，了解该体系的基本功能，建立子类对象即可使用该体系功能。
继承是一种联结类的层次模型，并且允许和鼓励类的重用，它提供了一种明确表述共性的方法。
对象的一个新类可以从现有的类中派生，这个过程称为类继承。新类继承了原始类的特性，新类称为原始类的派生类（子类），
而原始类称为新类的基类（父类）。
派生类可以从它的基类那里
继承方法和实例变量，并且类可以修改或增加新的方法使之更适合特殊的需要。
因此可以说，继承是为了重用父类代码，同时为实现多态性作准备。
&super关键字
super和this的用法相像
this代表本类对象的引用
super代表父类的内存空间的标识。
当子父类出现同名成员时，可以用super进行区分
子类要调用父类构造函数时，可以使用super语句。
函数覆盖(Override)
子类中出现与父类一模一样的方法时，会出现覆盖操作，也称为重写或者复写。
父类中的私有方法不可以被覆盖。
在子类覆盖方法中，继续使用被覆盖的方法可以通过super.函数名获取。
覆盖注意事项：
　　&覆盖时，子类方法权限一定要大于等于父类方法权限
　　&静态只能覆盖静态。
覆盖的应用：
　　&当子类需要父类的功能，而功能主体子类有自己特有内容时，可以复写父类中的方法，
这样，即沿袭了父类的功能，又定义了子类特有的内容。
子类的实例化过程
子类中所有的构造函数默认都会访问父类中空参数的构造函数
因为每一个构造函数的第一行都有一条默认的语句super();
子类会具备父类中的数据，所以要先明确父类是如何对这些数据初始化的。
当父类中没有空参数的构造函数时，子类的构造函数必须通过this或者super语句指定要访问的构造函数。
final关键字
final可以修饰类，方法，变量。
final修饰的类不可以被继承。
final修饰的方法不可以被覆盖。
final修饰的变量是一个常量。只能被赋值一次。
内部类只能访问被final修饰的局部变量。
抽象类概述
抽象定义：
　　&抽象就是从多个事物中将共性的，本质的内容抽取出来。
　　&例如：狼和狗共性都是犬科，犬科就是抽象出来的概念。
　　&Java中可以定义没有方法体的方法，该方法的具体实现由子类完成，该方法称为抽象方法，包含抽象方法的类就是抽象类。
抽象方法的由来：
　　&多个对象都具备相同的功能，但是功能具体内容有所不同，那么在抽取过程中，只抽取了功能定义，并未抽取功能主体，
那么只有功能声明，没有功能主体的方法称为抽象方法。
　　&例如：狼和狗都有吼叫的方法，可是吼叫内容是不一样的。所以抽象出来的犬科虽然有吼叫功能，但是并不明确吼叫的细节。
抽象&&就是忽略一个主题中与当前目标无关的那些方面，以便更充分地注意与当前目标有关的方面。
(就是把现实世界中的某一类东西，提取出来，用程序代码表示，抽象出来一般叫做类或者接口。)抽象并不打算了解全部问题，
而只是选择其中的一部分，暂时不用部分细节。抽象包括两个方面，一是数据抽象，二是过程抽象。
数据抽象&&就是用代码的形式表示现时世界中一类事物的特性，就是针对对象的属性。
比如建立一个鸟这样的类，鸟都有以下属性：一对翅膀、两只脚、羽毛等。抽象出来的类都是鸟的属性，或者成员变量。
过程抽象&&就是用代码形式表示现实世界中事物的一系列行为，就是针对对象的行为特征（方法）。
比如鸟会飞、会叫等。抽象出来的类一般都是鸟的方法。
抽象类的特点
抽象类和抽象方法必须用abstract关键字来修饰。
抽象方法只有方法声明，没有方法体，定义在抽象类中。
　　&格式：修饰符 abstract 返回值类型&& 函数名(参数列表) ;
抽象类不可以被实例化，也就是不可以用new创建对象。原因如下：
　　&抽象类是具体事物抽取出来的，本身是不具体的，没有对应的实例。例如：犬科是一个抽象的概念，真正存在的是狼和狗。
　　&而且抽象类即使创建了对象，调用抽象方法也没有意义。
抽象类通过其子类实例化，而子类需要覆盖掉抽象类中所有的抽象方法后才可以创建对象，否则该子类也是抽象类。
　　　　　 &用abstract关键字修饰类:抽象类
　　　　用abstract关键字修饰方法：抽象方法
　　　　抽象类必须被继承，抽象方法必须被重写
　　　　抽象方法只需声明，无需实现
　　　　抽象类不能被实例化，抽象类不一定要包含抽象方法
　　　　若类中包含抽象方法，给类必须被定义为抽象类
&&& interface {}
接口中的成员修饰符是固定的。
　　&成员常量：public static final
　　&成员函数：public abstract
　　&发现接口中的成员都是public的。
接口的出现将&多继承&通过另一种形式体现出来，即&多实现&。
&接口的特点
接口是对外暴露的规则。
接口是程序的功能扩展。
接口的出现降低耦合性。
接口可以用来多实现。
类与接口之间是实现关系，而且类可以继承一个类的同时实现多个接口。
接口与接口之间可以有继承关系。
接口是抽象类的一种，只包含常量和方法的定义，没有变量和方法的实现，且其方法都是抽象方法。
　　　　用处体现在：
　　　　　　通过接口，实现不相关类的相同行为
　　　　　　通过接口，指明多个类需要实现的方法
　　　　　　通过接口，了解对象的交互界面，无需了解对象所对应的类
　　　　接口的实现：
　　　　　　在类的声明中用implements子句来表示一个类使用某个接口
　　　　　　类体中可以使用接口中定义的常量，必须实现接口中定义的所有方法
　　　　　　一个类可以实现多个接口，在implements中用逗号隔开
　　　　接口类型的使用：
　　　　　　接口作为一种引用类型来使用
　　　　　　任何实现该接口的类的实例，都可以存储在该接口类型的变量中，通过这些实例，访问该类接口中的方法。
接口与抽象类
都是不断抽取出来的抽象的概念
抽象类体现继承关系，一个类只能单继承
接口体现实现关系，一个类可以多实现
抽象类是继承，是 "is a "关系
接口是实现，是 "like a"关系
抽象类中可以定义非抽象方法，供子类直接使用
接口的方法都是抽象，接口中的成员都有固定修饰符
定义：某一类事物的多种存在形态。
　　例：动物中猫，狗。
　　猫这个对象对应的类型是猫类型
　　　　&猫 x = new 猫();
　　同时猫也是动物中的一种，也可以把猫称为动物。
　　　　&动物& y = new 猫();
　　　　&动物是猫和狗具体事物中抽取出来的父类型。
　　　　父类型引用指向了子类对象。
void callme() {
System.out.println("Inside A‘s callme()) method");
class B extends A {
void callme() {
System.out.println("Inside B‘s callme() method");
public class Dispatch {
public static void main(String args[]) {
A a = new B(); // 引用子类的实例
a.callme();
程序中体现：
　　父类或者接口的引用指向或者接收自己的子类对象。
好处和作用：
　　多态的存在提高了程序的扩展性和后期可维护性
　　&需要存在继承或者实现关系
　　&要有覆盖操作
子类继承父类后，同一个方法有不同的表现
　　体现在两个方面：方法重载实现的静态多态性（编译时多态），方法重写实现的动态多态性（运行时多态）
　 & 重写方法的调用原则：子类重写父类的方法，调用子类方法；反之，调用父类的方法
多态的特点
成员函数：
　　&编译时：要查看引用变量所属的类中是否有所调用的成员。
　　&在运行时：要查看对象所属的类中是否有所调用的成员。
成员变量：
　　&只看引用变量所属的类。
多态指是的子类对象可以直接赋给父类变量，但运行时依然表现出子类的行为特征
多态性是指允许不同类的对象对同一消息作出响应。多态性包括参数化多态性和包含多态性。
多态性语言具有灵活、抽象、行为共享、代码共享
的优势，很好的解决了应用程序函数同名问题。总的来说，方法的重写、重载与动态链接构成多态性。
Java引入多态的概念原因之一就是弥补
类的单继承带来的功能不足。（为规避C++中多继承造成的复杂继承问题，java采用单继承。）
动态链接&&对于父类中定义的方法，如果子类中重写了该方法，那么父类类型的引用将会调用子类中的这个方法，这就是动态链接。
注意：继承与重载：一是子类与父类的关系，二是重载方法的调用问题。
子类对象可以直接当成父类对象使用，但反过来就不可以。举例来说，人是父类，学生是人的子类，
所以学生对象一定具备人对象的属性，但是人对象就未必具有学生对象的特性。
所以学生对象可以当做人对象来使用，但是人对象就不能当做学生对象使用。
注意当把子类对象当成父类对象使用时，子类对象将失去所有的子类特性，
只保留与父类同名的属性和方法（同名方法不仅是函数名相同，而且参数类型也要一样，否则不予
保留）。此时可以对父类方法进行重写。
一个类中如果定义了重载的方法，则系统在调用方法时，会根据参数的类型自动选择调用合适的方法。
将一个类定义在另一个类的里面，对里面那个类就称为内部类（内置类，嵌套类）。
访问特点：
　　&内部类可以直接访问外部类中的成员，包括私有成员。
　　&而外部类要访问内部类中的成员必须要建立内部类的对象。
&内部类的位置
内部类定义在成员位置上
　　&可以被private static成员修饰符修饰。
　　&被static修饰的内部类只能访问外部类中的静态成员。
内部类定义在局部位置上
　　&也可以直接访问外部类中的成员。
　　&同时可以访问所在局部中的局部变量，但必须是被final修饰的。
&匿名内部类
就是内部类的简化写法。
　　&内部类可以继承或实现一个外部类或者接口。
　　&new 外部类名或者接口名(){覆盖类或者接口中的代码，(也可以自定义内容。)}
简单理解：
　　&就是建立一个带内容的外部类或者接口的子类匿名对象。
什么时候使用匿名内部类呢？
通常在使用方法是接口类型参数，并该接口中的方法不超过三个时，可以将匿名内部类作为参数传递。
增强阅读性。
匿名内部类示例：
abstract class A {
abstract public void fun1();
class Outer {
public static void main(String[] args) {
new Outer().callInner(new A() {
public void fun1() {
System.out.println("implement for fun1");
public void callInner(A a) {
异常的体系
　　&Throwable
　　　　&Error
　　　　　　&通常出现重大问题如：运行的类不存在或者内存溢出等。
　　　　　　&不编写针对代码对其处理
　　　　&Exception
　　　　　　&在运行时运行出现的一种情况，可以通过try catch finally
lException和Error的子类名都是以父类名作为后缀。
Java在设计异常体系时，将容易出现的情况都封装成了对象。
Throwable中的方法
&getMessage()
　　&获取异常信息，返回字符串。
toString()
　　&获取异常类名和异常信息，返回字符串。
printStackTrace()
　　&获取异常类名和异常信息，以及异常出现在程序中的位置。返回值void。
printStackTrace(PrintStream&s)
　　&通常用该方法将异常内容保存在日志文件中，以便查阅。&
throws和throw
throws用于标识函数暴露出的异常。
throw用于抛出异常对象。
throws与throw的区别：
　　&thorws用在函数上，后面跟异常类名。
　　&throw用在函数内，后面跟异常对象。
定义功能方法时，需要把出现的问题暴露出来让调用者去处理。那么就通过throws在函数上标识。
在功能方法内部出现某种情况，程序不能继续运行，需要进行跳转时，就用throw把异常对象抛出。
& 需要检测的代码；
catch(异常类& 变量)
& 异常处理代码；
& 一定会执行的代码；&
Finally代码块只有一种情况不会被执行。就是在之前执行了System.exit(0)。
处理过程：
Try中检测到异常会将异常对象传递给catch，catch捕获到异常进行处理。
Finally里通常用来关闭资源。比如：数据库资源，IO资源等。
需要注意：try是一个独立的代码块，在其中定义的变量只在该变量块中有效。
如果在try以外继续使用，需要在try建立引用。在try对其进行初始化。IO，Socket就会遇到。
自定义异常
自定义类继承Exception或者其子类。
通过构造函数定义异常信息。
Class DemoException extends Exception
& DemoException(String message)
& super(message);
通过throw将自定义异常抛出。
RuntimeException以及其子类如果在函数中被throw抛出，可以不用在函数上声明。
一个方法被覆盖时，覆盖它的方法必须抛出相同的异常或异常的子类。
如果父类抛出多个异常，那么重写（覆盖）方法必须抛出那些异常的一个子集，不能抛出新的异常。
介绍异常在分层设计时的层内封装。
包(package)
对类文件进行分类管理。
给类提供多层命名空间。
写在程序文件的第一行。
类名的全称的是& 包名.类名。
包也是一种封装形式。
给JVM提供的一个环境变量。
指定类或者包所在的路径。
&包之间的访问
被访问的包中的类权限必须是public的。
类中的成员权限：public或者protected
protected是为其他包中的子类提供的一种权限
一个程序文件中只有一个package，可以有多个import。
用来导包中的类，不导入包中的包。
Java的压缩包
　　&方便项目的携带。
　　&方便于使用，只要在classpath设置jar路径即可。
　　&数据库驱动，SSH框架等都是以jar包体现的。
&Jar包的操作
通过jar.exe工具对jar的操作。
　　&创建jar包
　　　　&jar& -cvf& mypack.jar& packa packb
　　&查看jar包
　　　　&jar& -tvf& mypack.jar&& [&定向文件]
　　&解压缩
　　　　&jar& -xvf& mypack.jar
　　&自定义jar包的清单文件
　　　　&jar &cvfm& mypack.jar& mf.txt& packa packb
c：创建压缩文档。
f：制定存档名称。
v：显示详细信息。
m：加入自定义清单信息。
通常应用与Java制作的图形界面程序。在清单文件中其中定一个Main-Class:空格 带有主函数的类名回车
在设置一下jar文件的打开方式通过javaw &jar就可以双击执行了。
&&国之画&&&& &&
版权所有 京ICP备号-2
迷上了代码！