JAVA语言总结

JAVA语言总结

第一章 Java基础
一.Java常识
1.Java是sun公司在1995年开发的面向对象(Object Oriented Programming,OOP)的编程语言
2.Java是与平台无关及与互联网紧密结合,通用性极高的健壮语言
3.Java主要应用于Web服务器,关系型数据库,大型计算机,电话,移动通信与游戏
4.Java最初是由于可以在万维网上运行才流行起来,它通过浏览器下载Web页中的Java程序,在本地运行,称为applets(小应用程序)
5.Java的版本:
Java1.0:1995年推出,在Web浏览器中运行的以Web为核心的小型版本
Java1.1:1997年推出,改进了用户界面,重写了事件处理与JavaBean组件技术
带有SDK1.2的Java2:1998年推出,改写了图形化用户界面功能,数据库联接
带有SDK1.3的Java2:2000年推出,改进了多媒体功能,编译速度加快
带有SDK1.4的Java2:2002年推出,改进了安全性,对COBRA的支持,捆绑了Java Web Start技术,具有强大的Java Plug-in,支持Unicode3.0
6.C/C++语言都是针对特定CPU进行编译,生成机器代码,每一条机器指令都是由计算机事先设定好的,程序的可移植性差,Java不针对特定CPU进行编译,而是把程序编译为称作字节码的一种"中间代码",可以在提供了Java虚拟机(JVM)的任何系统上被解释执行
7.JIT(Just In Time,即时编译方式)用于将字节码直接转换为高性能的本地机器码,从而提高程序的运行速度,JIT是Java虚拟机的一部分
8.SDK安装目录下的bin文件夹中含有编译器javac.exe,解释器java.exe和其他可执行文件
9.为了方便的使用Java的编译器与解释器,应将bin包含在path设置中,在windows操作系统下,可以在我的电脑上右键单击属性→高级→环境变量窗口中输入变量名与变量值(路径),或在MS-DOS下输入如下命令:path F:/JDK1.4/bin
10.Java程序的编译过程:文件名.java(Java源程序)→javac.exe(Java编译器进行编译生成字节码文件)→Java虚拟机(解释字节码文件,利用JIT生成高性能的本地机器码)→Java应用程序(由Java解释器java.exe执行)/Java小应用程序(由浏览器执行)
11.JSP(Java Server Pages)是Sun公司于1999年推出的一种动态网页技术标准,JSP基于Java Servlet,JSP技术与ASP(Active Server Pages)技术比较相似,ASP的编写语言是VBScript,JSP的编写语言是Java,JSP完全克服了脚本语言级语言执行的缺点,能够摆脱硬件平台的束缚以及编译后运行的优点,并且具有动态页面与静态页面分离的特点
12.印度尼西亚有一个盛产咖啡的岛屿叫Java,中文名叫爪哇,开发人员为这种新语言起名Java,其寓意为世人端上一杯热咖啡
二.Java面向对象的编程
1.类:拥有相同特征行为的对象的集合,是创建对象的模版
2.对象:类的实例,每个来自相同类的对象都有相似,但可能不一样的特性
3.属性:区别对象的数据,用于确定对象的外观,状态和其他性质
4.行为:对象本身能够完成的事情,行为可以用于修改对象的属性,接受来自其他对象的信息和向其他向它们执行任务的对象发送消息
5.继承:让一个类继承(inheritance)另一个类的所有行为和属性,从一个类继承而来的类称为子类(subclass),而继承了他们的类称为超类(superclass),类只能有一个超类,但可以有无数个子类(子类的唯一任务就是指出它和超类行为和属性之间的差别),java中的所有类都继承自顶部的类Object(Object定义了Java类库中的所有类继承的行为),如果新定义的类不是另一个类的子类,Java会假设新类直接从Object类中继承没,另外Java只允许但继承
6.方法重载:在创建对象时,Java将跟踪这个对象定义的每个变量,以及对象的每个超类所定义的每个变量,对象可以访问它的类和超类的所有方法名称,这些方法名称将在使用方法的时候动态确定,调用方法时,解释程序会首先检查这个方法的对象的类,如果没有则将在这个类的超类中继续查找,依次类推,当子类中定义的方法与超类中所定义的方法名称,返回类型,参数都相同时,这种情况,解释程序从当前类开始依次向上查找,找到最近的一个目标方法,忽略更向上的相同方法(可以在子类中定义一个与超类中的某个方法名称,返回类型,参数都相同的方法,以防止调用超类中的这个方法)
7.接口:一组方法的集合,它可以使对象调用除了自身以及从超类中继承而来的方法之外的方法,接口中的方法并不会定义这个行为,而是留给实现接口的类完成,Java用接口解决了共享的问题
8.包:类和接口都包含在包中,Java包的包中包含较小的包,它们定义了Java功能的特定子集,Java中的包用"import 包名"来引入(eg:import java.awt.Color),java.lang(基本语言特性)包是系统默认加载的,因此不用引入
三.Java中的数据类型
1.Java语言使用unicode字符表,unicode字符表的前256个字符是ASCII码表,气候包括许多国家的语言字符
2.Java数据类型
<1>布尔类型:boolean
布尔型变量只允许有true与false两个值
<2>整数类型:
1/整形:int
int型变量占用内存4字节(byte,一个字节由8位(bit)组成,bit有两种状态0和1),占32位,取值范围是-2的31方到2的31次方减1
2/字节型:byte
byte型变量占用内存1字节,占8位,取值范围是-2的7次方到2的7次方减1
3/短整形:short
short型变量占用内存2字节,占16位,取值范围是-2的15次方到2的15次方减1
4/长整形:long
long型变量占用内存8字节,占64位,取值范围是-2的63次方到2的63次方减1
<3>字符类型:char
char型变量占用内存2字节,占16位,取值范围是0-65535
<4>浮点类型
1/单精度小数:float
float型变量占用内存4字节,占32位,取值范围是10的-38次方到10的38次方和-10的38次方到10的-38次方
2/双精度小数:double
double型变量占用内存8字节,占64位,取值范围是10的-308次方到10的308次方和-10的-308次方到10的308次方
3.基本数据类型的转换
类型精度从"底"到"高"排列:byte→short→int→float→double
把级别底的变量的值赋值给级别高的变量时,系统自动完成转换(eg:float x=100),但把级别高的变量转换为级别低的变量时,就必须使用强制类型转换运算符来进行,格式是:级别底的类型 (级别高的类型的值)/(级别底的类型) 级别高的类型的值(eg:int x=(int)34.85/int(34.85))
4.数组
数组是相同类型的数据按顺序组成的一种复合数据类型
<1>声明数组:
1/声明1维数组:数组元素类型 数字名称[]/数组元素类型[] 数组名称(eg:float boy[],double girl[],char cat[])
2/声明2维数组:数组元素类型 数字名称[][]/数字元素类型[][] 数组名称(eg:float a[][],double b[][],char[][] d)
<2>创建数组
声明数组仅仅是给出数组名称与元素数据类型,并没有分配内存空间
分配内存空间:数组名称=new 数组元素类型[数组元素个数](eg:float boy[];boy=new float[4]/int size=4;double number[]=new double[size])
四.运算符
1.加减运算符:+,-(eg:2+39,908.98-26),双目运算符
2.乘除运算符:*,/(eg:2*39,908.36/85),双目运算符
3.求余运算符:%(eg:5%5),双目运算符,优先级为3
4.自增,自减运算符:++,--(eg:5++,1--),单目运算符
5.关系运算符:>,<,>=,<=,==,!=(eg:10>5,5<12,10>=5,5<=10,4==4,3!=5),双目运算符
6.逻辑运算符:&&,||,!(eg:(4-3>0)&&(8+5<8),(4-3>0)||(8+5<8),!(4-3>0)),其中&&,||是双目运算符,!是单目运算符
7.赋值运算符:=(eg:int i=5),双目运算符
8.位运算符:
<1>按位与:&
整形数据a,b对应位都是1,则结果是1,否则是0,双目运算符
eg:
a: 00000000 00000000 00000000 00000111
b: 10000001 10100101 11110011 10101011
───────────────────
C: 00000000 00000000 00000000 00000011
<2>按位或:|
整形数据a,b对应位都是0,则结果是0,否则是1,双目运算符
eg:
a: 00000000 00000000 00000000 00000111
b: 10000001 10100101 11110011 10101011
───────────────────
c: 10000001 10100101 11110011 10101111
<3>按位非:~
整形数据a对应位是0,则结果是1,否则是0,单目运算符
eg:
a: 10000001 10100101 11110011 10101011
───────────────────
c: 01111110 01011010 00001100 01010100
<4>按位异或:^
整形数据a,b对应位相同,则结果是0,否则是1,双目运算符
eg:
a: 00000000 00000000 00000000 00000111
b: 10000001 10100101 11110011 10101011
───────────────────
c: 10000001 10100101 11110011 10101111
9.instanceof运算符
双目运算符,左边是一个对象,右边是一个类,当左边的对象是右面的类创建的对象时,该运算符运算结果为true,否则为false
五.Java语句
1.方法调用语句:调用对象方法的语句
eg:System.out.println("Hello")
2.表达式语句:表达式构成的语句
eg:3>2,int i=5
3.复合语句:在{}符号之中的都是复合语句
eg:
{
   z=23+x;
   System.out.println("Hello");
}
4.package语句,import语句:打包与引包语句
5.控制语句
<1>条件语句:if-else
eg:if(表达式){诺干语句;}else{诺干语句;}
<2>开关语句:switch
eg:switch(表达式){case:常量值1:诺干语句;break;case:常量值2;诺干语句;break;case:常量值n:诺干语句;break;default:诺干语句}
6.循环语句
<1>次数循环语句:for
eg:for(表达式1;表达式2;表达式3){诺干语句;}
<2>条件循环语句while/do-while
eg:while(表达式){诺干语句;}/do{诺干语句;}while(表达式);
*while与do-while循环语句的不同点,while循环语句如果条件不成立便不执行,而do-while循环语言先执行一次在作判断
<3>在循环体中使用break和continue
break:跳出当前循环
continue:结束本次循环
六.static关键字
1.类变量:用static关键字修饰的变量是类变量,所有对象的类变量公用一块内存,即改变其中一个对象的类变量,会影响所有拥有该类变量中的对象的该类变量的值,类变量可以被类直接调用
2.类方法:用static关键字修饰的方法是类方法,实例方法在类被实例化的时候分配入口地址,类方法在类创建的时候分配入口地址,因此类方法执行的效果会影响所有的拥有给类方法的对象的该类方法的效果,类方法可以被类直接调用
七.this关键字
this关键字代表使用该方法的对象
eg:
class A{
   int x  ;
   void f(){
      this.x=100;
   }
}
给例题中this就代表使用f方法的当前对象,this.x就代表使用f方法的当前对象的友好变量x
*this通常用于当成员变量的名称与局部变量的名称相同时,用于区分成员变量,即在成员变量的前面加this关键字
八.访问权限关键字
访问权限/访问者 该类自身 该类对象     该类对象的子类
private         可以访问 不可访问     不可访问
protected       可以访问 不可访问     可以访问
public          可以访问 可以访问     可以访问
friend          可以访问 同一包中可以 可以访问    
*不用private,protected,public关键字修饰的成员变量与成员方法的访问权限为friend,friend是默认的访问权限
九.final关键字
1.final类:final类不能被继承(大多数时候是出于安全性考虑,eg:java的String类对于编译器与解释器都十分的重要,不能被轻易改变,所以被修饰为final类)
2.final方法:final方法不能被重写
3.final属性:final属性就是变量
十.super关键字
1.使用super关键字调用超类构造方法
eg:
class A extends B{
   public static void main(String args[]){
      super("Hellow");
   }
}
该例使用了super关键在调用了A类的超类B类的构造方法
2.使用super关键字调用超类的隐藏成员和方法
eg:
class A extends B{
   private int x;
   public void print(){
      x=100;
      System.out.println("x="+x);
   }
   public static void main(String args[]){
      super.x=150;
      super.print();
   }
}
该例使用了super关键字调用了A类的超类B类的隐藏方法print()与隐藏属性x

第二章 接口,异常和包
一.接口
1.interface关键字
interface关键字用于声明接口,格式:interface 接口名称
2.接口中为常量与方法的声明(不实现)
eg:
interface PrintTable{
   final int MAX=100;
   void add();
   float sum(float x,float y);
}
3.implements关键字
类通过使用implements关键字声明其使用一个或多个接口的,格式:class 对象名 implements 接口名1,接口名2...接口名n
eg:
import javax.swing.*;
interface show{
   public void show();
}
class Test extends JFrame implements show{
   public static void main(String args[]){
      Test T=new Test(); 
      T.show();
   }
   public void show(){
      System.out.println("我使用了接口方法");
   }
}
二.异常
1.异常(exception):程序运行时可能出现的一些错误
2.Exception类:Exception类为异常类,Exception类的相应子类分别对应不同的异常
3.try-catch关键字:try-catch关键字用于处理异常,当可能出现的异常放在语句的try部分,当try部分的某个语句发生异常,try部分自动结束,转向执行相应的catch部分,try-catch关键字可以有有个catch构成,分别处理发生的相应异常
4.自定义异常类:继承Exception类,就可以自定义异常
eg:
class MyException extends Exception{
   String message;
   MyException(){
      message="数字不是正数";
   }
   public String toString(){
      return message;
   }
}
class A{
   public void f(int n) throws MyException{
      if(n<0){
         throw(new MyException());
      }
   }
   public static void main(String args[]){
      A a=new A();
      try{
         a.f(-1);
      }
      catch(MyException e){
         System.out.println(e.toString());
      }
   }
}
<1>该例有MyException类继承了Exception类,因此MyException类成为了自定义异常类
<2>方法在声明是使用throws关键字来声明要抛出的诺干异常,并用throw关键字在该方法中给出具体产生异常的条件或操作
<3>finally关键字跟在catch关键字后使用,不管try关键字中的程序是否异常,都会在执行完tye与catch关键字之后执行finally关键字中的程序
5.异常类结构
Throwable类有两个子类Error类与Exception类
Error类描述了程序在正常环境下不期望捕获的异常,发生Error类的异常时,通常程序会终止运行
Exception类描述了程序应该捕获的异常
6.常用异常类
类名                                  所在包    触发异常条件
<1>ArithmeticException类              java.lang 出现不合法的数字运算时发生(eg:除数为0)
<2>ArrayIndexOutOfBoundsException类   java.lang 使用非法索引值访问数组(eg:索引要么是负值,要么大于或小于数组的大小)
<3>ArrayStoreException类              java.lang 在对象数组中保存错误类型对象
<4>ClassCastException类               java.lang 把对象转换为其非实例的子类时
<5>ClassNotFoundException类           java.lang 在调用某类时,没有找到其相应的类文件
<6>EmptyStackException类              java.lang 从空的堆栈检索项(由Stack类中的方法抛出)
<7>FileNotFoundException类            java.io   访问文件对象(file)时,文件对象不存在
<8>IllegalArgumentException类         java.lang 向方法传递非法的参数时
<9>InterruptedException类             java.lang 休眠线程或挂起线程可能在休眠时间结束前或在调用resume()方法之前中断(休眠线程或                                                 挂起线程是应准备该异常)
<10>InvalidParameterException类       java.lang 给方法传递无效参数时
<11>IOException类                     java.io   在读写文件时发生错误的信号(使用流的方法是常常碰到给异常)
<12>MalformedURLException类           java.net  提供的URL字符不合要求时(创建URL时,需要处理该异常)
<13>NumberFormatException类           java.lang 字符串转换为数字时,字符串实际并不能代表数字(eg:String S="1000CA",String类的字                                                 符串对象S中的值并不都是数字类型的字符串)
<14>StringIndexOutOfBoundsException类 java.lang 在字符串边界外进行索引
<15>NullPointerException类            java.lang 在变量还没有分配内存空间时访问
                                                (eg:Button b[]=new Button();for(int i=0;i<2;i++){add.(b[i]);},该例中虽然创建                                                  了一个Button类的对象数组b,但是对象数组b并没有初始化,因此在访问对象数字b是会发                                                 生NullPointerException类的异常)
三.包
1.paclage关键字
package关键字可以将接口与类组织在一个包中,格式:package 包名(eg:package packageName)
2.实例
文件名:PrintInformation.java
package myPackage.print;
public class PrintInformation{
   public void printName(){
      System.out.println("baster bunny");
   }
   public void printAge(){
      System.out.println("eighteen");
   }
}
文件名:UseMyPackage.java
import myPackage.print.PrintInformation;
public class UseMyPackage extends PrintInformation{
 public static void main(String args[]){
  UseMyPackage UMP=new UseMyPackage();
  UMP.printName();
  UMP.printAge();
 }
}
<1>该例中把PrintInformation类定义在了myPackage/print文件夹下
<2>包中用public关键字修饰的方法与属性在引入后才可被调用

第三章 Java常用类与常用类的常用方法
一.String类
java.lang包中String类用于创建字符串变量,因此字符串变量是类类型变量
1.String()构造方法
eg:String s=new String("Hello");
为字符串对象s赋值
2.public int length()方法,返回值范围:字符串的长度
用于获取字符串对象的长度
eg:
String s=new String("Hello");
System.out.println(s.length());
*字符串对象s的长度是5
3.public boolean equals(String s)方法,返回值范围:true,false
用于比较当前字符串对象的值是否与参数指定的字符串对象的值相同
eg:
String s1=new String("baster bunny");
String s2=new String("solar eclipse");
String s3=new String("baster bunny");
s1.equals(s2);
s1.equals(s3);
*s1.equals(s2)的返回值是flase,s1.equals(s3)的返回值是true
4.public boolean startsWith(String s)方法,返回值范围:true,false
用于判断字符串对象的值的前缀是否是参数指定的字符串
eg:
String s1=new String("baster bunny");
String s2=new String("solar eclipse");
s1.startsWith("bas");
s2.startsWith("bas");
*s1.startsWith("bas")的返回值是true,s2.startsWith("bas")的返回值是flase
5.public boolean endsWith(String s)方法,返回值范围:true,false
用于判断字符串对象的值的后缀是否是参数指定的字符串
String s1=new String("baster bunny");
String s2=new String("solar eclipse");
s1.endsWith("nny");
s2.endsWith("nny");
s1.endsWith("nny")的返回值是true,s2.endsWith("nny")的返回值是flase
6.public boolean regionMatches(int firstStart,String other,int otherStart,int length)方法,返回值范围:true,false
用于将当前字符串对象的值的指定部分字符串与字符串对象参数other的值的指定部分字符串进行比较
eg:
String s1=new String("baster bunny");
String s2=new String("baster user");
System.out.println(s1.regionMatches(0,s2,0,6));
System.out.println(s2.regionMatches(7,s1,7,6));
System.out.println(s1.regionMatches(7,s2,0,1));
*s1.regionMatches(0,s2,0,6)的返回值是true,s2.regionMatches(7,s1,7,6)的返回值是flase,s1.regionMatches(7,s2,0,1)的返回值是true
7.public int compareTo(String s)方法,返回值范围:0,负值,正值
用于比较字符串对象s与当前字符串对象的(按字典顺序比较字符串)大小
eg:
String s1=new String("abcde");
String s2=new String("cde");
String s3=new String("aaa");
String s4=new String("abcde");
s1.compareTo(s2);
s1.compareTo(s3);
s1.compareTo(s4);
*s1.compareTo(s2)的返回值是-2,s1.compareTo(s3)的返回值是1,s1.compareTo(s4)0
8.public int indexOf(String s)方法,返回值范围:-1,首次出现字符串对象s的位置
用于确定字符串对象s是否在当前字符串对象中出现
eg:
String s1=new String("baster bunny");
String s2=new String("ste");
String s3=new String("solar eclipse");
s1.indexOf(s2);
s1.indexOf(s3);
*s1.indexOf(s2)的返回值是2,s1.indexOf(s3)的返回值是-1
9.public String substring(int start,int end)方法,返回值范围:以整形参数start开始,到整形参数end结束的字符串对象
用于从当前字符串对象上提取以整形参数start开始,到整形参数end结束的字符串对象
eg:
String s1=new String("baster bunny");
String s2=s1.substring(3,6);
*字符串对象s2的值是"ter"
10.public void getChars(int start,int end,char c[],int offset)方法
用于将当前字符串对象的值的指定部分字符复制到参数c的数组中的整形参数offset处(即从整形参数offset处开始复制)
eg:
String s=new String("baster bunny/solar eclipse");
char ch1[]=new char[50];
char ch2[]=new char[50];
s.getChars(0,12,ch1,0);
s.getChars(13,26,ch2,0);
*ch1[0]的值是'b',ch1[1]的值是'a',ch1[2]的值是's',ch1[3]的值是't',ch1[4]的值是'e',ch1[5]的值是'r',ch1[6]的值是' ',ch1[7]的值是'b',ch1[8]的值是'u',ch1[9]的值是'n',ch1[10]的值是'n',ch1[11]的值是'y',ch2[0]的值是's',ch2[1]的值是'o',ch2[2]的值是'l',ch2[3]的值是'a',ch2[4]的值是'r',ch2[5]的值是' ',ch2[6]的值是'e',ch2[7]的值是'c',ch2[8]的值是'l',ch2[9]的值是'i',ch2[10]的值是'p',ch2[11]的值是's',ch2[12]的值是'e'
11.String(byte[],int offset,int length)构造方法
用于将指定范围的字节数组参数byte,转换为当前字符串对象的值
eg:
byte d[]="baster bunny".getBytes();
String s=new String(d,7,5);
*字符串对象s的值是"bunny"
二.数据类
1.为了更加方便的使用Java中的八种基本数据类型,Java特意为他们分别在java.long包中编写了与之相对应的类
基础类型 与基础类型相对应的类
int      Integer类
byte     Byte类
float    Float类
double   Double类
char     Character类
long     Long类
short    Short类
boolean  Boolean类
2.字符串与基本数据类型的转换
<1>字符串对象的值转换为基本数据类型
用Integer,Float,Double,Byte,Long,Short类的相应方法可以把字符串对象格式的数据,转换为相应类型的基本类型(eg:"12345")
与基础类型相对应的类 与基础类型相对应的类的方法
int类                public static int parseInt(String s)
byte类               public static byte parseByte(String s)
Float类              public static float parseFloat(String s) throw NumberFormatException
Double类             public static double parseDouble(String s) throw NumberFormatException
Byte类               public static parseByte(String s)
Long类               public static long parseLong(String s)
Short类              public static short parseShort(String s)
以上方法都是用于将字符串对象格式的数据,转换为相应类型的基本类型
eg:
String s1=new String("30000");
String s2=new String("8");
String s3=new String("0.123456");
String s4=new String("0.0123456789");
String s5=new String("999999999");
String s6=new String("100");
int INT;
byte BYTE;
float FLOAT;
double DOUBLE;
long LONG;
short SHORT;
INT=Integer.parseInt(s1);
BYTE=Byte.parseByte(s2);
FLOAT=Float.parseFloat(s3);
DOUBLE=Double.parseDouble(s4);
LONG=Long.parseLong(s5);
SHORT=Short.parseShort(s6);
*INT的值是30000,BYTE的值是8,FLOAT的值是0.123456,DOUBLE的值是0.0123456789,LONG的值是999999999,SHORT的值是100
<2>基本数据类型转换为字符串对象的值
String类的public String valueOf(int n/byte n/float n/double n/long n/short n)方法可以把基本数据类型转换为字符串对象的值
eg:
int INT=30000;
byte BYTE=8;
float FLOAT=0.123456f;
double DOUBLE=0.0123456789;
long LONG=999999999;
short SHORT=100;
String s1=String.valueOf(INT);
String s2=String.valueOf(BYTE);
String s3=String.valueOf(FLOAT);
String s4=String.valueOf(DOUBLE);
String s5=String.valueOf(LONG);
String s6=String.valueOf(SHORT);
System.out.println(s1);
System.out.println(s2);
System.out.println(s3);
System.out.println(s4);
System.out.println(s5);
System.out.println(s6);
*对象s1的值是30000,对象s2的值是8,对象s3的值是0.123456,对象s4的值是0.0123456789,对象s5的值是999999999,对象s6的值是100
三.Object类的public String toString()方法
调用Object类的public String toString()方法,可以获得调用该方法的对象的字符串表示
eg:
Date date=new Date();
Button button=new Button("yes");
System.out.println(date.toString());
System.out.println(button.toString());
*输出结果:
Set Dec 17 21:31:57 CST 2005
java.awt.Button[button0,0,0,0x0,invaild,label=yes]
四.StringBuffer类
java.lang包中的StringBuffer类创建的字符串实体所占用的内存空间可以自动的改变大小
1.StringBuffer()构造方法
用于创建一个StringBuffer类的对象,自动分配16个字符的大小
2.StringBuffer(int size)构造方法
用于创建一个StringBuffer类的对象,并指定该对象实体的初始容量为字节参数size个字符
3.StringBuffer(String s)构造方法
用于创建一个StringBuffer类的对象,并指定该对象实体的初始容量为字节字符串类参数s的大小加16个字符的大小
4.public synchronized int length()方法,返回值范围:字符串的长度
5.public synchronized int capacity()方法,返回值范围:实体实际占用的内存空间