第一章java基础语法总结




抽象类 继承  必须实现其所有方法


儿子被父亲抽了   还想继承  必须用尽所有方法实现其规定




接中的方法一定是:public abstract




JAVA_HOME   F:\srv\j2sdk
.;
classpath                 %JAVA_HOME%\lib;%JAVA_HOME%\lib\tools.jar
path                      %JAVA_HOME%\bin;%JAVA_HOME%\jre\bin ;


一、java的命名规则






1、java中定义类名时，必须以字母开头，后者可以跟字母和数字的任意组合。在实际工作中要求类名必须以大写字母开头。


2、java中变量名必须是一个以字母开头的由字母和数字构成的序列。


3、java对大小写敏感，书写时一定要注意区分大小写。如果出现大小写拼写错误（如将main写成Main），那么程序将无法运行。


4、java中方法名首字母小写，第二个单词开始大写且为动词。


5、常量名习惯使用大写，单词之间用下划线连接。


 


二、注释


在java中有三种写注释的方式：


1、最常用的方式是使用//，其注释内容从//开始到本行末结束。


2、当需要长篇的注释时，可以使用将一段比较长的注释括起来。/*  */




3、使用结束，可以用来自动生成文档。/**  */


例1：




 


public class FistSample{


public static void mian(String[] arg){


    System.out.println(“Hello World !”)


}


}


三、数据类型


在java中，一共有8种基本类型，其中有4种整型、2种浮点类型、1种用于表示Unicode编码的字符单元的字符类型和1种用于表示真假值的boolean类型。


 


（1）、整型


整型用于表示没有小数部分的数值，它允许是负数。Java提供了4种整型，具体内容如表1。


                          表1 java整型       


 


类型
 存储需求
 取值类型
 
int
 4字节
 -2^31 — 2^31-1
 
short
 2字节
 -32768 —32767
 
long
 8字节
 -2^63 — 2^63-1
 
byte
 1字节
 -128 —127
 


 


（2）、浮点类型


浮点类型用于表示有小数部分的数值。在java中有两种浮点类型，具体内容见表2。其中double表示这种类型的数值精度是float的两倍。绝大部分应用程序采有double类型。


表2 浮点类型


 


类型
 存储需求
 取值类型
 
float
 4字节
 大约
 
double
 8字节
 大约
 


 


（3）、字符类型


char字符类型是一个16位无符号整数，用于表示单个字符，通常用来表示字符常量。


①、字符类型的值是对应字符的编码，是unicode 编码，java支持国际化，其中英文部分的值与ascll编码一致。Char是定长编码，所以的字符都是16位。例2：‘A’  0X0041


  ‘中’  0x4e2d


   在编码中：’0’ ’9’  ‘a’ ’z’  ‘A’ ’Z’都是连续编码的。


②、字符字面量使用单引号为定界符号：‘中’字面量也是整数常量。


③、最小值：0，最大值：65535 = 2^16-1


（4）boolean类型


Boolean类型有两个值：false和true，用来判定逻辑条件。整型值和布尔值之间不能进相互转换。


四、变量


1、java是强类型语言，其变量命名必须以字母开头，由字母和数字构成的序列。


2、变量必须声明，并且初始化以后使用。


3、变量必须有明确的类型，且变量不能重复定义。


4、变量的作用域，在声明的地方开始，到块结束为止，离开变量的作用结束时，变量将回收。


5、在java中，利用关键字final声明常量，这个常量只能被赋值一次，一旦赋值之后就不能够再更改了。习惯上，常量名使用大写。


例3        


public class Constants{


public static void main(String[] args){


    final double A=2.54;//常量名习惯用大写


    // a=3.14; 错误


    double b=3.12;


    double c=3.21;


    System.out.println（A+b+c）;


}


}


 


五、运算符           


1、数学运算符：+ - * / %，需注意的问题有：


（1）在作/运算时，只有当参与/运算的两个操作数都是整数时，表示整数除法；否则，表示浮点除法。如：15/2为7，15.0/2为7.5。


 


（2）运算具有封闭性，即同种类型参与运算，返回同种类型。值得注意的是可能发生上溢出和下溢出。如：int i = 1024*1024*1024*4(上溢出)。


 


（3）作%运算时，参与运算的两个操作数必须为整型，否则会报错。


 


（4）+可以作字符串的连接运算，如：“，”+2  “，2”


例4：


public class Yunxuan{


public static void mian(String[] args){


    int a=3;


    double b=3.0;


    int c=2;


    System.out.println(a/c);//1


    System.out.println(b/c);//1.5


    System.out.println(a%c);//1


    //System.out.println(b%c);//出错


   


    int i=1024*1024*1024*4+1;//上溢出


    System.out.println(i);//1


}


}


2、关系运算符


（1）自增、自减运算：++ --


     a、i++:先将i的值作为整个表达的值，然后将i增加1。


     b、i++：先将i增加1，然后将i的值作为整个表达的值。


（2）在java中，用&&、&表示逻辑“与”，用||、|表示逻辑“或”，其中&&、||表示短路的逻辑运算， &、|表示非短路运算，大多数时使用短路运算。


（3） >>   <<， 运算符将二进制进行右移或左移操作。


六、数组


（1）数组是一种数据结构，用来存储同一类型值的集合。在声明数组变量时，需要指出数组类型和数组变量的名字。


（2）数组初始化时一定要指定其维数，其初始化形式有以下两种：


     ①动态初始化数组：int[] arry = new int[];


     ②静态初始化数组：int[] arry = {1,2,3,4,5};  arry.length = 5;


七、大数值


如果基本的整数和浮点数精度不能够满足需求，那么可以使用java.math包中的两个很有用的类：BigInteger和BigDecimal，这两个类可以处理包含任意长度数序列的数值。


(1)BigInteger类实现了任意精度的整数运算，BigDecimal类实现了任意精度的浮点数运算。使用静态的ValuOf方法可以将普通的数值转换为大数值。


(2)Java.math.BigInteger中常用的API


①  BigInteger add(BigInteger other)


BigInteger subtract(BigInteger other)


BigInteger multiply(BigInteger other)


BigInteger divide(BigInteger other)


BigInteger mod(BigInteger other)


返回这个大整数与另一个大整数other的和、差、积、商以及余数。


②   int compareTo(BigInteger other)


如果这个大整数与另一个大整数other相等,返回0，如果这个大整数小于另一个大整数other，返回负数，否则，返回正数。


③   static Bigteger valueOf(long x)


返回值等于x的大整数


④  BigDecimal add(BigDecimal other)


BigDecimal subtract(BigDecimal other)


BigDecimal multiply(BigDecimal other)


BigDecimal divide(BigDecimal other)


BigDecimal mod(BigDecimal other)


返回这个大实数与另一个大实数other的和、差、积、商以及余数。


⑤  int compareTo(BigDecimal other)


如果这个大实数与另一个大实数other相等,返回0，如果这个大实数小于另一个大实数other，返回负数，否则，返回正数。


⑥  static BigDecimal valueOf(long x)


static BigDecimal valueOf(long x,int a)


返回值为x或 的一个大实数。


八、控制流程


（1）分支流程控制语名


①if(布尔表达式){


    //...


  }else{


    //...


  }


 


  ②switch(整数表达式){


    case 整数(int)常量:


      // ....


      break;


    case 整数常量:


      // ....


      break;


    default:


      //....


  }


（2）分支循环控制语句


 ① for(初始化表达式;布尔表达式; 递增表达式){


    //循环体


}


 


② While 循环控制


  while(布尔表达式){


  }


③do ... while() 循环控制


  do{


  //循环体


  }while(布尔表达式);


 


（3）For each 循环


Java SE 5.0 增加了一种功能很强的循环结构，可以用来依次处理数组中的每个元素而不必为指定下标值而分必。这种增强的for循环的语句格式为：


for(vriable : collection) statement


 


（4）break,continue,return,exit()的区别


break:跳出本层循环


continue:跳出本次循环


return:跳出方法


exit():跳出执行的程序


九、三大排序


（1） 选择排序


  原理: ① 将数组中的每个元素,与第一个元素比较


          如果这个元素小于第一个元素, 就将这


          两个元素交换.


        ② 每轮使用a的规则, 可以选择出一个最小元素


          放到第一个位置.


        ③ 经过n-1轮比较完成排序


   简单说: 每轮选择最小的放到前面.


      


数组的迭代(Iterate over Array)就是对数组的遍历


就是逐一处理数组元素.


逐一处理==遍历==迭代==Iterate


 


（2） 冒泡排序


  原理: ① 逐一比较数组中相邻的两个元素, 如果后面


         的数字小于前面的数字, 就交换先后元素.


        ② 经过一个轮次的比较, 一定有一个最大的排


         在最后的位置.


        ③ 每次比较剩下的元素, 经过n-1次比较, 可以


         实现排序


  简单说: 比较交换相邻元素,每次最大的漂移到最后


   


3 插入排序


  原理: ① 将数组分为两部分, 将后部分的第一张逐一


         与前部分每一张比较, 如果当前元素小, 就


         一点被比较元素.


        ② 找到合理位置插入.


例5：


public class SortDemo {


  public static void main(String[] args) {


    int[] ary = {8,3,5,1,4,2,7};


    //ary = selectionSort(ary);


    //ary = bubleSort(ary);


    ary = insertSort(ary);


       //输出数组ary内容


    for (int i = 0; i < ary.length; i++) {


      System.out.print(ary[i]+" ");


    }


  }


 


  public static int[] insertSort(int[] ary){


    for(int i=1; i<ary.length; i++){


      int temp = ary[i];


      int j;


      //for(j=i-1; j>=0 && temp<ary[j]; j--){


      for(j=i-1; j>=0; j--){


        if(temp<ary[j]){


          ary[j+1]=ary[j];


        }else{


          break;


        }


      }


      ary[j+1]=temp;//插入


    }


    return ary;


  }


 


  public static int[] bubleSort(int[] ary){


    for(int i=0; i<ary.length-1; i++){


      for(int j=0; j<ary.length-(1+i); j++){


        if(ary[j] > ary[j+1]){


          int temp = ary[j];


          ary[j] = ary[j+1];


          ary[j+1] = temp;


        }


      }


    }


    return ary;


  }


  public static int[] selectionSort(


      int[] ary){


    for(int i=0; i<ary.length-1; i++){


      for(int j=i+1; j<ary.length; j++){


        if(ary[j]<ary[i]){


          int temp = ary[j];


          ary[j] = ary[i];


          ary[i] = temp;


        }


      }


    }


    return ary;


  }


 


}


 


第二章 抽象类、接口总结


一、抽象类


1、抽象方法：只有行为的概念，没有具体的行为实现。使用abstract关键字修饰，并且没有方法体。


例6：


Public abstract class Question{


int  id;


String text;


public  Question(){};


public Question(int id ,String text){


    this.id=id;


    this.text=text;


}


public void setId(int id){


    this.id=id;


}


public int getId(){


    return id;


}


public void setText(String text){


this.text=text;


}


Public String getText(){


    return text;


}


//下面两个是抽象方法，没有方法体


public abstract void show();


public abstract Boolean check(char[] answers);


}


2．包含抽象方法的类，就一定是抽象类。


3、抽象方法和抽象类非常适合作为系统的分析和设计的工具。


4、抽象类不能直接真接创建实例，可以定义引用变量。


5、抽象类只能被继承，一个具体类继承一个抽象类，必须实现所有抽象方法。


例7：


public class SingleChoice extends Question{


    char[] answers;


public void show(){


System.out.println(“选择题”)


}


 


public Boolean check(char[] answers){


return Arrays.equals(this.answers,answers);


}


}


 


二、接口


1、 接口：全部的方法都是抽象方法，全部的属性都是常量。


   接口用来表示纯抽象概念，没有任何具体的方法和属性。


 2 、不能实例化，可以定义变量。


 3、 接口变量可以引用具体实现类的实例。


 4 、接口只能被实现，一个具体类实现接口，必须使用全部的


   抽象方法。


 5、 接口之间可以继承。


 6 、一个具体类可以实现多个接口，实现多继承现象，表示：


 一个概念即是XXX也是XXX.


 7、 接口中的属性，默认是常量 public static final


 8 、接中的方法一定是:public abstract


 9、 实现一个接口，使用关键字implements, 实现实际上是


   一种继承关系。接口和实现类是父子类型的关系


例8：


(1)


//一个具体类可以实现多个接口，实现多继承现象，


public class InterfaceDemo implements Area,Crea{


//一个具体类实现接口，必须使用全部的抽象方法


     public double area(double r){


     return Math.PI*r*r;


}


public double crea(double r){


     retrun 2*Math.PI*r;


}


}


interface Area{


    final static int MIN=4;// 接口属性都是常量


    abstract public double area(double r);


}


interface Crea{


    abstract public double crea(double r);


}


(2)


public class Inter {


     public static void main(String[] args){


double r=1.2;


     InterfaceDemo s = new InterfaceDemo();


     double s1 = s.area(r);


System.out.println(s1)


}


}


第三章  时间类、集合、异常类


一、时间类


1、java 中基本的时间表示 long


2 、Java提供了Date类型表示时间和日期


Date 是long类型的包装


3 、Calendar 是历法的的抽象.


历法: 公历, 农历, 太阳历, ...


GregorianCalendar 是历法的实现, 采用公历(太阳历) 算法实现的.


4 、long <---------->Date <---------> Calendar


  long getTime()     Date getTime()


  setTime(long)      setTime(Date)


例9：


import java.text.SimpleDateFormat;


import java.util.Clendar;


import java.util.Date;


import java.util.GregorianCalendar;


 


public class DateDemo1{


public static void main(String[] args){


     long time = 0;   //java中基本时间为long


     Date date = new Date();


     date.setTime(time);//将time转化为Date


     SimpleDateFormat fmt = new SimpleDateFormat(“yyyy-MM-dd”);


     String exp = fmt.format(date);//格式化输出日期


     System.out.println(exp);


     Calendar cal = new GregorianCalendar();//采用公历算法实现


     cal.setTime(date);//将date转化为cal


     Date d = cal.getTime();//将cal转化为date


}


}


5 、Date 和 Calendar 的默认值就是当前时间


6、 日期的计算


如: 计算商品的促销日期:


输入: 商品生产日期, 和保质期月份


返回: 商品的促销日期, 是过期前一周的周日


   


7 日期的输入与输出


java.text.SimpleDateFormat fmt = new SimpleDateFormat("yyyy-MM-dd");


    


构建SimpleDateFormat 一般提供日期的格式


"yyyy-MM-dd" 具体参看 javadoc


 如: "yyyy-MM-dd HH:mm:ss"


"yyyyMMdd"


   


 8、 fmt.parse(String)可以实现将(合法)字符串解析为日期类型, 经常用于处理日期输入。


9、fmt.format(Date) 可以把日期格式化为字符串用于输出处理.。


 


例10:


 


import java.text.SimpleDateFormat;


import java.util.Clendar;


import java.util.Date;


import java.util.GregorianCalendar;


import java.util.Scanner;


 


public class DateDemo2{


public static void main(String[] args) throws Exception{


    Scanner console = new Scanner(System.in);


    String str = console.nextLine();//输入商品的生产时期


    SimpleDateFormat fmt = new SimpleDateFormat(“yyyy-MM-dd”);


    Date date = fmt.parse(str);//str转化date


    Date date expDate(d,3);//调用函数计算促销日期


    String exp = date.format(date);


    System.out.println(“促销日期为:”+exp);//输出促销日期


}


 


public static Date expDate(Date date,int months){


      Calendar cal = new GregorianCalendar();


      cal.setTime(date);//将生产时期由date转化为cal


      cal.add(Calendar.MONTH,months);//计算过期日期cal.add(Calendar.WEEK_OF_YEAR,=1);//提前一周促销


      cal.set(Calendar.DAY_OF_WEEK,Calendar.SUNDAY);//更新到过期日前周日


      return cal.getTime();


}


}


 


二、集合与数据结构


  1 、数学集合在软件开发中应用广泛，如商品列表。


  2、 Java中使用接口Collection定义了集合的概念。Collection接口中定义了集合的功能抽象：添加元素，删除元素，集合的并，集合的交，集合差，...


  3、 Java提供了集合的实现类： ArrayList，LinkedList, HashSet等。


  4、 LinkedList 是使用双向循环链表实现的线性表集合；


      ArrayList 是使用变长数组实现的线性表集合。


  5、 线性表(List接口)是经常使用的。


例11：


import java.util.ArrayList;


import java.util.List;


public class ListDemo1{


public static void main(String[] args){


     List<Song> songs = new ArrayList<Song>();


     songs.add(new Song(“花好月圆”));


     songs.add(new Song(“明天”));


     songs.add(0,new Song(“今天”));


     System.out.println(songs);


}


}


class Song{


String name;


String filename;


public Song(String name){


this.name = name;


} 


public String toString(){


     return name;


}


}


 


例12:


import java.util.ArrayList;


import java.util.Collection;


import java.util.List;


 


public class ListDemo2{


public static void main(String[] args){


    Coolection<String> names = LinkedList<String>;


    //输出name集合的大小


System.out.println(names.size());//0


System.out.println(names.isEmpty());//true


 


names.add(“王定杰”)；


names.add(“凌晨”);


names.add(“林华标”);


names.add(“徐靖”);


 


System.out.println(names.size());//4


System.out.println(names.isEmpty());//false


System.out.println(names.contains(“王定杰”));//true


 


Collection<String> others = new ArrayList<String>();


others.add(“王定杰”);


others.add(“徐靖”);


 


names.retainAll(others);//保留公共部分，交


System.out.pringln(names);//王定杰、徐靖


 


others.cemoveAll(names);


Ssytem.out.println(others);


}


}


 


三、异常


1、行为的意外结果


2、 一个方法如果抛出了异常，这个方法就必须声明异常的抛出.


   异常的声明:在方法上声明方法的意外结果，如：


     User reg(String name, String pwd, String email)


       throws UserExistException;


     User login(String name, String pwd)


       throws NameOrPwdException;


    


 3、 异常类一般继承于Exception, 一般要手工继承


  父类全部的构造器


 


 4、 调用抛出异常的方法，必须处理异常


   4.1 使用try catch finally 捕获


   4.2 直接再抛出异常


   处理方式，依赖于具体业务逻辑，很灵活。


   * 一般处理原则: 底层尽量处理,如果处理不了


                 一定再抛出!


 5、 如果代码有异常发生，异常以后的代码将不再执行。


  


 6、 try catch finally：


  try 是尝试运程代码块，如果有异常会被随后的catch捕获


  异常发生以后代码不执行


  catch代码块是异常处理代码。需要提供合理的处理，异常的处理


  是与具体业务逻辑有关。可以写多个catch处理一系列异常，但是


  要注意：异常的大小关系，大类型的放到后面处理。


  有的时候 catch（Exception）粗粒度处理异常，代码简洁


  语义含糊. 根据业务逻辑适当选用。


  finally 代码块，不管是否出现异常，总会执行的代码块。


  经常用来处理现场的清理，比如：可靠的数据库连接关闭。


 


 7、 异常有一个基本原则：能够底层处理的尽量处理，但是


   如果不能处理，必须抛出到调用者（方法）。不应该简单的


   抛弃。


 8、 异常捕获再抛出, 是一种把底层异常进行封装,转换为另外


   一种异常类型。


 9 、建议在捕获到异常时候使用e.printStackTrace()，打印到


 控制台，输出内容是：出现异常时候的方法调用堆栈.


 一般情况下，凡是捕获异常代码都输出：e.printStackTrace()


 10 、异常的分类


  Throwable


    |--Error 是系统不可恢复的错误，由JVM发生


    |   |--OutOfMemoryError 堆内存溢出


    |   |--StackOverflowError 栈内存溢出


    |--Exception 程序可以检查处理的异常,常见的异常继承根


        |--java.text.ParseException format解析对象时候发生


        |  如：Date d = dateformat.parse("2010-5-5");


        |--RuntimeException 非检查异常，Javac忽略对


             |      这类异常的语法检查，如：异常抛出，异常处理等。


             |--IllegalArgumentException 


             |--NullPointerException  *


             |--ArrayIndexOutOfBoundsException *


             |--ClassCastException *


             |--NumberFormatException * Integer.parseInt()


 11、软件中会大量使用自定义异常，一般从Exception继承。


  异常类命名要有实际意义。


  


第四章 IO流


一、流的定义


流是数据传输的抽象表达，与具体设备无关，是在程序和设备之间加入的一个中间介质。程序一旦建立了流，就可以不用理会起步或终点是何种设备。建立流实际上就是建立数据传输通道，将起点和终点连接起来。


二、流的分类


java.io包封装了大量的数据流类，它们以数据类型的不同而分为两个继承层次：基于字节流的数据流类和基于字符流的数据流类。


基本流类有4个，它们都是抽象类：基Unicode字符的输入流Reader和输出流Writer，基于二进制字节的输入流InputStream和输出流OutputStream。其他所有数据流类都是从它们中派生出来的。


表1 Reader的子类


 


名称
 功能
 
BufferedReader
 读取输入流到缓冲区
 
CharArrayReader
 读取输入流到内建字符数组
 
FilterReader
 过滤输入流的抽象类
 
InputStreamReader
 读取字节流并转换为字符流
 
PipedReader
 建立输入流管道连接到输出流
 
StringReader
 建立数据源为字符串的输入流
 


 


表2 Writer的子类


 


名称
 功能
 
BufferedWriter
 将字符数据写入缓冲区
 
CharArrayWriter
 将字符数据写入输出流缓冲区
 
FilterWriter
 过滤输出流的抽象类
 
OutputStreamWtriter
 将字符流换转为字节流输出
 
PipedWriter
 建立输出流管道连接输入流
 
printWriter
 将格式化对象写入文本输出流
 
StringWriter
 建立终点为字符串的输出流
 


表3 InputStream的子类


 


名称
 功能
 
AudilInputStream
 读取声音字节流
 
ByteArrayStream
 读取输入流到内建缓冲区
 
FileInputStream
 读取文件输入流
 
FilterInputStream
 建立可过滤的输入流
 
ObjectInputStream
 读取对象并还原
 
PipedInputStream
 建立输入流管道连接输出流
 
SequenceInputStream
 建立顺序输入流并依次读取
 
StringBufferInputStream
 JDK 1.3不再支持
 


 


表4 OutputStream的子类


 


名称
 功能
 
ByteArrayOutputStream
 将字节数据写入缓冲区
 
FileOutputStream
 写入文件输出流
 
FilterOutputStream
 建立可过滤的输出流
 
ObjectOutputStream
 将对象原始数据类型写入输出流
 
PipedOutputStream
 建立输出流管道连接到输入流
 


 


 


三、数据流的应用


1、文件输入/输出流的应用


例13：


 


import java.io.*


public BytesCopy{


     public static void main(String[] args) throws IOException{


            FileInputStream in = new FileInputStream(“sort1.java”);


            FileOutputStream out = new FileOutputStream(“sort1.txt”);


            int c;


            while((c=in.read())!=-1)


                out.write;


            in.close();


            out.close();


}


}


 


14、缓冲流的应用


例2：


 


import java.io.*;


class ShowFile{


public static void main(String[] args) throws IOException{


     FilterReader fr = new FilterReader(“ShowFile.java”);


     BufferedReader bt = new BufferedReader(fr);


     String str;


     while((str = br.readLine())!=null)


        System.out.println(str);


     br.close();


     fr.close();


}


}


 


 


15、数据输入/输出流的应用


 


import java.io.*;


public class DataTest{


public static void main(String[] args) throws IOException{


     FileOutputStream fout = new FileOutputStream(“data.txt”);


     DataOutputStream out = new DataOutputStream(fout);


     float[] prices = {1.5f,2.1f,2.9f,1.8f,3.1f};


     int[] units = {5,2,4,3,1};


     String[] iterms = {“苹果”，“鸭梨”，“蜜桃”,“橙子”，“葡萄”};


    


     for(int i=0;i<prices.length;i++){


        out.writeFloat(prices[i]);


        out.writerChar(‘\t’);


        out.writeChars(‘units[i]’);


        out.writeChar(‘\t’);


        out.writeChar(‘\n’);


}


out.close();


fout.close();


 


FileInputStream fin = new FileInputStream(“data.txt”);


DataInputStream in = new DataInputStream(fin);


float price,total = 0.0f;


int unit;


char ch;


String item;


 


try{


    while(true){


        price = in.readFloat();


        in.readChar(); //跳过Tab


        in.readChar();


        unit = in.readInt();


        in.skip(2);// 跳过Tab


        item = new String();//清空字符串


        //每次读一个字符，碰到换行符结束


        while((ch=in.readChar())!=’\n’)


            item+=cb;


        System.out.println(“你买了”+unit+”斤”+item+”单价是”+price);


        total+=unit*price;


}


}catch(EOFException e) // 读取文件尾将抛出异常并终止循环


in.close();


fin.close();


System.out.println(“你总共花去”+total+”元”);


}


 


}








1.       类（class）








可见性修饰符： public—在所有类中可见，在其他包中可以用import导入。


                             缺省—就是没有修饰符，在同一个包中的类中可见，在其他包中不能用import导入。


              修饰符：final—终态类，表示该类不能被继承


                            abstract—抽象类，不能新建对象








2.       变量（variable）








Java中变量有两种，方法变量和字段变量


方法变量只能用一个修饰符：final—表示常量，不能修改


下面是字段变量的修饰符


        可见性修饰符：public—在任何类中可见


                                    protected—       在子类中或同一个包中可见


                                    private—只在本类中可见，子类中也不可见


                                    缺省—在同一个包中可见，子类不在一个包中，子类中也不可见   


        修饰符：static—静态变量，被类的所有实例共享


                        final—常量，定义后不能修改


*transient—告诉编译器，在类对象序列化的时候，此变量不需要持久保存 


*volatile—指出可能有多个线程修改此变量，要求编译器优化以保证对此变量的修改能够被正确的处理 


这两带*的不是很常用，但也是Java的修饰符，我也不是很清楚








3.      方法(method)








   可见性修饰符：public—在任何类中可见


                               protected—在子类中或同一个包中可见


                              private—只在本类中可见，子类中也不可见


                              缺省—在同一个包中可见，子类不在一个包中，子类中也不可见


   修饰符：   static—静态方法，并不需要创建类的实例就可以访问静态方法


                      final—常方法，所有子类不能覆盖该方法，但可以重载


                      abstract—抽象方法，在抽象类中没有实现的方法


                      native—本地方法，参见Java Native Interface(JNI) 


                             synchronized —在多线程中，synchronized方法调用时，其他所有方法不能调用该方法








4.       接口（interface）








         可见性修饰符：public—所有类中可见


                                     缺省—同一个包中可见


         接口中的变量总是需要定义为“ public static final 接口名称”，但可以不包含这些修饰符，编译器默认就是这样   




因为接口是不可能有直接实例的，那样的话也就是不可能修改(final)，也不可能通过实例访问的(static)。      


         接口中的方法只能使用public和abstract修饰符