java

简单介绍如下：Statement是Java执行数据库操作的一个重要方法，用于在已经建立数据库连接的基础上，向数据库发送要执行的SQL语句。Statement对象，用于执行不带参数的简单SQL语句。与此差不多的还有PreparedStatement，PreparedStatement继承了Statement，一般如果已经是稍有水平开发者，应该以PreparedStatement代替Statement。

您好，Statement类可以通过Java API查看，它是Java和执行数据库操作的一个重要方法。用于在已经建立数据库连接的基础上，向数据库发送要执行的SQL语句。Statement对象，用于执行不带参数的简单SQL语句。详情也可以通过访问Java API查看。

最常用读取properties文件的方法InputStream in = getClass().getResourceAsStream("资源Name");这种方式要求properties文件和当前类在同一文件夹下面。如果在不同的包中，必须使用：InputStream ins = this.getClass().getResourceAsStream("/cn/zhao/properties/testPropertiesPath2.properties");Java中获取路径方法获取路径的一个简单实现反射方式获取properties文件的三种方式 1 反射方式获取properties文件最常用方法以及思考：Java读取properties文件的方法比较多，网上最多的文章是"Java读取properties文件的六种方法"，但在Java应用中，最常用还是通过java.lang.Class类的getResourceAsStream(String name) 方法来实现，但我见到众多读取properties文件的代码中，都会这么干： InputStream in = getClass().getResourceAsStream("资源Name"); 这里面有个问题，就是getClass()调用的时候默认省略了this！我们都知道，this是不能在static（静态）方法或者static块中使用的，原因是static类型的方法或者代码块是属于类本身的，不属于某个对象，而this本身就代表当前对象，而静态方法或者块调用的时候是不用初始化对象的。 问题是：假如我不想让某个类有对象，那么我会将此类的默认构造方法设为私有，当然也不会写别的共有的构造方法。并且我这个类是工具类，都是静态的方法和变量，我要在静态块或者静态方法中获取properties文件，这个方法就行不通了。 那怎么办呢？其实这个类就不是这么用的，他仅仅是需要获取一个Class对象就可以了，那还不容易啊－－ 取所有类的父类Object，用Object.class难道不比你的用你正在写类自身方便安全吗 ？呵呵，下面给出一个例子，以方便交流。 import java.util.Properties; import java.io.InputStream; import java.io.IOException; /** * 读取Properties文件的例子 * File: TestProperties.java * User: leizhimin * Date: 2008-2-15 18:38:40 */ public final class TestProperties { private static String param1; private static String param2; static { Properties prop = new Properties(); InputStream in = Object. class .getResourceAsStream( "/test.properties" ); try { prop.load(in); param1 = prop.getProperty( "initYears1" ).trim(); param2 = prop.getProperty( "initYears2" ).trim(); } catch (IOException e) { e.printStackTrace(); } } /** * 私有构造方法，不需要创建对象 */ private TestProperties() { } public static String getParam1() { return param1; } public static String getParam2() { return param2; } public static void main(String args[]){ System.out.println(getParam1()); System.out.println(getParam2()); } } 运行结果： 151 152 当然，把Object.class换成int.class照样行，呵呵，大家可以试试。 另外，如果是static方法或块中读取Properties文件，还有一种最保险的方法，就是这个类的本身名字来直接获取Class对象，比如本例中可写成TestProperties.class，这样做是最保险的方法2 获取路径的方式:File fileB = new File( this .getClass().getResource( "" ).getPath()); System. out .println( "fileB path: " + fileB); 2.2获取当前类所在的工程名：System. out .println("user.dir path: " + System. getProperty ("user.dir"))<span style="background-color: white;">3 获取路径的一个简单的Java实现</span> /** *获取项目的相对路径下文件的绝对路径 * * @param parentDir *目标文件的父目录,例如说,工程的目录下,有lib与bin和conf目录,那么程序运行于lib or * bin,那么需要的配置文件却是conf里面,则需要找到该配置文件的绝对路径 * @param fileName *文件名 * @return一个绝对路径 */ public static String getPath(String parentDir, String fileName) { String path = null; String userdir = System.getProperty("user.dir"); String userdirName = new File(userdir).getName(); if (userdirName.equalsIgnoreCase("lib") || userdirName.equalsIgnoreCase("bin")) { File newf = new File(userdir); File newp = new File(newf.getParent()); if (fileName.trim().equals("")) { path = newp.getPath() + File.separator + parentDir; } else { path = newp.getPath() + File.separator + parentDir + File.separator + fileName; } } else { if (fileName.trim().equals("")) { path = userdir + File.separator + parentDir; } else { path = userdir + File.separator + parentDir + File.separator + fileName; } } return path; } 4 利用反射的方式获取路径：InputStream ips1 = Enumeration . class .getClassLoader() .getResourceAsStream( "cn/zhao/enumStudy/testPropertiesPath1.properties" ); InputStream ips2 = Enumeration . class .getResourceAsStream( "testPropertiesPath1.properties" ); InputStream ips3 = Enumeration . class .getResourceAsStream( "properties/testPropertiesPath2.properties" );

public class SafeProperties extends Properties {private static final long serialVersionUID = 5011694856722313621L;private static final String keyValueSeparators = "=: f";private static final String strictKeyValueSeparators = "=:";private static final String specialSaveChars = "=: f#!";private static final String whiteSpaceChars = " f";private PropertiesContext context = new PropertiesContext();public PropertiesContext getContext() {return context;}public synchronized void load(InputStream inStream) throws IOException {BufferedReader in;in = new BufferedReader(new InputStreamReader(inStream, "8859_1"));while (true) {// Get next lineString line = in.readLine();// intract property/comment stringString intactLine = line;if (line == null)return;if (line.length() > 0) {// Find start of keyint len = line.length();int keyStart;for (keyStart = 0; keyStart < len; keyStart++)if (whiteSpaceChars.indexOf(line.charAt(keyStart)) == -1)break;// Blank lines are ignoredif (keyStart == len)continue;// Continue lines that end in slashes if they are not commentschar firstChar = line.charAt(keyStart);if ((firstChar != "#") && (firstChar != "!")) {while (continueLine(line)) {String nextLine = in.readLine();intactLine = intactLine + " " + nextLine;if (nextLine == null)nextLine = "";String loppedLine = line.substring(0, len - 1);// Advance beyond whitespace on new lineint startIndex;for (startIndex = 0; startIndex < nextLine.length(); startIndex++)if (whiteSpaceChars.indexOf(nextLine.charAt(startIndex)) == -1)break;nextLine = nextLine.substring(startIndex, nextLine.length());line = new String(loppedLine + nextLine);len = line.length();}// Find separation between key and valueint separatorIndex;for (separatorIndex = keyStart; separatorIndex < len; separatorIndex++) {char currentChar = line.charAt(separatorIndex);if (currentChar == "\")separatorIndex++;else if (keyValueSeparators.indexOf(currentChar) != -1)break;}// Skip over whitespace after key if anyint valueIndex;for (valueIndex = separatorIndex; valueIndex < len; valueIndex++)if (whiteSpaceChars.indexOf(line.charAt(valueIndex)) == -1)break;// Skip over one non whitespace key value separators if anyif (valueIndex < len)if (strictKeyValueSeparators.indexOf(line.charAt(valueIndex)) != -1)valueIndex++;// Skip over white space after other separators if anywhile (valueIndex < len) {if (whiteSpaceChars.indexOf(line.charAt(valueIndex)) == -1)break;valueIndex++;}String key = line.substring(keyStart, separatorIndex);String value = (separatorIndex < len) ? line.substring(valueIndex, len) : "";// Convert then store key and valuekey = loadConvert(key);value = loadConvert(value);//memorize the property also with the whold stringput(key, value, intactLine);} else {//memorize the comment stringcontext.addCommentLine(intactLine);}} else {//memorize the string even the string is emptycontext.addCommentLine(intactLine);}}}/** Converts encoded uxxxx to unicode chars and changes special saved* chars to their original forms*/private String loadConvert(String theString) {char aChar;int len = theString.length();StringBuffer outBuffer = new StringBuffer(len);for (int x = 0; x < len;) {aChar = theString.charAt(x++);if (aChar == "\") {aChar = theString.charAt(x++);if (aChar == "u") {// Read the xxxxint value = 0;for (int i = 0; i < 4; i++) {aChar = theString.charAt(x++);switch (aChar) {case "0":case "1":case "2":case "3":case "4":case "5":case "6":case "7":case "8":case "9":value = (value << 4) + aChar - "0";break;case "a":case "b":case "c":case "d":case "e":case "f":value = (value << 4) + 10 + aChar - "a";break;case "A":case "B":case "C":case "D":case "E":case "F":value = (value << 4) + 10 + aChar - "A";break;default:throw new IllegalArgumentException("Malformed \uxxxx encoding.");}}outBuffer.append((char) value);} else {if (aChar == "t")outBuffer.append(" "); /* ibm@7211 */else if (aChar == "r")outBuffer.append(" "); /* ibm@7211 */else if (aChar == "n") {/** ibm@8897 do not convert a to a line.separator* because on some platforms line.separator is a String* of " ". When a Properties class is saved as a file* (store()) and then restored (load()) the restored* input MUST be the same as the output (so that* Properties.equals() works).* */outBuffer.append(" "); /* ibm@8897 ibm@7211 */} else if (aChar == "f")outBuffer.append("f"); /* ibm@7211 */else/* ibm@7211 */outBuffer.append(aChar); /* ibm@7211 */}} elseoutBuffer.append(aChar);}return outBuffer.toString();}public synchronized void store(OutputStream out, String header) throws IOException {BufferedWriter awriter;awriter = new BufferedWriter(new OutputStreamWriter(out, "8859_1"));if (header != null)writeln(awriter, "#" + header);List entrys = context.getCommentOrEntrys();for (Iterator iter = entrys.iterator(); iter.hasNext();) {Object obj = iter.next();if (obj.toString() != null) {writeln(awriter, obj.toString());}}awriter.flush();}private static void writeln(BufferedWriter bw, String s) throws IOException {bw.write(s);bw.newLine();}private boolean continueLine(String line) {int slashCount = 0;int index = line.length() - 1;while ((index >= 0) && (line.charAt(index--) == "\"))slashCount++;return (slashCount % 2 == 1);}

就是配置文件，用来配置一些经常修改的配置项的。

如果是properties文件的话，那么你应该知道key值。如果你不确定那个key值，那么应该知道这个指定的字符串。只能遍历文件内容了。

静态代码块中不行，之前我也遇到过类似的问题，后来我把static代码块去掉直接写到方法体里面了，就解决了

本人菜鸟,说说个人想法!Properties的 load方法参数是一个 输入流.你要加载的这些文件 一定在一个目录(文件夹)下吧.如果想要加载多个配置文件的话,可以用 File类的 list()方法 遍历改文件夹中的所有文件.当然也就能 获取这些文件的 输入流了.

一般用classloader吧

使用java.util.Propertiesx0dx0ax0dx0a1、创建一个Properties对象。x0dx0a2、使用对象的load方法加载你的property文件。x0dx0a3、使用getProperty方法取值。x0dx0a例子：x0dx0apackage com.bill.test;x0dx0ax0dx0aimport java.io.FileInputStream;x0dx0aimport java.util.Properties;x0dx0ax0dx0apublic class Test {x0dx0apublic static void main(String[] args) throws Exception{x0dx0aProperties property = new Properties();x0dx0aproperty.load(new FileInputStream("你的文件位置"));x0dx0aString value = property.getProperty("你的属性的key");x0dx0a//TODO 使用value...x0dx0a}x0dx0a}

properties 如上面所说，一般和文件相关这个文件比较特殊，必须是键值对的形式就像windows 里的 .ini文件一样如:window=800*600screen=1左边键名，右边值，用等号连接properties 读取文件后，会存为一个个键值对的形式，key=window value=800*600等.

最常用读取properties文件的方法InputStream in = getClass().getResourceAsStream("资源Name");这种方式要求properties文件和当前类在同一文件夹下面。如果在不同的包中，必须使用：InputStream ins = this.getClass().getResourceAsStream("/cn/zhao/properties/testPropertiesPath2.properties");Java中获取路径方法获取路径的一个简单实现反射方式获取properties文件的三种方式1 反射方式获取properties文件最常用方法以及思考：Java读取properties文件的方法比较多，网上最多的文章是"Java读取properties文件的六种方法"，但在Java应用中，最常用还是通过java.lang.Class类的getResourceAsStream(String name) 方法来实现，但我见到众多读取properties文件的代码中，都会这么干：InputStream in = getClass().getResourceAsStream("资源Name");这里面有个问题，就是getClass()调用的时候默认省略了this！我们都知道，this是不能在static（静态）方法或者static块中使用的，原因是static类型的方法或者代码块是属于类本身的，不属于某个对象，而this本身就代表当前对象，而静态方法或者块调用的时候是不用初始化对象的。问题是：假如我不想让某个类有对象，那么我会将此类的默认构造方法设为私有，当然也不会写别的共有的构造方法。并且我这个类是工具类，都是静态的方法和变量，我要在静态块或者静态方法中获取properties文件，这个方法就行不通了。那怎么办呢？其实这个类就不是这么用的，他仅仅是需要获取一个Class对象就可以了，那还不容易啊－－ 取所有类的父类Object，用Object.class难道不比你的用你正在写类自身方便安全吗 ？呵呵，下面给出一个例子，以方便交流。 import java.util.Properties; import java.io.InputStream; import java.io.IOException;/** * 读取Properties文件的例子 * File: TestProperties.java * User: leizhimin * Date: 2008-2-15 18:38:40 */ public final class TestProperties {private static String param1;private static String param2;static {Properties prop = new Properties();InputStream in = Object. class .getResourceAsStream( "/test.properties" );try {prop.load(in);param1 = prop.getProperty( "initYears1" ).trim();param2 = prop.getProperty( "initYears2" ).trim();} catch (IOException e) {e.printStackTrace();}}/*** 私有构造方法，不需要创建对象*/private TestProperties() {}public static String getParam1() {return param1;}public static String getParam2() {return param2;}public static void main(String args[]){System.out.println(getParam1());System.out.println(getParam2());} } 运行结果：151 152 当然，把Object.class换成int.class照样行，呵呵，大家可以试试。另外，如果是static方法或块中读取Properties文件，还有一种最保险的方法，就是这个类的本身名字来直接获取Class对象，比如本例中可写成TestProperties.class，这样做是最保险的方法2 获取路径的方式:File fileB = new File( this .getClass().getResource( "" ).getPath());System. out .println( "fileB path: " + fileB); 2.2获取当前类所在的工程名：System. out .println("user.dir path: " + System. getProperty ("user.dir"))<span style="background-color: white;">3 获取路径的一个简单的Java实现</span> /***获取项目的相对路径下文件的绝对路径** @param parentDir*目标文件的父目录,例如说,工程的目录下,有lib与bin和conf目录,那么程序运行于lib or* bin,那么需要的配置文件却是conf里面,则需要找到该配置文件的绝对路径* @param fileName*文件名* @return一个绝对路径*/public static String getPath(String parentDir, String fileName) {String path = null;String userdir = System.getProperty("user.dir");String userdirName = new File(userdir).getName();if (userdirName.equalsIgnoreCase("lib")|| userdirName.equalsIgnoreCase("bin")) {File newf = new File(userdir);File newp = new File(newf.getParent());if (fileName.trim().equals("")) {path = newp.getPath() + File.separator + parentDir;} else {path = newp.getPath() + File.separator + parentDir+ File.separator + fileName;}} else {if (fileName.trim().equals("")) {path = userdir + File.separator + parentDir;} else {path = userdir + File.separator + parentDir + File.separator+ fileName;}} return path;} 4 利用反射的方式获取路径：InputStream ips1 = Enumeration . class .getClassLoader() .getResourceAsStream( "cn/zhao/enumStudy/testPropertiesPath1.properties" ); InputStream ips2 = Enumeration . class .getResourceAsStream( "testPropertiesPath1.properties" ); InputStream ips3 = Enumeration . class .getResourceAsStream( "properties/testPropertiesPath2.properties" );

一个Properties只能加载一个问题，如果你需要加载多个的话只能多写几个了。例如：Propertiesprop=newProperties();prop.load(ConfigUtil.class.getClassLoader().getResourceAsStream("config.properties"));Propertiesprop1=newProperties();prop1.load(ConfigUtil.class.getClassLoader().getResourceAsStream("config.properties1"));

随便放在哪里,只要路径写对就可以;比如你直接放到src下prop.load(new FileInputStream( "database.properties "));如果放到你的包里就要写出包的路径:prop.load(new FileInputStream( "../myPackage/database.properties ")); 技术问题可以去itjob技术交流群探讨

右键,new file 输入:XXXXX.properties

properties 如上面所说，一般和文件相关这个文件比较特殊，必须是键值对的形式就像windows 里的 .ini文件一样如:window=800*600screen=1左边键名，右边值，用等号连接properties 读取文件后，会存为一个个键值对的形式，key=window value=800*600等.

我有动力节点的视频教程，从入门到精通都有，学习java就要学习专业的.

class A{ public static void main(){ double m=4.0; double n=Math.sqrt(m); System.out.println(n); }}其实就是调用Math下面的sqrt方法

因为BigDecimal的原因吧，也可以说是double的问题吧new BigDecimal(currentLat2); 时值不再是 2.455675而是2.455674999999999999999999因此在保留5位小数，四舍五入时，就变成2.45567而不是2.45568后一个正确是因为没形成这种数据。这种情况，用字符串可以避免这种问题String currentLat2 = "2.455675"; BigDecimal b = new BigDecimal(currentLat2); System.out.println(b.setScale(5, BigDecimal.ROUND_HALF_UP).doubleValue());

Java的BigDecimal类是java.math 包里的一个类，它提供了一些用于执行高精度浮点数计算的方法。由于它可以保持任意精度，所以它可以用于货币计算及其他需要精确结果的场合。下面是一些BigDecimal类的常用方法：add（）：该方法用于将两个BigDecimal对象相加，返回一个新的BigDecimal对象；subtract（）

用double型

1、e.一般习惯用来做异常信息的输出处理 2、比如在try ... catch块中，进行异常信息Exception e的对象e错误信息打印，如下： try { // 程序处理} catch(Exception e) { e.printStackTrace();}

可以，例如：BigDecimal a = new BigDecimal(1000.00);double b=a.doubleValue();

实现bigdecimal类型转成String类型： BigDecimal bd = new BigDecimal("xxx"); String str = bd.toString(); 扩展：String类型转成bigdecimal类型 String str = "xxx"; BigDecimal bd = new BigDecimal(str);

NumberFormat nf = NumberFormat.getInstance(); nf.format(3.300);

String s="125.671";BigDecimal b = new BigDecimal(s); b=b.setScale(2, BigDecimal.ROUND_DOWN); //小数位 直接舍去//b=b.setScale(2, BigDecimal.ROUND_HALF_UP); //四舍五入//BigDecimal add(BigDecimal augend) //BigDecimal subtract(BigDecimal subtrahend)//BigDecimal multiply(BigDecimal multiplicand) //BigDecimal divide(BigDecimal divisor)BigDecimal c = b.add(nwe BigDecimat("763.21"));

精度不同，Float，Double是float，double的封装类BigDecimal主要用于计算金额

sqrt函数原型：public static double sqrt(double a)作用是返回正确舍入的double值的正平方根。参数a的各种取值得到的结果： 1、如果参数是NaN或小于零，那么结果是NaN。 2、如果参数是正无穷大，那么结果就是正无穷大。 3、如果参数是正零或负零，那么结果与参数相同。 否则，结果是最接近该参数值的真实数学平方根的double值。sqrt函数所在类为数学工具包java.lang.Math类，调用格式：double v = Math.sqrt(2.0);//2的平方根赋值给v

BigDecimal num1 = new BigDecimal("3.14");BigDecimal num2 = new BigDecimal("0.37");System.out.println(b1.add(b2));

直接在java类中进行运算，可以明显看出，直接运算会产生精度丢失！！！

import java.math.BigDecimal;import java.text.ParseException;import java.text.SimpleDateFormat;import java.util.Date;public class CalcYourBirthDays {static SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");public static void main(String[] args) {String birthday = "1992-07-10"; //出生年月日try {calcTotalDays(birthday);} catch (Exception e) {System.out.println(e);}}public static int calcTotalDays(String birthday) throws Exception{Date now = new Date();long nowTime = now.getTime();BigDecimal totalDays = BigDecimal.ZERO;try {Date birth = sdf.parse(birthday);long birTime = birth.getTime();long diff = nowTime-birTime;BigDecimal difdec = new BigDecimal(diff);BigDecimal dayNum = new BigDecimal(24*3600*1000);totalDays = difdec.divide(dayNum, BigDecimal.ROUND_HALF_UP);System.out.println("您已出生："+totalDays+"天");System.out.println("您今年"+totalDays.divide(new BigDecimal(365), BigDecimal.ROUND_HALF_UP)+"岁");} catch (ParseException e) {throw new Exception("-------------格式转换异常："+e);}return 0;}}

Float，Double分别是对float和double的封装表示的精度和他们是一样的。但里面有很多有用的方法。。比如Double.praseDouble()等等。。BigDecimal也是对数字类型数据的封装。。但他的精度是任意精度。。即随便多长随便小数点后多少位。。

public static void main(String[] args) {double amount = 1200;// 消费金额 boolean isTeacherOrOld = true; // 是否有教师资格证或者老人标识BigDecimal discountEightFive = new BigDecimal("0.85");// 85折BigDecimal discountNine = new BigDecimal("0.9");// 95折BigDecimal discountNineFive = new BigDecimal("0.95");// 95折BigDecimal bdAmount = new BigDecimal(Double.toString(amount));BigDecimal calcAmount = new BigDecimal("0.00");if (amount >= 2000) {calcAmount = bdAmount.multiply(discountEightFive);} else if (amount > 1000 && amount < 2000) {calcAmount = bdAmount.multiply(discountNine);} else {calcAmount = new BigDecimal(Double.toString(amount));}if (isTeacherOrOld && amount >= 1000) {System.out.println("消费金额：" + calcAmount.multiply(discountNineFive).toString());} else {System.out.println("消费金额：" + calcAmount.toString());}}

public class Test{ public static void main(String[] args) { BigDecimal cnt = new BigDecimal(0); for (int i = 1; i <= 20; i++) { cnt = cnt.add(jiecheng(i)); } System.out.println(cnt); } public static BigDecimal jiecheng (int n) { if (n == 1) { return new BigDecimal(1); } //multiply()相乘 return jiecheng(n - 1).multiply(new BigDecimal(n)); }} 数值太大，只能用BigDecimal类型来表示

java中有存储大数值的类

我写的C语言的算法，应该你可以转换下吧？呵呵！就是通过整形数据的特点了；例如该变量为float x;浮点型数据四舍五入的算法为：{int i=0; 整型数据； i=(2*x*100+1)/2; x=(float)i/100;}当保留小数点后两位是用100；3为是1000，1位是当然是10了；明白？唉！没学过，看着有点困难。

import java.math.BigDecimal; /** * 银行还款计算 * @author cuiran * @version TODO */ public class BankRefund { /** * * 等额本金还款法【利息少，但前期还的多】 * @param totalMoeny 贷款总额 * @param rate 贷款商业利率 * @param year 贷款年限 */ public static void principal(int totalMoney,double rate,int year){ /** * 每月本金 */ int totalMonth=year*12; double monthPri=totalMoney/totalMonth; /** * 获取月利率 */ double monRate=resMonthRate(rate); BigDecimal b = new BigDecimal(monRate); monRate = b.setScale(6, BigDecimal.ROUND_HALF_UP).doubleValue(); for(int i=1;i<=totalMonth;i++){ double monthRes=monthPri+(totalMoney-monthPri*(i-1))*monRate; BigDecimal b1 = new BigDecimal(monthRes); monthRes = b1.setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue(); System.out.println("第"+i+"月，还款为："+monthRes); } } /** * * 等额本息还款【利息多】 * @param totalMoeny 贷款总额 * @param rate 贷款商业利率 * @param year 贷款年限 */ public static void interest(int totalMoney,double rate,int year){ /** * 获取月利率 */ double monRate=resMonthRate(rate); /** * 月还款本息 */ double monInterest=totalMoney*monRate*Math.pow((1+monRate),year*12)/(Math.pow((1+monRate),year*12)-1); BigDecimal b = new BigDecimal(monInterest); monInterest = b.setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue(); System.out.println("月供本息和："+monInterest); } /** * * 转换为月利率 * @param rate * @return */ public static double resMonthRate(double rate){ return rate/12; } /** * TODO * @param args */ public static void main(String[] args) { // TODO Auto-generated method stub int totalMoney=430000; double rate=0.0655; int year=20; // BankRefund.interest(totalMoney, rate, year); BankRefund.principal(totalMoney, rate, year); } }

用doubleValue()函数！

public String toString()：返回此 BigDecimal 的字符串表示形式，如果需要指数，则使用科学记数法。可以看一下Java帮助文档。希望对你有所帮助。 import java.math.BigDecimal;public class BigDecimalToString { public static void main(String[] args){ BigDecimal b1 = new BigDecimal("123.456777753413321231"); String result = b1.toString(); System.out.println("result = "+result); }}

import java.math.BigDecimal;public class Commodity{private BigDecimal beer_price = new BigDecimal("3.5");private BigDecimal noodle_price = new BigDecimal("4.5");private BigDecimal water_price = new BigDecimal("2");private BigDecimal total_price = new BigDecimal("0");public float pay(int beerNum,int noodleNum,int waterNum){payBeer(beerNum);payNoodle(noodleNum);payWater(waterNum);return total_price.floatValue();}public void payBeer(float num){BigDecimal bigDecimal;if (num > 2){bigDecimal = new BigDecimal(Double.toString(num)).multiply(beer_price).multiply(new BigDecimal("0.9"));}else{bigDecimal = new BigDecimal(Double.toString(num)).multiply(beer_price);}total_price = total_price.add(bigDecimal);}public void payNoodle(float num){BigDecimal bigDecimal;if (num > 2){bigDecimal = new BigDecimal(Double.toString(num)).multiply(noodle_price).multiply(new BigDecimal("0.9"));}else{bigDecimal = new BigDecimal(Double.toString(num)).multiply(noodle_price);}if (bigDecimal.floatValue() >= 20){bigDecimal.subtract(new BigDecimal("2"));}total_price = total_price.add(bigDecimal);}public void payWater(float num){BigDecimal bigDecimal;if (num > 2){bigDecimal = new BigDecimal(Double.toString(num)).multiply(water_price).multiply(new BigDecimal("0.9"));}else{bigDecimal = new BigDecimal(Double.toString(num)).multiply(water_price);}total_price = total_price.add(bigDecimal);}}=================================================public class Test{public static void main(String[] args){Commodity xiaomei = new Commodity();System.out.println("小美消费：" + xiaomei.pay(3,3,2));Commodity xiaoming = new Commodity();System.out.println("小明消费：" + xiaoming.pay(2,5,0));}}

var url ="run.php?name="+data.name+"&birthday="+data.birthday;

BigDecimal比Integer大得多，转换的话会有发生异常的可能，所以不建议这么做。1.Java是一门面向对象编程语言，不仅吸收了C++语言的各种优点，还摒弃了C++里难以理解的多继承、指针等概念，因此Java语言具有功能强大和简单易用两个特征。Java语言作为静态面向对象编程语言的代表，极好地实现了面向对象理论，允许程序员以优雅的思维方式进行复杂的编程 。2.Java具有简单性、面向对象、分布式、健壮性、安全性、平台独立与可移植性、多线程、动态性等特点。Java可以编写桌面应用程序、Web应用程序、分布式系统和嵌入式系统应用程序等。

不乱码你开不高兴么？ 楼主！你找想被乱码虐啊！！

一.JAR（Java ARchive，Java 归档）、安装java软件就可以了 ------------- JAR（Java ARchive，Java 归档）是一种与平台无关的文件格式，可将多个文件合成一个文件。用户可将多个 Java applet 及其所需组件（.class 文件、图像和声音）绑定到 JAR 文件中，而后作为单个的简单 HTTP（Hypertext Tranfer Protocal，超文本传输协议）事务下载到浏览器中，从而大大提高下载速度。JAR 格式也支持压缩，从而减小了文件的大小，进一步缩短下载时间。另外，applet 编写者也可在 JAR 文件中用数字签名的方式签写各项以确认其来源。它用 Java 编写，可与现有的 applet 代码完全向后兼容且可充分扩展。 本版本的 Java 平台扩展了 JAR 格式的用途。增强功能包括增加命令行 JAR 工具的功能，可用于创建和更新已签名的 JAR 文件。同时，它也提供了读取和写入 JAR 文件的新的标准 API（Application Programming Interface，应用程序接口）。另外，Java 扩展构架 (Extensions Framework) 也提供了一种机制，用来处理扩展相关性及打包为 JAR 文件的其它第三方库。 JAR 功能 JAR 指南。 清单和签名规范 JAR 文件和扩展构架 Java 平台中的新扩展机制用 JAR 文件格式打包扩展类。为了支持扩展机制和相关功能（如包的密封和版本演变），我们提供了新的清单属性。有关详细信息，参见扩展规范。 增强 Jar 工具 Jar 工具提供了新的 -C 和 u 选项，可用于创建和更新 JAR 文件。参见 Jar 工具参考页： Jar 工具参考页 (for Solaris) Jar 工具参考页 (for Windows) 读取和写入 JAR 文件：API 规范 包 java.util.jar：用来创建和读取 JAR 文件的类 类 java.net.JarURLConnection：利用 jar 协议实现到 JAR 文件的 URL（Uniform Resource Locators，统一资源定位符）连接的抽象类。 教程可以在Java Software 站点查到; Java 教程中的 Java 归档 (JAR) 文件格式。二.国际品牌的手机…只要不是超低端…基本都支持java只有性能的不同…智能机不用说…非智能机以索爱手机的java性能最强…有些机型甚至强过某些智能机…诺基亚 摩托罗拉 三星 索爱 所有型号都支持JAR格式的(除过蓝屏"黑白屏的机子)........

short,byte

tinyint在JAVA中对应是byte型.java:Java是一种可以撰写跨平台应用软件的面向对象的程序设计语言。Java 技术具有卓越的通用性、高效性、平台移植性和安全性，广泛应用于PC、数据中心、游戏控制台、科学超级计算机、移动电话和互联网，同时拥有全球最大的开发者专业社群。tinyint:TINYINT ，字段类型，如果设置为UNSIGNED类型，只能存储从0到255的整数,不能用来储存负数。

tinyint在JAVA中对应是byte型.java:Java是一种可以撰写跨平台应用软件的面向对象的程序设计语言。Java 技术具有卓越的通用性、高效性、平台移植性和安全性，广泛应用于PC、数据中心、游戏控制台、科学超级计算机、移动电话和互联网，同时拥有全球最大的开发者专业社群。tinyint:TINYINT ，字段类型，如果设置为UNSIGNED类型，只能存储从0到255的整数,不能用来储存负数。

注解的使用一般是与java的反射一起使用，下面是一个例子注解相当于一种标记，在程序中加了注解就等于为程序打上了某种标记，没加，则等于没有某种标记，以后，javac编译器，开发工具和其他程序可以用反射来了解你的类及各种元素上有无何种标记，看你有什么标记，就去干相应的事。标记可以加在包，类，字段，方法，方法的参数以及局部变量上。自定义注解及其应用1）、定义一个最简单的注解public @interface MyAnnotation { //......}2）、把注解加在某个类上：@MyAnnotationpublic class AnnotationTest{ //......}以下为模拟案例自定义注解@MyAnnotation 1 package com.ljq.test; 2 3 import java.lang.annotation.ElementType; 4 import java.lang.annotation.Retention; 5 import java.lang.annotation.RetentionPolicy; 6 import java.lang.annotation.Target; 7 8 /** 9 * 定义一个注解10 * 11 * 12 * @author jiqinlin13 *14 */15 //Java中提供了四种元注解，专门负责注解其他的注解，分别如下16 17 //@Retention元注解，表示需要在什么级别保存该注释信息（生命周期）。可选的RetentionPoicy参数包括：18 //RetentionPolicy.SOURCE: 停留在java源文件，编译器被丢掉19 //RetentionPolicy.CLASS：停留在class文件中，但会被VM丢弃（默认）20 //RetentionPolicy.RUNTIME：内存中的字节码，VM将在运行时也保留注解，因此可以通过反射机制读取注解的信息21 22 //@Target元注解，默认值为任何元素，表示该注解用于什么地方。可用的ElementType参数包括23 //ElementType.CONSTRUCTOR: 构造器声明24 //ElementType.FIELD: 成员变量、对象、属性（包括enum实例）25 //ElementType.LOCAL_VARIABLE: 局部变量声明26 //ElementType.METHOD: 方法声明27 //ElementType.PACKAGE: 包声明28 //ElementType.PARAMETER: 参数声明29 //ElementType.TYPE: 类、接口（包括注解类型)或enum声明30 31 //@Documented将注解包含在JavaDoc中32 33 //@Inheried允许子类继承父类中的注解34 35 36 @Retention(RetentionPolicy.RUNTIME)37 @Target({ElementType.METHOD, ElementType.TYPE})38 public @interface MyAnnotation {39 //为注解添加属性40 String color();41 String value() default "我是林计钦"; //为属性提供默认值42 int[] array() default {1, 2, 3}; 43 Gender gender() default Gender.MAN; //添加一个枚举44 MetaAnnotation metaAnnotation() default @MetaAnnotation(birthday="我的出身日期为1988-2-18");45 //添加枚举属性46 47 }注解测试类AnnotationTest 1 package com.ljq.test; 2 3 /** 4 * 注解测试类 5 * 6 * 7 * @author jiqinlin 8 * 9 */10 //调用注解并赋值11 @MyAnnotation(metaAnnotation=@MetaAnnotation(birthday = "我的出身日期为1988-2-18"),color="red", array={23, 26})12 public class AnnotationTest {13 14 public static void main(String[] args) {15 //检查类AnnotationTest是否含有@MyAnnotation注解16 if(AnnotationTest.class.isAnnotationPresent(MyAnnotation.class)){17 //若存在就获取注解18 MyAnnotation annotation=(MyAnnotation)AnnotationTest.class.getAnnotation(MyAnnotation.class);19 System.out.println(annotation);20 //获取注解属性21 System.out.println(annotation.color()); 22 System.out.println(annotation.value());23 //数组24 int[] arrs=annotation.array();25 for(int arr:arrs){26 System.out.println(arr);27 }28 //枚举29 Gender gender=annotation.gender();30 System.out.println("性别为："+gender);31 //获取注解属性32 MetaAnnotation meta=annotation.metaAnnotation();33 System.out.println(meta.birthday());34 }35 }36 }枚举类Gender，模拟注解中添加枚举属性 1 package com.ljq.test; 2 /** 3 * 枚举，模拟注解中添加枚举属性 4 * 5 * @author jiqinlin 6 * 7 */ 8 public enum Gender { 9 MAN{10 public String getName(){return "男";}11 },12 WOMEN{13 public String getName(){return "女";}14 }; //记得有“;”15 public abstract String getName();16 }注解类MetaAnnotation，模拟注解中添加注解属性 1 package com.ljq.test; 2 3 /** 4 * 定义一个注解，模拟注解中添加注解属性 5 * 6 * @author jiqinlin 7 * 8 */ 9 public @interface MetaAnnotation {10 String birthday();11 }

你这个太深奥了 我没法接

猜测一下，可能是因为注解，本身就是编译后不可改变的内容，使用位置也一定知道这个注解内的属性值的含义，如果有null的话，判断是一件很烦的事情

isAnnotationPresent(Class<? extends Annotation>)这句话的意思应该是说方法里的参数必须是Annotation的子类，你让你的Tx类继承下Annotation应该就可以了。

A是一个特定类型，必须是Annotation的子类

这是一个Annotation Annotation接口的实现类： Documented, Inherited, Retention, Target 都是用来定义自己定义的Annotation类的。 1. 注解(Annotation)类,以@interface 修饰 ，不能显示(explicit)extends或implements任何类 如： java 代码 public @interface DefineAnnotation { } 这种没有任何属性的Annotation类，也叫标识Annotation 2. 定义属性 java 代码 //属性必须加个小括号 public String value() ; //有默认值的属性 public String value() default "aaa"; 完整定义如下： java 代码 //注解Annotation类不能显示(explicit)extends或implements任何类 //不定义任何属性就叫maket annotation public @interface DefineAnnotation { //定义一个属性,有属性的话，必须赋值，除非有默认default public String value() default "aaa"; } 3.使用Annotation，有默认值的可以不用传参数，也可以传递参数。没有默认值的，必须传递参数。 如： java 代码 public class TestAnnotation { // @DefineAnnotation 有默认值的第一种使用方式 // @DefineAnnotation() 有默认值的第二种使用方式 @DefineAnnotation("ttitfly") public void say(){ System.out.println("say hello"); } public static void main(String[] args){ TestAnnotation ta = new TestAnnotation(); ta.say(); } } 4. Retention (保存) 所有的Annotation类都实现了Annotation接口 @Retention本身就是个Annotation（注解）类 它的值是个enum枚举类型的RetentionPolicy,该枚举类型RetentionPolicy有三个值RUNTIME （会被JVM加载，并可以通过反射来获得到Annotation类的信息） ，CLASS (不会被JVM加载)，Source @Retention的值标识自己定义的Annotation（注解）类 是属于哪种保存策略,将来哪个类如果使用了这个自定义的注解类，将会使用这种保存策略 如： java 代码 import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy; //所有的Annotation类都实现了Annotation接口 //@Retention本身就是个Annotation（注解）类 //它的值是个enum枚举类型的RetentionPolicy,该枚举类型RetentionPolicy有三个值RUNTIME （会被JVM加载，并可以通过反射来获得到Annotation类的信息） ，CLASS (不会被JVM加载)，Source //@Retention的值标识自己定义的Annotation（注解）类 是属于哪种保存策略,将来哪个类如果使用了这个自定义的注解类，将会使用这种保存策略 @Retention(RetentionPolicy.RUNTIME) public @interface MyAnnotation { String hello() default "ttitfly"; String world(); } java 代码 //使用自己定义的Annotation类 public class MyTest { //一个方法可以有多个注解类 @Deprecated @MyAnnotation(hello="china",world="earth") public void say(){ System.out.println("say hello"); } }java 代码 import java.lang.annotation.Annotation; import java.lang.reflect.Method;

楼主说的是@annotation百度一下，网上好多的。 Thinking in Java里面也说得很详细，楼主可以下一个电子版的放着，随时查阅。

在class上面用下列标记该类为一个注解类@Target({ElementType.METHOD}) @Retention(RetentionPolicy.RUNTIME) @Documented public @interface FiledAspectAnnotation { /** 关联方法 */ String associateMethod () default ""; String code() default "";}

annotation。Annotation，是Java5的新特性，下面是Sun的Tutorial的描述，因为是英文，这里我翻译下，希望能够比较清晰的描述一下Annotation的语法以及思想。Annotation:Release 5.0 of the JDK introduced a metadata facility called annotations. Annotations provide data about a program that is not part of the program, such as naming the author of a piece of code or instructing the compiler to suppress specific errors. An annotation has no effect on how the code performs. Annotations use the form @annotation and may be applied to a program"s declarations: its classes, fields, methods, and so on. The annotation appears first and often (by convention) on its own line, and may include optional arguments: JDK5引入了Metedata(元数据)很容易的就能够调用Annotations.Annotations提供一些本来不属于程序的数据，比如:一段代码的作者或者告诉编译器禁止一些特殊的错误。An annotation 对代码的执行没有什么影响。Annotations使用@annotation的形势应用于代码：类(class),属性(field),方法(method)等等。一个Annotation出现在上面提到的开始位置，而且一般只有一行,也可以包含有任意的参数。@Author("MyName")class myClass() { } or @SuppressWarnings("unchecked")void MyMethod() { } Defining your own annotation is an advanced technique that won"t be described here, but there are three built-in annotations that every Java programmer should know: @Deprecated, @Override, and @SuppressWarnings. The following example illustrates all three annotation types, applied to methods: 定义自己的Annotation是一个比较高级的技巧，这里我们不做讨论，这里我们仅仅讨论每一个Java programer都应该知道的内置的annotations:@Deprecated, @Override, and @SuppressWarnings。下面的程序阐述了这三种annotation如何应用于methods。import java.util.List; class Food {} class Hay extends Food {} class Animal { Food getPreferredFood() { return null; } /** * @deprecated document why the method was deprecated */ @Deprecated static void deprecatedMethod() { } } class Horse extends Animal { Horse() { return; } @Override Hay getPreferredFood() { return new Hay(); } @SuppressWarnings("deprecation") void useDeprecatedMethod() { Animal.deprecateMethod(); //deprecation warning - suppressed }} } } @DeprecatedThe @Deprecated annotation indicates that the marked method should no longer be used. The compiler generates a warning whenever a program uses a deprecated method, class, or variable. When an element is deprecated, it should be documented using the corresponding @deprecated tag, as shown in the preceding example. Notice that the tag starts with a lowercase "d" and the annotation starts with an uppercase "D". In general, you should avoid using deprecated methods — consult the documentation to see what to use instead. @Deprecated@Deprecated annotation标注一个method不再被使用。编译器在一个program(程序？)使用了不赞成的方法，类，变量的时候会产生警告(warning)。如果一个元素(element:method, class, or variable)不赞成被使用，应该像前面的例子里使用相应的@deprecated 标签，并且注意标签的首字母是小写的"d",而annotation时大写的"D"。一般情况下，我们应该避免使用不赞成使用的方法(deprecated methods)，而应该考虑替代的方法。 @OverrideThe @Override annotation informs the compiler that the element is meant to override an element declared in a superclass. In the preceding example, the override annotation is used to indicate that the getPreferredFood method in the Horse class overrides the same method in the Animal class. If a method marked with @Override fails to override a method in one of its superclasses, the compiler generates an error. While it"s not required to use this annotation when overriding a method, it can be useful to call the fact out explicitly, especially when the method returns a subtype of the return type of the overridden method. This practice, called covariant return types, is used in the previous example: Animal.getPreferredFood returns a Food instance. Horse.getPreferredFood (Horse is a subclass of Animal) returns an instance of Hay (a subclass of Food). For more information, see Overriding and Hiding Methods. @Override@Override annotation 告诉编译器当前元素是重写(override)自父类的一个元素。在前面的例子中，override annotation用来说明Horse类中的getPreferredFood这个方法重写(override)自Animal类中相同的方法。如果一个方法被标注了@Override，但是其父类中没有这个方法时，编译器将会报错。但是并不是说我们一定要使用这个annotation，但是它能够很明显的给出实际行为，尤其是在方法返回一个被重写的方法返回类型的子类型的时候。上面的例子中，Animal.getPreferredFood 返回一个 Food实例，Horse.getPreferredFood 返回一个Hay实例，这里Horse是Animal的子类，Hay是Food的子类。 @SuppressWarningsThe @SuppressWarnings annotation tells the compiler to suppress specific warnings that it would otherwise generate. In the previous example, the useDeprecatedMethod calls a deprecated method of Animal. Normally, the compiler generates a warning but, in this case, it is suppressed. Every compiler warning belongs to a category. The Java Language Specification lists two categories: "deprecation" and "unchecked". The "unchecked" warning can occur when interfacing with legacy code written before the advent of generics. To suppress more than one category of warnings, use the following syntax: @SuppressWarnings@SuppressWarnings annotation 告诉编译器禁止别的元素产生的特殊的警告(warnings)，在前面的例子里，useDeprecatedMethod调用了Animal的不赞成使用的一个方法。一般情况下，编译器会给出一个警告(warning)，但是在这种情况下，不会产生这个警告，也就是说被suppress。每个编译器的警告都属于一个类型。Java Language Specification列出了两种类型："deprecation" 和 "unchecked"。"unchecked" warning 发生在使用非generic的旧代码交互的generic collection类时。为了禁止不止一种的警告时，使用下面的语法:@SuppressWarnings({"unchecked", "deprecation"})

@是注解的意识，楼主百度 java 注解

请输入你Annotation提供了一条与程序元素关联任何或者任何元数据（metadata）的途径。从某些方面看，annotation就像修饰符一样被使用，并应用于包、类型、构造方法、方法、成员变量、参数、本地变量的声明中。这些被存储在annotation的“name=value”结构对中。annotation类型是一种接口，能够通过反射API的方式提供对其的访问。annotation能被用来为某个程序元素（类、方法、成员变量等）关联任何的。需要注意的是，这里存在着一个基本的潜规则：annotaion不能影响程序代码的执行，无论增加、删除annotation，代码都始终如一的执行。另外，尽管一些annotation通过java的反射api方法在运行时被访问，而java语言解释器在工作时忽略了这些annotation。正是由于忽略了annotation，导致了annotation类型在代码中是“不起作用”的；只有通过某种配套的工具才会对annotation类型中的进行访问和处理。本文中将涵盖标准的annotation和meta-annotation类型，陪伴这些annotation类型的工具是java编译器（当然要以某种特殊的方式处理它们）。

建议楼主看下Effective Java中的某条目,条目名是组合优先于继承.讲得很清楚明白...都是复用的技术,但是各有优势..

微擎可以用JAVA开发。微擎ERP的开发不局限于是B/S或者C/S模式，基于web形式的ERP开发采用PHP或者Java都可以，而Java相对而言在桌面应用，或者web开发亦或者移动应用开发方面，比较灵活，所以选择了ERP的模式之后在确定选择用那种开发语言。JAVA编译和解释性：Java编译程序生成字节码（byte-code），而不是通常的机器码。Java字节码提供对体系结构中性的目标文件格式，代码设计成可有效地传送程序到多个平台。Java程序可以在任何实现了Java解释程序和运行系统（run-time system）的系统上运行JAVA开发在一个解释性的环境中，程序开发的标准“链接”阶段大大消失了。如果说Java还有一个链接阶段，它只是把新类装进环境的过程，它是增量式的、轻量级的过程。因此，Java支持快速原型和容易试验。

public class Light { private int watts; private boolean indicator; public Light(int watts) { this.watts = watts; } public Light(int watts, boolean indicator) { this.watts = watts; this.indicator = indicator; } public void swithOh() { this.indicator = true; } public void printlnOff() { this.indicator = false; } pucblic void printInfo() { System.out.println("灯的瓦数：" + watts); if (this.indicator) { System.out.println("灯的状态为开！"); } else { System.out.println("灯的状态为关！"); } }}竟然有人发同样的问题，没测试。

微擎可以用JAVA开发。微擎ERP的开发不局限于是B/S或者C/S模式，基于web形式的ERP开发采用PHP或者Java都可以，而Java相对而言在桌面应用，或者web开发亦或者移动应用开发方面，比较灵活，所以选择了ERP的模式之后在确定选择用那种开发语言。JAVA编译和解释性：Java编译程序生成字节码（byte-code），而不是通常的机器码。Java字节码提供对体系结构中性的目标文件格式，代码设计成可有效地传送程序到多个平台。Java程序可以在任何实现了Java解释程序和运行系统（run-time system）的系统上运行JAVA开发在一个解释性的环境中，程序开发的标准“链接”阶段大大消失了。如果说Java还有一个链接阶段，它只是把新类装进环境的过程，它是增量式的、轻量级的过程。因此，Java支持快速原型和容易试验。

public class Light { private int watts; private boolean indicator; public Light(int watts) { this.watts = watts; } public Light(int watts, boolean indicator) { this.watts = watts; this.indicator = indicator; } public void swithOh() { this.indicator = true; } public void printlnOff() { this.indicator = false; } pucblic void printInfo() { System.out.println("灯的瓦数：" + watts); if (this.indicator) { System.out.println("灯的状态为开！"); } else { System.out.println("灯的状态为关！"); } }}没有测试

private static String hexString = "0123456789ABCDEF";public static void main(String[] args) { System.out.println(encode("中文")); System.out.println(decode(encode("中文")));}/* * 将字符串编码成16进制数字,适用于所有字符（包括中文） */public static String encode(String str) { // 根据默认编码获取<a href="https://www.baidu.com/s?wd=%E5%AD%97%E8%8A%82%E6%95%B0%E7%BB%84&tn=44039180_cpr&fenlei=mv6quAkxTZn0IZRqIHckPjm4nH00T1Ydn1D4nWDvuWN9mvRvnWDv0ZwV5Hcvrjm3rH6sPfKWUMw85HfYnjn4nH6sgvPsT6KdThsqpZwYTjCEQLGCpyw9Uz4Bmy-bIi4WUvYETgN-TLwGUv3EnHT4rjR3n101njc4PHnLrHTYPs" target="_blank" class="baidu-highlight">字节数组</a> byte[] bytes = str.getBytes(); StringBuilder sb = new StringBuilder(bytes.length * 2); // 将<a href="https://www.baidu.com/s?wd=%E5%AD%97%E8%8A%82%E6%95%B0%E7%BB%84&tn=44039180_cpr&fenlei=mv6quAkxTZn0IZRqIHckPjm4nH00T1Ydn1D4nWDvuWN9mvRvnWDv0ZwV5Hcvrjm3rH6sPfKWUMw85HfYnjn4nH6sgvPsT6KdThsqpZwYTjCEQLGCpyw9Uz4Bmy-bIi4WUvYETgN-TLwGUv3EnHT4rjR3n101njc4PHnLrHTYPs" target="_blank" class="baidu-highlight">字节数组</a>中每个字节拆解成2位16进制整数 for (int i = 0; i < bytes.length; i++) { sb.append(hexString.charAt((bytes[i] & 0xf0) >> 4)); sb.append(hexString.charAt((bytes[i] & 0x0f) >> 0)); } return sb.toString();} /* * 将16进制数字解码成字符串,适用于所有字符（包括中文） */public static String decode(String bytes) { ByteArrayOutputStream baos = new ByteArrayOutputStream(bytes.length() / 2); // 将每2位16进制整数组装成一个字节 for (int i = 0; i < bytes.length(); i += 2) baos.write((hexString.indexOf(bytes.charAt(i)) << 4 | hexString .indexOf(bytes.charAt(i + 1)))); return new String(baos.toByteArray());}

Font是JAVA中的字体类，PLAIN是Font类中的静态常量(staticfinal),表示是:普通样式常量。其他可用样式为:BOLD:粗体样式常量,ITALIC:斜体样式常量.如可以如下初始化对象:FonttextFont=newFont("宋体",Font.BOLD,23);该字体表示23磅粗体的宋体字。

Font是JAVA中的字体类，PLAIN是Font类中的静态常量( static final ) ,表示是:普通样式常量。其他可用样式为:BOLD :粗体样式常量 ,ITALIC: 斜体样式常量.如可以如下初始化对象:Font textFont = new Font("宋体" , Font.BOLD , 23);该字体表示23磅粗体的宋体字。

即使你没有用过对象序列化（serialization），你可能也知道它。但你是否知道 Java 还支持另外一种形式的对象持久化，外部化（externalization）？下面是序列化和外部化在代码级的关联方式：public interface Serializable {}public interface Externalizable extends Serializable {void readExternal(ObjectInput in);void writeExternal(ObjectOutput out);}序列化和外部化的主要区别外部化和序列化是实现同一目标的两种不同方法。下面让我们分析一下序列化和外部化之间的主要区别。通过Serializable接口对对象序列化的支持是内建于核心 API 的，但是java.io.Externalizable的所有实现者必须提供读取和写出的实现。Java 已经具有了对序列化的内建支持，也就是说只要制作自己的类java.io.Serializable，Java 就会试图存储和重组你的对象。如果使用外部化，你就可以选择完全由自己完成读取和写出的工作，Java 对外部化所提供的唯一支持是接口：voidreadExternal(ObjectInput in)void writeExternal(ObjectOutput out)现在如何实现readExternal() 和writeExternal() 就完全看你自己了。序列化会自动存储必要的信息，用以反序列化被存储的实例，而外部化则只保存被存储的类的标识。当你通过java.io.Serializable接口序列化一个对象时，有关类的信息，比如它的属性和这些属性的类型，都与实例数据一起被存储起来。在选择走Externalizable这条路时，Java 只存储有关每个被存储类型的非常少的信息。每个接口的优点和缺点Serializable接口? 优点：内建支持? 优点：易于实现? 缺点：占用空间过大? 缺点：由于额外的开销导致速度变比较慢Externalizable接口? 优点：开销较少（程序员决定存储什么）? 优点：可能的速度提升? 缺点：虚拟机不提供任何帮助，也就是说所有的工作都落到了开发人员的肩上。在两者之间如何选择要根据应用程序的需求来定。Serializable通常是最简单的解决方案，但是它可能会导致出现不可接受的性能问题或空间问题；在出现这些问题的情况下，Externalizable可能是一条可行之路。

　　Java 序列化 serialization主要职责就是将一个对象的状态转化为一个字节序列，以方便对象的持久化或网络传输。反序列化的过程正好相反。开发人员所要做的只是实现Serializable接口，然后调用ObjectOutputStream/ObjectInputStream的WriteObject/ReadObject方法即可，其他的工作 JVM　会自动帮你做了。　　那通过实现Serializable 接口所获取的序列化能力是否有安全隐患？由于这些字节序列已经脱离了Java的安全体系存在于磁盘或网络上，我们能否对序列化后的字节序列进行查看和修改，甚至于注入恶意病毒呢？ Java 反序列化机制是否又会对建立的对象进行验证以确保它的安全性、准确性呢？ 如果你想到这些问题，那恐怕答案会让你失望了。Java序列化后的字节序列基本都是明文存在的，而且字节序列的组成有很明确的文档进行说明，你可以试着用一些十六进制的文本编辑工具，如Hexeditor 查看一下对象序列化后的内容，你都能看到很多私有变量的实际赋值。关于字节序列的说明，可参考对象序列化流协议 ,这里就不多说了。这篇文章的重点是说一些Java提供的安全机制，通过这些机制，我们能够提升序列化/反序列化的安全指数。

通常在需要序列化属性下标记即可：[JsonProperty(Name="password")]publicstringPassword{get;set;}你试试不标记的情况下能否实现~

声明的时候加上 transient 这个关键字就可以了

类中影响Serialization进程的特征，两边的操作使用的类版本不同，但它们的 serialVersionUID 必须是一样的。它是用来识别两边的类是否兼容的，两边不同时不应该继续还原状态，而是应该停止下来，因为有人把事情搞错了。如果你的类没有实现 java.io.Serializable 或 java.io.Externalizable，这个字段则没有意义。如果你没听说过 Java Serialization (序列化，有人书翻译成串行化），那去找些 serialization 介绍看看，下面说的第2段类结构变化时是中级水平的，理解 Java 的一些细节才能理解，多数情况下人们只提到第一种情况(类的结构没有变化时)，也只需要第一种情况。当Serialization两端(比如Socket两端)使用一个类的不同版本时，我们必须提供 serialVersionUID，它可以用JDK自带的 serialver 命令行来计算:private static final long serialVersionUID = xxxx ;如果类中出现了下面两个方法，那么将会被用到，否则使用默认的实现:private void readObject(ObjectInputStream) throws IOException,ClassNotFoundException;private void writeObject(ObjectOutputStream)throws IOException;记住这里出现的方法和字段都是 private.新版本中仅增加了字段或方法而没有改变旧版本中已有的东西时，我们只要保证两个版本中的 serialVersionUID 是一样的就行了.具体样例可以看 JDK 源码中的像 ArrayList 这些类的代码的 readObject 和 writeObject 方法。类的结构有些变化时,新版本对旧版本中某些东西进行了删减时, Field 的变化我们需要在readObject和writeObject方法中进行处理ObjectOutputStream.PutField 类可达到这个目的只是保证两个版本中的 serialVersionUID 一致是行不通的类中必需两个常量：private static final long serialVersionUID;private static final ObjectStreamField[] serialPersistentFields下面样例是当客户端和服务端使用的类的版本不同并且类的结构也改变了，比如：12345678910111213 对方使用的类 Entry 是：public class Entry12 ... { private String name, email; private static final long serialVersionUID = 12L;}现在我们改变了类的设计了：public class Entry12 ... { private EntryInternal basic; private static final long serialVersionUID = 12L; private class EntryInternal { private String name, email; }}/* 这是一段代码片段，我们假设新版本的类 name & email 两个字段进行了修改 * (这里我们放到一个内部类EntryInternal 中),而旧版本中直接属于这个类. * * 请注意这里的字段和方法的签名, 它们都是 private 的或者是常量. */public class Entry12 implements Serializable { private EntryInternal pair = new EntryInternal(); /* 这是必要的，因为版本不同 */ private static final long serialVersionUID = 12L; ** 这也是必要的，否则写 putFields 时会抛出异常. * This field will be used by {@link #writeObject(ObjectOutputStream)}, * if this field is missing, follwing exception will be threw when invoke * {@link java.io.ObjectOutputStream.PutField#put(String,)} : * an exception ‘java.lang.IllegalArgumentException: No such object field" will be threw. */ private static final ObjectStreamField[] serialPersistentFields = new ObjectStreamField[] { new ObjectStreamField("name" , String.class),// new ObjectStreamField("email" , String.class),// }; /* 我们在这里不是直接写出字段，而把要写出的字段包装起来， 我们按需交换字段，而不是直接读写pair 这个字段. */ private void readObject(ObjectInputStream input) throws IOException, ClassNotFoundException { ObjectInputStream.GetField getFields = input.readFields(); /* 请注意：使用 Serializable 进行交换时不使用构造方法，所以这时 pair 还未初始化. */ pair = new EntryInternal(); pair.name = (String) getFields.get("name", null); pair.email = (String) getFields.get("email", null); } /* 写出时跟读入时一样 */ private void writeObject(ObjectOutputStream output) throws IOException { ObjectOutputStream.PutField putFields = output.putFields(); putFields.put("name", pair == null ? null : pair.name); putFields.put("email", pair == null ? null : pair.email); output.writeFields(); } ….. }

java序列化中如果要标记为不可序列化的字段，可以使用关键字：tranisant修饰。Java的serialization提供了一种持久化对象实例的机制。当持久化对象时，可能有一个特殊的对象数据成员，我们不想用serialization机制来保存它。为了在一个特定对象的一个域上关闭serialization，可以在这个域前加上关键字transient。transient是Java语言的关键字，用来表示一个域不是该对象串行化的一部分。当一个对象被串行化的时候，transient型变量的值不包括在串行化的表示中，然而非transient型的变量是被包括进去的。

at weblogic.servlet.internal.session.SessionData.getAttribute(SessionDat

楼主您好序列化就是用特定的流将对象持久化(将一个对象的属性写到内存，硬盘文件或者其他什么地方)的一个过程，用到的不多，好处？也没什么吧，就是你需要保存这个对象的时候用

java程序的运行包括执行程序加载和链接class， 机器码的生成，程序的动态优化（比方说垃圾回收），和实际执行。

没听说过。是不是你写错了呀？

准确来说，java中没有goto这样的语句百，当然即使在c中也不推荐使用。在java中可以找到实现类似功能的度方法,该方法仅限于循环嵌套跳转到外层循环的情况。例如你可以在外层循环上使用lablename:(lablename是自定义标签名)的方问式标注，在内循环中,可以使用breaklablename;或者continuelablename跳转到外循环上。答这样就可以模拟出类似goto语句的功能。

准确来说，java中没有goto这样的语句，当然即使在c中也不推荐使用。在java中可以找到实现类似功能的方法,该方法仅限于循环嵌套跳转到外层循环的情况。例如你可以在外层循环上使用lablename:(lablename是自定义标签名)的方式标注，在内循环中,可以使用break lablename;或者continue lablename跳转到外循环上。这样就可以模拟出类似goto语句的功能。

查转化规则

gradle user home指定一个放库文件的目录。上面distribution只有第二项local installation directory是用本地gradle程序其余的都需要网络，自动下载。