java打包详解
大多数Java 程序员都熟悉对JAR 文件的基本操作。但是只有少数程序员了解JAR 文件格式的强大功能。在本文中，作者探讨了JAR 格式的许多功能和优势，包括打包、可执行的JAR 文件、安全性和索引。JAR 文件是什么？
JAR 文件格式以流行的ZIP 文件格式为基础，用于将许多个文件聚集为一个文件。与ZIP 文件不同的是，JAR 文件不仅用于压缩和发布，而且还用于部署和封装库、组件和插件程序，并可被像编译器和JVM 这样的工具直接使用。在JAR 中包含特殊的文件，如manifests 和部署描述符，用来指示工具如何处理特定的JAR。
一个JAR 文件可以用于：
用于发布和使用类库
作为应用程序和扩展的构建单元
作为组件、applet 或者插件程序的部署单位
用于打包与组件相关联的辅助资源
JAR 文件格式提供了许多优势和功能，其中很多是传统的压缩格式如ZIP 或者TAR 所没有提供的。它们包括：
安全性。可以对JAR 文件内容加上数字化签名。这样，能够识别签名
的工具就可以有选择地为您授予软件安全特权，这是其他文件做不到的，它还可以检测代码是否被篡改过。
减少下载时间。如果一个applet 捆绑到一个JAR 文件中，那么浏览器就可以在一个HTTP 事务中下载这个applet 的类文件和相关的资源，而不是对每一个文件打开一个新连接。
压缩。JAR 格式允许您压缩文件以提高存储效率。
传输平台扩展。Java 扩展框架(Java Extensions Framework)提供了向Java 核心平台添加功能的方法，这些扩展是用JAR 文件打包的(Java 3D 和JavaMail 就是由Sun 开发的扩展例子)。
包密封。存储在JAR 文件中的包可以选择进行密封，以增强版本一致性和安全性。密封一个包意味着包中的所有类都必须在同一JAR 文件中找到。
包版本控制。一个JAR 文件可以包含有关它所包含的文件的数据，如厂商和版本信息。
可移植性。处理JAR 文件的机制是Java 平台核心API 的标准部分。压缩的和未压缩的JAR
jar 工具(有关细节参阅jar 工具)在默认情况下压缩文件。未压缩的JAR 文件一般可以比压缩过的JAR 文件更快地装载，因为在装载过程中要解压缩文件，但是未压缩的文件在网络上的下载时间可能更长。
META-INF 目录
大多数JAR 文件包含一个META-INF 目录，它用于存储包和扩展的配置数据，如安全性和版本信息。Java 2 平台识别并解释META-INF 目录中的下述文件和目录，以便配置应用程序、扩展和类装载器：
MANIFEST.MF。这个manifest 文件定义了与扩展和包相关的数据。
INDEX.LIST。这个文件由jar 工具的新选项-i 生成，它包含在应用程序或者扩展中定义的包的位置信息。它是JarIndex 实现的一部分，并由类装载器用于加速类装载过程。
xxx.SF。这是JAR 文件的签名文件。占位符xxx 标识了签名者。
xxx.DSA。与签名文件相关联的签名程序块文件，它存储了用于签名JAR 文件的公共签名。
jar 工具
为了用JAR 文件执行基本的任务，要使用作为Java Development Kit 的一部分提供的Java Archive Tool (jar 工具)。用jar 命令调用jar 工具。
表 1 显示了一些常见的应用：
表 1. 常见的jar 工具用法功能命令
用一个单独的文件创建一个JAR 文件jar cf jar-file input-file...
用一个目录创建一个JAR 文件jar cf jar-file dir-name
创建一个未压缩的JAR 文件jar cf0 jar-file dir-name
更新一个JAR 文件jar uf jar-file input-file...
查看一个JAR 文件的内容jar tf jar-file
提取一个JAR 文件的内容jar xf jar-file
从一个JAR 文件中提取特定的文件jar xf jar-file archived-file...
运行一个打包为可执行JAR 文件的应用程序java -jar app.jar
可执行的JAR
一个可执行的jar 文件是一个自包含的Java 应用程序，它存储在特别配置的JAR 文件中，可以由JVM 直接执行它而无需事先提取文件或者设置类路径。要运行存储在非可执行的JAR 中的应用程序，必须将它加入到您的类路径中，并用名字调用应用程序的主类。但是使用可执行的JAR 文件，我们可以不用提取它或者知道主要入口点就可以运行一个应用程序。可执行JAR 有助于方便发布和执行Java 应用程序。
创建可执行JAR
创建一个可执行JAR 很容易。首先将所有应用程序代码放到一个目录
中。假设应用程序中的主类是com.mycompany.myapp.Sample。您要创建一个包含应用程序代码的JAR 文件并标识出主类。为此，在某个位置(不是在应用程序目录中)创建一个名为manifest 的文件，并在其中加入以下一行：
Main-Class: com.mycompany.myapp.Sample
然后，像这样创建JAR 文件：
jar cmf manifest ExecutableJar.jar application-dir
所要做的就是这些了-- 现在可以用java -jar 执行这个JAR 文件ExecutableJar.jar。
一个可执行的JAR 必须通过menifest 文件的头引用它所需要的所有其他从属JAR。如果使用了-jar 选项，那么环境变量CLASSPATH 和在命令行中指定的所有类路径都被JVM 所忽略。
启动可执行JAR
既然我们已经将自己的应用程序打包到了一个名为ExecutableJar.jar 的
可执行JAR 中了，那么我们就可以用下面的命令直接从文件启动这个应用程序：
java -jar ExecutableJar.jar
包密封
密封JAR 文件中的一个包意味着在这个包中定义的所有类都必须在同一个JAR 文件中找到。这使包的作者可以增强打包类之间的版本一致性。密封还提供了防止代码篡改的手段。
要密封包，需要在JAR 的manifest 文件中为包添加一个Name 头，然后加上值为“true”的Sealed 头。与可执行的JAR 一样，可以在创建JAR 时，通过指定一个具有适当头元素的manifest 文件密封一个JAR，如下所示：
Name: com/samplePackage/
Sealed: true
Name 头标识出包的相对路径名。它以一个“/”结束以与文件名区别。在Name 头后面第一个空行之前的所有头都作用于在Name 头中指定的文件或者包。在上述例子中，因为Sealed 头出现在Name 头后并且中间没有空行，所以Sealed 头将被解释为只应用到包
com/samplePackage 上。
如果试图从密封包所在的JAR 文件以外的其他地方装载密封包中的一个类，那么JVM 将抛出一个SecurityException。
扩展打包
扩展为Java 平台增加了功能，在JAR 文件格式中已经加入了扩展机制。扩展机制使得JAR 文件可以通过manifest 文件中的Class-Path 头指定所需要的其他JAR 文件。
假设extension1.jar 和extension2.jar 是同一个目录中的两个JAR 文件，extension1.jar 的manifest 文件包含以下头：
Class-Path: extension2.jar
这个头表明extension2.jar 中的类是extension1.jar 中的类的扩展类。extension1.jar 中的类可以调用extension2.jar 中的类，并且不要求extension2.jar 处在类路径中。
在装载使用扩展机制的JAR 时，JVM 会高效而自动地将在Class-Path 头中引用的JAR 添加到类路径中。不过，扩展JAR 路径被解释为相对路径，所以一般来说，扩展JAR 必须存储在引用它的JAR 所在的同一
目录中。
例如，假设类ExtensionClient 引用了类ExtensionDemo,它捆绑在一个名为ExtensionClient.jar 的JAR 文件中，而类ExtensionDemo 则捆绑在ExtensionDemo.jar 中。为了使ExtensionDemo.jar 可以成为扩展，必须将ExtensionDemo.jar 列在ExtensionClient.jar 的manifest 的Class-Path 头中，如下所示：
Manifest-Version: 1.0
Class-Path: ExtensionDemo.jar
在这个manifest 中Class-Path 头的值是没有指定路径的ExtensionDemo.jar，表明ExtensionDemo.jar 与ExtensionClient JAR 文件处在同一目录中。
JAR 文件中的安全性
JAR 文件可以用jarsigner 工具或者直接通过java.security API 签名。一个签名的JAR 文件与原来的JAR 文件完全相同，只是更新了它的manifest，并在META-INF 目录中增加了两个文件，一个签名文件和一个签名块文件。
JAR 文件是用一个存储在Keystore 数据库中的证书签名的。存储在
keystore 中的证书有密码保护，必须向jarsigner 工具提供这个密码才能对JAR 文件签名。
图 1. Keystore 数据库
JAR 的每一位签名者都由在JAR 文件的META-INF 目录中的一个具有.SF 扩展名的签名文件表示。这个文件的格式类似于manifest 文件-- 一组RFC-822 头。如下所示，它的组成包括一个主要部分，它包括了由签名者提供的信息、但是不特别针对任何特定的JAR 文件项，还有一系列的单独的项，这些项也必须包含在menifest 文件中。在验证一个签名的JAR 时，将签名文件的摘要值与对JAR 文件中的相应项计算的摘要值进行比较。
清单1. 签名JAR 中的Manifest 和signature 文件
Contents of signature file META-INF/MANIFEST.MF
Manifest-Version: 1.0
Created-By: 1.3.0 (Sun Microsystems Inc.)
Name: Sample.java
SHA1-Digest: 3+DdYW8INICtyG8ZarHlFxX0W6g=
Name: Sample.class
SHA1-Digest: YJ5yQHBZBJ3SsTNcHJFqUkfWEmI=
Contents of signature file META-INF/JAMES.SF
Signature-Version: 1.0
SHA1-Digest-Manifest: HBstZOJBuuTJ6QMIdB90T8sjaOM=
Created-By: 1.3.0 (Sun Microsystems Inc.)
Name: Sample.java
SHA1-Digest: qipMDrkurQcKwnyIlI3Jtrnia8Q=
Name: Sample.class
SHA1-Digest: pT2DYby8QXPcCzv2NwpLxd8p4G4=
数字签名
一个数字签名是.SF 签名文件的已签名版本。数字签名文件是二进制文件，并且与.SF 文件有相同的文件名，但是扩展名不同。根据数字签名的类型-- RSA、DSA 或者PGP -- 以及用于签名JAR 的证书类型而有不同的扩展名。
Keystore
要签名一个JAR 文件，必须首先有一个私钥。私钥及其相关的公钥证书存储在名为keystores 的、有密码保护的数据库中。JDK 包含创建和修改keystores 的工具。keystore 中的每一个密钥都可以用一个别名标识，它通常是拥有这个密钥的签名者的名字。
所有keystore 项(密钥和信任的证书项)都是用唯一别名访问的。别名是在用keytool -genkey 命令生成密钥对(公钥和私钥)并在keystore 中添加项时指定的。之后的keytool 命令必须使用同样的别名引用这一项。
例如，要用别名“james”生成一个新的公钥/私钥对并将公钥包装到自签名的证书中，要使用下述命令：
keytool -genkey -alias james -keypass jamespass
-validity 80 -keystore jamesKeyStore
-storepass jamesKeyStorePass
keytool -genkey -alias james -keypass jamespass -validity 80 -keystore jamesKeyStore -storepass jamesKeyStorePass
keytool -genkey -alias 别名-keypass 密码-validity 80 -keystore jamesKeyStore -storepass 密钥的文件名称
这个命令序列指定了一个初始密码“jamespass”，后续的命令在访问keystore “jamesKeyStore”中与别名“james”相关联的私钥时，就需要这个密码。如果keystore“jamesKeyStore”不存在，则keytool 会自动创建它。
jarsigner 工具
jarsigner 在目录C:\Program Files\Java\jdk1.6.0_25\bin下面
jarsigner 工具使用keystore 生成或者验证JAR 文件的数字签名。
假设像上述例子那样创建了keystore “jamesKeyStore”，并且它包含一个别名为“james”的密钥，可以用下面的命令签名一个JAR 文件：
jarsigner -keystore jamesKeyStore -storepass jamesKeyStorePass
-keypass jamespass -signedjar SSample.jar Sample.jar james
jarsigner -keystore jamesKeyStore -storepass jamesKeyStorePass -keypass jamespass -signedjar JTwain1.jar JTwain.jar james
jarsigner -keystore jamesKeyStore -storepass 密钥的文件名称-keypass 密码-signedjar SSample.jar Sample.jar 别名
这个命令用密码“jamesKeyStorePass”从名为“jamesKeyStore”的keystore 中提出别名为“james”、密码为“jamespass”的密钥，并对Sample.jar 文件签名、创建一个签名的JAR -- SSample.jar。
jarsigner 工具还可以验证一个签名的JAR 文件，这种操作比签名JAR 文件要简单得多，只需执行以下命令：
jarsigner -verify SSample.jar
如果签名的JAR 文件没有被篡改过，那么jarsigner 工具就会告诉您JAR 通过验证了。否则，它会抛出一个SecurityException，表明哪些文件没有通过验证。
还可以用java.util.jar 和java.security API 以编程方式签名JAR(有关细节参阅参考资料)。也可以使用像Netscape Object Signing Tool 这样的工具。
JAR 索引
如果一个应用程序或者applet 捆绑到多个JAR 文件中，那么类装载器就使用一个简单的线性搜索算法搜索类路径中的每一个元素，这使类装载器可能要下载并打开许多个JAR 文件，直到找到所要的类或者资源。如果类装载器试图寻找一个不存在的资源，那么在应用程序或者applet 中的所有JAR 文件都会下载。对于大型的网络应用程序和applet，这会导致启动缓慢、响应迟缓并浪费带宽。
从JDK 1.3 以后，JAR 文件格式开始支持索引以优化网络应用程序中类的搜索过程，特别是applet。JarIndex 机制收集在applet 或者应用程序中定义的所有JAR 文件的内容，并将这些信息存储到第一个JAR 文件中的索引文件中。下载了第一个JAR 文件后，applet 类装载器将使用收集的内容信息高效地装载JAR 文件。这个目录信息存储在根JAR 文件的META-INF 目录中的一个名为INDEX.LIST 的简单文本文件中。
创建一个JarIndex
可以通过在jar 命令中指定-i 选项创建一个JarIndex。假设我们的目录结构如下图所示：
图 2. JarIndex
您将使用下述命令为JarIndex_Main.jar、JarIndex_test.jar 和JarIndex_test1.jar 创建一个索引文件：
jar -i JarIndex_Main.jar JarIndex_test.jar SampleDir/JarIndex_test1.jar
INDEX.LIST 文件的格式很简单，包含每个已索引的JAR 文件中包含的包或者类的名字，如清单2 所示：
清单2. JarIndex INDEX.LIST 文件示例
JarIndex-Version: 1.0
JarIndex_Main.jar
JarIndex_test.jar
Sample
SampleDir/JarIndex_test1.jar
org
org/apache
org/apache/xerces
org/apache/xerces/framework
org/apache/xerces/framework/xml4j
结束语
JAR 格式远远超出了一种压缩格式，它有许多可以改进效率、安全性和组织Java 应用程序的功能。因为这些功能已经建立在核心平台-- 包括编译器和类装载器-- 中了，所以开发人员可以利用JAR 文件格式的能力简化和改进开发和部署过程。
Java分页类封装
java分页类封装 分页类的主要有3个基本字段：当前页（页码）、分页大小(每页显示的数据大小)、数据总数目。 当前页：currentPage 分页大小：pageSize 数据总数目: recordTotalCount 注意： “/”:代表求商，如7/3=2 “%”:代表求余，如7%3=1 由基本字段派生出来的字段：是否有上一页previous、是否有下一页next、总页数totalPage 是否有上一页是由当前页决定，看当前页是否大于1 是否有下一页是由总页数决定，看当前页是否小于总页数 总页数是由数据总数目和分页大小决定。 例如：如果数据有92条，你要每页显示10条，92÷10=9...2 ,多出来的2条数据，也算1页，总页数就是9+1=10页。 怎么处理余数，看以下公式 公式1 总页数=[数据总数目]/[分页大小]+(余数>0,则+1，余数=0,则+0)。 如92÷10=9...2 ，9+1=10 公式2 总页数=[数据总数目]÷[分页大小]的向上取整。 如92÷10=9.2 ,向上取整为10 公式3 总页数=([数据总数目]+([分页大小]-1))/[分页大小] 不明白为什么[分页大小]要减去1? (92+(10-1))/10=10 => 90/10+ (2+(10-1))/10= > 9+1 它是这样处理余数的 不管数据总数目是多少，余数的范围是0<=余数<=被除数-1，所以，余数的范围是0<=余数<=分页大小-1 (余数值+(余数范围的最大值))/分页大小=> (2+(10-1))/10=1 也就是(余数值+(分页大小-1))/分页大小的结果是等价于公式1中的(余数>0,则+1，余数=0,则+0) 公式3不方便开发人员理解，但是就是有许多人用，本人不推荐用，没必要弄复杂，自己不明白，其他人也是一脸闷逼。最好就用公式一或公式二，简单明了迅速准确。
java面向对象—封装详解
Java面向对象 面向对象 在Java中，高手们的概念就是万物皆对象。 面向对象的概念： 面向对象：是基于面向过程的一种思想。 面向过程：强调的是功能行为。 面向对象：将功能封装进对象，强调具备了功能的对象。面向对象是基于面向过程的。 面向对象和面向过程： 图例：
面向对象特点： 1，面向对象就是一种常见的思想。符合人们的思考习惯。 2，面向对象的出现，将复杂的问题简单化。 3，面向对象的出现，让曾经在过程中的执行者，变成了对象中的指挥者。面试题：你怎么理解面向对象的？ 1，它符合现在人们思考的一种习惯 2，它让我们复杂的事情简单化 3，让我们从曾经的执行都变为现在的指挥者 其实面试官你本身就在用面向对象的方式思考问题
因为以面试官您的能力而言，来了一个软件项目的话，您从需求分析到设计到开发到测试，都能完成，但是这样特别耗时间，所以您为了提高效率，您就需要 去找一些具备专业编程经验的人来完成这些项目，我正好就是那个具备专业编程经验的对象，您只要指挥我这个对象做事情就可以了，我会给您一个非常满意的 结果，至于过程您不用管。所以面试官您就在用面向对象的方式思考问题，来提高公司的效率，而我就是具备专业编程经验的人。 面向对象有三个特征：封装，继承，多态 以后的开发过程：其实就是找对象用。没有对象，就创建一个对象。 找对象，建立对象，使用对象，并维护对象的关系。 类和对象的关系： 类：就是对现实生活中事物的描述。 对象：就是这类事物，实实在在存在的个体。 想要描述：提取对象中共性内容。对具体的抽象。 映射到Java中描述就是class定义的类。 具体对象就是对应Java在堆内存中用new建立实体。 例子： 需求：描述小汽车。描述事物其实就是在描述事情的属性和行为。 分析： 1，属性：轮胎数。颜色。 2，行为：运行。 定义类其实就是在定义类中的成员。 成员：成员变量<-->属性，成员函数<-->行为。 属性对应是类中变量，行为对应的类中函数或方法。 其实定义类，就是在描述事物，就是在定义属性和方法，属性和行为共同成为类中的成员（成员变量和成员方法）。
Java面向对象程序设计 类封装
计算机工程系实验报告 课程名称：Java面向对象程序设计 班级：姓名：学号： 一、实验目的: 掌握使用类来封装对象的属性和功能。 二、实验要求: 1、编写一个Java应用程序，该程序中有3个类：Trangle，Lader和Circle，分别用来刻画三角形、梯形和圆形，具体要求如下： 1）Trangle类具有三个边长、周长和面积属性，具有返回周长、面积以及修改三个边的功能。另外还有一个boolean类型的属性，该属性用来判断三个数能否构成一个三角形。 2）Lader类具有上底、下底、高、面积属性，具有返回面积的功能。 3）Circle类具有半径、周长和面积属性，具有返回周长和面积的功能。 4）按程序模板的要求，将代码1-代码24替换为Java程序代码 5）给Trangle类增加三个方法，分别用来返回三个边：sideA,sideB,sideC。 6）让AreaAndLength类中的circle对象调用方法修改半径，然后输出修改后的半径以及修改半径后的圆的面积和周长。 2、编写一个类Person，可描述姓名、性别、年龄，可获取姓名、性别、年龄。该类含两个构造方法，一个无参数，一个带三个参数。编写主类，在主方法中分别用两个构造方法创建两个Person类的对象，分别输出这两个对象的姓名、性别、年龄。 三、程序代码: 1、程序模板 class Trangle { double sideA,sideB,sideC,area,length; boolean boo; public Trangle(double a,double b,double c) { sideA=a; sideB=b; sideC=c; //a,b,c分别赋值给sideA,sideB,sideC if(sideA+sideB>sideC&&sideB+sideC>sideA&&sideA+sideC>sideB) //a,b,c构成三角形的条件 { boo=true; //给boo赋值 } else {
java封装对象
package cn.itcast.introspector; import java.io.BufferedReader; /* 需求：编写一个工厂方法根据配置文件的内容，工厂方法返回对应的对象，并且把对象要有对应的属性值。 */ import java.io.FileReader; import https://www.360docs.net/doc/b314268415.html,ng.reflect.Constructor; import https://www.360docs.net/doc/b314268415.html,ng.reflect.Field; /* 以后我们开发框架的时候，我们是经常需要把一些数据封装到对象中的。 */ public class Demo1 { public static void main(String[] args) throws Exception { Person p = (Person) getInstance(); System.out.println(p); } //根据配置文件的内容生产对象的对象并且要把对象的属性值封装到对象中。
public static Object getInstance() throws Exception{ BufferedReader bufferedReader = new BufferedReader(new FileReader("obj.txt")); String className = bufferedReader.readLine(); //读取配置文件获取到完整的类名。 Class clazz = Class.forName(className); //通过class对象获取到无参的构造方法 Constructor constructor = clazz.getConstructor(null); //创建对象 Object o = constructor.newInstance(null); //读取属性值 String line = null; while((line = bufferedReader.readLine())!=null){ String[] datas = line.split("="); //通过属性名获取到对应的Field对象。 Field field = clazz.getDeclaredField(datas[0]); if(field.getType()==int.class){ field.set(o, Integer.parseInt(datas[1])); }else{ field.set(o, datas[1]); } } return o; } }
Java中八种基本数据类型和八种封装数据类型
Java中八种基本数据类型和八种封装数据类型 初使值的求解过程及比较 作者：Zealjiang 1.八种基本数据类型 创建名为MemberTestBasic的java文件，其内容如下：public class MemberTestBasic { /** 八种基本类型 int, short, float ,double, long, boolean, byte, char */ int i; short s; float f; double d; long l; boolean bo; byte by; char c; public static void main(String[] args) { //创建对象m
MemberTestBasic m=new MemberTestBasic(); m.printMember(); } //为对象m创建一个printMember方法 public void printMember() { System.out.print("int->"+i+"\n"); System.out.print("short->"+s+"\n"); System.out.print("float->"+f+"\n"); System.out.print("double->"+d+"\n"); System.out.print("long->"+l+"\n"); System.out.print("boolean->"+bo+"\n"); System.out.print("byte->"+by+"\n"); System.out.print("char->"+c+"\n"); } } 运行结果如下：
Java-面向对象(基础篇)--构造方法私有化及对象数组
构造方法私有化及对象数组 一．构造方法私有化 1.问题的引出 类的封装性不只体现在对属性的封装上，实际上方法也是可以进行封装的，当然， 在方法封装中也包括了对构造方法的封装。 例： class Singleton{ private Singleton(){ } public void print(){ System.out.println("Hello World！"); } } 从之前的讲解中可以清楚的知道，一个类想使用，则必须要有实例化的对象，现在 要想调用Singleton类中的print()方法则一定要首先产生Singleton的实例化对象， 但是由于此时构造方法被私有化了，所以如果按照如下的程序编写，则肯定会出现 错误。 【错误代码，直接实例化Singleton类对象】 public class SingletonDemo02 { public static void main(String[] args){ Singleton s1=null; s1=new Singleton(); s1.print(); } } 程序运行的结果为： SingletonDemo02.java:13: 错误: Singleton()可以在Singleton中访问private s1=new Singleton(); ^ 1 个错误 从上述错误提示中可以发现，程序是在使用new关键字实例化对象时出现了错误， 而对于声明对象则没有任何的错误，那么该如何解释那？ 封装是指一切外部不可见性，那么就意味着在外部根本无法调用被封装的构造方法，既然外部不能调用，那么在内部码？ 【在内部产生Singleton的对象】 class Singleton{ staticSingleton instance=new Singleton(); private Singleton(){ } public void print(){
java基本数据类型与其封装类
java基本数据类型与其封装类 1 Boolean VS boolean public final class Boolean extends [url=file:///G:/html_zh_CN/html/zh_CN/api/java/lang/Object.html]Object[/url]implements [url=file:///G:/html_zh_CN/html/zh_CN/api/java/io/Serializable.html]Serializable[/url], [url=file:///G:/html_zh_CN/html/zh_CN/api/java/lang/Comparable.html]Comparable[/url]<[url=fil e:///G:/html_zh_CN/html/zh_CN/api/java/lang/Boolean.html]Boolean[/url]> Boolean 类将基本类型为boolean的值包装在一个对象中。一个Boolean类型的对象只包含一个类型为boolean的字段。 此外，此类还为boolean和String的相互转换提供了许多方法，并提供了处理boolean时非常有用的其他一些常量和方法。 2 Byte VS byte public final class Byte extends [url=file:///G:/html_zh_CN/html/zh_CN/api/java/lang/Number.html]Number[/url]implements [url=file:///G:/html_zh_CN/html/zh_CN/api/java/lang/Comparable.html]Comparable[/url]<[url=fil e:///G:/html_zh_CN/html/zh_CN/api/java/lang/Byte.html]Byte[/url]> Byte类将基本类型byte的值包装在一个对象中。一个Byte类型的对象只包含一个类型为byte的字段。 此外，该类还为byte和String的相互转换提供了几种方法，并提供了处理byte时非常有用的其他一些常量和方法。 3 Character VS char public final class Character extends [url=file:///G:/html_zh_CN/html/zh_CN/api/java/lang/Object.html]Object[/url]implements [url=file:///G:/html_zh_CN/html/zh_CN/api/java/io/Serializable.html]Serializable[/url], [url=file:///G:/html_zh_CN/html/zh_CN/api/java/lang/Comparable.html]Comparable[/url]<[url=fil e:///G:/html_zh_CN/html/zh_CN/api/java/lang/Character.html]Character[/url]> Character类在对象中包装一个基本类型char的值。Character类型的对象包含类型为char的单个字段。 此外，该类提供了几种方法，以确定字符的类别（小写字母，数字，等等），并将字符从大写转换成小写，反之亦然。 4 Double VS double public final class Double extends [url=file:///G:/html_zh_CN/html/zh_CN/api/java/lang/Number.html]Number[/url]implements [url=file:///G:/html_zh_CN/html/zh_CN/api/java/lang/Comparable.html]Comparable[/url]<[url=fil e:///G:/html_zh_CN/html/zh_CN/api/java/lang/Double.html]Double[/url]> Double类在对象中包装了一个基本类型double的值。每个Double类型的对象都包含一个double类型的字段。 此外，该类还提供了多个方法，可以将double转换为String，将String转换为double，还提供了其他一些处理double时有用的常量和方法。
java中构造方法和方法全面解析
构造方法和方法的区别： 构造方法要与类名相同，无返回类型，在类初始化的时候调用。 方法最好与类名不同，对象调用，静态方法可用类名.方法（）. 构造器和方法在下面三个方面区别：修饰符，返回值，命名。 1。和方法一样，构造器可以有任何访问的修饰：public, protected, private或者没有修饰（通常被package 和friendly调用）. 不同于方法的是，构造器不能有以下非访问性质的修饰：abstract, final, native, static, 或者synchronized。 2。返回类型也是非常重要的。方法能返回任何类型的值或者无返回值（void），构造器没有返回值，也不需要void。 3。两者的命名。构造器使用和类相同的名字，而方法则不同。按照习惯，方法通常用小写字母开始，而构造器通常用大写字母开始。构造器通常是一个名词，因为它和类名相同；而方法通常更接近动词，因为它说明一个操作。 构造方法和方法中this和supper的用法区别： "this"的用法 构造器和方法使用关键字this有很大的区别。方法引用this指向正在执行方法的类的实例。静态方法不能使用this关键字，因为静态方法不属于类的实例，所以this也就没有什么东西去指向。构造器的this指向同一个类中，不同参数列表的另外一个构造器，我们看看下面的代码： package com.dr.gouzao; public class Platypus { String name; Platypus(String input) { name = input; }
Platypus() { this("John/Mary Doe"); } public static void main(String args[]) { Platypus p1 = new Platypus("digger"); Platypus p2 = new Platypus(); System.out.println(https://www.360docs.net/doc/b314268415.html, + "----" + https://www.360docs.net/doc/b314268415.html,); } } 在上面的代码中，有2个不同参数列表的构造器。第一个构造器，给类的成员name赋值，第二个构造器，调用第一个构造器，给成员变量name一个初始值"John/Mary Doe". 在构造器中，如果要使用关键字this,那么，必须放在第一行，如果不这样，将导致一个编译错误。在一个构造方法中只能调用一次其它的构造方法，并且调用构造方法的语句必须是第一条语句。 "super"的用法 构造器和方法，都用关键字super指向超类，但是用的方法不一样。方法用这个关键字去执行被重载的超类中的方法。看下面的例子： package com.dr.gouzao;
Java语言基本数据类型、转换及其封装
Java语言基本数据类型、转换及其封装Java语言基本数据类型、转换及其封装 1. 逻辑类型 ·常量 true，false。 ·变量的定义 使用关键字boolean来定义逻辑变量： boolean x; boolean tom_12; 也可以一次定义几个： boolean x,tom,jiafei,漂亮 x，tom，jiafei，漂亮都是变量的名字。定义时也可以赋给初值： boolean x=true,tom=false,漂亮=true,jiafei 2.整数类型 ·常量123，6000（十进制），077（八进制），0x3ABC（十六进制）。 ·整型变量的定义分为4种： 1.int 型 使用关键字int来定义int型整形变量 int x int tom_12 也可以定义几个： int x,tom,jiafei,漂亮 x，tom，jiafei，漂亮都是名字。定义时也可以赋给初值： int x=12,tom=-1230,漂亮=9898,jiafei 对于int型变量，分配给4个字节byte,一个字节由8位（bit）组成，4个字节占32位（bit）。bit 有两状态，分别用来表示0，1。这样计算机就可以使用2进制数来存储信息了。内存是一种特殊的电子元件，如果把内存条放大到摩天大
楼那么大，那么它的基本单位——字节，就好比是大楼的房间，每个房间的结构都是完全相同的，一个字节由8个能显示两种状态的bit组成，就好比每个房间里有8个灯泡，每个灯泡有两种状态——亮灯灭灯。 对于 int x=7; 内存存储状态如下： 00000000 00000000 00000000 00000111 最高位：左边的第一位，是符号位，用来区分正数或负数，正数使用原码表示，最高位是0，负数用补码表示，最高位是1。例如： int x=-8; 内存的存储状态如下： 11111111 11111111 11111111 11111000 要得到-8的补码，首先得到7的原码，然后将7的原码中的0变成1，1变成0，就是-8的补码。 因此，int型变量的取值范围是-2^31~2^31-1。 2. byte型 使用关键字byte来定义byte型整型变量 byte x ; byte tom_12; 也可以一次定义几个： byte x,tom,jiafei,漂亮 x，tom，jiafei，漂亮都是名字。定义时也可以赋给初值： byte x=-12,tom=28,漂亮=98,jiafei 注：对于byte型变量，内存分配给1个字节，占8位，因此byte型变量的取值范围是： -2^7~2^7-1。
java面向对象编程、类的封装、接口和基本类库练习题
面向对象编程基本知识练习 一、判断题 1.不需要定义类，就能创建对象。（） 2.构造方法用于给类的private 实例变量赋值。（） 3.对象一经声明就可以立即使用。（） 4.在定义变量和方法时，必须清楚地在其面前标上访问权限修饰符。（） 5.Java 程序中的参数传递都是把参数值传递给方法定义中的参数。（） 6.在类定义中，成员访问权限修饰符不能多次出现。（） 7.new 操作符动态地为对象按其指定的类型分配内存，并返回该类型的一个引用。（） 8.类的方法通常设为public ，而类的实例变量一般也设为public 。（） 9.构造方法在创建对象时被调用。（） 10.通过点运算符与类对象的引用相连，可以访问此类的成员。（） 11.声明为protected 的类成员只能被此类中的方法访问。（） 12.同一个类的对象使用不同的内存段，但静态成员共享相同的内存空间。（） 13.类的成员变量可以放在类体的任意位置。（） 14.声明为protected 的类成员可以被此类作用域中的任何对象访问。（） 15.没有返回值的方法可以用void 来表示，也可以不加。（） 二、选择题 1.下面对对象概念描述错误的是：（） A 操作是对象的动态属性 B 任何对象都必须有继承性 C 对象间的通讯靠消息传递 D 对象是属性和方法的封装体 2．编译并运行下面的程序，运行结果为：（） public class A { public static void main（String[] args） { A a=new A（）； a.method（8）； } void method（int i） { System.out.println（“int：“+i）；
Java封装、继承、多态
第一章 抽象和封装 1.为什么使用面向对象 面向对象就是采用“现实模拟”的方法设计和开发程序。 面向对象实现了虚拟世界和现实世界的一致性，符合人们的思维习惯，使得客户和软件设计开发人员之间，软件设计开发人员内部交流更加顺畅，同时还带来了代码重用性高、可靠性高等优点，大大提高了软件尤其是大型软件的设计和开发效率 2.使用面向对象进行设计 面向对象设计的过程就是抽象的过程。 根据业务相关的属性和行为，忽略不必要的属性和行为，由现实世界中“对象”抽象出软件开发中的对象 第一步：发现类 第二步：发现类的属性 第三步：发现类的方法 类的基本结构，其主要由属性和行为组成，称为类的成员变量（或者成员属性）和成员方法，统称为类的成员（除此之外类的成员还包括构造方法，代码块等） 对象的创建： 通过够造方法来创建对象。 通过对象名.属性名的方式调用属性 通过对象名.方法名的方式调用方法 Static 可以用来修饰属性、方法和代码快。Static的变量属于这个类所有，即由这个 类创建的所有对象共同用一个 Static 变量。通常把Static修饰的属性和方法称为类 属性（类变量）、类方法。不使用Static修饰的属性和方法，属于单个对象，通常称为 实例属性（实例变量），实例方法。 类属性、类方法可以通过类名和对象名访问，实例属性、实例方法只能通过对象名访问。Final 可以用来修饰属性、方法和类。用final修饰的变量称为常量，其值固定不变。 构造方法的名字和类名相同，没有返回值类型。构造方法的作用主要就是在创建对象时 执行一些初始化操作，如给成员属性赋初值。
在没有给类提供任何构造方法时，系统会提供一个无参的方法体为空的默认构造方法。一旦提供了自定义构造方法，系统将不会再提供这个默认的构造方法，如果要使用，必须手动添加。 如果一个类中包含了两个或两个以上方法，他们的方法名相同，方法参数个数或参数类型不同，则称该方法被重载了，这个过程称为方法重载，成员方法和构造方法都可以进行重载。 常见错误： 在类中可以定义Static变量，在方法里是否可以定义Static变量？ 结论：在方法里不可以定义Static变量，也就是说类变量不能是局部变量。 给构造函数加上返回值类型会出现什么情况？ 结论：构造方法没有返回值类型，如果有，就不是构造方法，而是和构造方法同名的成员变量。 4．用封装优化类 封装：将类的状态信息隐藏在类内不能，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问。 封装的具体步骤：修改属性的可见性来限制对属性的访问；为每个属性创建一对赋值方法（setter）和取值方法（getter），用于对这些属性的存取；在赋值方法中加入对属性的存取控制语句。 封装的好处主要有：隐藏类的实现细节；让使用者只能通过程序员规定的方法来访问数据；可以方便地加入存取控制语句，限制不合理操作。 封装时会用到多个权限控制符来修饰成员变量和方法，区别如下。 Private:成员变量和方法只能在类内被访问，具有类可见性 默认：成员变量和方法只能被同一个包里的类访问，具有包可见性。 Protected：可以被同一个包中的类访问，被同一个项目中不同包中的子类访问Public：可以被同一个项目中所有的类访问，具有项目可见性，这是最大的访问权限 第二章 继承 2.1 继承基础 1.在java中，继承通过extends关键字来实现， 2.父类又叫基类和超类。
Java中的构造方法和方法
Java中的方法和构造方法 如果你在学习的过程中有任何问题，都可以在下面留言，我会尽快给你回复。 一、方法 1.方法的定义：解决一类问题的代码的有序组合，是一个功能模块。 2.语法结构： 访问修饰符返回值类型方法名(参数列表){ 方法体； } 详解： (1)访问修饰符：方法允许被访问的权限范围，可以是public、protected、private、 也可以省略。各个修饰符权限大小如下表： (2)返回值类型：方法返回值的类型，如果方法不返回任何值，则返回值类型指定 为void ；如果方法有返回值，则需要指定返回值的类型，并且在方法体中使用return 语句返回值（注意：如果方法无返回值，也可以使用return语句返回，只不过return 后面不写任何东西）。 (3)方法名：定义的方法的名字，必须使用合法的标识符 这里我们回顾下标识符的命名规则：①.标识符必须是字母、数字、下划线（_）、$符；②.不能以数字开头；③.区分大小写；④.不能是java中的关键字和保留字。 (4)参数列表：传递给方法的参数列表，参数可以有多个，多个参数间以逗号隔开， 每个参数由参数类型和参数名组成，以空格隔开（比如：String name）。 根据方法是否带参、是否带返回值，可将方法分为四类：无参无返回值方法、无参有返回值方法、带参无返回值方法、带参带返回值方法。 3.无参无返回值方法： public void show(){ System.out.println("无参无返回值的方法"); } 4.无参有返回值方法： public int show(){ int num=555; System.out.println("无参无返回值的方法"); return num; } 注意：该方法返回值为int，必须使用return返回一个int型数值； 5.带参无返回值方法：
java封装(拼接)json 对象
今天在项目中需要用到使用java代码，拼成json的list对象，小研究一下，写出来分享给大家： 方法一： if (CollectionUtil.isNotEmpty(userModelList)) { List
JSONObject jsonobj = JSONObject.fromObject(oo); jsonobj.putAll(status); o.put("jsonp", jsonobj); System.out.println(o.toString()); return o.toString(); } //////////结果类似这样： {jsonp={"users":[{"id":"1","name":"客服NO1","image":null},{"id":"asfdafasd","name":"sdaf","image":"sadfas "},{"id":"asfdafasd","name":"sdaf","image":"sadfas"}],"status":"ok"} } 你也可以继续嵌套构造多级 方法2 直接使用string拼接 先new一个list，下边是部分代码
java类的封装实验报告
实验四、类的封装 一、实验目的 1. 掌握类的声明和定义； 2. 理解有静态成员和非静态成员变量的区别； 3. 理解基本参数和引用参数的区别； 4. 掌握类构造方法的编写； 5. 实现类的方法； 6. 掌握创建类实例的方法； 7. 学会定义和使用具有重载方法的继承类； 8. 掌握方法的重新定义。 二、实验内容 1．以下程序运行的结果是。 运行结果初始时 x=10, y=10 方法调用中 x=100, y=100 方法调用后 x=100, y=100 public class sy4_1 { public static void main(String[] args) { Power p=new Power(); p.ff2(10,10); System.out.println("方法调用后x="+p.x+", y="+p.y); } } class Power{ int x=10, y=10; void ff2(int passX, int passY){ System.out.println("初始时x="+x+", y="+y); x=passX*passX; y=passY*passY; System.out.println("方法调用中x="+x+", y="+y); } } 2.建立日期类及日期对象的简单引用，程序结构如下，写出完整代码。public class MyDate0 //声明日期类 { int year, month, day; //成员变量 void set(int y, int m, int d) { ... } //成员方法，设置日期 public String toString() { … } //成员方法返回中文日期 public static void main(String args[]) // 主方法 { ….//创建日期对象d1 ….//显示d1 的中文日期 ….//设置d1 的成员变量为今天日期
java实现协议封装
竭诚为您提供优质文档/双击可除 java实现协议封装 篇一：浅谈java封装 封装 封装就是指利用抽象数据类型将数据和基于数据的操作封装在一起，使其构成一个不可分割的独立实体，数据被保护在抽象数据类型的内部，尽可能地隐藏内部的细节，只保留一些对外接口使之与外部发生联系。也就是说用户是无需知道对象内部的细节（当然也无从知道），但可以通过该对象对外的提供的接口来访问该对象。 使用封装有三大好处： 1、良好的封装能够减少耦合。 2、类内部的结构可以自由修改。 3、可以对成员进行更精确的控制。 4、隐藏信息，实现细节。 1.publicclasshusband{ 2. 3./* 4.*对属性的封装
5.*一个人的姓名、性别、年龄、妻子都是这个人的私有属性 6.*/ 7.privatestringname; 8.privatestringsex; 9.privateintage; 10.privatestringwife; 11. 12./* 13.*setter()、getter()是该对象对外开发的接口 14.*/ 15.publicstringgetname(){ 16.returnname; 17.} 18. 19.publicvoidsetname(stringname){ https://www.360docs.net/doc/b314268415.html,=name; 21.} 22. 23.publicstringgetsex(){ 24.returnsex; 25.}
26. 27.publicvoidsetsex(stringsex){ 28.this.sex=sex; 29.} 30. 31.publicintgetage(){ 32.returnage; 33.} 34. 35.publicvoidsetage(intage){ 36.this.age=age; 37.} 38. 39.publicvoidsetwife(stringwife){ 40.this.wife=wife; 41.} 42.} 从上面两个实例我们可以看出： 封装把一个对象的属性私有化，同时提供一些可以被外界访问的属性的方法，如果不想被外界方法，我们大可不必提供方法给外界访问。但是如果一个类没有提供给外界访问的方法，那么这个类也没有什么意义了。
java封装类)
一：包装类（封装类）： 1：Java中的8中简单类型：（不是对象，与一切皆是对象相悖） byte、short、int、long char、 float、double boolean 2：所以针对以上8种简单类型构造了封装类。 对应的封装类： Byte、Short、Integer、Long Charater、 Float、Double Boolean 3:jdk1.5之后： 自动装箱:把简单数据类型变成相对应的封装类。 自动拆箱：把封装类变成相对应的简单数据类型。 Int i=10; Integer m=new Integer（10）； Int i=10； Integer m=i；（自动装箱） Int j=m；（自动拆箱） double pi=3.14d; Double d=pi;// （自动装箱）:new Double(3.14) double d1=d;// （自动拆箱） 4：封装类提供类实用的数据类型之间的转换。提供了众多对数字以及字符串操作的方法。 封装类都是final类 封装类的对象是不变的，和string类似。 覆盖（重写）了Object里面的equals和toString方法。 例如：string a=“hello”； a=“world”； 在内存空间里面给a重新开辟了一块空间用来保存“world”，“hello”这块空间没有被改写。 常用的：
字符串转换为数字 String age=”19”; Int intAge=Integer.parseInt(age);// parseInt:把字符串转换为整形 String salary=“5678.9”； double dsalary=Double.ParseDouble（salary）； 数字转换为字符串 int intage=19; String age=intage+””; String age=Integer.toString(intage); 十进制数字转化为十六进制字符： String age = Integer.toHexString(intage); 十进制数字转化为二进制字符： String age = Integer.toBinaryString(intage);
java-类的继承-构造方法与重写实验报告
计算机工程学院实验报告 2017-2018学年第1学期 课程名称：面向对象程序设计专业：计算机科学与技术班级： 学号： 姓名： 指导教师：
radius=r; } void disp() { System.out.println("圆的周长："+getperimeter()); System.out.println("圆的面积："+getarea()); } } class cylinder extends circle{ double height; double getvol() { return getarea()*height; } cylinder(double r,double h) { super(r); height=h; } void dispvol() { disp(); System.out.println("圆的体积："+getvol()); } } 运行截图： 2.创建Sw类,属性：上网时间time，构造方法和方法f( )：根据上网时间计算上网费用，设一个月的上网费用按照如下公式计算：大于等于300小时每小时0.1元；小于300小时每小时0.15元。之后创建Sw的子类StudentSw属性包含flag(是否包月),创建学生类构造方法，重写f( )计算上网费用: 如果包月则每月20元，如果不包月则按父类计算方式计算。然后根据学生的上网小时数和是否包月情况，求出一个月上网的费用。 代码部分：public class swang { public static void main(String[] args) { studentsw st1 = new studentsw(500,1); studentsw st2 = new studentsw(500,0); st1.disp(); st2.disp(); } } class sw{
JAVA封装的简单例子
先来个例子看看； public class Man { //对属性的封装，一个人的姓名，年龄，妻子都是这个对象（人）的私有属性 private String name; private int age; private Woman wife; //对改人对外界提供方法的封装，可以设定妻子，姓名，年龄也可以获得男人的姓名和年龄public void setWife(Woman wife) { this.wife = wife; } public String getName() { return name; } public void setName(String name) { https://www.360docs.net/doc/b314268415.html, = name; } public int getAge() { return age; }
{ this.age = age; } } public class Woman { //属性封装 private String name; private int age; private Man husband; //方法封装 public String getName() { return name; } public void setName(String name) { https://www.360docs.net/doc/b314268415.html, = name; } public int getAge() { return age; }
{ this.age = age; } public Man getHusband() { return husband; } public void setHusband(Man husband) { this.husband = husband; } } /** * 仔细看就会发现，Man类没有提供getWife的方法，这是以为男人不想让自己的妻子被外界访问，* * 直接下来呢，就是封装可以吧一个对象的属性私有，而提供一些可以被外界访问的属性的方法， * * 比如说，name属性，Man和Woman类都有相应的get和set方法，外界都可以通过这些方法访问和修改 * * 同时对一些改对象不想让外界访问的属性，就不提供其方法，比如说Man的wife属性，就没有get 方法 * * 外界是不能带到Man类的wife属性的
java的类和对象及构造方法
java 的类和对象及构造方法 类与对象的概念:程序设计所面对的问题域——客观世界，是由许多事物构成的，这些事物既可以是有形的（比如一辆汽车），也可以是无形的（比如一次会议）。把客观世界中的事物映射到面向对象的程序设计中就是对象。对象是面向对象程序设计中用来描述客观事物的程序单位。客观世界中的许多对象，无论其属性还是其行为常常有许多共同性，抽象出这些对象的共同性便可以构成类。所以，类是对象的抽象和归纳，对象是类的实例。抽象原则所谓抽象（abstraction），就是从被研究对象中舍弃个别的、非本质的、或与研究主旨无关的次要特征，而抽取与研究工作有关的实质性内容加以考察，形成对所研究问题正确的、简明扼要的认识。例如，“马”就是一个抽象的概念，实际上没有任何两匹马是完全相同的，但是我们舍弃了每匹马个体之间的差异，抽取其共同的、本质性的特征，就形成了“马”这个概念。抽象是科学研究中经常使用的一种方法，是形成概念的必要手段。在计算机软件开发领域，抽象原则的运用非常广泛，概括起来，可分为过程抽象和数据抽象两类。 过程抽象过程抽象是指：软件开发者可以把任何一个完成确定功能的操作序列都看作是一个单一的实体，尽管它实际上可能是由一系列更低级的操作完成的。运用过程抽象，软件
开发者可以把一个复杂的功能分解为一些子功能（模块），如果子功能仍比较复杂，则可以进一步分解。这使得开发者可以在不同的抽象层次上考虑问题，在较高层次上思考时可以不关心较低层次的实现细节。面向过程的程序设计采用的是过程抽象方法。使用过程抽象有利于控制、降低整个程序的复杂度，但是，这种方法允许在全系统的范围内进行功能的描述，本身自由度大，难于规范化和标准化，不易保证软件的质量，而且操作起来也有一定难度。数据抽象:数据抽象把系统中需要处理的数据和施加于这些数据之上的操作结合在一起，根据功能、性质、作用等因素抽象成不同的抽象数据类型。每个抽象数据类型既包含了数据，也包含了针对这些数据的授权操作，并限定数据的值只能由这些操作来观察和修改。因此，数据抽象是相对于过程抽象更为严格、更为合理的抽象方法。面向对象的程序设计就是采用数据抽象这一方法来构建程序中的类和对象的。它强调把数据和操作结合为一个不可分的系统单位——对象，对象的外部只需要知道这个对象能做什么，而不必知道它是如何做的。对象:只要仔细研究程序设计所面对的问题域——客观世界，我们就可以看到：客观世界是由一些具体的事物构成的，每个事物都具有自己的一组静态特征（属性）和一组动态特征（行为）。例如，一辆汽车有颜色、型号、马力、生产厂家等静态特征，又具有行驶、转弯、停车等动态特