java

这个原因是，你的test类里没有change1.这个方法。

getday 获得某一天

SimpleDateFormat sdf = new SimpleDateFormat("YYYYMMMDD");Date date = new Date();System.out.println(sdf.format(date));

表达不清晰，如用Data类输入一个人的生日？

不是sql包里的

用字符串的截取方法substring

给你点提示,java中有一个Calendar类,可以解决你的问题,实现过程比较简单!

heeh

package meta;public class BirthDate {private int day = 1;private int month = 1;private int year = 1900;public BirthDate(int day ,int month,int year){this.day = day;this.month = month;this.year = year;}public BirthDate(BirthDate date){this.day = date.day;this.month = date.month;this.year = date.year;}public BirthDate addDays(int add_days){BirthDate date1 = new BirthDate(this);date1.day = date1.day + add_days;return date1;}public static BirthDate addDays2(BirthDate date1,int add_days){date1.day = date1.day + add_days;return date1;}public static void printDate(BirthDate date){System.out.println(date.year + " " + date.month + " " + date.day);}public static void main(String[] args) {// TODO Auto-generated method stubBirthDate date0 = new BirthDate(3,5,1988);printDate(date0);date0 = date0.addDays(7);printDate(date0);date0 = addDays2(date0,4);printDate(date0);}}这是我写的一个 BirthDate.java全文你放到自己的编辑器里去执行一下，然后再思考一下就明白了。开发语言的学习一定要实践，实践才能出真知。其实，更推荐用 addDays2 这种调用方法啊。。不容易错。而且，拎得清。

java用户管理的代码中查询不了是哪出问题了?英文字段不会出现问题，发生这种情况的很大一个原因是字符集出问题只要在你的配置url中设置字符集就好了～在springboot的配置文件加上，其他框架原理相同，即在jdbc的url中设置与数据库相同的字符集，如果数据库中是UTF8mb4，设置为UTF8即可.

应该是一个代码同步的模块吧，大概猜的，没怎么用过这个ide

你是想把图片放到面板上还是想在面板上绘图？？？

好象 是个平台什么的,在安装成功后,在控制面板能够看到这个东东

1.悬浮层树(Tree) 这种树结构实现类似面包屑导航功能，监听的是节点鼠标移动的事件，然后在节点下方或右方显示子节点，依此递归显示子节点的子节点。 用户首页博客设置文章相册留言评论系统 这里要注意几个小问题，其一这种树结构是悬浮层绝对定位的，在创建层的时候一定要直接放在body的下面，这样做的是确保在IE里面能遮掩住任何层，因为在IE里面是有stacking context这种东西的潜规则在里面的，另外当然还有一个select你能遮住我吗？老掉牙的问题，这里是采用在每个悬浮层后面加个iframe元素，当然同一级的菜单只产生一个iframe元素，菜单有几级将产生几个iframe遮掩，然后菜单显示和隐藏的时候同时显示和隐藏iframe。 不过这种菜单并不合适前台，因为目前只支持在脚本里动态添加菜单节点，而不能从现有的html元素获取菜单节点，我们为了SEO等前台导航一般是在后台动态输出的，假如菜单有多级的话也建议不超过2层，对客户来说太多层也懒得去看，不过有个面包屑导航显示还是很不错的。 menu.js 代码如下:/* ** Author : Jonllen ** Create : 2009-12-13 ** Update : 2010-05-08 ** SVN : 152 ** WebSite: http://www.jonllen.com/ */ var Menu = function (container) { this.container = container; return this; } Menu.prototype = { list : new Array(), active : new Array(), iframes : new Array(), settings : { id : null, parentId : 0, name : null, url : null, level : 1, parent : null, children : null, css : null, element : null }, push : function (item) { var list = Object.prototype.toString.apply(item) === "[object Array]" ? item : [item]; for( var i=0; i< list.length; i++) { var settings = list[i]; for( p in this.settings) { if( !settings.hasOwnProperty(p) ) settings[p] = this.settings[p]; } this.list.push(settings); } return this; }, getChlid : function (id) { var list = new Array(); for( var i=0;i < this.list.length; i++) { var item = this.list[i]; if( item.parentId == id) { list.push(item); } } return list; }, render : function (container) { var _this = this; var menuElem = container || this.container; for( var i=0;i < this.list.length; i++) { var item = this.list[i]; if ( item.parentId != 0 ) continue; var itemElem = document.createElement("div"); itemElem.innerHTML = ""+item.name+""; itemElem.className = "item"; if ( item.css ) itemElem.className += " "+item.css; var disabled = (" "+item.css+" ").indexOf(" disabled ")!=-1; if ( disabled ) { itemElem.childNodes[0].disabled = true; itemElem.childNodes[0].className = "disabled"; itemElem.childNodes[0].removeAttribute("href"); } if ( (" "+item.css+" ").indexOf(" hidden ")!=-1 ) { itemElem.style.display = "none"; } itemElem.menu = item; itemElem.menu.children = this.getChlid(item.id); itemElem.onmouseover = function (e){ _this.renderChlid(this); }; menuElem.appendChild(itemElem); } document.onclick = function (e){ e = window.event || e; var target = e.target || e.srcElement; if (!target.menu) { var self = _this; for( var i=1;i

Java为了支持多语言，没有固定的日期格式。你需要根据自己的需要指定日期格式，然后用DateFormat类或者SimpleDateFormat类来判断是否是正确的日期格式。下面的例子供参考。更详细的内容（比如yyyy,MM,dd各代表什么）可以参考javadoc。public class DateUtil{ private static final SimpleDateFormat dateFormat = null; static { // 指定日期格式为四位年/两位月份/两位日期，注意yyyy/MM/dd区分大小写； dateFormat = new SimpleDateFormat("yyyy/MM/dd"); // 设置lenient为false. 否则SimpleDateFormat会比较宽松地验证日期，比如2007/02/29会被接受，并转换成2007/03/01 dateFormat.setLenient(false); } public static boolean isValidDate(String s) { try { dateFormat.parse(s); return true; } catch (Exception e) { // 如果throw java.text.ParseException或者NullPointerException，就说明格式不对 return false; } } // 下面这个方法则可以将一个日期按照你指定的格式输出 public static String formatDate(Date d) { return dateFormat.format(d); }}

var，let和const的区别在于：var的变量声明在代码执行前且工作范围在当前执行的上下文中，let是允许创建一个变量但只作用在它的块里，const与let什么相似唯一的差别是const定义的变量不可更改本篇文章主要是通过在JavaScript (ES6) 中创建变量的方法来介绍var、 let和const之间的区别，具有一定的参考作用，希望对大家有所帮助。【推荐课程：JavaScript教程】var VS letvar和let之间的主要区别不是使用函数作用域，而是使用块作用域。 这意味着使用let关键字创建的变量在创建它的“块”内以及任何嵌套块中都可用。 例function discountPrices (prices, discount) { var a = [] for (var i = 0; i < prices.length; i++) { var discountedPrice = prices[i] * (1 - discount) var finalPrice = Math.round(discountedPrice * 100) / 100 a.push(finalPrice) } console.log(i) // 3 console.log(discountedPrice) // 150 console.log(finalPrice) // 150 return a }在上面的例子中之所以能够在for循环之外使用i，discountedPrice和finalPrice，是因为它们是用var声明的，而var是函数作用域。如果我们将var换成let会发生什么情况呢？ function discountPrices (prices, discount) { let a = [] for (let i = 0; i < prices.length; i++) { let discountedPrice = prices[i] * (1 - discount) let finalPrice = Math.round(discountedPrice * 100) / 100 a.push(finalPrice) } console.log(i) // 3 console.log(discountedPrice) // 150 console.log(finalPrice) // 150 return a } discountPrices([100, 200, 300], .5) // 这儿会报错i未定义这个案例告诉我们的是，使用let声明的变量是块作用域，而不是函数作用域。 因此在“块”之外访问i（或discountedPrice或finalPrice）都会报错下一个区别与变量提升有关。提升的定义是“JavaScript解释器会在所谓的"创建"阶段将变量声明赋值为undefined的默认值。例：function discountPrices (prices, discount) { console.log(discounted) // undefined var a = [] for (var i = 0; i < prices.length; i++) { var discountedPrice = prices[i] * (1 - discount) var finalPrice = Math.round(discountedPrice * 100) / 100 a.push(finalPrice) } console.log(i) // 3 console.log(discountedPrice) // 150 console.log(finalPrice) // 150 return a}如果想要在声明变量之前使用let声明的变量，而不是未定义（如使用var声明的那些变量），程序将会报错function discountPrices (prices, discount) { console.log(discounted) // 错误 let a = [] for (let i = 0; i < prices.length; i++) { let discountedPrice = prices[i] * (1 - discount) let finalPrice = Math.round(discountedPrice * 100) / 100 a.push(finalPrice) } console.log(i) // 3 console.log(discountedPrice) // 150 console.log(finalPrice) // 150 return a}结论是var：变量声明在代码执行之前被处理，它的作用范围在其当前执行的上下文中let：let语句允许我们创建一个变量，其范围仅限于使用它的块里。let VS const既然已经理解了var和let之间的区别，那么const呢？ 事实证明，const与let几乎完全相同。 但是唯一的区别是，一旦使用const为变量赋值，就无法将其重新赋值给新值。let name = "Tyler"const handle = "tylermcginnis"name = "Tyler McGinnis" //正确handle = "@tylermcginnis" //错误从上面的内容可以看出用let声明的变量可以重新赋值，但用const声明的变量不能。所以只要你想要一个变量是不可变的，你可以用const声明它。但是用const声明变量并不意味着它是不可变的，只是无法重新赋值，例：const person = { name: "Kim Kardashian" }person.name = "Kim Kardashian West" // 正确person = {} // 错误因此即使使用const声明对象，也不意味着不能改变其任何属性。 它只表示无法将其重新分配给新值总结：

搜一下：java面试题大全。这个都是基础，对面试也有帮助。

是不是问题写错了，字符最多的字符串吧？

那你就封装一个对象，包含那几个字段

好乱的东东。。。。。。。

this.setBackground(Color.blue)完全是多余的，你设置的是面板里的jpList.setBackground(Color.blue); 而且JPanel jp=new JPanel()定义的2次

<meta content="all" name="robots" />

URLConnection context = url.openConnection();InputStream in = context.getInputStream();BufferedReader br = new BufferedReader(new InputStreamReader(in, "gbk"));包装流的时候要加入网站的编码 ，gbk和utf-8都试试最近我也在做爬虫，今天也遇到这个问题了。

爬虫目前主要开发语言为java、Python、c++ 对于一般的信息采集需要，各种语言差别不大。c、c++ 搜索引擎无一例外使用CC++ 开发爬虫，猜想搜索引擎爬虫采集的网站数量巨大，对页面的解析要求不高，部分支持javascriptpython 网络功能强大，模拟登陆、解析javascript，短处是网页解析 python写起程序来真的很便捷，著名的python爬虫有scrapy等java java有很多解析器，对网页的解析支持很好，缺点是网络部分 java开源爬虫非常多，著名的如 nutch 国内有webmagic java优秀的解析器有htmlparser、jsoup对于一般性的需求无论java还是python都可以胜任。如需要模拟登陆、对抗防采集选择python更方便些，如果需要处理复杂的网页，解析网页内容生成结构化数据或者对网页内容精细的解析则可以选择java。

　　开发网络爬虫应该选择Nutch、Crawler4j、WebMagic、scrapy、WebCollector还是其他的？这里按照我的经验随便扯淡一下：上面说的爬虫，基本可以分3类：1.分布式爬虫：Nutch　　2.JAVA单机爬虫：Crawler4j、WebMagic、WebCollector　　3. 非JAVA单机爬虫：scrapy　　第一类：分布式爬虫　　爬虫使用分布式，主要是解决两个问题：　　1）海量URL管理　　2）网速　　现在比较流行的分布式爬虫，是Apache的Nutch。但是对于大多数用户来说，Nutch是这几类爬虫里，最不好的选择，理由如下：　　1）Nutch是为搜索引擎设计的爬虫，大多数用户是需要一个做精准数据爬取（精抽取）的爬虫。Nutch运行的一套流程里，有三分之二是为了搜索引擎而设计的。对精抽取没有太大的意义。也就是说，用Nutch做数据抽取，会浪费很多的时间在不必要的计算上。而且如果你试图通过对Nutch进行二次开发，来使得它适用于精抽取的业务，基本上就要破坏Nutch的框架，把Nutch改的面目全非，有修改Nutch的能力，真的不如自己重新写一个分布式爬虫框架了。　　2）Nutch依赖hadoop运行，hadoop本身会消耗很多的时间。如果集群机器数量较少，爬取速度反而不如单机爬虫快。

hadoop是用Java写的,2005年12月-- Nutch移植到新的框架，Hadoop在20个节点上稳定运行。2004年-- 最初的版本（称为HDFS和MapReduce）由Doug Cutting和Mike Cafarella开始实施。2004年9月30日18:00PM，J2SE1.5发布，成为Java语言发展史上的又一里程碑。为了表示该版本的重要性，J2SE1.5更名为Java SE 5.0 　　2005年6月，JavaOne大会召开，SUN公司公开Java SE 6。也就是说6.0及以上是支持的

我觉得这个用于验证url的表达式用：^http://[[a-z0-9\.]+/?]+$ 也许会更准确些。以http://开头，中间是字母数字或英文句号组成，后面可跟或可不跟斜杠

有些人问，开发网络爬虫应该选择Nutch、Crawler4j、WebMagic、scrapy、WebCollector还是其他的？这里按照我的经验随便扯淡一下：上面说的爬虫，基本可以分3类：1.分布式爬虫：Nutch2.JAVA单机爬虫：Crawler4j、WebMagic、WebCollector3. 非JAVA单机爬虫：scrapy第一类:分布式爬虫爬虫使用分布式，主要是解决两个问题：1)海量URL管理2)网速现在比较流行的分布式爬虫，是Apache的Nutch。但是对于大多数用户来说，Nutch是这几类爬虫里，最不好的选择，理由如下：1)Nutch是为搜索引擎设计的爬虫，大多数用户是需要一个做精准数据爬取（精抽取）的爬虫。Nutch运行的一套流程里，有三分之二是为了搜索引擎而设计的。对精抽取没有太大的意义。也就是说，用Nutch做数据抽取，会浪费很多的时间在不必要的计算上。而且如果你试图通过对Nutch进行二次开发，来使得它适用于精抽取的业务，基本上就要破坏Nutch的框架，把Nutch改的面目全非，有修改Nutch的能力，真的不如自己重新写一个分布式爬虫框架了。2)Nutch依赖hadoop运行，hadoop本身会消耗很多的时间。如果集群机器数量较少，爬取速度反而不如单机爬虫快。3)Nutch虽然有一套插件机制，而且作为亮点宣传。可以看到一些开源的Nutch插件，提供精抽取的功能。但是开发过Nutch插件的人都知道，Nutch的插件系统有多蹩脚。利用反射的机制来加载和调用插件，使得程序的编写和调试都变得异常困难，更别说在上面开发一套复杂的精抽取系统了。而且Nutch并没有为精抽取提供相应的插件挂载点。Nutch的插件有只有五六个挂载点，而这五六个挂载点都是为了搜索引擎服务的，并没有为精抽取提供挂载点。大多数Nutch的精抽取插件，都是挂载在“页面解析”(parser)这个挂载点的，这个挂载点其实是为了解析链接（为后续爬取提供URL），以及为搜索引擎提供一些易抽取的网页信息(网页的meta信息、text文本)。4)用Nutch进行爬虫的二次开发，爬虫的编写和调试所需的时间，往往是单机爬虫所需的十倍时间不止。了解Nutch源码的学习成本很高，何况是要让一个团队的人都读懂Nutch源码。调试过程中会出现除程序本身之外的各种问题(hadoop的问题、hbase的问题)。5)很多人说Nutch2有gora，可以持久化数据到avro文件、hbase、mysql等。很多人其实理解错了，这里说的持久化数据，是指将URL信息（URL管理所需要的数据）存放到avro、hbase、mysql。并不是你要抽取的结构化数据。其实对大多数人来说，URL信息存在哪里无所谓。6)Nutch2的版本目前并不适合开发。官方现在稳定的Nutch版本是nutch2.2.1，但是这个版本绑定了gora-0.3。如果想用hbase配合nutch（大多数人用nutch2就是为了用hbase)，只能使用0.90版本左右的hbase，相应的就要将hadoop版本降到hadoop 0.2左右。而且nutch2的官方教程比较有误导作用，Nutch2的教程有两个，分别是Nutch1.x和Nutch2.x，这个Nutch2.x上写的是可以支持到hbase 0.94。但是实际上，这个Nutch2.x的意思是Nutch2.3之前、Nutch2.2.1之后的一个版本，这个版本在官方的SVN中不断更新。而且非常不稳定（一直在修改）。所以，如果你不是要做搜索引擎，尽量不要选择Nutch作为爬虫。有些团队就喜欢跟风，非要选择Nutch来开发精抽取的爬虫，其实是冲着Nutch的名气（Nutch作者是Doug Cutting），当然最后的结果往往是项目延期完成。如果你是要做搜索引擎，Nutch1.x是一个非常好的选择。Nutch1.x和solr或者es配合，就可以构成一套非常强大的搜索引擎了。如果非要用Nutch2的话，建议等到Nutch2.3发布再看。目前的Nutch2是一个非常不稳定的版本。

字符串的操作，文本框对象.copy();文本框对象.paste();文本框对象.cut();

不用

不用，jre是一个java运行时环境。通常java developer 才需要设置JAVA_HOME,普通用户使用jre 就可以了。二者区别：1、如果仅仅将jre目录设置为JAVA_HOME ，则在Command Prompt（命令行窗口）输入javac 时 会显示找不到。2、如设置了JAVA_HOME 与JARE_HOME，则在Command Prompt（命令行窗口）输入javac 时 会显示javac 的相关方法参数。扩展资料：配置JAVA_HOME：1、JAVA_HOME 配置：C:Program FilesJavajdk1.6.0_062、classpath配置：.;%JAVA_HOME%lib;%JAVA_HOME%lib ools.jar;%JAVA_HOME%lib t.jar;3、path：%JAVA_HOME%in;

Filter是接口, 不是类所以你需要点击Interfaces右边的ADD, 而不是superclass

1.Hello!IloveJAVA2.第二题你写的有问题，编译都不会通过3.第三题不更第一题一模一样么4.s=180

Yes, it is extreamly right! Everything is Object. It just means that.

?????说的完吗?

当然能！java中object类是所有类的父类，有谁没有重写过它的toString()方法？

String s = ""; s.getClass().getSuperclass();如果返回值为null 说明已经是最高级别的了，一般object的superclass才为null

class Superclass { int x; Superclass() { x = 3; System.out.println("in Superclass:x=" + x); //打印信息 in Superclass:x=3 } void dosomething() { System.out.println("in Superclass.dosomething()"); //打印信息 in Superclass.dosomething() }}class Subclass extends Superclass { int x; Subclass() { super();// 调用Subclass的父类Superclass的构造方法 x = 5;// B System.out.println("in Subclass:x=" + x); //打印信息 in Subclass:x=5 } void dosomething() { super.dosomething(); // 调用父类的dosomething方法 System.out.println("in Subclass.dosomething()"); //打印信息 in Subclass.dosomething() System.out.println("super.x=" + super.x + " sub.x=" + x); // super.x=3 sub.x=5 }}public class Li4_06 { public static void main(String[] args) { Subclass Subc = new Subclass(); //声明并定义一个对象，此时调用Subclass类的构造方法Subclass() Subc.dosomething(); // 调用Subclass的方法dosomething }}

为楼上的补充一下：try{ in = new FileInputStream(args[0]); out= new FileOutputStream(args[1]); copyFile(in,out); }另外应该有关闭in和out的地方，不知道为什么没有给出来地方？？？？？？

1．封装性　　封装性就是把对象的属性和服务结合成一个独立的相同单位，并尽可能隐蔽对象的内部细节，包含两个含义：　　◇ 把对象的全部属性和全部服务结合在一起，形成一个不可分割的独立单位（即对象）。　　◇ 信息隐蔽，即尽可能隐蔽对象的内部细节，对外形成一个边界〔或者说形成一道屏障〕，只保留有限的对外接口使之与外部发生联系。　　封装的原则在软件上的反映是：要求使对象以外的部分不能随意存取对象的内部数据（属性），从而有效的避免了外部错误对它的"交叉感染"，使软件错误能够局部化，大大减少查错和排错的难度。2．继承性　　特殊类的对象拥有其一般类的全部属性与服务，称作特殊类对一般类的继承。一个类可以是多个一般类的特殊类，它从多个一般类中继承了属性与服务，这称为多继承。 在java语言中，通常我们称一般类为父类（superclass,超类），特殊类为子类(subclass)。3．多态性　　对象的多态性是指在一般类中定义的属性或服务被特殊类继承之后，可以具有不同的数据类型或表现出不同的行为。这使得同一个属性或服务在一般类及其各个特殊类中具有不同的语义。例如："几何图形"的"绘图"方法，"椭圆"和"多边形"都是"几何图"的子类，其"绘图"方法功能不同。

1: 输出结果 i=5j=-32: 输出结果 43：输出结果 34：输出结果 int: 8 double: 8.05：输出结果 Not Equal6：输出结果 SubClass: 200SuperClass: 1007 ：public class TestSum{ public long sum(int number){ long s=1; long k=1;; for(long i=2;i<=number;i++){ if(i%k==0){ s*=i; k=i; } } return s; } public static void main(String[] args){ System.out.println(new TestSum().sum(12)); }}8：extends ,super.test()9: 输出结果 i = 010: 输出结果 The value is 2 The value is 3

java中是可以多继承的，所以子类获得父类的类名，可以使用getSuperClass（）这个方法来获得，示例如下：public class Test1 extends Date { public static void main(String[] args) { new Test1().test();//测试获得父类类名方法 } public void test() { System.out.println(Test1.class.getSuperclass().getName());//打印父类类名，使用getSuperclass()方法 }}

　java语言中有三个典型的面向对象的特性：封装性、继承性和多态性。1． 封装性　　java语言中，对象就是对一组变量和相关方法的封装，其中变量表明了对象的状态，方法表明了对象具有的行为。通过对象的封装，实现了模块化和信息隐藏。通过对类的成员施以一定的访问权限，实现了类中成员的信息隐藏。◇ java类中的限定词　　java语言中有四种不同的限定词，提供了四种不同的访问权限。　　1） private 　　类中限定为private的成员，只能被这个类本身访问。　　如果一个类的构造方法声明为private,则其它类不能生成该类的一个实例。　　2） default　　类中不加任何访问权限限定的成员属于缺省的（default）访问状态：friend，可以被这个类本身和同一个包中的类所访问。3） protected　　类中限定为protected的成员，可以被这个类本身、它的子类（包括同一个包中以及不同包中的子类）和同一个包中的所有其他的类访问。4） public　　类中限定为public的成员，可以被所有的类访问。【表3-1】　java中类的限定词的作用范围比较同一个类同一个包 不同包的子类 不同包非子类private*default **protected***public****2． 继承性　　通过继承实现代码复用。Java中所有的类都是通过直接或间接地继承java.lang.Object类得到的。继承而得到的类称为子类，被继承的类称为父类。子类不能继承父类中访问权限为private的成员变量和方法。子类可以重写父类的方法，及命名与父类同名的成员变量。但Java不支持多重继承，即一个类从多个超类派生的能力。◇ 成员变量的隐藏和方法的重写　　子类通过隐藏父类的成员变量和重写父类的方法，可以把父类的状态和行为改变为自身的状态和行为。例如：　　class SuperClass{　　　　int x; …　　　　void setX( ){ x=0; } …　　}　　class SubClass extends SuperClass{　　　　int x; 　　//隐藏了父类的变量x　　　　…　　　　void setX( ) { //重写了父类的方法 setX()　　　　x=5; } ….　　}　　注意：子类中重写的方法和父类中被重写的方法要具有相同的名字，相同的参数表和相同的返回类型，只是函数体不同。　　◇ super　　java中通过super来实现对父类成员的访问，super用来引用当前对象的父类。Super 的使用有三种情况：　　1）访问父类被隐藏的成员变量，如：　　　　super.variable; 　　2）调用父类中被重写的方法，如：　　　　super.Method([paramlist]);　　3）调用父类的构造函数，如：　　　　super([paramlist]);【例3-5】　　import java.io.*;　　class SuperClass{　　　　int x;　　　　SuperClass( ) {　　　　　x=3;　　　　　System.out.println("in SuperClass : x=" +x);　　　　}　　　　　void doSomething( ) {　　　　　System.out.println("in SuperClass.doSomething()");　　　　}　　}　　class SubClass extends SuperClass {　　　　int x;　　　　SubClass( ) {　　　　　super( ); 　　　//调用父类的构造方法　　　　　x=5;　　　　　　//super( ) 要放在方法中的第一句　　　　　System.out.println("in SubClass :x="+x);　　　　}　　　　　void doSomething( ) {　　　　　super.doSomething( ); //调用父类的方法　　　　　System.out.println("in SubClass.doSomething()");　　　　　System.out.println("super.x="+super.x+" sub.x="+x);　　　　}　　}　　public class Inheritance {　　　　　public static void main(String args[]) {　　　　　SubClass subC=new SubClass();　　　　　subC.doSomething();　　　　}　　}3． 多态性　　在java语言中，多态性体现在两个方面：由方法重载实现的静态多态性（编译时多态）和方法重写实现的动态多态性（运行时多态）。　　1） 编译时多态　　在编译阶段，具体调用哪个被重载的方法，编译器会根据参数的不同来静态确定调用相应的方法。　　2） 运行时多态　　由于子类继承了父类所有的属性（私有的除外），所以子类对象可以作为父类对象使用。程序中凡是使用父类对象的地方，都可以用子类对象来代替。一个对象可以通过引用子类的实例来调用子类的方法。　　◇ 重写方法的调用原则：java运行时系统根据调用该方法的实例，来决定调用哪个方法。对子类的一个实例，如果子类重写了父类的方法，则运行时系统调用子类的方法；如果子类继承了父类的方法（未重写），则运行时系统调用父类的方法。在例3-6中，父类对象a引用的是子类的实例，所以，java运行时调用子类B的callme方法。【例3-6】　　import java.io.*;　　class A{　　　　　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( );　　　　　}　　}◇ 方法重写时应遵循的原则：　　1）改写后的方法不能比被重写的方法有更严格的访问权限（可以相同）。　　2）改写后的方法不能比重写的方法产生更多的例外。4． 其它　　◇ final 关键字　　final 关键字可以修饰类、类的成员变量和成员方法，但final 的作用不同。　　1） final 修饰成员变量：　　final修饰变量,则成为常量，例如　　final type variableName;　　修饰成员变量时，定义时同时给出初始值，且以后不能被修改，而修饰局部变量时不做要求。　　2） final 修饰成员方法：　　final修饰方法，则该方法不能被子类重写　　final returnType methodName(paramList){　　…　　}　　3） final 类： 　　final修饰类，则类不能被继承　　final class finalClassName{　　…　　}　　◇ 实例成员和类成员　　用static 关键字可以声明类变量和类方法，其格式如下：　　static type classVar;　　static returnType classMethod({paramlist}) {　　…　　}　如果在声明时不用static 关键字修饰，则声明为实例变量和实例方法。　　1） 实例变量和类变量　　每个对象的实例变量都分配内存，通过该对象来访问这些实例变量，不同的实例变量是不同的。　　类变量仅在生成第一个对象时分配内存，所有实例对象共享同一个类变量，每个实例对象对类变量的改变都会影响到其它的实例对象。类变量可通过类名直接访问，无需先生成一个实例对象，也可以通过实例对象访问类变量。　　2） 实例方法和类方法　　实例方法可以对当前对象的实例变量进行操作，也可以对类变量进行操作，实例方法由实例对象调用。　　但类方法不能访问实例变量，只能访问类变量。类方法可以由类名直接调用，也可由实例对象进行调用。类方法中不能使用this或super关键字。　　例3-7 是关于实例成员和类成员的例子。【例3-7】　　class Member {　　　　static int classVar;　　　　int instanceVar;　　　　static void setClassVar(int i) {　　　　　classVar=i;　　　　　// instanceVar=i; // 类方法不能访问实例变量　　　　}　　　　static int getClassVar()　　　　　{ return classVar; }　　　　void setInstanceVar(int i)　　　　　{ classVar=i; //实例方法不但可以访问类变量，也可以实例变量　　　　　instanceVar=i; }　　　　　int getInstanceVar( ) 　　　　　{ return instanceVar; }　　　　}　　　　public class MemberTest{　　　　　public static void main(String args[]) {　　　　　　　　 Member m1=new member();　　　　　　　　 Member m2=new member();　　　　　　　　 m1.setClassVar(1);　　　　　　　　 m2.setClassVar(2); 　　　　　　　　 System.out.println("m1.classVar="+m1.getClassVar()+" 　　　　　　　　 　　　　　　　　　　m2.ClassVar="+m2.getClassVar());　　　　　　　　 m1.setInstanceVar(11); 　　　　　　　　 m2.setInstanceVar(22);　　　　　　　　 System.out.println("m1.InstanceVar="+m1.getInstanceVar　　　　　　　　　　　　　　()+" m2.InstanceVar="+m2.getInstanceVar());　　　　　}　　　　}◇ 类java.lang.Object　　类java.lang.Object处于java开发环境的类层次的根部，其它所有的类都是直接或间接地继承了此类。该类定义了一些最基本的状态和行为。下面，我们介绍一些常用的方法。　　equals() ：比较两个对象(引用)是否相同。　　getClass()：返回对象运行时所对应的类的表示，从而可得到相应的信息。　　toString()：用来返回对象的字符串表示。　　finalize()：用于在垃圾收集前清除对象。　　notify(),notifyAll(),wait()：用于多线程处理中的同步。

ublic static Collection getDatas(Collection result, ResultSet rs, Class clazz) {// 这里的clazz代表的是一个类型参数，表示某种类型 try { while (rs.next()) { Object vo = clazz.newInstance(); // 表示根据这种类型来创建一个这种类型的实例 Field[] fields = clazz.getDeclaredFields(); // 这种类型中有哪些被声明的属性 Field[] superFields = clazz.getSuperclass().getDeclaredFields(); // 这种类型的父类型中有哪些声明的属性 Field[] allFields = addFields(superFields, fields); for (Field field : allFields) { String setterMethodName = getSetterMethodName(field.getName()); Method setterMethod = clazz.getMethod(setterMethodName, field.getType()); // 这种类型中取出指定的声明方法 invokeMethod(rs, field, vo, setterMethod); }

http://bbs.csdn.net/topics/90149194

import java.io.*;public class A { public static void main(String[] args) throws Exception { System.out.println(System.in.getClass()); System.out.println(System.out.getClass()); new A().transform(System.in, System.out); } public void transform(InputStream in, OutputStream out) { BufferedInputStream bis = new BufferedInputStream(in); PrintStream ps = new PrintStream(out); int c = 0; try { c = bis.read()(); ps.print(c); } catch (Exception e) { e.printStackTrace(); } }}楼主试试，用你原来的inPutStream包装，只能传参数对象，要用system.in还需找到它的类，再用它的方法。system.in.read()读入的只会是字符型，所以返回是它的ASCII值。a 就是 97

从你的代码中来解释public static Collection getDatas(Collection result, ResultSet rs, Class clazz) {// 这里的clazz代表的是一个类型参数，表示某种类型 try { while (rs.next()) { Object vo = clazz.newInstance(); // 表示根据这种类型来创建一个这种类型的实例 Field[] fields = clazz.getDeclaredFields(); // 这种类型中有哪些被声明的属性 Field[] superFields = clazz.getSuperclass().getDeclaredFields(); // 这种类型的父类型中有哪些声明的属性 Field[] allFields = addFields(superFields, fields); for (Field field : allFields) { String setterMethodName = getSetterMethodName(field.getName()); Method setterMethod = clazz.getMethod(setterMethodName, field.getType()); // 这种类型中取出指定的声明方法 invokeMethod(rs, field, vo, setterMethod); }

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

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上不必要的属性，同时还保持了原型链。

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); }}

构造方法没有返回值，方法名和类名一样，其作用是用于在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); }}

看看String 的 substring方法

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

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

extends关键字。

也就是父类

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

请去读教程和做实验

楼上可以的

在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成员，别无它法。

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(); }}}

第一个阶段: 代码如下: 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

这篇文章主要介绍了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源码（详细教程）

在父类的构造方法中，获取泛型的具体类型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;}}

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

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

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

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

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

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

你太聪明了

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

除了楼上说的我再补充一下，根据经典的MVC（Model-View-Controller）项目不断完善与规范化，以Spring框架为代表，常见的项目结构被划分成了：Entity层（存放各类实体）、DAO层（数据持久化层，写sql）、Service层（服务层，处理业务逻辑）、Controller层（控制器，对外暴露接口）、View层（视图层，存放html页面或jsp页面，但是现在基本都是前后端分离架构了，视图层已经被单独抽离到前端项目中了）所以Service可以理解为MVC架构的一个重要的层级部分，专门用来处理业务逻辑。一个业务流程基本上是：用户访问Controller的某个接口，控制器调用Service，Service中的业务逻辑调用DAO完成数据库操作，最终返回接口处理结果给用户。然后说一下Server，我的理解是Server一般是用于定义服务器。例如：如果我们的项目中需要用到Socket通信，通信双方就需要对应的创建一个服务器Server和一个客户端Client，客户端与服务器建立连接后，就可以向服务器传输数据。这时的Server和Spring框架的Service就是完全不同的两样东西了。一般来说，基于TCP进行通讯时，都要在服务端创建Server，在客户端创建Client。如果Spring框架中使用到TCP通讯，甚至可以看到，我们在Spring中创建服务端Server后，服务端Server还可以通过依赖注入调用Spring的Service进行业务逻辑处理。综上，Service是MVC这类框架的重要组成部分，用于处理业务处理；Server用于创建一个服务器。

session是会话，最常见的就是购物车，购物车用的就是session，只要你的账号在登录期间，那你的信息就一直保存着。

AB

　一般情况下，session都是存储在内存里，当服务器进程被停止或者重启的时候，内存里的session也会被清空，如果设置了session的持久化特性，服务器就会把session保存到硬盘上，当服务器进程重新启动或这些信息将能够被再次使用。1、session在何时被创建　　一个常见的误解是以为session在有客户端访问时就被创建，然而事实是直到某server端程序调用HttpServletRequest.getSession(true)这样的语句时才被创建，注意如果JSP没有显示的使用 <%@page session="false"%>关闭session，则JSP文件在编译成Servlet时将会自动加上这样一条语句HttpSession session = HttpServletRequest.getSession(true);这也是JSP中隐含的session对象的来历。　　由于session会消耗内存资源，因此，如果不打算使用session，应该在所有的JSP中关闭它。　　2、session何时被删除　　综合前面的讨论，session在下列情况下被删除a.程序调用HttpSession.invalidate();或b.距离上一次收到客户端发送的session id时间间隔超过了session的超时设置;或c.服务器进程被停止（非持久session）　　3、如何做到在浏览器关闭时删除session　　严格的讲，做不到这一点。可以做一点努力的办法是在所有的客户端页面里使用javascript代码window.oncolose来监视浏览器的关闭动作，然后向服务器发送一个请求来删除session。但是对于浏览器崩溃或者强行杀死进程这些非常规手段仍然无能为力。　　4、有个HttpSessionListener是怎么回事　　你可以创建这样的listener去监控session的创建和销毁事件，使得在发生这样的事件时你可以做一些相应的工作。注意是session的创建和销毁动作触发listener，而不是相反。类似的与HttpSession有关的listener还有HttpSessionBindingListener，HttpSessionActivationListener和HttpSessionAttributeListener。

java 里的session是由服务器管理的，一般在服务器配置里都能设置比如tomcat默认配置为30分钟tomcat/conf/web.xml文件中.......... <session-config> <session-timeout>30</session-timeout> </session-config>...........

session的作用域是你(浏览器)和服务器之间存在的连接,也就是说浏览器不关闭session就一直存在并且不会自动清空.所以你在任何地方set,在没有改变的情况下,在任何地方也可以get出来

有以下几种用途：通过 session 来储存用户信息。存储用户的对话状态，对话状态就是当前用户和服务。是一个jsp内置对象，保存跟一个会话相关的信息。JAVA中的session的作用非常重要，起到保存对话的作用。Session，在计算机中，尤其是在网络应用中，称为“会话”。具体到Web中的Session指的就是用户在浏览某个网站时，从进入网站到浏览器关闭所经过的这段时间，也就是用户浏览这个网站所花费的时间。

.classpath保存的是项目所用的外部引用包的路径。.mymetadata 保存的是工程属性文件.project 是工程构建配置文件.metadata文件夹的作用 Eclipse内所有改动都放在这个文件夹.setting文件夹的作用 .settings 把.js文件的编码方式由改成默认的ISO-8859-1改成GBK时，这个文件会有记录。 如果把这个文件删了，在eclipse中查看js文件的中文字符就是乱码，但发布的时候还是能正常显示中文的。 结论：这个文件是eclipse查看js文件的时候用的，记录了用什么编码方式查看。与发布无关。.settings文件夹不会被打到.war包里。-----------by copy