Java一些知识点，比较零散，可作复习用

本文主要是介绍Java一些知识点，比较零散，可作复习用，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

Sun公司对Java的定义

Java是一种具有“简单、面向对象、分布式、解释型、健壮、安全、与体系结构无关、可移植、高性能、多线程和动态执行”等特性的语言。

2.Java语言的特点

简单安全：语法借鉴C/C++，消除指针，接口代替了多重继承，垃圾自动回收机制，提供丰富的类库

可移植性：与具体平台架构无关，代码可移植

面向对象：纯面向对象语言，复用、可扩展，可维护

多线程：应用程序在同一时间并发执行多项任务

动态性：动态加载类库，运行时创建对象，适应环境发展

分布性：访问不同网络主机的数据，在不同主机上执行相关操作

3.Java平台

按应用范围划分成Java SE、 Java EE、 Java ME三个版本，用于不同的平台

Java SE是Java Standard Edition，主要用于个人工作站、桌面应用程序的开发。Java基础平台。（本课程使用的平台）

Java EE是Java Enterprise Edition，主要是为企业计算提供一个应用服务器的运行和开发平台。

Java ME是Java Micro Edition，主要是面向电子产品提供一个java运行平台，使java程序能够在手机、机顶盒、PDA等产品上运行。

4.JDK（Java Development Kit）

       Java开发工具包，供开发人员开发、编译、运行、测试Java程序

5.JRE (Java Runtime Environment)

       Java运行环境，提供Java虚拟机，解释运行Java程序

       提供Java API类库

JDK8中包含了JRE

6.JAVA程序的分类

	Application	Applet
程序   标志	静态main方法	继承java.applet.Applet,方法中为void  paint(Graphics g)
运行	独立运行，利用 java工具	不能独立运行，需要依赖浏览器，用 appletviewer工具来调试

1. 局部变量使用前必须进行初始化赋值操作，而类属性变量因为可以进行默认初始化，因此可以不用显式初始化。

1. Java数据类型划分

Java中的数据类型：简单类型和复合类型：

简单数据类型包括：
    整数类型：byte（8位）， short， int， long（64位） (都是有符号类型)
　  浮点类型：float，double
　  字符类型：char （16位，使用Unicode字符集）
　  布尔类型：boolean （C++ 的布尔类型是bool）

复合数据类型包括： 

           class(类)
　        interface（接口）

             数组

9.两个整数相加，结果默认转化为int，赋值给byte或short时会发生类型转化问题。例如下面的代码b+c的结果必须进行显式转化。

    public static void main (String[] args) {

                byte b = 27;

                byte c = 26;

                byte d =(byte)( b + c);

    }

10.十六进制赋值注意事项

     int i = 0xFFFFFFF1;

i的值为－15，因为最高位为符号位，其它取反加1得到－15

1. 字符类型

字符常量：字符常量是用单引号括起来的一个字符。

如普通字符‘a’，‘A’，

或是形如‘\u????’的Unicode形式的字符，其中“????”应严格按照四个 16进制数字进行替换，例如

    char ch = ‘\u1f1a0’; //错误

    char ch = ‘\u0041’; //正确        System.out.println(ch); // A

或是单引号所引的转义字符，如 ‘\n’，表示换行。

12.注意

字符型变量：类型为char，它在机器中占16位，其范围为0～65535。

‘a’实际上是一个数字，因此它可以赋值给一个数，例如float f =’a’; int i=’a’，它的取值范围为0－65535。

Java使用Unicode字符集，这种字符集中每个字符用二个字节即16位表示

13.字符串变量

字符串变量：用String表示，String 不是原始类型，而是一个类（class），它被用来表示字符序列。

字符本身符合 Unicode 标准，且上述 char 类型的反斜线符号适用于 String。

    例：String str= “Hello\u0041\n”; // 定义一个字符串变量，初值为Hello

     char[] str=“Hello”;  //编译错误，不支持字符串类型到字符数组类型的转换

1. 布尔类型（boolean）

布尔型数据只有两个值true和false，且它们不对应于任何整数值。布尔型变量的定义如：boolean b=true;

有些语言（特别值得强调的是 C 和 C++）允许将数字值转换成逻辑值， 这在 Java 编程语言中是不允许的；boolean 类型只允许使用 boolean 值。

1. 优先关系

不同类型数据间的优先关系如下：
低------------------------------------------->高
byte,short,char-> int -> long -> float -> double

1. 强制类型转换

高级数据要转换成低级数据，需用到强制类型转换，否则发生type mismatch编译错误，如：
int i;
byte b=(byte)i; /*把int型变量i强制转换为byte型*/

17.简单数据类型及其对应包装类

简单数据类型不是类，但Java提供了与简单类型对应的包装类

 

实现不同数据类型的转化  (通过包装类的静态方法)

如将字符串转化为整型数据

int a = Integer.parseInt("123");

如将整型数据转化为字符串

       String s = String.valueOf(123);

相应数据类型的范围信息 （通过包装类的静态属性）

如整型最大最小值

       Integer.MAX_VALUE,  Integer.MIN_VALUE

18.

Java中的算术运算主要依赖于Math类的静态方法，例如：

取绝对值：Math.abs(Type i),Type可以为int、long、float、double

对数取三角和反三角函数、对数和指数、乘方、开方

求两个数的最大最小值

得到随机数(random(),类型为double)

对浮点数进行处理：四舍五入(round)、ceil(取大值)、floor(取小值)

1. 控制语句

Java程序通过控制语句来执行程序流，完成一定的任务。

Java中的控制语句有以下几类：
    分支语句：if-else, switch
    循环语句：while, do-while, for
    与程序转移有关的跳转语句：break, continue, return
    异常处理语句：try-catch-finally, throw
    注释语句：//，/* */， /** */

20.多分支语句 switch

switch (expression){
　　　　case value1 : statement1;
　　　                          break;
　　　　case value2 : statement2;
　　　                          break;
　　　             ……
　　　　case valueN : statemendN;
　　　                          break;
　　　　[default : defaultStatement; ]
  }
    表达式expression的返回值类型必须是这几种类型之一：byte,short ,int, char——请注意是普通数据类型，而不是包装类，如Short、Byte等，也不能是long、float或double。

case子句中的值valueN必须是常量，而且所有case子句中的值应是不同的。

default子句是可选的。

break语句用来在执行完一个case分支后，使程序跳出switch语句，即终止switch语句的执行（在一些特殊情况下，多个不同的case值要执行一组相同的操作，这时可以不用break）。

21.跳转语句

Java语言提供了4种转移语句：break，continue，return和throw。

转移语句的功能是改变程序的执行流程。

break语句可以独立使用，而continue语句只能用在循环结构的循环体中。

22.break语句

break语句通常有下述不带标号和带标号的两种形式：

break；（跳出本层循环）

break lab;  （跳出多重循环的外层循环）

其中：break是关键字；lab是用户定义的标号。

23.continue语句

continue语句只能用于循环结构中，其作用是使循环短路。

continue；（跳出本层的本次循环，继续本层下一次循环）

continue lab；（跳出外层的本次循环，继续外层下一次循环）

lab是用户定义的标号。

1. 数组的数据类型

数组元素的数据类型可以是Java的任何数据类型，例如：

基本类型（int、float、double、char等）

类（class）

接口（interface）等。

1. 一维数组声明格式

类型标识符 数组名[]；

类型标识符[] 数组名；

例如： int[]  arr; 

           String[]  example; 

           myClass[]  mc ;    

注：Java中的数组可以看作是一个对象。

       注意声明时不可在方括号内指定数组大小，

       如int [10] arr;   是错误的

1. 一维数组初始化

·使用关键字new——可将数组看成一个特殊对象

类型标识符 数组名[]=new 类型标识符[数组长度]；

类型标识符[] 数组名=new 类型标识符[数组长度]；

数组元素为基本数据类型的情形

例如： int[] arr = new int[10];

Int arr[] = new int[10];

数组元素为“类”类型 （实质是对象引用）

例如：String[] example = new String[10];  //对象引用数组

·直接在声明的时候进行定义及初始化，例如：

String[] s={"ab","bc","cd"};

    int[] a = {3,4,5,6}；

对于对象数组：

    Integer results[] ={new Integer(3), new Integer(5), new Integer(8)};

    String[] dogs ={new String(“Fido”),new  String(“Spike”),new String(“Aiko”)};

注：这种初始化方法只能写在声明代码中（“{}”内用 , 号分隔）,下面的写法是错误的：int[] a ; a= {3,4,5,6};

·采用1和2相结合方式进行初始化，例如：

    float f4[] = new float[] { 1.0f, 2.0f, 3.0f}; 

     float f4[] ;

     f4= new float[] { 1.0f, 2.0f, 3.0f};

     注：此时float中的[ ]不应该给出具体数字

1. 数组中的一些异常

Java中数组的下标从0开始，如果数组越界，产生的异常为：IndexOutOfBoundsException （它继承RuntimeException）

    若定义数组大小为负数会产生NgativeArraySizeException（它继承RuntimeException），但是数组长度可以为0（不是null）

28.一维数组的相关方法

某些类的方法返回数组对象引用:

       例如：linkedList、Vector对象可以调用方法toArray()返回

       Object[]数组，此时数组中为对象的引用，不是对象。

    Arrays. sort方法：对char,byte,short,int,float,double,long按升

 序排列，也可指定排序方法对对象进行排序(见JDK文档)。

    System.arraycopy()——复制数组

   public static void arraycopy(

            Object src, int srcPos,     //源数组，起始下标位置

            Object dest,int destPos,  //目的数组，起始下标位

            int length)                        //拷贝长度

29.二维数组的声明格式

类型说明符   数组名[ ][ ]；

类型说明符[ ][ ]   数组名；

       例如：

            int arr[ ][ ];

     　     int [ ][ ] arr;

1. 二维数组初始化

·使用关键字new

  格式如下：

数组名=new 类型说明符[数组长度][ ]； 

数组名=new 类型说明符[数组长度][ 数组长度]；

其中：对数组名、类型说明符和数组长度的要求与一维数组一致。对于没有初始化的维度，其值为null。

int arra[][];

 arra=new int[3][4]；

 等价于：

 arra=new int[3][]；  创建有3个元素的数组，各元素也是一个数组

                  此时arra[0],arra[1], arra[2]的初值默认均为null

 arra[0]=new int[4]；创建arra[0]元素的数组，它有4个元素

 arra[1]=new int[4]；创建arra[1]元素的数组，它有4个元素

 arra[2]=new int[4]；创建arra[2]元素的数组，它有4个元素

 也等价于：

 arra=new int[3][]

 for(int i=0;i<3;i++) { arra[i]=new int[4]；}

使用foreach语句遍历二维数组：

   for(int[] arr1: arra){

      for(int x: arr1)

          System.out.println(x);

   }  //二维数组每个元素的初值默认为0

·是用指定的初值对数组初始化，例如：

int[][] arr1={{3,-9,6},{8,0,1},{11,9,8}}

    它等价于：

    int[][] arr1=new int[3][];

    arr1[0]=new int[]{3,-9, 6};

    arr1[1]= new int[]{8,0,1};

    arr1[2]= new int[]{11,9,8};

对于二维数组，当只定义第一维维数时，另一维的维数可以不一样，也就是说不一定是规则的矩阵形式，

1. 冒泡排序

private static void bubbleSort(int[] pre)

{    //交换标志/交换次数控制/临时参数

     int switchMark =1,m=pre.length-1,temp;    

     while(m>0 && switchMark ==1)  //交换条件

     {    switchMark =0;                      //交换前初值

          for(int i=0;i<m;i++)                 //进行一趟交换

         {  if (pre[i]>pre[i+1])               //将大数放入到数组的后面

            {   temp = pre[i+1];             //进行数的交换

            pre[i+1] = pre[i];

            pre[i] = temp;

            switchMark =1; } }

         m = m-1;                               //下一趟交换的最大次数

     }     

 }

1. Java程序编写规范

·有多个import语句时，先写java包（都是java包时，按照字母先后顺序排序），后写javax，最后写其它公司的包和自己定义的包。

·命名规则为：

包名中的字母一律小写，xxxyyyzzz。

类名、接口名应该使用名词，每个单词的首字母大写，如XxxYyyZzz。

变量名、方法名第一个字母小写，后面每个单词的首字母大写，如xxxYyyZzz。

常量中的每个字母大写，如XXXYYYZZZ。

·程序{}强调匹配的同时，要保持适当的缩进，以便于阅读。

·必要时应有一定的程序注释量（20％－50％）：

   注释内容有：程序头说明，属性说明，方法说明。

   Java中的注释共有两种方式

多行注释：/*  文字或程序语句 */

单行注释：//  文字或程序语句

/*  文字或程序语句 */不能嵌套，即/*  /*文字或程序语句*/ */是非法的。

程序中写注释不仅有助记作用，而且还可以利用javadoc生成帮助文档，当然能够    生成帮助文档的注释必须具备一定的规则，那就是注释格式必须为：

        /** 说明信息 */

1. 生成帮助文档的注释格式

1）程序头说明：注释符为/**  说明部分   */,在说明部分一般包括文档的标题、描述、版权、作者、版本等信息。其中作者用 “@author <作者>”的形式体现，内容和关键字之间用空格隔开。其它为：

    @version <版本>；

    @see <相关内容或类>；

    @since <本内容在哪个版本以后开始出现>。

2）方法说明：用于说明本方法的主要用途，实现的基本思 路，属性信息有：

   @param <属性名称> <参数说明> ；

   @return <返回值说明>；

   @exception <例外说明>；

   @throws <异常类> ；

   @deprecated <功能逐渐被淘汰说明>。

程序说明：

<br>的含义是在生成的html中换行；而@author不用写<br>的原因是，这种属性可以自动换行。

javadoc -d HelloWorldDoc -version -author HelloWorldApplet.java
-d的含义是将所有生成的帮助文件全部放入本目录下的子目录HelloWorldDoc下， -version和-author是在帮助文件中列出相关的这方面信息。

如果想知道更多javadoc，输入javadoc –help。

1. 面向对象的程序设计思想

面向对象的世界

程序 = 对象 + 消息

三大特征

封装 （encapsulation）： 类与对象

继承 （inheritance）     ： 基类与派生类

多态 （Polymorphism）： 抽象类与接口

优点

可重用（通用代码）

可扩展（插入新的功能，不需要改变原有的代码）

可维护（代码结构优良，接口清晰）

1. 类与对象及其关系

对象是对客观事物的抽象。

类是对对象的抽象，在语言中是一种抽象的数据类型。

类的定义在Java中可简述为   class  类名{  }

它们的关系是，对象是类的实例，类是对象的模板。

36.类中的域变量和方法存在以下关系

类中定义的域变量可以被类中所有的方法所访问。

方法中的形式参数和定义的局部变量的作用域仅限于方法，局部变量在使用前必须进行赋值初始化。如果局部变量和类中的属性变量重名，则在方法中对同名变量操作改变的是局部变量 。

1. 对象(object)与对象引用（object reference）

创建对象：    new FighterPlane();     （分配在堆上）

声明一个对象引用：    FighterPlane  fp ;  （分配在栈上）    

遥控器（对象引用）和电视机（对象）的关系。

初始化对象引用：FighterPlane fp  = new FighterPlane()

实质是将新创建的FighterPlane对象的地址赋给对象引用fp，从此fp与该对象关联，通过fp即可操纵该对象

37.对象作为参数的特点

普通数据类型作为参数传递是值传递，而对象是引用传递。

public class X {

    private static int a;

     public static void main(String [] args) {

         modify(a);

          System.out.println(a);

    }

     public static void modify(int a) { a++; }

 }

本程序的输出为0，因为a++是对形式参数进行自增，而不是对

象属性a进行自增。

对象的引用传递举例

class IntClass {

    int value;  

}  

public class RunIntClass

{

     public static void modifyValue(IntClass s, int val){

            s.value = val;

     }

   public static void main(String args[]) {

        IntClass  a = new IntClass();    

             modifyValue(a,8);

             System.out.println(a.value); 

   }

}

class IntClass { 

    int value; 

}  

public class RunIntClass { 

    public static IntClass getInstance() {

        //在方法中产生对象

            IntClass s = new IntClass ();

              s.value=8;

              return  s; //返回对象引用

       }

      public static void main(String args[]) {

            IntClass a = getInstance();

            System.out.println(a.value);

      }

}

38.创建对象时的初始化顺序：

1）系统会对数据成员进行默认初始化

2）执行数据成员定义处的初始化语句

3）调用构造方法为数据成员指定初值

39.finalize方法与垃圾回收

什么是垃圾对象? 

      对象没有任何引用

垃圾对象何时回收?

   虚拟机在系统资源不够的情况下才会回收垃圾对象

垃圾对象回收时调用finalize方法

   垃圾回收不能保证一定会发生

1. Static

用static修饰符修饰的数据成员是不属于任何一个类的具体对象，而是属于类的静态数据成员。

它被保存在类的内存区的公共存储单元中,而不是保存在某个对象的内存区中。因此,一个类的任何对象访问它时，存取到的都是相同的数值。

访问方式为通过类名加点操作符来访问，也可通过对象引用来访问。

静态数据成员仅在类加载时进行初始化，且只执行一次初始化

Static修饰的方法有如下特点：

static方法是类方法，但可以被所有对象所访问，引用这个方法时，可以使用对象名做前缀，也可以使用类名做前缀。

static方法内部的代码，只能访问类中的static属性或方法，不能直接访问类中的非static属性或方法（因为那是对象方法），但非static方法（对象方法）可以访问static数据成员。

main方法是特殊的静态方法，是Application程序入口点，必须写成public static void main(String args[])的形式。

当首次访问某类的静态字段或静态方法时，会加载该类(.class)，并执行静态初始化语句

1. 静态代码模块

一个类中可以使用不包含在任何方法体中的静态代码块，当类被装载时，静态代码块被执行，且只被执行一次，静态代码块经常用来对类中定义的属性进行初始化。 

class Test {

   static int value ;

   static { 

            value = 3;

            System.out.println("value="+value);

   }

   public static void main(String[] args){   }

}

程序输出结果为value=3

1. final

final修饰属性，则属性为常量；

如果修饰方法，则方法称为最终方法，在子类当中不能被覆盖（见多态一节），可防止任何继承类修改此方法，保证了程序的安全性和正确性。

     public Constant{

        static final int OK=0;

        static final int CANCEL=1; 

        .. .. ..}

可以在Constant类中定义一些静态常量，在别的类当中这样来使用： Constant.OK。

也可定义对象的属性常量

1. 包（Packge）

随着Java的应用，SUN公司的JDK，各系统开发商，以及自己开发的类越来越多，如何对这些类进行有效的组织管理和有效使用，Java的解决办法是“包”。

JDK的类库：以包的形式组织，存放于rt.jar文件中 (.class形式)

                     语言包：java.lang

                     实用包：java.util

                     输入输出流包：java.io

                     …….

自定义类库：包名小写，单词中间用‘.’隔开，遵循互联网的逆向顺序

      例如：org.hzau.info.web    

1. 访问控制

体现封装，则需要掌握访问控制符

     Public（接口访问权限）

     protected（包访问权限、继承访问权限）

   “默认”（包访问权限）

     private（无法直接访问）

在java中这些修饰符可以用于：

修饰类 

修饰类的属性成员（域）

修饰类的成员方法

protected属性具有包访问权限，可以被同一包中的所有类访问

子类的类定义中可以访问父类的protected属性和方法，不论是否在同一包

不能通过对象引用fp来访问不在同一包的类的protected属性和方法

1. 消息

面向对象程序 = 对象+ 消息

消息的实质就是引用向对象发出的服务请求，是对数据成员和成员方法的调用，例如 fp.name 和 fp.fire()就是发送消息。

能否发送消息取决于：

引用必须引用了特定的对象，否则会在运行时抛出NullPointerException异常。

对象必须定义了相应的属性或方法，否则编译不会通过。

被访问的属性或方法必须具有可访问的权限。

1. 继承

通过extends关键字实现；

子类继承了父类的所有属性和方法， 但只有public、protected的属性和方法在子类是可见的。

子类可以直接访问父类的protected属性和方法

子类不能直接访问父类的private属性和方法，可以调用父类的公共方法来间接访问私有属性

1. Object类

Object类是所有类的共同祖先，即使定义类时没有写extents Object。

在Object当中定义了许多方法，这些方法都可以被所有子类所继承。

1. 多态

多态的概念：多态是指一个程序中同名的不同方法共存的情况

Java中提供两种多态的机制：重载（overloading）与覆盖（overriding）

重载

如果一个类中有多个具有相同名称但参数不同的方法，则称为方法重载。

重载有两种方法：

通过改变参数的数量

通过改变参数的类型

重载与返回类型无关。

覆盖

子类对父类的同名方法（方法名称相同，参数相同，返回类型相同）重新进行定义，即在子类中定义与父类中已定义的相同名而内容不同的方法。

覆盖注意：

子类的访问修饰符权限应等于或大于父类

同名的static方法和非static方法不能相互覆盖

方法前有final修饰符，此方法不能在子类方法中进行覆盖

在JDK中，很多父类的方法被子类重新覆盖，赋予了不同的含义，如Object类中的boolean equals(Object obj)方法

抽象类中如果存在抽象方法，则具体子类必须对抽象方法进行覆盖

方法名称相同，参数名称相同，返回类型相同：覆盖

方法名称相同，参数名称不同：重载

方法名称相同，参数名称相同，返回类型不同：编译不能通过

1. this

this 用法有三种，主要应用场合：

    用法一：表示当前对象引用，常用于形参或局部变量与类的成员变量同名的情形，使用this.成员名表示当前对象的成员

用法二：表示当前对象

用法三： 调用当前类的构造方法

50.super

super访问当前类的直接父类，主要应用场合：

    子类的数据成员或成员方法与父类的数据成员或成员方法名字相同时，当要调用父类的同名方法或同名数据成员时则可用super来指明。即super.数据成员；super.成员方法

  super(参数) , 表示调用父类构造方法

子类和父类定义了同名数据成员，子类继承了父类的x，自己又定义了一个x，则会发生父类数据成员的隐藏。在子类中用的x都是子类自己的，若要使用父类x，则必须用super.x。

1. 抽象类（abstract类）

抽象（abstract）类的概念：用abstract修饰的类称为抽象类，用abstract 修饰的成员方法称为抽象方法。

·抽象类和具体类的关系就是一般类和特殊类之间的关系，是继承和被继承的关系。抽象类中可以有零个或多个抽象方法，也可以包含非抽象方法。只要有一个抽象方法，类前就必须有abstract修饰。若没有抽象方法，类前也可有abstract修饰。

·抽象类不能创建对象，创建对象由具体子类来实现，但可以有声明，声明能引用所有具体子类的对象。

·对于抽象方法，在抽象类中只指定方法名及类型，而不写实现代码。抽象类必定要派生子类，若派生的子类是具体类，则具体子类中必须实现抽象类中定义的所有抽象方法（覆盖）。

·若子类还是抽象类，如果父类中已有同名abstract方法，则子类中就不能再有同名的抽象方法了。

·在抽象类中，非抽象方法可以调用抽象方法。

·abstract不能与final并列修饰同一个类（产生逻辑矛盾）；

   ·abstract 不能与private ,static（因为static修饰的方法必然被直接调用）,final或native并列修饰同一个方法。

1. 接口（interface）

接口的两种含义：

可以被引用调用的方法（public方法或同包中的protected方法或默认方法）；

另一种是同“类”概念地位相当的专有概念interface， interface是方法说明的集合。

接口扮演将实现者和使用者有机联系到一起的角色。

在类中，用implements关键字来实现接口。一个类可以实现多个接口，在implements后用逗号隔开多个接口的名字。一个接口也可被多个类来实现。

接口的实现者可以继承接口中定义的常量，其效果等效于在这个实现类当中定义了一个静态常量。

如果实现某接口的类不是abstract的抽象类，则在类的定义部分必须实现接口的所有抽象方法，而且方法头部分应该与接口中的定义完全一致。

如果实现接口的类是abstract类，则它可以不实现该接口的所有方法。但对于抽象类的任何一个非抽象的子类而言，接口中的所有抽象方法都必须实现。

接口的抽象方法的访问限制符如果为缺省或public时，类在实现方法时，必须显式使用public修饰符，否则将被警告为缩小了接口中定义的方法的访问控制范围。

抽象类与接口

		抽象类	接口
共同点		二者都可具有抽象方法，都不能实例化，但都可以有自己的声明，并能引用子类或实现类对象。
不同点	属性变量	可以有变量	不能有，只能是静态常量。
	成员方法	可以有具体方法(而且具体方法可以调用抽象方法)。	如果有方法，则全部是抽象方法。
	实现策略	必须有子类继承	必须有实现类实现
	扩展性	弱	强

1. Java类库

包名	含义
Java.lang	语言包
Java.util	实用工具
Java.awt	抽象窗口工具
Java.applet	Applet应用程序
Java.text	文本工具
Java.io	输入输出流及文件
Java.net	网络功能
Java.rmi	远程方法调用
Java.sql	数据库API

1. String与StringBuffer

String

String 不是简单类型，而是一个类，它被用来表示字符序列。

字符本身符合 Unicode 标准，其基本的初始化方式如下：

String s1 = "Hello\n";

String s2 = new String("Hello\n");

String对象是不可变的，在String类中每一个看起来会修改String对象内容的方法，实质都是创建了一个全新的String对象。

StringBuffer是一个具有对象引用传递特点的字符串对象

StringBuffer对象的值是可变的，对字符串的增加、插入、修改、删除等操作比String高效（不需多次创建新的对象）。

DK1.5 引入了StringBuilder，其与StringBuffer的API兼容，性能比StringBuffer更高，但不是线程安全的

1. 进程与线程

 一个进程就是一个执行中的程序，而每一个进程都有自己独立的一块内存空间、一组系统资源，每一个进程的内部数据和状态都是完全独立的。

Java程序执行中的单个顺序的流控制称为线程，多线程则指一个进程中可以同时运行多个不同的线程，执行不同的任务。

线程与进程的区别：同类的多个线程共享一块内存空间和一组系统资源，而线程本身的数据通常只有微处理器的寄存器数据，以及一个供程序执行时使用的堆栈。所以系统在产生一个线程，或者在各个线程之间切换时，负担要比进程小的多 。

为什么需要多线程：提高CPU利用率。

这篇关于Java一些知识点，比较零散，可作复习用的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！