j初学ava所得一丝丝总结，望指教！！！

 

             JAVA

“boolean”开头是小写的，和其他关键字一样，整型和浮点型等等。

Byte的解释：

int占4个字节，byte是1个字节，每个字节8位。 所以2进制的话，int最多可以表示正负一共2的32次方个数，byte则是2的8次方。   e.g.   int=21;在计算机中表示为00000000，00000000，00000000，00010101 byte=21;就是00010101 byte 转换int直接赋值，int转byte强制类型转换，因为涉及精度。

二进制的数转十进制直接转，不用其他形式。

对于十六进制和八进制的数值写的时候用的是零“0”而不是小写的”o”，强制类型转换是

(int)x而不是int(x);

“+”号是字符连接符号。“final”是指一个变量只被赋值一次，一旦赋值便不能再改了，习惯上常量名用的是大写。在java中，经常希望某个常量可以在一个类中的多个方法中使用，通常将这些常量称为类常量，可以使用关键字static final设置一个类常量，例如：

public class Contants2 {public static void main (String [] args) {double i=1.5; double x=11; System.out.println(“This is ”+i*y+”by”+x*y); } public static final double  y=2.54; }

对于sringbuffer的用法有如下解释：

Stringbuffer 有append()方法 Stringbuffer其实是动态字符串数组 append()是往动态字符串数组添加，跟“xxxx”+“yyyy”相当那个‘+’号 跟String不同的是Stringbuffer是放一起的 String1+String2 和Stringbuffer1.append("yyyy")虽然打印效果一样，但在内存中表示却不一样 String1+String2 存在于不同的两个地址内存 Stringbuffer1.append(Stringbuffer2) 放再一起

然而在sringbuffer中还存在一些问题，

public class CapacityTest {        public static void main(String[] args)        {               StringBuffer sb = new StringBuffer(10);               sb.append("this is a a");               System.out.println(sb.capacity());               System.out.println(sb.length());        } }

 

capacity() 是返回当前的容量 . 当它的容量不够存储字符串时 . 它会以 ( 初始的容量 +1)*2 作为新的容量 , 前面有说明容量是 10 了，而赋值后 sb 的长度是 11 （ "this is a a" ），不够存储字符串，所以将是 11*2 等于 22 ；即为 capacity() 的值。如果超过 22 就按实际输入的字符串长度来输出容量。

•        在字符串创建后，往往需要获得字符串的长度值， String 类对象的字符串的长度值是固定的，一旦字符串对象创建后长度就不再变化，而 StringBuffer 类有缓冲空间，默认是 16 个字符的长度，在操作 String 类对象时是生成一个新的字符串，而操作 StringBuffer 类的对象时，不用生成新的字符串而是在原串的基础上实现操作。二者都提供了获得字符串长度的函数 length （）获得当前对象中的字符数量，但 StringBuffer 类还提供了 Capacity() 函数说明字符容量，因为有缓冲区，所以容量大小肯定大于当前对象中的字符数量。 •        1       String s = new String( “ hello ” );        // 创建一个字符串，内容为” hello ”，字符串名为 s1 •        2       StringBuffer sf = new StringBuffer( “ world ” ); // 创建一个 StringBuffer 类 •        3       System.out.println(s.length());             // 输出 String 类对象的长度，结果为 5 •        4       System.out.println(sf.length());           // 输出 StrinBuffer 类对象的长度，结果为 5 •        5       System.out.println(s.capacity()); // 输出 StrinBuffer 类对象的容量，结果为 5+16 = 21

如果输出的够容量就在实际输入的字符串长度加 16 为总的容量。

下面来看一个关于字符串的程序。

/*  * 命令行参数的输入，从命令行输入的任何参数，对于 Java 来讲都是用字符串处理的。  */ public class CommandInput {        public static void main(String[] args)        {               if(args.length == 0)               {                      System.out.println(" 你没有输出参数，程序退出！ ");               }               else               {                      System.out.println(" 你一共输入了 " + args.length + " 个参数 ");                      if(args[0].equals("h"))                             System.out.print(" 你好 ");                      if(args[0].equals("g"))                             System.out.print(" 再见 ");                        for(int i = 1; i < args.length; i++)                      {                             System.out.print(" " + args[i]);                      }               }        } }

本程序需要输入值才能运行，而其中的“ args.length ”表示的是输入的字符串个数。

接着介绍算术运算符，其中值得提及的是“ / ”和“ % ”，前者表示除以，但值取的是整数，而后者是取余，结果也是整数。下面是关于浮点型的具体数字后面的加上“ F” 和 ”D” 的意义。

浮点型        浮点型是表示有小数部分的数字。总共有两种类型组成：单精度浮点型（ float ）或双精度浮点型（ double 型）。       float 型 ，它是占位四个字节，有效数字最长为 7 位，它也有一个后缀 F ，大小写都可以接受。想声明一个 float 型的浮点数值，后面必须加上 F ，否则的话系统会认为是 double 型的。示例如下： /* 测试 float 型数值 */ public class FloatTest {   public static void main(String[] args)   {     float x = 22.2F;     float y = 42.6F;     float z = x * y;     System.out.println(x + "*" + y + "=" + z);   } }   输入的结果： 22.2*42.6=945.72        double 型 ，它是占八个字节，有效数字最长为 15 位。它的精度是 float 型精度的两倍，所以称为双精度型，同样也有一个后缀是 D ，大小写都可以接受的。示例如下： /* 测试 double 型数据类型 */ public class DoubleTest {   public static void main(String[] args)   {    double x = 22;    double y = 42.6D;    double z = x * y;       System.out.println("double 型 x = " + x);       System.out.println(x + " x " + y + " =" + z);    } } 输出结果： double 型 x=22.0                     22.0*42.6=937.2

在单精度和双精度后面加上 F 和 D 都是为了声明它是 float, 和 double. （一般单双精度的保留位没有特殊的指明则是保留小数点后一位。）为的是在运行的时候不会出现损失精度。

D:/java/3>javac FloatTest.java FloatTest.java:10: 可能损失精度 找到： double 需要： float                 float x = 22.2;                           ^ 1 错误   D:/java/3>

如果不使用圆括号，按照给出的运算符优先级次序进行计算，同个级别的运算符按照从左往右的次序进行计算，除了给出的右结合运算符外，例如 a+=b+=c 等价于 a+=(b+=c),”+=” 是右结合运算符，也就是将 b+=c 的结果（加上 c 之后的 b ）加到 a 上。

对于全局变量的有关问题：

/* * 测试全局变量的操作 */ public class GlobalVar {        int a = 10;        double b = 20;        public static void main(String[] args)        {               GlobalVar globalVar = new GlobalVar();               System.out.println("the value a = " + globalVar.a);               globalVar.print();               System.out.println("after changed the value a = " + globalVar.a);        }        public void print()        {               System.out.println("the global variable 　 a = " + a + ", b = " + b);               a=30;               System.out.println("the global variable 　 a = " + a + ", b = " + b);          } }

其中在

System.out.println("after changed the value a = " + globalVar.a);

输出的是在

public void print()        {               System.out.println("the global variable 　 a = " + a + ", b = " + b);               a=30;               System.out.println("the global variable 　 a = " + a + ", b = " + b);          }

后变化了的“ a ” , 所以输出的是 30 。

定义变量时可以在 main 里面定义，也可以在 main 外的开头定义，即第一个语句块前定义。如果初始化那就是全局变量了。布尔值默认的是 false ，字符型默认的是什么也没有。

public class InputTest {        public static void main(String[] args)        {               String strName = JOptionPane.showInputDialog(" 请输入你的姓名： ");               String strAge = JOptionPane.showInputDialog(" 请输入你的年龄： ");               int age = Integer.parseInt(strAge);               System.out.println(" 欢迎你： " + strName);               System.out.println(" 你还有 " + (60 - age) + " 年可以退休了 !");               System.exit(0);        }     }

 

parseInt (String s)            将字符串参数作为有符号的十进制整数进行解析。 parseInt public static int parseInt(String s)                     throws NumberFormatException 将字符串参数作为有符号的十进制整数进行解析。除了第一个字符可以是用来表示负值的 ASCII 减号 '-' ('/u002D') 外，字符串中的字符都必须是十进制数字。返回得到的整数值，就好像将该参数和基数 10 作为参数赋予 parseInt(java.lang.String, int) 方法一样。 参数： s - 包含要解析的 int 表示形式的 String。 返回： 用十进制参数表示的整数值。 抛出： NumberFormatException - 如果字符串不包含可解析的整数。

最后一行的 System.exit(0);

exit public static void exit(int status) 终止当前正在运行的 Java 虚拟机。参数用作状态码；根据惯例，非 0 的状态码表示异常终止。 该方法调用 Runtime 类中的 exit 方法。该方法永远不会正常返回。 调用 System.exit(n) 实际上等效于调用：  Runtime.getRuntime().exit(n)   参数： status - 退出状态。 抛出： SecurityException - 如果安全管理器存在并且其 checaExit 方法不允许以指定状态退出。 另请参见： Runtime.exit(int)

接下来是整型的长短和除“ 0 ”，

public class IntegerTest {     public static void main(String[] args) {        int i = 1000000;        System.out.println(i * i);        long l = i;        System.out.println(l * l);        System.out.println(1000 / (l - i));// 注意，要判断 / 下面不能为零       }   }

关于局部变量，是在一个语句块中才能起作用，其他语句块则不能使用，而全局变量是无论哪个语句块都能使用，而且能在某个语句块中改变某个变量值。

布尔值的输出，可以将整型进行逻辑比较后赋值给定义布尔值变量。

public class ReOperator {    public static void main(String[] args) {        int x = 100;        int y = 200;        boolean bl;        // 把表达式 x < y 的计算结果赋予布尔变量 bl ，显然 bl 的值为 true ；        bl = x < y;        System.out.println("x < y is :" + bl);     } }

自加自减的问题需要注意的是先加了再和其他变量加，还是先和其他变量加完之后再自加。

public class SelfAction {        public static void main(String[] args)        {               int x = 10;               int a = x + x++;               System.out.println("a=" + a);               System.out.println("x=" + x);               int b = x + ++x;               System.out.println("b=" + b);               System.out.println("x=" + x);               int c = x + x--;               System.out.println("c=" + c);               System.out.println("x=" + x);               int d = x + --x;               System.out.println("d=" + d);               System.out.println("x=" + x);              } } 结果是 ，第一个先 10+10 ，再将 10+1 为 11

有关于三个作用域的一些疑问，即 public 和 private,protected 之间的区别

public private protected: public: 在任何处都可以调用 private: 只能在本类中调用 protected: 子类中或者同一个包内使用。       以下说的更好：   http://blog.csdn.net/ladofwind/archive/2006/06/05/774072.aspx   在说明这四个关键字之前，我想就 class 之间的关系做一个简单的定义，对于继承自己的 class ， base class 可以认为他们都是自己的子女，而对于和自己一个目录下的 classes ，认为都是自己的朋友。       1 、 public ： public 表明该数据成员、成员函数是对所有用户开放的，所有用户都可以直接进行调用       2 、 private ： private 表示私有，私有的意思就是除了 class 自己之外，任何人都不可以直接使用，私有财产神圣不可侵犯嘛，即便是子女，朋友，都不可以使用。       3 、 protected ： protected 对于子女、朋友来说，就是 public 的，可以自由使用，没有任何限制，而对于其他的外部 class ， protected 就变成 private 。       作用域 当前类 同一 pacaage 子孙类 其他 pacaage       public       √             √            √             √       protected √             √            √             ×       friendly     √              √             ×            ×       private     √               ×            ×            ×       不写时默认为 friendly

在将时间格式化过程中少不了用到 SimpleDateFormat, 而 SimpleDateFormat 的解释，只是原理性的解释：

SimpleDateFormat 是一个以与语言环境有关的方式来格式化和解析日期的具体类。它允许进行格式化（日期 -> 文本）、解析（文本 -> 日期）和规范化。 SimpleDateFormat 使得可以选择任何用户定义的日期-时间格式的模式。

关于方法，类，对象，属性的关系：

对象是通过类定义出来的， A a=new A()     a就是类A的对象 类里面定义的方法 比如 public class A {   int c=3;  public void write() {  System.out.println("123"); }  }    方法write 就是类A的 要想调用方法 可以通过对象 就像刚才定义的 a ; 可以这么写 a.write(); 刚才定义的int c=3;就是 对象a的属性，任何类a定义的对象 都具有c=3的属性。    这么写System.out.println( a.c)   打印出3.

下面是时间表的模式字母：

字母 日期或时间元素 表示 示例 G Era 标志符 Text AD y 年 Year 1996; 96 M 年中的月份 Month July; Jul; 07 w 年中的周数 Number 27 W 月份中的周数 Number 2 D 年中的天数 Number 189 d 月份中的天数 Number 10 F 月份中的星期 Number 2 E 星期中的天数 Text Tuesday; Tue a Am/pm 标记 Text PM H 一天中的小时数（0-23） Number 0 a 一天中的小时数（1-24） Number 24 A am/pm 中的小时数（0-11） Number 0 h am/pm 中的小时数（1-12） Number 12 m 小时中的分钟数 Number 30 s 分钟中的秒数 Number 55 S 毫秒数 Number 978 z 时区 General time zone Pacific Standard Time; PST; GMT-08:00 Z 时区 RFC 822 time zone -0800

在使用 If 语句时，需要有 else 与其配对组成相应的返回值，就是需要有完整的结构。还有哦就是在定义一个类时，大类需要包含所有子类，所谓包含就是要将花括号括在开头和结尾形成一个整体的大类。

import java.util.Date; import java.text.SimpleDateFormat; public class HaoDate{     public static String getDate(String input){     if (input.equals("yyyy-MM-dd"))        {return getDate1(new Date());       }        else return ""; }       private static String getDate1(Date d) {SimpleDateFormat a = new SimpleDateFormat("yyyy-MM-dd");    return (a.format(d));   } }

对于字符串的声明定义时要写大写。即写成 String 而不是 string 。

字符串的分割形式及方法：

•        分割字符串指按照指定的划界表达式把字符串分割成几部分，每部分是一个字符串，方法返回值是字符串数组（ String[] ）。 •        split(String) ； •        该参数指定划界表达式，通过该表达式来分割字符串。如字符串联“ hello:moto ”，如果划界表达式是 “ : ”，则分割结果是 { “ hello ” , “ moto ” } ，如果划界表达式是“ o ”，则分割结果是 { “ hell ” , “ :m ” , “ t ” } 下面代码对字符串 s1 进行分割。 •        1       String s1 = new String( “ hello ” ); // 创建一个字符串，内容为” hello ”，字符串名为 s1 •        2       String[] splitresult = s1.split( “ l ” );      // 划界表达式是” l ”；分割结果是 { “ he ” , ” ” , ” o ” } 。

接着是字符串获得指定位置的字符的方法：

•        在字符串操作中获取指定位置的字符提供了字符操作的灵活性，通过该操作可以直接获取字符串中一个特定位置的字符，前提是首先知道字符串的长度值，在长度范围内获得一个指定的字符。 •        String charAt(int index) •        该参数方式获得字符串中指定位置的字符 (char 类型 ) ，参数 index 是 int 型数据类型，用以指定字符位置。下面代码获得字符串 s1 中指定位置的字符。 •        1       String s1 = new String( “ hello ” );        // 创建一个字符串，内容为” hello ”，字符串名为 s1 •        2       Char resultchar = s1.charAt(0);              // 获得字符串 s1 中第一个位置的字符。

关于之前的字符串长度有诸多看法和误解，但是之后一切尽在实践中，以下面这种方法来实现，即实际的字符串长度，就是字符的个数：

•        在字符串创建后，往往需要获得字符串的长度值， String 类对象的字符串的长度值是固定的，一旦字符串对象创建后长度就不再变化，而 StringBuffer 类有缓冲空间，默认是 16 个字符的长度，在操作 String 类对象时是生成一个新的字符串，而操作 StringBuffer 类的对象时，不用生成新的字符串而是在原串的基础上实现操作。二者都提供了获得字符串长度的函数 length （）获得当前对象中的字符数量，但 StringBuffer 类还提供了 Capacity() 函数说明字符容量，因为有缓冲区，所以容量大小肯定大于当前对象中的字符数量。 •        1       String s = new String( “ hello ” );          // 创建一个字符串，内容为” hello ”，字符串名为 s1 •        2       StringBuffer sf = new StringBuffer( “ world ” );      // 创建一个 StringBuffer 类 •        3       System.out.println(s.length());        // 输出 String 类对象的长度，结果为 5 •        4       System.out.println(sf.length());              // 输出 StrinBuffer 类对象的长度，结果为 5 •        5       System.out.println(s.capacity());     // 输出 StrinBuffer 类对象的容量，结果为 5+16 = 21

对于字符串的连接可以看成是连接符。

For 循环中对于首先赋值的那个变量要先声明变量的数据类型。

在进行调用时 public 和 private 只是区别于能否跨文件，即所谓的跨类。还有一个就是值的传递问题，对于固定类型的数据只能严格按照数据类型来进行传递。

使用 BigInteger 大容量运算类计算 100 的阶乘   一 . 一般算法 ( 循环 )   view plaincopy to clipboardprint? public class Test {       public static void main(String[] args) {           int result = 1;           for (int i = 1; i <= 100; i++) {               result *= i;           }           System.out.println(result);       }   }  public class Test {  public static void main(String[] args) {  int result = 1;  for (int i = 1; i <= 100; i++) {    result *= i;  }  System.out.println(result);  } }   输出结果为 0 ，因为 int 无法保存下 100 的阶乘的结果， 100 的阶乘的长度至少大于 50 位，也要大于 long,double   二 . 使用 BigInteger 大容量运算类   view plaincopy to clipboardprint? import java.math.BigInteger;     public class Test {       public static void main(String[] args) {           BigInteger result = new BigInteger("1");// 为 result 赋初始值，为 1           for (int i = 1; i <= 100; i++) {               BigInteger num = new BigInteger(String.valueOf(i));               result = result.multiply(num);// 调用自乘方法            }           System.out.println(result);// 输出结果            System.out.println(String.valueOf(result).length());// 输出长度        }   }  import java.math.BigInteger;   public class Test {  public static void main(String[] args) {  BigInteger result = new BigInteger("1");// 为 result 赋初始值，为 1  for (int i = 1; i <= 100; i++) {    BigInteger num = new BigInteger(String.valueOf(i));    result = result.multiply(num);// 调用自乘方法  }  System.out.println(result);// 输出结果  System.out.println(String.valueOf(result).length());// 输出长度  } }   计算结果为： 93326215443944152681699238856266700490715968264381621468592963895217599993229915608941463976156518286253697920827223758251185210916864000000000000000000000000 产度 :158

要求在控制台输入时，只需要按照固定模式的写法然后再运行的时候输入要求的内容即可。

public class CommandInput {        public static void main(String[] args)        {               if(args.length == 0)               {                      System.out.println(" 你没有输出参数，程序退出！ ");               }               else               {                      System.out.println(" 你一共输入了 " + args.length + " 个参数 ");                      if(args[0].equals("h"))                             System.out.print(" 你好 ");                      if(args[0].equals("g"))                             System.out.print(" 再见 ");                        for(int i = 1; i < args.length; i++)                      {                             System.out.print(" " + args[i]);                      }               }        } }

对于在控制台上的输入，用到是 Scanner 类里的 System.in 的 next 方法。不过用之前要先开辟一下内存，即赋给一个对象，后来才调用。

import java.util.*; public class ATM {        public static void main ( String[] args )        {               Scanner in= new Scanner ( System.in );               System.out.println ( " 用户先输入卡号，然后输入密码，查询余额请按‘ 1 ’ " );               System.out.println ( " 请输入您的卡号： " );               for ( int k=0; k<3; k++ )               {                      String kahao=in.next();                      if ( kahao.equals ( "10001" ) )                      {                             System.out.println ( " 请输入您的密码： " );                             String mima=in.next();                             if ( mima.equals ( "123456" ) )                             {                                    System.out.println ( " 张三你好，欢迎来到一生创展银行 " );                                    System.out.println ( " 请选择你的服务种类（目前只有一种）：余额查询请按 '1'" );                             } 后面的程序还没结束，只是其中用到的输入功能。

对于循环来说要理清之间的嵌套和结构。自行运行完后，正确才行。

Switch 的具体格式：

switch(aa[0].charAt(j)){               case '0': a+=" 〇 ";break;               case '1': a+=" 一 ";break;               case '2': a+=" 二 ";break;               case '3': a+=" 三 ";break;               case '4': a+=" 四 ";break;               case '5': a+=" 五 ";break;               case '6': a+=" 六 ";break;               case '7': a+=" 七 ";break;               case '8': a+=" 八 ";break;               case '9': a+=" 九 ";break;                 }

使用 break 时在一般的 main 方法中可以使用，但在调用的方法中则不能使用；可在调用的方法中设一个 for 循环，循环中就可以用 break ；

动态方法中，全局变量可以改变。而动态方法之间可以直接调用，不用在另开辟空间。数组中 New 只是为了分配一个空间，这个空间可以表明数组的大小和元素个数。  

数组的使用格式为： •        一维数组的定义方式是： •        datatype arrayName[ ] 或 datatype[] arrayName; •        其中 type 为任意数据类型，数组中的数据元素也是 type 类型， arrayName 是数组名称，在编写程序时该名称应该具有一定的意义。 [] 是数组的标识符，此时定义了一个数组，但数组中没有数据元素，也就是说 Java 允许定义一个数组但数据元素的数量为 0 ，通常称这样的数组为空数组。空数组没有获得内存空间，所以无法使用，必须 new 关键字为数据分配内存空间如下例子所示。 •        arrayName = new arrayName[size] ； •        在 Java 中 new 关键字的作用是产生该类的某个对象，并为该对象分配内存空间，内存空间的大小视对象大小而定，如一个 double 类型的浮点数据对象肯定比 int 类型的整型数据对象分配的内存空间更大。下面举例定义 int 型数组。 •        int IntArrayExample = new int[100]; •        这里 int 是声明了数组中元素的数据类型，数组名字是 IntArrayExample 。 new 关键字为该数据类型分配内存空间，空间大小是 100 个整型 int 型数据的大小，即 4 （字节） *100 = 400 字节的内存空间。

 

有关于字符串与其他数据类型之间的转换，用到的关键词眼是 parse ，有两种，一种是字符转换为整型用到的是“ Integer.parseInt() ” , 另一种是字符串转换为浮点型用到是“ Double.parseDouble() ” , 实例如下：

public class Arry{ public static void main(String args[]){   String a="10000.00"; double num; num=Double.parseDouble(a); System.out.printf("%,.2f/n",num); String b="123456"; int c; c=Integer.parseInt(b); System.out.println(c); }   }

附加其他数据类型转换为字符串：

其中要注意的是转换整型时是“Integer.parse.Int()”,进行字符型转换为整型或者浮点型，定义输入的字符串不能写成“String a=in.nextLine()”而要写成“String a=in.next()”,区别就在于前者输入进去的字符串含有空格，而在转换的时候要求是字符串中必须是十进制的数组成的字符串。后者就没有。格式化的输入String.out.printf(“%,.2f”,a);其中“2”前面的“。”是小数点，整个意思是小数点后面保留两位。

静态方法中引用动态方法，需要另辟空间，分配内存，即new一个新的空间给它，而在动态方法中引用静态态可以直接引用，不过无论是动态还是静态都无法调用入口方法即main方法。四舍五入需要用到的是

double x=9.89; int nx=(int)Math.round(x);