java

1、设置JS_ENGINE变量。有两个值：jsc,v8。这是最方便的方式2、如果JS_ENGINE变量没有设置，或者设置的值不是jsc,v8其中的一个的话，这个makefile会选择一个默认的引擎进行编译。对于默认引擎的选择，主要取决于两个变量ARCH_ARM_HAVE_VFP(是否支持VFP)和USE_ALT_JS_ENGINE（与安装buildbot有关，这里不考虑，略过）。如果ARCH_ARM_HAVE_VFP为true的话，系统默认JS引擎选择v8，否则选择jsc引擎确定后，接下来把JS引擎编译为.a静态库libv8.a(使用v8引擎)或libjs.a（使用jsc引擎）最后，编译libwebcore.sov8引擎位于/external/v8下面，编译libwebcore.so时需要libv8.a。所以，如果是在/external/webkit下面使用mm的话，一定要确保v8已经被编译过了

几个著名Java开源缓存框架介绍(OSCache,JSC) OSCache是个一个广泛采用的高性能的J2EE缓存框架，OSCache能用于任何Java应用程序的普通的缓存解决方案。 OSCache有以下特点：缓存任何对象，你可以不受限制的缓存部分jsp页面或HTTP请求，任何java对象都可以缓存。拥有全面的API--OSCache API给你全面的程序来控制所有的OSCache特性。永久缓存--缓存能随意的写入硬盘，因此允许昂贵的创建(expensive-to-create)数据来保持缓存，甚至能让应用重启。支持集群--集群缓存数据能被单个的进行参数配置，不需要修改代码。缓存记录的过期--你可以有最大限度的控制缓存对象的过期，包括可插入式的刷新策略(如果默认性能不需要时)。Java Caching system JSC(Java Caching system)是一个用分布式的缓存系统，是基于服务器的java应用程序。它是通过提供管理各种动态缓存数据来加速动态web应用。 JCS和其他缓存系统一样，也是一个用于高速读取，低速写入的应用程序。动态内容和报表系统能够获得更好的性能。如果一个网站，有重复的网站结构，使用间歇性更新方式的数据库(而不是连续不断的更新数据库)，被重复搜索出相同结果的，就能够通过执行缓存方式改进其性能和伸缩性。EHCache EHCache 是一个纯java的在进程中的缓存，它具有以下特性：快速，简单，为Hibernate2.1充当可插入的缓存，最小的依赖性，全面的文档和测试。 JCache JCache是个开源程序，正在努力成为JSR-107开源规范，JSR-107规范已经很多年没改变了。这个版本仍然是构建在最初的功能定义上。ShiftOne ShiftOne Java Object Cache是一个执行一系列严格的对象缓存策略的Java lib，就像一个轻量级的配置缓存工作状态的框架。 SwarmCache SwarmCache是一个简单且有效的分布式缓存，它使用IP multicast与同一个局域网的其他主机进行通讯，是特别为集群和数据驱动web应用程序而设计的。SwarmCache能够让典型的读操作大大超过写操作的这类应用提供更好的性能持。 SwarmCache使用JavaGroups来管理从属关系和分布式缓存的通讯。TreeCache / JBossCache JBossCache是一个复制的事务处理缓存，它允许你缓存企业级应用数据来更好的改善性能。缓存数据被自动复制，让你轻松进行JBoss服务器之间的集群工作。JBossCache能够通过JBoss应用服务或其他J2EE容器来运行一个MBean服务，当然，它也能独立运行。 JBossCache包括两个模块：TreeCache和TreeCacheAOP。 TreeCache --是一个树形结构复制的事务处理缓存。TreeCacheAOP --是一个“面向对象”缓存，它使用AOP来动态管理POJO(Plain Old Java Objects) 注：AOP是OOP的延续，是Aspect Oriented Programming的缩写，意思是面向方面编程。 WhirlyCache Whirlycache是一个快速的、可配置的、存在于内存中的对象的缓存。它能够通过缓存对象来加快网站或应用程序的速度，否则就必须通过查询数据库或其他代价较高的处理程序来建立。

http://blog.csdn.net/zliu789/archive/2009/02/13/3885919.aspx

首先，我们先看一下http的头信息到底是什么：HTTP（HyperTextTransferProtocol） 即超文本传输协议，目前网页传输的的通用协议。HTTP协议采用了请求/响应模型，浏览器或其他客户端发出请求，服务器给与响应。就整个网络资源传输而 言，包括message-header和message-body两部分。首先传递message- header，即http header消息。http header 消息通常被分为4个部分： general header, request header, response header, entity header。但是这种分法就理解而言，感觉界限不太明确，根据日常使用，大体分为Request和Response两部分。在通常的servlet/jsp应用中，我们只是从http的header中取得信息，如果要设置信息，需要用到HttpClient，具体的设置方法如下：HttpResponse response = null; HttpGet get = new HttpGet(url); get.addHeader("Accept", "text/html"); get.addHeader("Accept-Charset", "utf-8"); get.addHeader("Accept-Encoding", "gzip"); get.addHeader("Accept-Language", "en-US,en"); get.addHeader("User-Agent", "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.22 (KHTML, like Gecko) Chrome/25.0.1364.160 Safari/537.22"); response = client.execute(get); HttpEntity entity = response.getEntity(); Header header = entity.getContentEncoding(); if (header != null) { HeaderElement[] codecs = header.getElements(); for (int i = 0; i < codecs.length; i++) { if (codecs[i].getName().equalsIgnoreCase("gzip")) { response.setEntity(new GzipDecompressingEntity(entity)); } } } return response; 其中，client为一个HttpClient的实力，创建方式如：SchemeRegistry schemeRegistry = new SchemeRegistry(); schemeRegistry.register(new Scheme("http", 80, PlainSocketFactory.getSocketFactory())); schemeRegistry.register(new Scheme("https", 443, SSLSocketFactory.getSocketFactory())); PoolingClientConnectionManager cm = new PoolingClientConnectionManager(schemeRegistry); cm.setMaxTotal(200); cm.setDefaultMaxPerRoute(2); HttpHost googleResearch = new HttpHost("research.google.com", 80); HttpHost wikipediaEn = new HttpHost("en.wikipedia.org", 80); cm.setMaxPerRoute(new HttpRoute(googleResearch), 30); cm.setMaxPerRoute(new HttpRoute(wikipediaEn), 50); DefaultHttpClient client = new DefaultHttpClient(cm);

　　本文中演示如何通过URLConnection获取Http响应Header信息 　　 从响应中获得Header信息 　　URL obj = new URL 　　URLConnection conn = obj openConnection（） 　　Map<String List<String》 map = conn getHeaderFields（） 　　 从响应Header中获取Server信息 　　Map<String List<String》 map = conn getHeaderFields（） 　　List<String> server = map get（ Server ） 　　完整的示例 　　package qiyadeng ; 　　import URL; 　　import URLConnection; 　　import java util List; 　　import java util Map; 　　public class GetHttpResponseHeader { 　　public static void main（String[] args） { 　　try { 　　URL obj = new URL 　　URLConnection conn = obj openConnection（） 　　Map<String List<String》 map = conn getHeaderFields（） 　　System out println（ 显示响应Header信息 ） 　　for （Map Entry<String List<String》 entry : map entrySet（）） { 　　System out println（ Key : + entry getKey（） + 　　 Value : + entry getValue（）） 　　} 　　System out println（ 使用key获得响应Header信息 ） 　　List<String> server = map get（ Server ） 　　if （server == null） { 　　System out println（ Key Server is not found! ） 　　} else { 　　for （String values : server） { 　　System out println（values） 　　} 　　} 　　} catch （Exception e） { 　　e printStackTrace（） 　　} 　　} 　　} 　　输出 　　显示响应Header信息… 　　Key : null Value : [HTTP/ OK] 　　Key : X Pingback Value : 　　Key : Date Value : [Sun Mar : : GMT] 　　Key : Transfer Encoding Value : [chunked] 　　Key : Connection Value : [close] 　　Key : Content Type Value : [text/; charset=UTF ] 　　Key : Server Value : [Apache/ （CentOS）] 　　Key : X Powered By Value : [PHP/ ] lishixinzhi/Article/program/Java/hx/201311/25662

估计把.没有人 帮你做. 思路不难但是做界面就很麻烦. java 用来做 桌面级应用 还是比较少的

代码是看懂了，你的意思不是很懂

1、用abstract修饰的方法叫“抽象方法”2、而包含“抽象方法”的类必须也用abstract来修饰才可以，这样的类叫做“抽象类”其实抽象类可以有多个抽象方法。3、接口则是一个特殊的抽象类，因为接口中的方法都必须是抽象方法，并用interface定义。注：1、普通类与抽象类之间只有继承(extends)关系，JAVA是唯一继承的，所以一个类只能有一个 父类。 2、普通类与接口之间只有实现(implements)关系，一个类可以实现多个接口。 3、另外，抽象类也可以实现接口。 4、接口和抽象方法都不能只有用new来创建对象，而必须由实现了所有“抽象方法”的子类来创 建对象----一个经典的设计模式“工厂法”就充分的体现了这一点。

去掉static

java序列化的作用就是把存储在内存中的文件可以转存为文件的形式。实现Serializable这个接口就是一个标记，说明这个对象是可以序列化的一般Object.clone()就需要有序列化的标记。

interface

将以下四个文件放在同一个目录下编译运行:文件1:/**MyApp.java**/public class MyApp { public static void main(String[] args) { IBaseGraphics c1 = new Circle(5); IBaseGraphics r1 = new Rectangle(3,4); c1.printData(); r1.printData(); }}文件2:/**IBaseGraphics.java**/public interface IBaseGraphics { public double computeCircumference();//计算周长 public double computeSquare ();//计算面积 public void printData();}文件3:/**Circle.java**/public class Circle implements IBaseGraphics { private double r = 0.0; public Circle(double r){ this.r = r; } public double computeCircumference() { return 2*Math.PI*r; } public double computeSquare() { return Math.PI*r*r; } public void printData() { System.out.println("该圆形的周长:"+this.computeCircumference()+";面积:"+this.computeSquare()); }}文件4:/**Rectangle.java**/public class Rectangle implements IBaseGraphics { private double width = 0; private double length =0; public Rectangle(double width, double length){ this.width = width; this.length = length; } public double computeCircumference() { return 2*(width+length); } public double computeSquare() { return width * length; } public void printData() { System.out.println("该长方形的周长:"+this.computeCircumference()+";面积:"+this.computeSquare()); }}

路过 不好意思

A这个类必须要实现B

interface

3个问题的答案都是肯定的

继承父类用extend，实现接口用implements 没有implementation

interface是定义接口的关键字，所谓的接口说白了就是一个规则，用电脑的USB插口打个比方public interface USB接口{ 这个接口只能插标准USB接口（）；/*所谓接口中的方法就是定义了个规范，而我这个标准USB接口中要插鼠标还是优盘，那就是在你的实现类中根据具体情况来看了*/}而implement就是实现接口的关键字，你要是现实了一个接口，那就必须实现里边的方法，接着上边的例子说public class 类名 implement USB接口{ //现在就要具体实现刚才接口中定义的方法了， 接口中的方法（）{ 我这个接口是插鼠标的; }就是在你的类的原来的基础上又引进了别的方法，好比电脑，有触摸板，但引进个USB接口我可以插鼠标，可以插音箱等，是功能扩展extendes，是继承的关键字，是子类继承父类的功能和属性，还用电脑打比方，电脑是一个类，有显示器，键盘这些属性，笔记本电脑也是一个类，它具有电脑的全部属性，但是比电脑又多了其他属性和功能，笔记本电脑是从电脑那里派生出来的，这样，我们称电脑是父类，笔记本是子类，同理台式机也是电脑的子类，一个类可以有多个子类，但一个类只能有一个直接父类interface和extendes的区别interface实现接口必须实现接口中的全部方法extendes是继承了父类的属性和方法，但可能永远都用不上这样说应该明白了吧，我觉得我说的够详细了，呵呵，拿分来吧

1.public static main(String[] args){}2.final3.24.抽象类5.implements6.自己意会7.try是抓捕异常,catch是抓捕后处理,finally是无论有无异常都要走的代码8...9...(程序不会的可以私聊)

可以实现接口

person 类继承了student 类，同时实现了Idao层接口。 DAO层是数据持久层接口。

人家语法规定的就是这样 没什么必须不必须的

extends 是继承某个类继承之后可以使用父类的方法也可以重写父类的方法implements 是实现多个接口接口的方法一般为空的必须重写才能使用

一个是继承，一个是实现接口，继承这个可以理解为继承父类的方法，父类中的方法可以在子类中用到，super(),实现接口就是在接口中定义了方法，这个方法要你自己去实现，接口可以看作一个标准，比如定义了一个动物的接口，它里面有吃（eat()）这个方法，你就可以实现这个方法implements，这个方法是自己写，可以是吃苹果，吃梨子，香蕉，或者其他的。IMPLEMENTS就是具体实现这个接口。

impliment的作用是为了实现某个接口。例子如下：（1）声明一个接口A:interfaceA{publicvoida();}（2）有B类为了实现A接口classBimplimentA{publicvoida(){System.out.println("B");}}科普：impliment是在java程序中一个类实现接口类时用的关键词。ObjectimplementsObject如java中定义的接口Animal,实现接口的类定义如下:publicclassTigerimplementsAnimal{}

一个类实现接口class 类名 implements 接口

implements是一个类实现一个接口用的关键字，他是用来实现接口中定义的抽象方法。比如：people是一个接口，他里面有say这个方法。public interface people(){public say();}但是接口没有方法体。只能通过一个具体的类去实现其中的方法体。比如chinese这个类，就实现了people这个接口。public class chinese implements peopel{public say(){System.out.println("你好！");}}--亲，希望能帮助到你，记得采纳哦

implements 是实现某个接口的意思。如果某个类 后面使用 implements，并指定了相应的接口，那在该类下面就需要实现相应接口的方法。比如：接口interface java.lang.Comparable 下面定义了一个虚方法 public int compareTo(T o)，如果某个类这样写public XXX implements Comparable{@Overridepublic int compareTo(T o) {这里就是必须实现的比较方法}}

implements实现的意思。在Java中是实现接口时使用implements。extends是继承父类，只要那个类不是声明为final或者那个类定义为abstract的就能继承JAVA中不支持多重继承，但是可以用接口来实现，这样就要用到implements，继承只能继承一个类，但implements可以实现多个接口，用逗号分开就行了比如：classAextendsBimplementsC，D，E接口实现的注意点：a．实现一个接口就是要实现该接口的所有的方法（抽象类除外）。b．接口中的方法都是抽象的。c．多个无关的类可以实现同一个接口，一个类可以实现多个无关的接口。扩展资料与Extends的不同extends，可以实现父类，也可以调用父类初始化this．parent（）。而且会覆盖父类定义的变量或者函数。这样的好处是：架构师定义好接口，让工程师实现就可以了。整个项目开发效率和开发成本大大降低。implements，实现父类，子类不可以覆盖父类的方法或者变量。即使子类定义与父类相同的变量或者函数，也会被父类取代掉。这两种实现的具体使用，是要看项目的实际情况，需要实现，不可以修改implements，只定义接口需要具体实现，或者可以被修改扩展性好，用extends。

从概念上来说，extends表示的是类与类或接口与接口的继承，implements表示的是类对接口的实现。也就是说，一个是扩展，另一个是实现。从设计思路来回答，就要讲明白为什么会有类和接口这两个不同的概念。事实上，仅仅通过类的单继承就可以解决绝大部分问题，而C++的多重继承可以解决任何面向对象问题。之所以要设计接口这个概念，主要还是为了使面向对象设计中的多态得到优美的解决。接口是一个特殊的抽象类。Java的设计者认为，多重继承增加了系统设计和实现时的复杂性，并且容易出错和产生歧义（例如A同时继承了B和C，而A定义了一个方法，在B和C中都存在这个方法的同名方法，此时A重写了B还是C的方法？），因此Java只允许单重继承，这完全是Java的设计者强加的限制。为了解决单重继承无法解决的问题（或者说不容易解决的问题），Java设计者设计了接口的概念，实际上，Java设计者鼓励使用接口而不是继承，因为接口的抽象性更加纯粹。总结：单继承+接口和多继承都是为了解决面向对象问题，只是方式不同。在Java设计者看来，单继承+接口的好处 > 多继承

接口可以被继承，用extends关键字接口继承(inheritance)与类继承很类似，就是以被继承的interface为基础，增添新增的接口方法原型这样可以扩展接口的多样性

对。（1）创建接口时，接口的命名一般以大写字母 I 开头（2）建议接口中的方法和属性不要加任何修饰符号, 保持代码的简洁性uf30d3. 掌握接口的用法uf7e5接口是不能直接使用的，必须要有一个类来实现该接口，实现接口中的所有抽象方法

implement是动词，第三人称单数要加s

接口（Interface）里面只有常量和抽象方法，如果某个类继承了接口那么他就必须实现这个接口或几个接口里面的抽象方法同时他也继承了接口里面的常量！你应该仔细的看一下接口的定义，你可能对接口不太熟！

都是关键字啊关键字啊。

public interface Person{ public String man();}public class Person_Item implements Person{ public String man(){ System.out.print("不给分就不是男人，呵呵~"); }}public class App{ public static void main(String[] args) { Person ps = new Person_Item(); ps.man(); }}

去看下jdk的API文档

interface B{public void sayuff08uff09uff1b}class A implements B{public void sayuff08uff09uff1b}

补充楼上的...implements接口abstract方法是不可以直接使用的..你必须重写他.如例所示,你可以在DBCatEvent类中重写ActionListener里面存在的abstract方法,当然你也可以自定义ActionListener中不存在的方法.extends是继承,你只能继承于一个父类,你可以直接使用父类里的方法..当然你也可以重写他..或者你自定义父类里不存在的方法.

补充楼上的...implements接口abstract方法是不可以直接使用的..你必须重写他.如例所示,你可以在DBCatEvent类中重写ActionListener里面存在的abstract方法,当然你也可以自定义ActionListener中不存在的方法.extends是继承,你只能继承于一个父类,你可以直接使用父类里的方法..当然你也可以重写他..或者你自定义父类里不存在的方法.

实现接口的时候interface A{ public void aMethod();}class B implments A{ public void aMethod();}

extends 后面跟着的是类，只能是一个，implements后面跟着的接口，可以多个

extends是子类继承父类，implements是实现接口//实现类MessageDaoOracleImpl继承BaseDao类实现MessageDao接口public class MessageDaoOracleImpl extends BaseDao implements MessageDao {}

implements 是实现某个接口的意思。x0dx0ax0dx0a如果某个类 后面使用 implements，并指定了相应的接口，那在该类下面就需要实现相应接口的方法。x0dx0a比如：接口interface java.lang.Comparable 下面定义了一个虚方法 public int compareTo(T o)，x0dx0a如果某个类这样写x0dx0apublic XXX implements Comparable{x0dx0ax0dx0a@Overridex0dx0apublic int compareTo(T o) {x0dx0a这里就是必须实现的比较方法x0dx0a}x0dx0a}

implements 实现的意思 在Java中是实现接口时使用implements。比如你定义了一个类要实现某个接口就用implements。

FFFFFFFF转换2进制后首位为1即为负数（计算机规定如此），绝对值则是后面0111……1111（63个1）取反即为0000……0001，也就是说FFFFFFFF即为-1PS：我是看了楼上聂鑫给出的博文，看明白了后终于想清楚了。想清楚了之后才想出答案是如此。PPS：首位是符号位，计算正负的时候取反即得相应负正，但是计算反码补码时取反是不算符号位的，即如博文中所说1XXXXXXX取补码时是XXXXXXX取反，符号位1不取反。

我用的python,对java不了解

u200du200du200du200d 修饰符 可修饰 可被访问 public 类,属性,方法 任何private 属性,方法 本类中(default) 类,属性,方法 本包内protected 属性,方法 本包内和包外有继承关系的子类

需要继承又不公开的时候才会用的这个

换为 private 私有的

protected是按包定义范围的~~~~~~~！！！！！！！！~~~~~~~~~~~~~~~~~~~

简单的说 默认的缺省是限定在同一个包中可以访问而protected 则可以在不同包的子类中被访问

java中的访问控制权限 类的访问范围 A、public修饰类，表示该类在所有包中可见 B、(default)修饰类，表示该类仅在同一个包中可见 不能用protected和private修饰类成员变量及成员方法的访问范围 A、public 包内、包外，所有类中可见 B、protected 包内所有类可见，包外有继承关系的子类可见 (子类对象可调用) C、(default)表示默认，不仅本类访问，而且是同包可见。 D、private 仅在同一类中可见

java中没有protect这个修饰符

public:类内部、当前包、子类、外部包都可访问protected:类内部、当前包、子类可以访问，外部包不可以访问default:类内部、当前包可以访问，子类、外部包不可以访问private:只有类内部可以访问

protected的范围比friendly大在可以被继承类访问，如果是超类被继承，则不论超类放在什么位置都可以访问，所以没有必要再定义成protected

1、public：public表明该数据成员、成员函数是对所有用户开放的，所有用户都可以直接进行调用 2、private：private表示私有，私有的意思就是除了class自己之外，任何人都不可以直接使用，私有财产神圣不可侵犯嘛，即便是子女，朋友，都不可以使用。 3、protected：protected对于子女、朋友来说，就是public的，可以自由使用，没有任何限制，而对于其他的外部class，protected就变成private。 作用域 当前类 同一package 子孙类 其他package public √ √ √ √ protected √ √ √ × friendly √ √ × × private √ × × ×

private只可以被同一类中访问友好类型只可以被同一类中+同一个包中的类访问protected只可以被同一类中+同一个包中的类+不在同一个包中但继承它的子类访问public基本上没限制

protected的作用：主要的作用就是用来保护子类的。它的含义在于子类可以用它修饰的成员，其他的不可以，它相当于传递给子类的一种继承的东西。public的作用：具有最大的访问权限，可以访问任何一个在classpath下的类、接口、异常等。它往往用于对外的情况，也就是对象或类对外的一种接口的形式。default的作用：有时候也称为friendly，它是针对本包访问而设计的，任何处于本包下的类、接口、异常等，都可以相互访问，即使是父类没有用protected修饰的成员也可以。private的作用：访问权限仅限于类的内部，是一种封装的体现，例如，大多数成员变量都是修饰符为private的，它们不希望被其他任何外部的类访问。注意：java的访问控制是停留在编译层的，也就是它不会在.class文件中留下任何的痕迹，只在编译的时候进行访问控制的检查。其实，通过反射的手段，是可以访问任何包下任何类中的成员，例如，访问类的私有成员也是可能的。区别：public：可以被所有其他类所访问private：只能被自己访问和修改protected：自身、子类及同一个包中类可以访问default：同一包中的类可以访问，声明时没有加修饰符，认为是friendly。Java简介Java是一种可以撰写跨平台应用软件的面向对象的程序设计语言。Java 技术具有卓越的通用性、高效性、平台移植性和安全性，广泛应用于PC、数据中心、游戏控制台、科学超级计算机、移动电话和互联网，同时拥有全球最大的开发者专业社群。Java由四方面组成：1、Java编程语言，即语法。2、Java文件格式，即各种文件夹、文件的后缀。3、Java虚拟机(JVM)，即处理*.class文件的解释器。4、Java应用程序接口(Java API)。Java分为三个体系1、Java SE（J2SE，Java2 Platform Standard Edition，标准版）。2、JavaEE（J2EE，Java 2 Platform, Enterprise Edition，企业版）。3、Java ME（J2ME，Java 2 Platform Micro Edition，微型版）。

外部类只能使用了public修饰或者是默认。只要此类没有用final修饰都可以被其它类继承。如果可以用protected修饰那不是重复了吗。如果是内部类那就可以使用protected修饰了。

protected 放在onActivityResult方法前，表示这个方法是受保护的。无论是属性还是方法，用了protected，则表示该属性或方法不能被不同包的非子类访问。可以参考一下这个：

受保护 的意思。可以在自身类、子类中使用。

子类可以访问

protected修饰的变量或方法只能被当前类，同包类或者子孙类继承或使用。一般情况下为了实现纯粹的封装用的就是private，而使用protected可以封装也可以继承一个比较典型的例子，不知道你学没学过Android开发（用java的）一个界面类需要继承Activity类，重写其中onCreate(),onPause(),onDestroy()等方法，这些方法就是protected的，这是为了继承同时也避免直接调用从而混乱应用的执行顺序

它们的作用域不同，private 作用域只在当前类可以访问，pdrotected的作用域是在同一个包内都可以访问

类NewObject中有protected修饰的方法或者属性，则：同一个包中：可在同一个包里的子类中实例化NewObject类获得对象，然后可用该对象访问protected修饰的方法或者属性，即.操作访问。可在同一个包里的非子类中实例化NewObject类获得对象，然后可用该对象访问protected修饰的方法或者属性。可在同一个包里的非子类中实例化NewObject类的子类（该子类和NewObject类在同一个包中）获得对象，然后可用该对象访问protected修饰的方法或者属性。可在同一个包里的NewObject类的子类中调用NewObject类中protected修饰的方法或者属性，即protected修饰的方法和属性可被同一个包中的子类继承。非同一个包中：可在非同一个包里的子类中实例化NewObject类获得对象，但无法用该对象问protected修饰的方法或者属性。可在非同一个包里的非子类中实例化NewObject类获得对象，但无法用该对象问protected修饰的方法或者属性。可在非同一个包里的非子类中实例化NewObject类的子类（该子类和NewObject类不在同一个包中）获得对象，但无法用该对象问protected修饰的方法或者属性。可在非同一个包里的NewObject类的子类中调用NewObject类中protected修饰的方法或者属性，即protected修饰的方法和属性可被不同一个包中的子类继承。

protected 是受保护的！他的类成员中不能访问不同包了的非自类！而public 是可以访问的！两者之间也就这点区别！

protected，代表的是保护类型。用这个声明的变量或者类，只能在子类和同一个包里面的类访问，其他的类是不能访问的。就相当于访问控制

protected的作用：主要的作用就是用来保护子类的。它的含义在于子类可以用它修饰的成员，其他的不可以，它相当于传递给子类的一种继承的东西。public的作用：具有最大的访问权限，可以访问任何一个在classpath下的类、接口、异常等。它往往用于对外的情况，也就是对象或类对外的一种接口的形式。default的作用：有时候也称为friendly，它是针对本包访问而设计的，任何处于本包下的类、接口、异常等，都可以相互访问，即使是父类没有用protected修饰的成员也可以。private的作用：访问权限仅限于类的内部，是一种封装的体现，例如，大多数成员变量都是修饰符为private的，它们不希望被其他任何外部的类访问。注意：java的访问控制是停留在编译层的，也就是它不会在.class文件中留下任何的痕迹，只在编译的时候进行访问控制的检查。其实，通过反射的手段，是可以访问任何包下任何类中的成员，例如，访问类的私有成员也是可能的。区别：public：可以被所有其他类所访问private：只能被自己访问和修改protected：自身、子类及同一个包中类可以访问default：同一包中的类可以访问，声明时没有加修饰符，认为是friendly。Java简介Java是一种可以撰写跨平台应用软件的面向对象的程序设计语言。Java 技术具有卓越的通用性、高效性、平台移植性和安全性，广泛应用于PC、数据中心、游戏控制台、科学超级计算机、移动电话和互联网，同时拥有全球最大的开发者专业社群。Java由四方面组成：1、Java编程语言，即语法。2、Java文件格式，即各种文件夹、文件的后缀。3、Java虚拟机(JVM)，即处理*.class文件的解释器。4、Java应用程序接口(Java API)。Java分为三个体系1、Java SE（J2SE，Java2 Platform Standard Edition，标准版）。2、JavaEE（J2EE，Java 2 Platform, Enterprise Edition，企业版）。3、Java ME（J2ME，Java 2 Platform Micro Edition，微型版）。

CommonBeanUtils 好像有

//创建Socket 客户端对象 Socket s = new Socket("127.0.0.1",6666);//创建ServerSocket 服务器端对象。。ServerSocket ss = new ServerSocket(6666); //监听服务器连接 s = ss.accept();

所谓socket通常也称作"套接字"，用于描述IP地址和端口，是一个通信链的句柄。应用程序通常通过"套接字"向网络发出请求或者应答网络请求。x0dx0a以J2SDK-1.3为例，Socket和ServerSocket类库位于java.net包中。ServerSocket用于服务器端，Socket是建立网络连接时使用的。在连接成功时，应用程序两端都会产生一个Socket实例，操作这个实例，完成所需的会话。对于一个网络连接来说，套接字是平等的，并没有差别，不因为在服务器端或在客户端而产生不同级别。不管是Socket还是ServerSocket它们的工作都是通过SocketImpl类及其子类完成的。x0dx0a重要的Socket API：x0dx0ajava.net.Socket继承于java.lang.Object，有八个构造器，其方法并不多，下面介绍使用最频繁的三个方法，其它方法大家可以见JDK-1.3文档。x0dx0a. Accept方法用于产生"阻塞"，直到接受到一个连接，并且返回一个客户端的Socket对象实例。"阻塞"是一个术语，它使程序运行暂时"停留"在这个地方，直到一个会话产生，然后程序继续；通常"阻塞"是由循环产生的。x0dx0a. getInputStream方法获得网络连接输入，同时返回一个InputStream对象实例。x0dx0a. getOutputStream方法连接的另一端将得到输入，同时返回一个OutputStream对象实例。x0dx0a注意：其中getInputStream和getOutputStream方法均会产生一个IOException，它必须被捕获，因为它们返回的流对象，通常都会被另一个流对象使用。x0dx0a2ServerSocket类例子编辑x0dx0ax0dx0apackage com.lanber.socket;x0dx0aimport java.io.DataInputStream;x0dx0aimport java.io.DataOutputStream;x0dx0aimport java.io.IOException;x0dx0aimport java.net.ServerSocket;x0dx0aimport java.net.Socket;x0dx0apublic class ServerDemo {x0dx0a/**x0dx0a* 注意：Socket的发送与接收是需要同步进行的，即客户端发送一条信息，服务器必需先接收这条信息，x0dx0a* 而后才可以向客户端发送信息，否则将会有运行时出错。x0dx0a* @param argsx0dx0a*/x0dx0apublic static void main(String[] args) {x0dx0aServerSocket ss = null;x0dx0atry {x0dx0ass = new ServerSocket(8888);x0dx0a//服务器接收到客户端的数据后，创建与此客户端对话的Socketx0dx0aSocket socket = ss.accept();x0dx0a//用于向客户端发送数据的输出流x0dx0aDataOutputStream dos = new DataOutputStream(socket.getOutputStream());x0dx0a//用于接收客户端发来的数据的输入流x0dx0aDataInputStream dis = new DataInputStream(socket.getInputStream());x0dx0aSystem.out.println("服务器接收到客户端的连接请求：" + dis.readUTF());x0dx0a//服务器向客户端发送连接成功确认信息x0dx0ados.writeUTF("接受连接请求，连接成功!");x0dx0a//不需要继续使用此连接时，关闭连接x0dx0asocket.close();x0dx0ass.close();x0dx0a} catch (IOException e) {x0dx0ae.printStackTrace();x0dx0a}x0dx0a}x0dx0a}x0dx0ax0dx0a3客户端的例子编辑x0dx0apackage com.lanber.socket;x0dx0aimportjava.io.DataInputStream;x0dx0a　　import java.io.DataOutputStream;x0dx0a　　importjava.io.IOException;x0dx0a　　import java.io.OutputStream;x0dx0a　　import java.net.Socket;x0dx0a　　import java.net.UnknownHostException;x0dx0apublic class ClientDemo {x0dx0a/**x0dx0a　　* @param argsx0dx0a　　*/x0dx0a　　public static void main(String[] args) {x0dx0a　　Socket socket = null;x0dx0a　　try {x0dx0a　　socket = new Socket("localhost",8888);x0dx0a　　//获取输出流，用于客户端向服务器端发送数据x0dx0a　　DataOutputStream dos = new DataOutputStream(socket.getOutputStream());x0dx0a　　//获取输入流，用于接收服务器端发送来的数据x0dx0a　　DataInputStream dis = new DataInputStream(socket.getInputStream());x0dx0a　　//客户端向服务器端发送数据x0dx0a　　dos.writeUTF("我是客户端，请求连接!");x0dx0a　　//打印出从服务器端接收到的数据x0dx0a　　System.out.println(dis.readUTF());x0dx0a　　//不需要继续使用此连接时，记得关闭哦x0dx0a　　socket.close();x0dx0a　　} catch (UnknownHostException e) {x0dx0a　　e.printStackTrace();x0dx0a　　} catch (IOException e) {x0dx0a　　e.printStackTrace();x0dx0a　　}x0dx0a　　}x0dx0a}

所谓socket通常也称作"套接字"，用于描述IP地址和端口，是一个通信链的句柄。应用程序通常通过"套接字"向网络发出请求或者应答网络请求。以J2SDK-1.3为例，Socket和ServerSocket类库位于java.net包中。ServerSocket用于服务器端，Socket是建立网络连接时使用的。在连接成功时，应用程序两端都会产生一个Socket实例，操作这个实例，完成所需的会话。对于一个网络连接来说，套接字是平等的，并没有差别，不因为在服务器端或在客户端而产生不同级别。不管是Socket还是ServerSocket它们的工作都是通过SocketImpl类及其子类完成的。重要的Socket API：java.net.Socket继承于java.lang.Object，有八个构造器，其方法并不多，下面介绍使用最频繁的三个方法，其它方法大家可以见JDK-1.3文档。. Accept方法用于产生"阻塞"，直到接受到一个连接，并且返回一个客户端的Socket对象实例。"阻塞"是一个术语，它使程序运行暂时"停留"在这个地方，直到一个会话产生，然后程序继续；通常"阻塞"是由循环产生的。. getInputStream方法获得网络连接输入，同时返回一个InputStream对象实例。. getOutputStream方法连接的另一端将得到输入，同时返回一个OutputStream对象实例。注意：其中getInputStream和getOutputStream方法均会产生一个IOException，它必须被捕获，因为它们返回的流对象，通常都会被另一个流对象使用。2ServerSocket类例子编辑package com.lanber.socket;import java.io.DataInputStream;import java.io.DataOutputStream;import java.io.IOException;import java.net.ServerSocket;import java.net.Socket;public class ServerDemo {/*** 注意：Socket的发送与接收是需要同步进行的，即客户端发送一条信息，服务器必需先接收这条信息，* 而后才可以向客户端发送信息，否则将会有运行时出错。* @param args*/public static void main(String[] args) {ServerSocket ss = null;try {ss = new ServerSocket(8888);//服务器接收到客户端的数据后，创建与此客户端对话的SocketSocket socket = ss.accept();//用于向客户端发送数据的输出流DataOutputStream dos = new DataOutputStream(socket.getOutputStream());//用于接收客户端发来的数据的输入流DataInputStream dis = new DataInputStream(socket.getInputStream());System.out.println("服务器接收到客户端的连接请求：" + dis.readUTF());//服务器向客户端发送连接成功确认信息dos.writeUTF("接受连接请求，连接成功!");//不需要继续使用此连接时，关闭连接socket.close();ss.close();} catch (IOException e) {e.printStackTrace();}}}3客户端的例子编辑package com.lanber.socket;importjava.io.DataInputStream;　　import java.io.DataOutputStream;　　importjava.io.IOException;　　import java.io.OutputStream;　　import java.net.Socket;　　import java.net.UnknownHostException;public class ClientDemo {/**　　* @param args　　*/　　public static void main(String[] args) {　　Socket socket = null;　　try {　　socket = new Socket("localhost",8888);　　//获取输出流，用于客户端向服务器端发送数据　　DataOutputStream dos = new DataOutputStream(socket.getOutputStream());　　//获取输入流，用于接收服务器端发送来的数据　　DataInputStream dis = new DataInputStream(socket.getInputStream());　　//客户端向服务器端发送数据　　dos.writeUTF("我是客户端，请求连接!");　　//打印出从服务器端接收到的数据　　System.out.println(dis.readUTF());　　//不需要继续使用此连接时，记得关闭哦　　socket.close();　　} catch (UnknownHostException e) {　　e.printStackTrace();　　} catch (IOException e) {　　e.printStackTrace();　　}　　}}

1.FamilyDoctor应该是Doctor的子类吧，若FamilyDoctor继承了Doctor类就可以了2.for (Doctor d:dlist)是集合遍历的一种写法

Socket是网络上运行的两个程序间双向通讯的一端，它既可以接受请求，也可以发送请求，利用它可以较为方便的编写网络上的数据的传递。在java中，有专门的socket类来处理用户的请求和响应。利用SOCKET类的方法，就可以实现两台计算机之间的通讯。这里就介绍一下在JAVA中如何利用socket进行网络编程。 在Java中Socket可以理解为客户端或者服务器端的一个特殊的对象，这个对象有两个关键的方法，一个是getInputStream方法，另一个是getOutputStream方法。getInputStream方法可以得到一个输入流，客户端的Socket对象上的getInputStream方法得到的输入流其实就是从服务器端发回的数据流。GetOutputStream方法得到一个输出流，客户端Socket对象上的getOutputStream方法返回的输出流就是将要发送到服务器端的数据流，（其实是一个缓冲区，暂时存储将要发送过去的数据）。 程序可以对这些数据流根据需要进行进一步的封装。本文的例子就对这些数据流进行了一定的封装（关于封装可以参考Java中流的实现部分）。 一、建立服务器类 Java中有一个专门用来建立Socket服务器的类，名叫ServerSocket，可以用服务器需要使用的端口号作为参数来创建服务器对象。ServerSocket server = new ServerSocket(9998) 这条语句创建了一个服务器对象，这个服务器使用9998号端口。当一个客户端程序建立一个Socket连接，所连接的端口号为9998时，服务器对象server便响应这个连接，并且server.accept()方法会创建一个Socket对象。服务器端便可以利用这个Socket对象与客户进行通讯。Socket incoming = server.accept() 进而得到输入流和输出流，并进行封装BufferedReader in = new BufferedReader(new InputStreamReader(incoming.getInputStream())); PrintWriter out = new PrintWriter(incoming.getOutputStream(),true); 随后，就可以使用in.readLine()方法得到客户端的输入，也可以使用out.println()方法向客户端发送数据。从而可以根据程序的需要对客户端的不同请求进行回应。

网络套接字，应用程序通常通过"套接字"向网络发出请求或者应答网络请求。

如果txt,xls，按行读，用特定的字符作分隔符来拆分，读一行处理一行，直到结束，导入都是这样的．给个txt的案例给你看看：File logFile = new java.io.File("d://PartInputLog.txt"); //ins = form.getFile().getInputStream(); //读取数据流workBook = Workbook.getWorkbook(ins); //打开工作簿sheet = workBook.getSheet(0); //打开SHEETint rowSize = sheet.getRows(); //获取总行数for(int i=0;i<rowSize;i++){if(sheet.getCell(0, i).getContents().trim().equals(""))break;String gysNo = sheet.getCell(0, i).getContents().trim();　　//获取第i行第1列的具体数据String bpNo = sheet.getCell(1, i).getContents().trim(); //获取第i行第2列的具体数据String numStr = sheet.getCell(2, i).getContents().trim(); //获取第i行第3列的具体数据.................................................｝//数据都可以读取到剩下的就在循环中插入了

这是EJB的东西 Session Bean 即会话Bean， EntityBean 即实体Bean在实体类上加上@entity表示这个类是实体类，可以被Session Bean操作，在Session Bean中获取实体管理器，对其操作。

1、Bean，参考百科：http://baike.baidu.com/view/209585.htm实体对象类，可以将数据库操作抽象成对类的操作。数据库不是面相对象的。如hibernate DTO 数据传输对象 这些都是bean的意思。如struts1中formbean 就是一种传输对象，将页面传递的参数封装正一个对象。2.Entity Bean 域模型对象，用于实现O/R映射，负责将数据库中的表记录映射为内存中的Entity对象，事实上，创建一个Entity Bean对象相当于新建一条记录，删除一个Entity Bean会同时从数据库中删除对应记录，修改一个Entity Bean时，容器会自动将Entity Bean的状态和数据库同步。3、JavaBean，参考百科：http://baike.baidu.com/view/28155.htm 是一种JAVA语言写成的可重用组件。为写成JavaBean，类必须是具体的和公共的，并且具有无参数的构造器。JavaBean 通过提供符合一致性设计模式的公共方法将内部域暴露成员属性。众所周知，属性名称符合这种模式，其他Java 类可以通过自身机制发现和操作这些JavaBean 的属性。

一看名字，就是注解的一个实体类