Exception in thread "main" org.hibernate.MappingException: Unknown entity: java.lang.Object

superclass[英]["sju:pu0259klɑ:s][美]["sju:pu0259u02ccklɑ:s]n.超类; 总纲; 母集合; 超纲; 双语例句英英释义1Also, each subclass inherits methods from the superclass.同时，每个亚纲继承来自总纲的方法。2The abstract superclass defines and may partially implement the behavior, but much of the class is undefined and unimplemented.抽象的总纲而且下定义可能部份地履行行为，但是许多类别是未阐明的：未解释的和未实施的。

好。1、合法平台。superclass英语平台是杭州班超Superclass科技有限公司推出的英语学习平台，是经过许可经营的合法平台。2、教学质量好。superclass英语平台所聘用的教师都是硕士类教师，教学资历丰富，整体的教学水平高，所以superclass英语平台好。

是父类。超类(SuperClass) ：用java术语来讲,被继承的类称为超类(SuperClass)，也有叫做父类，继承的类称为子类。比如：java">public class A{//定义类A}public class B extends A{//定义类B，继承类A}则，类A就是超类或父类，类B叫子类

你太聪明了

父类。 也就是从那个类继承。

"SuperClass("+n+")""SuperClass("：表示字符串SuperClass(，双引号括起来的都是字符串+n+：n表示变量，+号表示字符串连接")"：表示字符串)举例：如果n等于4，则这个拼接的串就是SuperClass(4)

导语：传统课堂是什么?是大便;名校教师是什么?是bullshit(牛屎);中国的传统教育是什么?其实就是“逗你玩”。光是什么?电是什么?电流是如何产生的?你不知道?糟糕!传统教育又在“坑爹伤娘了”!现年28岁的超级课堂CEO杨平明决定用自己的“超级课堂”颠覆传统教育培训业，他的教育培训公司现在一年已做到2000万元的营收。　　A对自己小学语文老师没啥印象了，但这位老师讲过一个苏东坡沾花惹草的故事，让A极度迷恋，于是他就记住了这位老师。但后来，他发现，语文根本不是“烟花柳巷”，A提不起一点兴趣，这是他受教育生涯以来的第一次打击。　　后来，A渐渐长大，考上了浙江大学，兴趣随即转移到了计算机上面。什么C+, java一大堆乱七八糟的东西他都学，每天12个小时全窝在课堂。但那些老师什么都不讲，教你C语言却不教你编程，比如说 “贪吃蛇”是怎么出来的，他就是不告诉你。几年过去，A由一个“电脑狂人”变成了一个 “电脑白痴”。　　A就是如今超级课堂的创始人杨平明。　　据杨平明说，超级课堂现在在杭州和上海开了5家分支机构，每年的营收超过了2000万元，然而这个帅气、儒雅的80后老板其实是个“暴发户”——他最早是开饭馆的。　　开饭店：十几万才够亏一年　　在杭州浙江大学的校园里，有一家餐馆叫星空餐厅——是浙大学生聚餐的首选，一到毕业时节，这里的生意尤其兴旺，当然也同时有表白、醉酒等表演，作为这家餐馆的幕后老板，杨平明时常还来视察一番，顺带温故一下自己的青葱岁月。　　其实这个餐厅最早是杨的学长开的，装修、房租共花了27万元。尽管背靠浙大，饭馆的生意不好做，三个月就逼得这位学长忍痛割爱，愿意以6万元的“白菜价”转手。杨平明一听到消息，马上就打起“哈哈”：“六万!这么便宜!”认为这是个大便宜的他刚上大三，家境一般，杨平明四处找亲戚借钱，最终还找来几个合伙人才把钱的事情搞定。随后，他们找来一个厨师，挂上餐馆牌匾，饭店就算开张了，接着，饭店合伙人开始了“集体唱洋戏”的历程。　　杨平明当初以为拿下饭馆后，就能“坐地收钱”，于是什么手续也没办，卫生许可证，财务证，环保证三样全缺，营业执照被“高高挂起”。　　结果工商局的队伍来查时，杨眼睁睁地看着他们把店里的包厢用锤子全部砸掉，他的心里在淌血。还没完，饭馆违规还得罚钱，唯一让杨心里宽慰的是罚款额度相当大，从两百到两万，于是他好话说尽，才没让自己破大财。　　当时，店里只有一个员工，那就是厨师，其余均为“董事长”。杨平明当时以为有厨师了就能开饭店，所以，待到开业那天，就一股脑儿把所有朋友都请了过来，结果把厨师吓坏了。配菜，切菜，服务员一概没有，倒是请来的一班客人有说有笑。那一天，店里的厨师格外值得同情，左手拿菜刀，右手拎锅铲，两头忙乎，被迫干起了“全职”。　　那一晚，杨平明洗碗洗到了凌晨3点。　　后来，杨平明终于明白自己是个“傻帽”，当年那位学长就是不忍自己再亏钱，所以才把烂摊子低价甩给了他。店子开张后，累积的客户并不多，一年下来，杨平明开饭馆就像“走泥丸”，一分没赚还往里倒贴了十几万。　　开业初期，由于厨师劳苦功高，杨平明非常感激又信任，于是经常是把票子扔给厨师，自己跑去上课了。时间一长，杨平明钱包越来越薄，感觉很不对劲，有了查账的冲动。所以，以后每天的凌晨四五点，杨平明亲自跑菜市场，亲自用麻袋裹菜，就像古时候镖局的“镖头”一样，并且每次都必过校园。　　为了让饭馆生意尽快扭亏为盈，杨什么招都想了，世界杯促销，换厨师、菜系……一次偶然的机会，他听说火锅利润挺高，于是转做火锅，结果第一天的营业额就达到了12000元，随后生意如芝麻开花节节高。他说，浙大的学生有啥聚会都会到星空餐厅，一来餐厅的环境比较“学生气”，二来他们的服务比较贴心，比如喝醉了啥的照应得很好。　　我们问他，为何不把如此好生意的餐厅规模和连锁化，他苦笑：开餐馆累啊……　　做教育：有钱人更愿意掏钱　　把餐馆小老板的光荣任务交给自己的姐姐后，杨平明毕业去了银行工作，那是有钱人最爱去的地方，慢慢地他摸索出了一条规律，有钱人的孩子学习成绩普遍不好，而家长又挺上心。另外，杨的一个朋友也要在郊区做培训，这不，杨这次又“从善如流”了。　　新店开业第一天，就来了两个大客户，在店里甩下12万块钱，千叮咛万嘱咐，一定要把孩子教好。当然，由此可以想象，这两孩子的学习基础基本就是豆腐渣，分子分母约分都不会。这个价位杨开店得开几个月，而现在一天就全赚回来了。　　杨火急火燎地跑到母校浙大，请来了几个在读博士，这是创业以来的第一桶金，可不能搞砸了。但后来发现，两博士也教得不怎么样，杨就硬着头皮自己上了。　　就这样，杨赚得越来越多，老师的待遇也跟着上来，一般是7000-30000不等，对于刚毕业的大学生来说，这算是“天价”工资了。　　杨一直怀念那位讲东坡艳遇故事的老师，觉得上课就得像这样，不然就是大便，是bullshit，是牛屎，所以杨招聘的老师都有点才。有的讲着讲着课，就冷不丁地扯到罗马 史。 杨喜欢玩“穿越”，每次上课情到深处，都会来几句爱因斯坦时空穿梭，那些小屁 孩对课程没点兴趣，就只爱“穿梭”，每次课后都刨根究底，一定得弄明白。除此之外，杨要求所有的老师都要用故事去教学，老师要自己动笔写剧本，剧本也不能胡来乱编，要有认知学，心理学的逻辑在里面。　　由于，杨惯行的是一对一精英教育，在中学一个老师一年才能把教材过一遍，而在这里，一个老师一年能讲几百次。几年过去，这些老师都已经达到炉火纯青的境界，翅膀也慢慢长硬，觉得该去“海阔天空”了，于是陆陆续续，优秀的人才开始外流。　　又一个陷阱　　老师都要走怎么办?杨平明也很无奈，家长付两百学费，顶多顶多分一百出去，否则自己就吃亏了。后来，杨想，要是把老师的课程用视频录下来，就算是人走了，茶也不会凉。其实，这就是现在的E-learnin(网络教育)。　　做E-learning特别赚钱，简简单单建一个网站，然后请一些名校的老师过来录一段视频，价格在500-2000块不等，前期的总成本也就20-30万，但一年的总销售额能达到2000-3000万。杨一想到这里，内心又是无比激动。　　近几年，传统网络教育风生水起，不过新陈代谢速度严重超标，起得快，死得也快，往年有滋有味的黄冈网校现在基本被挤出市场。国外也是如此，哈弗，耶鲁公开课程之前在行业内一直无人敢叫板，现在虽然依旧名声在外，但真正会去看的人很少。　　他们第一年很赚钱，招许多人就忙着打电话，把孩子家长都叫来，开一个气势宏大的“动员大会”：“在座的各位，我已知晓你们心急如焚，这里汇集了全国名师的教学视频，只要你花个2万块钱，课程全部带回家。”　　那家长一听就乐晕了，名校花多少钱都塞不进去，两万块的数目相比之下就是九牛一毛，赶紧地“拉下皮条”，掏钱就买。结果买回家来，孩子连五分钟都看不下去。等到第二年，这些传统E-learning企业就走到了绝路，再去打电话时，家长就像听见“狼来了”，死都不肯去。　　这一次，杨平明幸亏有了先知，否则又可能掉进了“钱眼”。　　做网络教育：上课应该像看电影　　怎么才能不把传统E-learning做死?杨自己深有体会，因为报过新东方，里面赠送的flash，难看得要命，杨苦苦煎熬半小时，至少得看上两个小时电影才能把内心的阴影完全去除。他就想，一个视频在十秒钟之内如果没有抓住受众的兴趣点，别人就会pass掉。传统教育下的学生就像在“坐牢”，好不容易上上网玩会，再去拿视频折腾人家，太不人道了。　　根据这个想法，杨平明创立了superclass，也是录视频，但是在录什么的问题上，他一度绞尽脑汁。之前做精英教育的时候积累了不少经验，比如说写故事，写剧本，绝对地用生动的方式传授知识。　　也就是这个时候，杨的合伙人从国外回来，也顺便带回一个好莱坞女朋友，但这个女朋友可不得了，职业是做电影特效，几年前的大片《赤壁》特效就是她做的。后来的国产大片都以此为荣，《新西游记》，《画壁》虽然都是狗血的剧情，但“好莱坞特效”五个大字，把国内的观众一下子忽悠到了国外。“少壮不努力，一生在内地”，观众看电影也是有追求的。　　酷，炫，学生一看到superclass的视频都傻了眼，一节课十几分钟，但是包含的内容很充足。初中物理一般的老师两年都讲不完，而杨这套课程100分钟就讲完了，关键是学生还喜欢。有一次，杨带着自己的产品来到浙江卫视，打算要他们帮自己做一个现场栏目，结果拿出来后把他们震住了，这个“单”浙江卫视最后没敢接。　　名校老师就是牛屎　　杨把教育做火了，好多名校的老师校长都来应聘过，但是没有能成功的。之前有一个英语老师来应聘，教高三的，杨想让他说个自我介绍，他唧唧歪歪了大半会，结果什么都不会，这让杨多年沉积在内心的“毒瘤”轰然崩裂。　　现在superclass的网站才刚建了个雏形，像是在“开中药铺”，只是把视频挂在了窗口上，仅此而已。实体教育一对一的模式持续性不强，学生对老师的依赖性很大，而且力量有限，能改变少部分人，但改变不了世界。杨的团队开发出了一个优盘，里面有精心录制的课程，有密码，一般人不能盗用。学生报了名，既能在店里上课，又能把整套产品带走，目前还没拉到线上卖。但从流量上看，superclass已经把做了5-10年的elearning的企业打败了。　　后续还有许多sns功能在开发，比如学生一点击就能直接与老师视频，还有综合能力排行榜，根据上课，考试等情况计算学生的综合分数，每个学生都能看见自己的位置。　　杨对产品很有信心，以后会找代理商来卖，利润五五分成，于是代理商络绎不绝：哇塞，这块肉太肥了!其中就包括湖南卫视的快乐购，杨希望把这些资源全部整合起来，然后以superclass的教育理念改变世界。　　他有一个梦想　　杨这次从上海大老远跑到北京，就像找个能理解自己的投资人。员工很理解，经常说要把老爸的私房钱拿出来支援杨，杨感动的都要哭了。华睿资本就很理解superclass，帮他们介绍会计，帮他们如何应付投资商检查。　　前几天，真格基金与杨进行了接洽，他说有点遗憾，徐小平自己没过来，只有个老外表示很理解自己，真是个悲哀。他有一个梦想，那就是建成一个多功能影院，灯光一灭，就是豪华大片，是超级课堂，灯光一亮，所有的老师各霸一方开始与学生互动。这秘诀就像可口可乐的秘方一样，要想山寨的企业都是慢性服毒自杀。

你是有C++的基础还是C的基础?class subClass extends superClass是subClass 继承superClass的意思Bank 是另外一个叫Bank 的类.在Bank 类中定义了someMethod方法

同意楼上wgaby的观点, 其给出的代码也是正确的,就不在写一次了

您好 您调用max类的方法的时候 没有传入数组参数啊 望采纳 谢谢

public class JavaProgram011 { public static void main(String [] args) { SubClass b=new SubClass(); b.printAll(); }}class SuperClass{ private int i=16; private char c=65; public void myPrint() { System.out.println("i="+i+",c="+c); }}class SubClass extends SuperClass{ private double d=16.0; private String s="Java Program Tesst"; public void myPrint() { System.out.println("d="+d+",s="+s); } public void printAll() { super.myPrint(); this.myPrint(); }}

是super classic e-bike吧？这是不摩托车的品牌，而是超级复古电动自行车、超级经典电动自行车之类的意思，一般是用作摩托车或电动车上的装饰贴花，而不是车的品牌，也可能是某个摩托车上的装饰贴花，如超级经典摩托车的意思。

是在继承当中，默认加载在重写方法中的，默认先调用父类的方法。先执行父类的方法在执行子类的方法。可以理解为，子类方法调用父类方法，是写在方法体的最上方。如果super()表示调用父类的构造函数，super.method表示调用父类中的函数(非构造函数)。这里是调用java.awt.Frame的构造函数。

结果：SuperClass::constructor: data=0SuperClass::constructor: data=2SubClass::constructor: data=2SubClass::constructor: data=618

界：kingdom门：phylum纲：class目：order科：family属：genus种：species要说亚什么，在这些词前面加sub- 。例如亚门就是subphylum。

这个是因为默认就是这个父类，要其它的只需要点右边的Browse删除掉里面已选的java,lang就行了，这相当于是个过滤选择

因为getClass和super一起用没意义，因为super表示的是继承关系下的父类引用，用来访问父类的方法，但是getClass（）是final和native的，final表示就是不能被重写，也就是说他根本没有父类的可以选用，你调的永远都是当前对象的getClass（）方法；native表示用的是源生c的代码写的，所以没必要了解具体的，知道不能得到你想要的就可以了

要把代码发现来才知道，以下是常见的错误下面终于要讲到当你用到更多的Python的功能（数据类型，函数，模块，类等等）时可能碰到的问题了。由于篇幅有限，这里尽量精简，尤其是对一些高级的概念。要想了解更多的细节，敬请阅读Learning Python, 2nd Edition的“小贴士”以及“Gotchas”章节。打开文件的调用不使用模块搜索路径当你在Python中调用open()来访问一个外部的文件时，Python不会使用模块搜索路径来定位这个目标文件。它会使用你提供的绝对路径，或者假定这个文件是在当前工作目录中。模块搜索路径仅仅为模块加载服务的。不同的类型对应的方法也不同列表的方法是不能用在字符串上的，反之亦然。通常情况下，方法的调用是和数据类型有关的，但是内部函数通常在很多类型上都可以使用。举个例子来说，列表的reverse方法仅仅对列表有用，但是len函数对任何具有长度的对象都适用不能直接改变不可变数据类型记住你没法直接的改变一个不可变的对象（例如，元组，字符串）：T = (1, 2, 3)T[2] = 4 # 错误用切片，联接等构建一个新的对象，并根据需求将原来变量的值赋给它。因为Python会自动回收没有用的内存，因此这没有看起来那么浪费：T = T[:2] + (4,) # 没问题了: T 变成了 (1, 2, 4)使用简单的for循环而不是while或者range当你要从左到右遍历一个有序的对象的所有元素时，用简单的for循环（例如，for x in seq:）相比于基于while-或者range-的计数循环而言会更容易写，通常运行起来也更快。除非你一定需要，尽量避免在一个for循环里使用range：让Python来替你解决标号的问题。在下面的例子中三个循环结构都没有问题，但是第一个通常来说更好；在Python里，简单至上。S = "lumberjack"for c in S: print c # 最简单for i in range(len(S)): print S[i] # 太多了i = 0 # 太多了while i < len(S): print S[i]; i += 1不要试图从那些会改变对象的函数得到结果诸如像方法list.append()和list.sort()一类的直接改变操作会改变一个对象，但不会将它们改变的对象返回出来（它们会返回None）；正确的做法是直接调用它们而不要将结果赋值。经常会看见初学者会写诸如此类的代码：mylist = mylist.append(X)目的是要得到append的结果，但是事实上这样做会将None赋值给mylist，而不是改变后的列表。更加特别的一个例子是想通过用排序后的键值来遍历一个字典里的各个元素，请看下面的例子：D = {...}for k in D.keys().sort(): print D[k]差一点儿就成功了——keys方法会创建一个keys的列表，然后用sort方法来将这个列表排序——但是因为sort方法会返回None，这个循环会失败，因为它实际上是要遍历None（这可不是一个序列）。要改正这段代码，将方法的调用分离出来，放在不同的语句中，如下：Ks = D.keys()Ks.sort()for k in Ks: print D[k]只有在数字类型中才存在类型转换在Python中，一个诸如123+3.145的表达式是可以工作的——它会自动将整数型转换为浮点型，然后用浮点运算。但是下面的代码就会出错了：S = "42"I = 1X = S + I # 类型错误这同样也是有意而为的，因为这是不明确的：究竟是将字符串转换为数字（进行相加）呢，还是将数字转换为字符串（进行联接）呢？在Python中，我们认为“明确比含糊好”（即，EIBTI（Explicit is better than implicit）），因此你得手动转换类型：X = int(S) + I # 做加法: 43X = S + str(I) # 字符串联接: "421"循环的数据结构会导致循环尽管这在实际情况中很少见，但是如果一个对象的集合包含了到它自己的引用，这被称为循环对象（cyclic object）。如果在一个对象中发现一个循环，Python会输出一个[…]，以避免在无限循环中卡住：>>> L = ["grail"] # 在 L中又引用L自身会>>> L.append(L) # 在对象中创造一个循环>>> L["grail", [...]]除了知道这三个点在对象中表示循环以外，这个例子也是很值得借鉴的。因为你可能无意间在你的代码中出现这样的循环的结构而导致你的代码出错。如果有必要的话，维护一个列表或者字典来表示已经访问过的对象，然后通过检查它来确认你是否碰到了循环。赋值语句不会创建对象的副本，仅仅创建引用这是Python的一个核心理念，有时候当行为不对时会带来错误。在下面的例子中，一个列表对象被赋给了名为L的变量，然后L又在列表M中被引用。内部改变L的话，同时也会改变M所引用的对象，因为它们俩都指向同一个对象。>>> L = [1, 2, 3] # 共用的列表对象>>> M = ["X", L, "Y"] # 嵌入一个到L的引用>>> M["X", [1, 2, 3], "Y"]>>> L[1] = 0 # 也改变了M>>> M["X", [1, 0, 3], "Y"]通常情况下只有在稍大一点的程序里这就显得很重要了，而且这些共用的引用通常确实是你需要的。如果不是的话，你可以明确的给他们创建一个副本来避免共用的引用；对于列表来说，你可以通过使用一个空列表的切片来创建一个顶层的副本：>>> L = [1, 2, 3]>>> M = ["X", L[:], "Y"] # 嵌入一个L的副本>>> L[1] = 0 # 仅仅改变了L，但是不影响M>>> L[1, 0, 3]>>> M["X", [1, 2, 3], "Y"]切片的范围起始从默认的0到被切片的序列的最大长度。如果两者都省略掉了，那么切片会抽取该序列中的所有元素，并创造一个顶层的副本（一个新的，不被公用的对象）。对于字典来说，使用字典的dict.copy()方法。静态识别本地域的变量名Python默认将一个函数中赋值的变量名视作是本地域的，它们存在于该函数的作用域中并且仅仅在函数运行的时候才存在。从技术上讲，Python是在编译def代码时，去静态的识别本地变量，而不是在运行时碰到赋值的时候才识别到的。如果不理解这点的话，会引起人们的误解。比如，看看下面的例子，当你在一个引用之后给一个变量赋值会怎么样：>>> X = 99>>> def func():... print X # 这个时候还不存在... X = 88 # 在整个def中将X视作本地变量...>>> func( ) # 出错了！你会得到一个“未定义变量名”的错误，但是其原因是很微妙的。当编译这则代码时，Python碰到给X赋值的语句时认为在这个函数中的任何地方X会被视作一个本地变量名。但是之后当真正运行这个函数时，执行print语句的时候，赋值语句还没有发生，这样Python便会报告一个“未定义变量名”的错误。事实上，之前的这个例子想要做的事情是很模糊的：你是想要先输出那个全局的X，然后创建一个本地的X呢，还是说这是个程序的错误？如果你真的是想要输出这个全局的X，你需要将它在一个全局语句中声明它，或者通过包络模块的名字来引用它。默认参数和可变对象在执行def语句时，默认参数的值只被解析并保存一次，而不是每次在调用函数的时候。这通常是你想要的那样，但是因为默认值需要在每次调用时都保持同样对象，你在试图改变可变的默认值（mutable defaults）的时候可要小心了。例如，下面的函数中使用一个空的列表作为默认值，然后在之后每一次函数调用的时候改变它的值：>>> def saver(x=[]): # 保存一个列表对象... x.append(1) # 并每次调用的时候... print x # 改变它的值...>>> saver([2]) # 未使用默认值[2, 1]>>> saver() # 使用默认值[1]>>> saver() # 每次调用都会增加！[1, 1]>>> saver()[1, 1, 1]有的人将这个视作Python的一个特点——因为可变的默认参数在每次函数调用时保持了它们的状态，它们能提供像C语言中静态本地函数变量的类似的一些功能。但是，当你第一次碰到它时会觉得这很奇怪，并且在Python中有更加简单的办法来在不同的调用之间保存状态（比如说类）。要摆脱这样的行为，在函数开始的地方用切片或者方法来创建默认参数的副本，或者将默认值的表达式移到函数里面；只要每次函数调用时这些值在函数里，就会每次都得到一个新的对象：>>> def saver(x=None):... if x is None: x = [] # 没有传入参数？... x.append(1) # 改变新的列表... print x...>>> saver([2]) # 没有使用默认值[2, 1]>>> saver() # 这次不会变了[1]>>> saver()[1]其他常见的编程陷阱下面列举了其他的一些在这里没法详述的陷阱：在顶层文件中语句的顺序是有讲究的：因为运行或者加载一个文件会从上到下运行它的语句，所以请确保将你未嵌套的函数调用或者类的调用放在函数或者类的定义之后。reload不影响用from加载的名字：reload最好和import语句一起使用。如果你使用from语句，记得在reload之后重新运行一遍from，否则你仍然使用之前老的名字。在多重继承中混合的顺序是有讲究的：这是因为对superclass的搜索是从左到右的，在类定义的头部，在多重superclass中如果出现重复的名字，则以最左边的类名为准。在try语句中空的except子句可能会比你预想的捕捉到更多的错误。在try语句中空的except子句表示捕捉所有的错误，即便是真正的程序错误，和sys.exit()调用，也会被捕捉到。

getGenericSuperclass 返回表示此 Class 所表示的实体（类、接口、基本类型或 void）的直接超类的 Type

呵呵，，很简单，就是java的反射机制。使用的方法为getSuperclass().getName()

在父类的构造方法中，获取泛型的具体类型import java.lang.reflect.ParameterizedType;import java.lang.reflect.Type;import com.opensymphony.xwork2.ModelDriven;/*** 工具类直接返回ModelDriven的对象*/public class ModelBaseAction<T> extends BaseAction implements ModelDriven<T> {protected T model;/*** 通过反射，获取泛型的具体类型并实例化这个类型*/public ModelBaseAction() {// 获取反射的类型java.lang.reflect.Type cls = super.getClass().getGenericSuperclass();if (cls instanceof ParameterizedType) {ParameterizedType pt = (ParameterizedType) cls;// 获取所有放到泛型里面的类型Type[] tps = pt.getActualTypeArguments();System.err.println(tps[0].getTypeName());try {// 实例化这个泛型所代表的类对象model = (T) Class.forName(tps[0].getTypeName()).newInstance();} catch (Exception e) {throw new RuntimeException("没有默认构造方法", e);}}}@Overridepublic final T getModel() {return model;}}

这篇文章主要介绍了JavaScript实现多重继承的方法,结合实例形式详细分析了javascript实现多重继承的具体步骤与相关操作技巧,需要的朋友可以参考下本文实例讲述了JavaScript实现多重继承的方法。分享给大家供大家参考，具体如下：1. 定义一个空的父类构造函数，然后通过prototype的方式为该父类定义属性和方法2. 定义一个空的子类的构造函数，然后将子类的原型绑定在父类的实例上，再将子类原型的父类也绑定在父类的实例上。通过prototype的方式为子类设置自己的属性和方法。3. 定义一个空的孙类构造函数，然后将孙类的原型绑定到子类的实例上，再将孙类原型的父类绑定到子类的实例上。通过prototype方式为孙类定义自己的属性和方法。4. 实例化一个孙类对象，通过调用该实例对象，调用自身的方法，也可以调用孙类的父类即文中的子类的方法，也可直接调用最大父类即这里父类的方法，也可以为当前对象添加属性和方法。function Person(){}Person.prototype.name = "人";// 为人类创建一个name属性Person.prototype.say = function(content){// 为人类创建一个说话的方法 if(!this.name){ // 如果对象不存在name属性，则使用原型链的name this.name = this.__proto__.name; } console.log("我是" + this.name + ",我想说"+content);};function Parent(){}Parent.prototype = new Person(); // 设置Parent类继承Person类Parent.prototype.superClass = new Person();// 设置superClass保存父类Person的方法属性Parent.prototype.name = "父辈类";// 设置Parent类的name属性Parent.prototype.say = function(){// 设置Parent类自己的 say 方法 console.log("我是Parent类的say方法！");};function Child(){}Child.prototype = new Parent();// 设置Child类继承Parent类Child.prototype.superClass = new Parent();// 设置superClass保存父类Parent的方法属性Child.prototype.say = function(){ //设置Child类自己的say方法 console.log("我是Child类的say方法！");}var c = new Child();// 实例化一个Child对象c.say(); // 调用自身原型的say方法，输出：我是Child类的say方法！c.superClass.say(); // 调用父类Parent的say方法，输出： 我是Parent类的say方法！c.superClass.superClass.say("哈哈");// 直接调用最大的父类Person的say方法(方法中的this指向Person)，输出：我是人,我想说哈哈"// 用call调用最大的父类Person的say方法(方法中的this指向实例化对象c，但此时c并没有name属性，所以this.name用的是Parent的name)c.superClass.superClass.say.call(c,"嘻嘻"); // 输出：我是父辈类,我想说嘻嘻c.name = "子类实例";// 给当前对象增加name属性// 还是用call调用最大父类Person的say方法(此时c对象中已经有name属性);c.superClass.superClass.say.call(c,"我是子类的实例化对象"); // 输出：我是子类实例,我想说我是子类的实例化对象上面是我整理给大家的，希望今后会对大家有帮助。相关文章：在vue中使用eventBus如何实现同级组件的通讯在node.js中如何实现下载图片使用vue2.0+vue-dplayer这些技术如何实现hls播放的示例在vue2.0 + element UI 中 通过el-table 如何实现数据导出Excel详细讲解FastClick源码（详细教程）

第一个阶段: 代码如下: function A(){ this.funB = function(){ alert("A:funB"); }; } A.prototype = { funA:function(){ alert("A:funA"); } }; function B(){ } function extend(sub,parent){ sub.prototype = new parent(); sub.prototype.constructor = sub; } extend(B,A); var b = new B(); b.funA(); // out "A:funA" b.funB(); // out "A:funB" alert(b instanceof A); // out "true" 想必大家一眼就看出什么意思了，先是定义了A,B两个类，然后使用extend方法来让B继承A类。extend的原理就是让父类 new 到子类的prototype上。 用instanceof来检测也为true，想要让instanceof为true，那就必须两个类的prototype对象要为同一个object，不管是间接或直接的。 这样的方式有没有问题呢？在通常面向对象语言中，子类在继承父类时，是不会触发父类的构造函数执行,而这里是父类是在继承时执行的。 第二个阶段 代码如下: function A(){ this.Astr = "hello A"; } A.prototype = { funA:function(){ alert(this.Astr); } }; function B(){ arguments.callee.superclass && arguments.callee.superclass.apply(this,arguments); this.Bstr = "hello B"; } B.prototype = { funB:function(){ alert(this.Bstr); } }; function C(){ arguments.callee.superclass && arguments.callee.superclass.apply(this,arguments); alert(this.Astr); alert(this.Bstr); } function extend(sub,parent){ var subproto = sub.prototype; sub.prototype = parent.prototype; typeof subproto != "object" && (subproto = {}); typeof sub.prototype != "object" && (sub.prototype = {}); for(var i in subproto){ sub.prototype[i] = subproto[i]; } sub.superclass = parent; } //B 继承 A extend(B,A); //C 继承 B extend(C,B); var c = new C(); // out "hello A","hello B" c.funA(); //out "hello A" c.funB(); // out "hello B" alert(c instanceof A) // out true alert(c instanceof B) // out true; 这里对extend方法做了一些改动，这里有个约定，每个子类都拥有一个superclass的属性，用来引用她所继承的父类，用一个空函数proto来获得父类的prototype，实例化给子类的prototype，这样就没有执行父类构造器。 而是在子类的构造器中用下来一段代码来执行约定要的父类构造器。 代码如下: arguments.callee.superclass && arguments.callee.superclass.apply(this,argumengs); 这样就完成了类的继承。 对于上面的代码有没有更方便的继承写法呢，修改Function的原型来看看: 代码如下: Function.prototype.extend = function(parent){ var subproto = this.prototype; this.prototype = parent.prototype; typeof subproto != "object" && (subproto = {}); typeof this.prototype != "object" && (this.prototype = {}); for(var i in subproto){ this.prototype[i] = subproto[i]; } this.superclass = parent; return this; } function A(){ this.Astr = "hello A"; } A.prototype = { funA:function(){ alert(this.Astr); } }; var B = function(){ arguments.callee.superclass && arguments.callee.superclass.apply(this,arguments); this.Bstr = "hello B"; } B.prototype = { funB:function(){ alert(this.Astr); } }; B.extend(A); var C = function(){ arguments.callee.superclass && arguments.callee.superclass.apply(this,arguments); alert(this.Astr); alert(this.Bstr); }.extend(B); var c = new C(); // out "hello A","hello B" c.funA(); //out "hello A" c.funB(); // out "hello B" alert(c instanceof A) // out true alert(c instanceof B) // out true; 这里的extend做的事情是: subproto引用子类的原prototype ,将子类的prototype 指向 父类的prototype对象，这样就继承了父类（这样的目的是让 子类实例 instanceof 父类 为 true）。然后历遍subproto,将原prototype的成员添加到现prototype上,这样子类重名的重名的成员就会覆盖父类的成员。最后将子类的属性superclass 指向 父类。 js继承的关键就是保持原型链的唯一性，instanceof就以判断实例的__proto__是否和父类的prototype为同一Object. 作者 cnblogs OD

java中通过super来实现对父类成员访问，super用来引用当前对象的父类。super的使用有三种情况。1.访问父类被隐藏的成员变量。例如：super.variable;2.调用父类中被重写的方法。例如：super.Method([paramlist]):3.调用父类的构造函数，例如：super([paramlist]):例子：class SuperClass{ int x ; SuperClass() { x=0; System.out.println("in SuperClass:x="+x); } void member() { x=0; System.out.println("in SuperClass.member()"); }}class SubClass extends SuperClass{ int x; SubClass() { super(); //调用父类superClass的构造方法 x=6; //super()要放在犯法中的第一句 System.out.println("in SubClass:x="+x); } void member() { super.member(); //调用父类的方法 System.out.println("in SubClass.member"); System.out.println("super.x="+super.x+"sub.x="+x); }}public class AutInherit{ public static void main(String[] args) { SubClass SubC=new SubClass(); SubC.member(); }}}

1. 定义js类 js并不是一种面向对向的语言, 没有提供对类的支持, 因此我们不能像在传统的语言里那样 用class来定义类, 但我们可以利用js的闭包封装机制来实现js类, 我们来封装一个简的Shape类. 复制代码代码如下:function ShapeBase() { this.show = function() { alert("ShapeBase show"); }; this.init = function(){ alert("ShapeBase init"); }; } 这个类里定义了两个方法:show和init, 需要注意的是这里用到了this来声明, 而不是var, 因为用var是用来定义私有方法的. 另外, 我们还可以用prototype属性来定义Shape的方法. 复制代码代码如下:ShapeBase.prototype.show=function() { alert("ShapeBase show"); } ShapeBase.prototype.init=function() { alert("ShapeBase init"); } 上面这种写法看起来不太直观，我们可以将所有的方法写在一起. 复制代码代码如下:ShapeBase.prototype={ show:function() { alert("ShapeBase show"); }, init:function() { alert("ShapeBase init"); } }; 现在, 类是写好了， 让我们写个js来测试下, 看看结果是不是跟我们想象的一样呢? 复制代码代码如下:function test(src){ var s=new ShapeBase(); s.init(); s.show(); } 看到了吧, 其调用方式和C#一模一样, 而结果也如我们所料. 到目前为止, 我们学会了如何创建js的类了, 但还只是实例方法，要是实现跟C#中的静态方法要怎么做呢？ 其实, 实现js的静态方法很简单, 看下面如何实现: 复制代码代码如下://静态方法 ShapeBase.StaticDraw = function() { alert("method draw is static"); } 2. 实现JS类抽象和继承 同样, js中也不支持类继承机制，但我们可以通过将父类prototype中的成员方法复制到子类的prototype中来实现. 和类的继承一样,JavaScript也没有任何机制用于支持抽象类.但利用JavaScript语言本身的性质.可以实现自己的抽象类. 首先来看看js中的虚方法, 在传统语言中虚方法是要先定义的, 而包含虚方法的类就是抽象类,不能被实例化,而在JavaScript中，虚方法就可以看作该类中没有定义的方法，但已经通过this指针使用了. 和传统面向对象不同的是，这里虚方法不需经过声明，而直接使用了, 并且类也可以被实例化. 先定义object的extend方法, 一个为静态方法，一个为实例方法, 这两个方法用于实现继承的prototype复制 复制代码代码如下:Object.extend = function(destination, source) { for (property in source) { destination[property] = source[property]; } return destination; } Object.prototype.extend = function(object) { return Object.extend.apply(this, [this, object]); } 接下来我们实现一个继承类Rect, 这里先用一种简单的方法来实现。 复制代码代码如下:function Rect() { } Rect.prototype = ShapeBase.prototype; //只这一句就行了 //扩充新的方法 Rect.prototype.add=function() { alert("Rect add"); } 这种方法不能用于重写,如果改变了show方法, ShapeBase的show也会指向同一函数可能是由于prototype赋值只是简单的改变指向地址. 如果上面也定义了: Rect.prototype.show=function() { alert("Rect show"); } 那么执行结果如下: function test(){ var s=new ShapeBase(); s.show(); //结果:Rect show var r=new Rect(); r.show(); //结果:Rect show r.add(); } 我们再使用object.extend实现继承, 并实现一个oninit虚方法, 修改ShapeBase如下: 复制代码代码如下:ShapeBase.prototype={ show:function() { alert("ShapeBase show"); }, initialize:function () { this.oninit(); } }; 实现Rect类继承. 复制代码代码如下:Rect.prototype=(new ShapeBase).extend({ //添加新的方法 add:function() { alert("Rect add"); }, //使用这种方法可以重写show方法 show:function() { alert("Rect show"); }, //实现虚方法 oninit:function() { alert("Rect oninit"); } }) 现在我们的类写好了， 测试下看看: 复制代码代码如下:function test(src){ ShapeBase.StaticDraw(); var s=new ShapeBase(); s.show(); //alert("ShapeBase show") var r=new Rect(); r.show(); //alert("Rect show") r.add(); r.initialize(); //alert("Rect oninit") } 另外,在网上看到一篇用专门的对象来创建类，代码如下: 复制代码代码如下:// //对象属性复制方法,很多库都有实现,如PrototypeJS里面的extend和Ext里面的Ext.apply // function extend(des, src) { if (!des) des = {}; if (src) { for (var i in src) { des[i] = src[i]; } } return des; } var CC = {}; //全局变量 // //create 用于创建类 // CC.create = function(superclass, constructor){ var clazz = (function() { this.initialize.apply(this, arguments); }); //如果无参数,直接返回类. if(arguments.length == 0) return clazz; //如果无父类,此时constructor应该为一个纯对象,直接复制属性返回. if(!superclass){ extend(clazz.prototype, constructor); return clazz; } var absObj = clazz.prototype, sprPropty = superclass.prototype; if(sprPropty){ //用于访问父类方法 clazz.superclass = sprPropty; extend(absObj, sprPropty); //调用属性构造函数创建属性,这个是实现关键. extend(absObj, constructor(sprPropty)); // 子类实例直接通过obj.superclass访问父类属性, // 如果不想造成过多引用,也可把这句注释掉,因为多数时候是没必要的. absObj.superclass = sprPropty; // clazz.constructor = constructor; } return clazz; } // //创建一个动物类 // var Animal = CC.create(null, { //属性 footprint : "- - - - - - =", //类初始化方法,必须的,当用 new 生成一个类时该方法自动被调用,参见上定义. initialize : function(options){ extend(this, options); alert("Animal initialize method is called."); }, eat : function(){ alert("Animal eat method is called."); }, move : function(){ alert("I am moving like this "+ this.footprint +" ."); } }); // //创建一个Duke类 // var Duke = CC.create(Animal, function(superclass){ //在这可以定义一些类全局静态数据,该类每个实例都共享这些数据. //计算实例个类,包括派生类实例. var static_instance_counter = 0; function classUtilityFuncHere(){ } //返回类具体属性. return { //重写初始化方法 //@override initialize : function(options) { alert("Initializing Duke class.."); //调用父类初始化,这种方法比一般其它库的要简洁点吧,可以不管父类是什么. superclass.initialize.call(this, options); //做一些子类喜欢做的事. alert("Duke initialize method is called."); //读取或修改类静态属性 static_instance_counter++; }, //重写move方法,增加Duke自己的移动方式. move : function(){ this.footprint = this.footprint + "zzzzzzzz"; superclass.move.call(this); }, //重写eat方法,注意,里面不调用父类方法,即父类eat被覆盖了. eat : function(){ alert("Duke is eating.."); }, //新增一个say方法,显示当前已经初始化的Duke类实例数量. say : function(){ alert("the number of Duke instances is "+static_instance_counter); } }; }); var DukeChild = CC.create(Duke, function(superclass){ return { move : function(){ this.footprint = this.footprint + "++++++++++++="; superclass.move.call(this); }, say : function(){ alert(this.msg || ""); } }; }); (function test() { var animal = new Animal(); animal.eat(); animal.move(); var dukeA = new Duke(); dukeA.eat(); dukeA.move(); dukeA.say(); var dukeB = new Duke(); dukeB.eat(); dukeB.move(); dukeB.say(); var dukeC = new DukeChild({msg : "I am a child of duke."}); dukeC.move(); dukeC.say(); })();

T.getClass()或者T.class都是非法的，因为T是泛型变量。由于一个类的类型是什么是在编译期处理的，故不能在运行时直接在Base里得到T的实际类型。有一种变通的实现方式：import java.lang.reflect.Array;import java.lang.reflect.ParameterizedType;import java.lang.reflect.Type;public class Generic extends Base<String> {public static void main(String[] args) {Generic c = new Generic();System.out.println(c.array);}Object array ;public Generic() {array = Array.newInstance(getGenericType(0), 100);}}class Base<T> {public Class getGenericType(int index) {Type genType = getClass().getGenericSuperclass();if (!(genType instanceof ParameterizedType)) {return Object.class;}Type[] params = ((ParameterizedType) genType).getActualTypeArguments();if (index >= params.length || index < 0) {throw new RuntimeException("Index outof bounds");}if (!(params[index] instanceof Class)) {return Object.class;}return (Class) params[index];}}其中Base<T>是泛型类，在父类中声明getGenericType，子类继承具体的Base<String>，那么在子类中就可以通过getGenericType(0)获取到String的class.

关于继承的说法正确的是如下：A、子类只继承父类public方法和属性；B、子类继承父类的非私有属性和方法；C、子类只继承父类的方法，而不能继承父类的属性；D、子类将继承父类的所有的属性和方法；答案B继承是面向对象软件技术当中的一个概念，与多态、封装共为面向对象的三个基本特征。继承可以使得子类具有父类的属性和方法或者重新定义、追加属性和方法等。继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的属性和方法，或子类从父类继承方法，使得子类具有父类相同的行为。Java继承是使用已存在的类的定义作为基础建立新类的技术，新类的定义可以增加新的数据或新的功能，也可以用父类的功能，但不能选择性地继承父类。子类的创建可以增加新数据、新功能，可以继承父类全部的功能，但是不能选择性的继承父类的部分功能。继承是类与类之间的关系，不是对象与对象之间的关系。例如：先定义一个类叫车，车有以下属性：车体大小、颜色、轮胎、方向盘、品牌、速度、排气量，由车这个类派生出轿车和卡车两个类，为轿车添加一个小后备箱，而为卡车添加一个大货箱。如果某类B“继承”另某类A，就把这个B称为“A的子类或派生类（subclass）”，而把类A称为“B的父类”也可以称为“A是B的超类或基类（superclass）”。

getClass().getGenericSuperclass()返回表示此 Class 所表示的实体（类、接口、基本类型或 void）的直接超类的 Type然后将其转换ParameterizedType。。getActualTypeArguments()返回表示此类型实际类型参数的 Type 对象的数组。[0]就是这个数组中第一个了。。简而言之就是获得超类的泛型参数的实际类型。。比如超类public class GenericDAO<T> {private Class<T> entityClass;protected GenericDAO() { Type type = getClass().getGenericSuperclass(); Type trueType = ((ParameterizedType) type).getActualTypeArguments()[0]; this.entityClass = (Class<T>) trueType; }}子类public class OptionManager extends GenericDAO<MSGC_OPTION> {}测试类public class OracleTest {public static void main(String[] args) throws Exception {OptionManager manager = new OptionManager();}}这样在你new OptionManager();以后超类里的entityClass就是子类那里的public class OptionManager extends GenericDAO<MSGC_OPTION> 里面的MSGC_OPTION所对应的class对象了..

在itjob时老师讲过：首先要说super就先要说this。"this"，作为一个特殊的关键字，它的规则如下：1。可以表示构造函数传递。this(a,b)表示调用另外一个构造函数。这里面的this就是一个特殊语法，不是变量，没有什么类型。2。可以在一个类的非static成员内部使用，表示当前这个对象。此时，this就是一个final的普通变量，它有静态类型，就是这个类c本身；它有动态类型，就是当前这个对象的类型。你可以对它调用成员函数，把它传递给别的函数，等等等等。只要一个c类型的final变量可以出现的地方，它就可以出现。"super"。它和"this"类似，但是也有不同的地方：1。表示调用父类的构造函数。也是一个特殊语法，不是变量，没有什么类型。2。可以在一个类的非static成员内部使用。比如super.method()。但是，注意，这个super.method()只是长得跟some_var.method()一样，一个语法糖而已。实质上，"super"根本不是一个变量。为什么不是？因为如果是就坏了。java里面有一个金科玉律：任何public非static函数的调用都是多态的。所以，如果super是个变量，也指向当前对象，那么，不管super的静态类型是什么super.method()必然调用的是子类的那个版本，而不会是我们期望的，静态地选择父类的那个版本。你只要把super.xxx看成一个特殊的语法，比如理解为“super::xxx”就好了。3.既然super不是一个变量，那么不能把它象一个普通变量那样"=="，或者传递给某个函数就看起来很正常了，是么？何况，你其实也用不着它，有this你这些要求就都可以办到了。4.super的另外一个作用是调用父类的protected函数。只有通过"super"这个魔咒，我们才能操作父类的protected成员，别无它法。

楼上可以的

u伐猢tru伐猢g洎ㄈa渐c≤sp堡xm 多态中3的一s个o对象具有多种特征，他可以0根据不q同的情况来做出不v同的响应,例如,一p个r停车j场大w车p收费80元x，小n车r20元j 这就是多态 多态在可以4很有效的简化6代码

警告：超类不不存在

在Java1.4及以前，子类方法如果要覆盖超类的某个方法，必须具有完全相同的方法签名，包括返回值也必须完全一样。Java5.0放宽了这一限制，只要子类方法与超类方法具有相同的方法签名，或者子类方法的返回值是超类方法的子类型，就可以覆盖。注意："协变返回(covariant return)"，仅在subclass（子类）的返回类型是superclass（父类）返回类型的extension（继承）时才被容许。举例：=====================================class Base{ public Object OverrideredFunction(){ return new Object(); }}class Inherit extends Base{ //String死Object的子类，所以可以这么写 @Override public String OverrideredFunction(){ return "Nice!"; }}=====================================class Base{ public String OverrideredFunction(){ return "NO!"; }}class Inherit extends Base{ //String和Integer虽然都是Object的子类 //但这么写的话编译错误 @Override public Integer OverrideredFunction(){ return new Integer(10); }}=====================================另外，实践表明，就算返回的两个类继承自同一个interface，也无法进行协变。

在面向对象的编程中，基类（base class）指的是被其他类继承的类。也可以称为父类（parent class）、超类（superclass）或顶层类（top-level class）。一个基类可以定义一组公共属性和方法，这些属性和方法可以被其子类继承和使用，从而减少代码重复。子类（子类、派生类、derived class）则是继承自基类的类，可以使用基类中的公共属性和方法，并且还可以添加自己特有的属性和方法。子类可以继承多个基类，并且可以通过重载基类的方法来改变其行为。例如，假设有一个基类Animal，其中定义了name和age两个属性以及eat和sleep两个方法。现在我们可以创建一个子类Dog，继承自Animal，并添加自己的bark方法。这样，Dog就可以使用Animal中定义的属性和方法，同时还可以调用自己特有的bark方法。```public class Animal {public string name;public int age;public void eat() {// 吃东西}public void sleep() {// 睡觉}}public class Dog : Animal {public void bark() {// 汪汪叫}}```在上面的例子中，Animal为基类，Dog为子类。由于Dog继承自Animal，因此它可以使用Animal中定义的name、age、eat和sleep四个属性和方法。同时，Dog也可以添加自己特有的bark方法。

请去读教程和做实验

就是父类，他有几个代名词，基类，父类，超类等等

也就是父类

在新建class的时候可以指定superClass.

extends关键字。

出现了2次class SubClass extends FatherClass重复定义了建议楼主变成一个类对一个java文件，这样调理清晰

人品太差，无法使用

User.java: package com.newbingo.entity; import java.io.Serializable; import javax.persistence.Embedded; import javax.persistence.MappedSuperclass; @MappedSuperc

任意放置super()函数在AS2中,如果您没有将对 super() 的调用放入子类的构造函数中，则编译器将自动生成对其直接超类的构造函数的调用，并将此作为该函数的第一个语句。在AS3中,同AS2一样,如果您没有将对 super() 的调用放入子类的构造函数中,编译器同样会自动生成对其接超类的构造函数的调用，不同的是现在可以将对 super() 的调用放在构造函数中任意位置,不仅仅如AS2时那样放在第一句.package {public class SubClass extends SuperClass {protected var value:int;public function SubClass(value:int = 0) {this.value = value;super(20);//not only the first statement}}}

输出类的路径如：com.test.action.Test

先查看这个方法是不是重载父类的方法，如果没有父类，那么使用了@override一定会报错；查看重载时是不是方法名/参数有区别；若以上问题都不存在，则可能是以下原因：引用IDK5版本中存在bug；@override是JDK5就已经有了，但是不支持对接口的实现，认为这不是override报错。JDK6修复了这个bug，无论是父类方法的覆盖还是对接口的实现都可以加上注解@Override。扩展资料：用过UtralEdit的肯定对其的列编辑模式赞赏不已，因为它减少了很多无聊的重复工作，而IDEA完全支持该模式，从而更加提高了编码效率。预置模板可以让把经常用到的方法编辑进模板，使用时你只用输入简单的几个字母就可以完成全部代码的编写。例如使用比较高的public static void main(String[] args){}可以在模板中预设pm为该方法，输入时你只要输入pm再按代码辅助键，IDEA将完成代码的自动输入。集成了市面上常见的所有版本控制工具插件，包括git、svn、github，让开发人员在编程的工程中直接在intellij idea里就能完成代码的提交、检出、解决冲突、查看版本控制服务器内容等等。参考资料来源:百度百科-IntelliJ IDEA

你实现ActionListener接口，就必须实现里面全部的方法，你要在里面写一个actionPerformed(ActionEvent)方法

构造方法没有返回值，方法名和类名一样，其作用是用于在NEW一个类的时候，会总先调用这个类的构造方法，构造方法内部可以作一些变量的初始化或在创建这个类时必须调用的一些方法和运算，他是不用特意去调用的方法，会随着类的创建而自动去调用例如：我们需要做一个i+j的运算，在这期间我们用到了构造函数，让其改变了i和j的初始化值public class Text { int i = 0; int j = 0; /** * Text 的构造函数 将i和J的值重新初始化赋值 */ public Text() { i = 1; j = 2; }; public static void main(String[] args) { Text s = new Text(); //此时当你NEW完Text()时程序已经自动执行了Text的构造 函数i和j的值已经是1和2 System.out.println(s.i + s.j); }}

2.Java中的类和对象【第一部分草案】 收藏 （本章的学习量相对比较大，我把整体分为三个部分讲解，第一个部分和第二个部分为Java关于类和对象以及OO的基础，第三个部分为在OO设计技巧中针对Java程序的一些性能提升的小技巧，因为尽量保证Java关于类和对象的基本概念以及关键知识点都能够涉及到，一是为了方便查询，二是按照常用的关键点来进行的整理，其中的关键点都是在开发过程中的一些相关内容涉及，所以本文特意提供了一个目录进行检索。类和对象属于面向对象的基本概念，在开发过程中，需要掌握了对象和类的基本思想过后才明白如何进行OO设计，Java本身是纯面向对象的语言，这篇文章的主要目的是针对Java里面一些关于类和对象的基本操作进行简单的讲解，若有笔误，请来Email提点，谢谢：silentbalanceyh@126.com） 本文目录：【蓝色部分为本章的目录】1.基本概念2.Java变量相关1)Java变量分类2)Java中变量的初始化3)Java变量修饰符和访问域4)Java类修饰符[不包含内部类]3.Java涉及OO的关键知识点【主体】1)继承的基本概念2)抽象类、接口、final类：3)重载和重写：4)对象的拷贝[深拷贝和浅拷贝]：5)关键字this、super6)Java中的inlining[内联]7)带继承的构造函数以及构造顺序8)谈谈Object中的方法：equals、hashCode、toString9)带继承的类型转换以及转换中关于成员变量和成员函数的调用10)Java语言中的反射11)按引用传递和值传递原理12)Java中的包和导入13)匿名类和内部类4.Java编程OO设计技巧1)对象创建以及周期2)对象属性设置3)垃圾回收4)继承、接口、抽象类5.总结1.基本概念： 　　类和对象：OO里面什么称为类，类一般性我们定义为创建对象的一个蓝图，当我们根据某个类创建了一个对象的时候，我们就说该对象是这个类的一个实例（instance），类描述了某些对象的基本结构，是对对象的相关属性的一种定义，它定义了对象所具有的属性、方法、事件等各种基本点。 　　类设计的关键概念：封装是对象在工作的时候的一个关键概念，也是我们在进行OO设计的时候的一个需要掌握的点，封装简单讲就是将对象内部的一些细节实现隐藏起来不对外公布，仅仅对外公布某个对象能够提供的操作结果，从而实现信息隐藏的目的。在封装过程，对象内的数据我们一般称为成员变量（instance fields），对象内针对这些数据执行的操作我们可以叫做操作方法（成员函数）（methods），一个对象这些属性的集合所反映出来的就是该对象的状态。 　　在Java里面，所有的复合数据都是从Object类继承而来的，这一点可以通过使用Java反射去获取父类的名称来获得。　　对象：在OO设计里面，对象有几个需要掌握的基本点： 　　对象的行为：对象的行为指代的是这个对象能够做什么，不能做什么，包括这个对象有哪些接口是对外提供了我们可以直接进行使用等相关概念。 　　对象的状态：对象的状态指代的是在程序运行过程，某个对象实例的一些属性发生了相关的变化过后产生的一个对象状态，在ORM设计中我们经常会遇到对象状态的操作。 　　对象的标识：对象的标识指代的是这个对象如何区别于其他对象，即是是同一个类产生的新实例，其本质上讲它们属于两个不同的对象，而不应该是同一个对象。 　　类与类的关系： 　　依赖（Dependence）：依赖关系简单讲就是users-a的关系，两个类创建的对象实例本身没有任何关系，在编程过程反映出来的就是两个对象在相互之间的调用关系，比如某个对象在执行它自己的行为的时候调用了其他对象的方法这些相关操作都属于users-a的基本关系，或者说在某个Class里面使用了其他Class来定义成员变量。　　组合（Aggregation）：组合关系可以认为是has-a的关系，这种关系的两个类存在一个包含关系，很容易理解就是比如某个类包含了另外一个类，这种概念严格上讲不在操作，主要是成员变量，比如一个用户有个姓名属性成为NameInfo，然后这个NameInfo定义为一个包含了两个String的对象，一个是FirstName，另外一个是LastName，这种情况可以认为该对象本身和NameInfo之间的关系是has-a的关系。 　　继承（Inheritance）：继承关系属于is-a的关系，这种关系意味着两个类存在父类（superclass）和子类（subclass）的概念，Java里面使用extends和implements两个关键字来体现两个类的集成关系。 　　（上边这些概念基本上在各种OO语言学习的开篇都会遇到，没什么特殊的，所以熟悉的人可以不用去了解） 　　Java中的Class： 　　预定义Class：在Java里面，什么称为预定义Class，学过Java的人都知道，JVM会在我们编写java程序的时候默认载入包java.lang，而java.lang里面已经存在了很多Class，这种Class就属于预定义的Class；不仅仅如此，以及Java API里面提供的Network相关类、IO相关类、XML相关类，这些可以不需要我们自定义，只需要import过后就可以直接使用的类就属于预定义的类。预定义类的各种使用方法可以参考JDK的API文档，里面针对目前存在的很多类都有详细的描述信息，有些类还提供了我们所需要的相关使用Demo可做参考。 一些代码的使用例子。 　　自定义Class：如果我们要使用自己的Class就需要在Java中自己定义Class，定义语法如下： class UserInfo{ ……} 使用该语法我们就可以定义一个属于自己的Class，而在Class里面我们就可以根据自己的需求来设计相关成员变量和成员函数以及其他相关信息。2.Java变量：　　1)Java中的变量分为四种：类变量（又称为静态变量）、实例变量、局部变量、块变量　　类变量——类变量只能在一个class域里面进行定义，同样只能在类里面使用，使用关键字为static关键字，这种变量可以直接通过Class.VAR的方式来调用，而且不需要对象实例存在就可以调用，它的执行原理在于当JVM的类加载器将类加载进来的时候，这个变量就已经存在的，而且可以使用了。定义方式和调用方式如下，下边的A就属于类变量：class UserInfo{ static int A; public static void main(String args[]) { System.out.println(UserInfo.A); }}

javascript本身不是面向对象的语言，而是基于对象的语言，对于习惯了其他OO语言的人来说，起初有些不适应，因为在这里没有“类”的概念，或者说“类”和“实例”不区分，更不要指望有“父类”、“子类”之分了。那么，javascript中这一堆对象这么联系起来呢？幸运的是，javascript在设计之初就提供了“继承”的实现方式，在认识“继承”之前，我们现在先来了解下原型链的概念。原型链具体代码如下：使用原型链实现继承通过上面的代码中可以看出SubClass继承了SuperClass的属性和方法，这个继承的实现是通过将SuperClass的实例赋值给SubClass的原型对象，这样SubClass的原型对象就被SuperClass的一个实例覆盖掉了，拥有了它的全部属性和方法，同时还拥有一个指向SuperClass原型对象的指针。在使用原型链实现继承时有一些需要我们注意的地方：注意继承后constructor的变化。此处sub的constructor指向的是SuperClass，因为SubClass的原型指向了SuperClass的原型。在了解原型链时，不要忽略掉在末端还有默认的Object对象，这也是我们能在所有对象中使用toString等对象内置方法的原因。通过原型链实现继承时，不能使用字面量定义原型方法，因为这样会重写原型对象：实例共享的问题。在前面讲解原型和构造函数时，我们曾经介绍过包含引用类型属性的原型会被所有的实例共享，同样，我们继承而来的原型中也会共享“父类”原型中引用类型的属性，当我们通过原型继承修改了“父类”的引用类型属性后，其他所有继承自该原型的实例都会受到影响，这不仅浪费了资源，也是我们不愿看到的现象：注意：此处在数组中添加一个元素，所有继承自SuperClass的实例都会受到影响，但是如果修改name属性则不会影响到其他的实例，这是因为数组为引用类型，而name为基本类型。如何解决实例共享的问题呢？我们接着往下看...经典继承（constructor stealing）正如我们介绍过很少单独使用原型定义对象一样，在实际开发中我们也很少单独使用原型链，为了解决引用类型的共享问题，javascript开发者们引入了经典继承的模式（也有人称为借用构造函数继承），它的实现很简单就是在子类型构造函数中调用超类型的构造函数。我们需要借助javascript提供的call()或者apply()函数，我们看下示例：SuperClass.call(this);这一句话的意思是在SubClass的实例（上下文）环境中调用了SuperClass构造函数的初始化工作，这样每一个实例就会有自己的一份bra属性的副本了，互不产生影响了。但是，这样的实现方式仍不是完美的，既然引入了构造函数，那么同样我们也面临着上篇中讲到的构造函数存在的问题：如果在构造函数中有方法的定义，那么对于没一个实例都存在一份单独的Function引用，我们的目的其实是想共用这个方法，而且我们在超类型原型中定义的方法，在子类型实例中是无法调用到的：组合式继承组合式继承就是结合原型链和构造函数的优势，发出各自特长，组合起来实现继承的一种方式，简单来说就是使用原型链继承属性和方法，使用借用构造函数来实现实例属性的继承，这样既解决了实例属性共享的问题，也让超类型的属性和方法得到继承：组合继承的方式也是实际开发中我们最常用的实现继承的方式，到此已经可以满足你实际开发的需求了，但是人对完美的追求是无止境的，那么，必然会有人对这个模式“吹毛求疵”了：你这个模式调用了两次超类型的构造函数耶！两次耶。。你造吗，这放大一百倍是多大的性能损失吗？最有力的反驳莫过于拿出解决方案，好在开发者找到了解决这个问题的最优方案：寄生组合式继承在介绍这个继承方式前，我们先了解下寄生构造函数的概念，寄生构造函数类似于前面提到的工厂模式，它的思想是定义一个公共函数，这个函数专门用来处理对象的创建，创建完成后返回这个对象，这个函数很像构造函数，但构造函数是没有返回值的：寄生式继承的实现和寄生式构造函数类似，创建一个不依赖于具体类型的“工厂”函数，专门来处理对象的继承过程，然后返回继承后的对象实例，幸运的是这个不需要我们自己实现，道哥（道格拉斯）早已为我们提供了一种实现方式：在公共函数中提供了一个简单的构造函数，然后将传进来对象的实例赋予构造函数的原型对象，最后返回该构造函数的实例，很简单，但疗效很好，不是吗？这个方式被后人称为“原型式继承”，而寄生式继承正是在原型式基础上，通过增强对象的自定义属性实现的：寄生式继承方式同样面临着原型中函数复用的问题，于是，人们又开始拼起了积木，诞生了——寄生组合式继承，目的是解决在指定子类型原型时调用父类型构造函数的问题，同时，达到函数的最大化复用。基于以上基础实现方式如下：这个实现方式避免了超类型的两次调用，而且也省掉了SubClass.prototype上不必要的属性，同时还保持了原型链。

就是数组中能被3整除的数的和 300