Java基本学习小结

从一个简单Java程序的范例开始：

public class 类名（）{

publicstatic void main(string[] args){

       system.out.println("helloworld!");

 }

}

类的声明方式：由"public class"声明的类，类名必须与文件名一致；使用"class"声明类时可不与文件名一致，执行时一定会执行生成后的*.class文件。一个Java文件中可有多个class类的定义，但只能有一个public class的定义。

所有的程序都会以方法：public static void main(string[] args)作为起点运行下去，是程序的主方法。

 system.out.println("helloworld!");定义程序的输出信息程序，hello world!是输出内容。Java中的所有程序由一个个使用"{}"声明的代码段组成，这些代码段可以嵌套。

Java中的包、类、方法、参量和变量名不能与Java中的关键字冲突，可以以字母、下划线或美元符号开头，由以上三种加上数字组成。

 

组成程序的基础部分：八种基本数据类型的声明类型、大小、可表示的数据范围以及默认值；数据类型的转换：自动转换--容量小的数据类型能自动转化为容量大的数据类型（容量大小指的是表示范围，不是指字节数），另外任何数据类型碰到String类型的变量或常量后都会向String类型转换，所以表达式中有string类又有数据类型的算术运算时要注意使用括号将进行数值运算的部分括起来，表示输出时先计算数值运算的结果。强制转换--避免运算过程丢失数据精确度的操作。在需要强制转换的运算前由()声明想要转换的数据类型即可。引用数据类型——类，接口，数组。

各种运算符的作用、优先级以及表达式与运算符之间的关系。

三种控制语句：顺序结构；选择结构（单选：if；双选：if-else；多选:if-if-…-if-else或switch-Case）、循环结构（while循环；do-while循环；for循环）。关键字break与continue的作用。

 

数组：一维数组声明与创建(内存分配)的一般方法：

type arr_name[]；//声明一维数组，数组名存放在栈内存中

arr_name=new type[length]； //为数组分配堆内存的操作

故可简洁写作：typearr_name[]=new type[length]；//声明数组的同时为数组分配堆内存

数组的静态初始化方法：typearr_name[]={初值0，初值1，...，初值n}

Java中数组的索引Index编号从0开始，由arr_name[index]表示对应的数组元素。

二维数组的声明与创建和一维相似，注意必须告诉编译器它的行数和列数。

type arr_name[][]=new type[行数][列数]；//声明数组的同时为数组分配堆内存

数组的静态初始化方法：typearr_name[][]={

                                                                               {第0行初值},

                                                                               {第1行初值},  

                                                                                  …

                                                                                 }

方法：小结Java方法定义的完整格式：

访问权限{private|default|protected|public}[final][static][synchronized] 返回值类型|void 方法名(参数类型 参数名,...)[throws Exception]{

          [return [返回值|返回调用处]];

}

方法的使用：重载——由方法名相同，但参数类型与个数的不同完成方法的重载，实现不同功能的调用。

                          递归——中心思想"自己调用自己"，使用时要注意定义明确的结束递归的条件，避免内存的溢出。

                          结束——出方法完全执行完代码后结束外，执行到return语句的方法也会直接结束。

向方法中传递数组时，方法定义的参数要为符合其类型的数组。而且。数组作为引用数据类型，把数组传递进方法后，若方法中对数组有任何修改，修改结果也将被保存下来。

java中的可变参数定义格式：

返回值类型|void 方法名(类型...参数名){}     在传参时不受参数个数的限制，全部参数都能以数组形式保存。

Java中的foreach输出，输出数组内容的格式如下：

for(typevalue_name : arr_name){

            …

}

类表示某类群体基本特性的抽象，对象则表示具体的东西。要使用一个类，就一定要产生一个对象，每个对象又依靠类中规定好的方法来进行操作，由各自不同的属性来进行区分。

类的定义：class 类名{

                           成员变量声明；

                             方法定义；

                         }

类与数组一样，都属于引用数据类型，故对象的创建格式类比数组定义的格式：

            类名 对象名=new 类名();  //对象的声明与实例化

实例化后的对象可通过"对象名.属性名（方法名()）"来访问对象中的属性和方法。

面向对象具有封装性、继承性和多态性。

封装性：类中的属性通过private声明达到封装的目的；不希望被外部调用或者没必要外部可见的方法也可用private声明。封装后的属性要通过setter-getter方法来访问。不过构造方法可以在对象实例化时直接把对象的值赋给属性，比起setter-getter方法更为简单和便利，其主要作用就是为类中的属性初始化。

构造方法定义：class 类名{

                                       访问权限 类名(类型1 参数1，类型2 参数2...){  //构造方法名必须与类名一致，声明处不能有任何返回值类型的声明

                                                   程序语句；//构造方法中不能使用return返回一个值

                                  }

                           }

常用类String类的对象可以通过直接赋值或调用构造方法的方式来实例化，两种方法的主要差别体现在对其的内存分配中。字符串的内容一旦声明则不可改变，一个String类对象的改变实际是通过内存地址“断开—连接”变化完成的，而本身字符串中的内容并没有任何变化。

this关键字：强调调用本类的方法和属性，也可以用来调用本类的构造方法或表示当前对象。

static关键字：由static声明的属性或方法可以被所有对象共享，直接使用类名称可以对其进行调用。

对象数组的声明：类 对象数组名[]=new 类[数值长度];///数组要先开辟空间，但因为其是引用数据类型，所以数组中每一个对象默认值都是null值，使用时，数组中的每一个对象都必须进行实例化操作。

内部类的存在虽然实际上破坏了一个类的基本结构，但它的存在可以方便的访问外部类的私有属性。

 

继承性：类的继承格式： class 子类 extends 父类(){}  子类继承父类，可以得到父类的全部属性和方法（除了父类的构造方法）；Java中类只有单继承，没有C++中的多继承，一个类只有一个直接父类；Java中的多继承，可以通过接口来实现，即Java中内没有多继承，接口有多继承。

super关键字：使用super可以从子类中调用父类的构造方法（与this相同，语句必须放在子类构造方法的首行）、普通方法和属性。

final关键字：完结器。其声明的类不能有子类，声明的方法不能被子类覆写，声明的变量成为常量不可修改。

抽象类与抽象方法：抽象类的作用相当于为子类提供“模板”，并不能由它创建对象，它为设计者提供它的格式来修改并创建新的类；只用被声明不用被实现的方法即为抽象方法；抽象方法和抽象类都有abstract声明；包含抽象方法的类必是抽象类，但抽象类中可以不全是抽象方法，抽象类被子类继承后，其全部抽象方法必须被子类覆写。

接口：比抽象类更抽象的特殊类，仅有全局变量和公共抽象方法组成。

接口的定义：  interface 接口名{

                                    全局变量；

                                    抽象方法；

                             }

接口的使用也要通过子类来实现：class 子类implements 接口1，接口2…{}  //接口可以使用多继承

 

多态性：两种体现方式——方法的重载和覆写；对象的多态性。

对象的多态性：向上转型：子类对象—>父类对象 ：父类 父类对象=子类实例；必要条件：要有继承，要有重写，父类引用指向子类对象。要想调用子类中独有的方法，需将父类引用强制转型；即向下转型：父类对象—>子类对象，需指明要转型的子类类型，且首先要发生对象的向上转型，让父类“意识”到它有这样一个子类，才能发生向该子类的向下转型。

instanceof关键字：判断一个对象是否是给定类的实例。（boolean） 对象 instanceof 类

throws关键字处理异常在定义的方法名() throws 异常类{}  抛出异常不处理；

throw关键字可以认为抛出异常，可由try...catch块捕获异常并处理。

 

Java中实现多线程操作有两种手段：一是继承Thread类，另一种是实现Runnable接口。

继承了Thread类的子类就成为多线程的实现类，必须覆写Thread中的run()方法,实例化的对象通过对象名.start()来调用覆写的run()方法来启动线程；如果一个类通过继承Thread类来实现线程，那么一个实例化对象只能调用一次start()方法，多次调用会抛出异常，所以继承Thread实现多线程的方法受到单继承的局限并且不能实现资源共享，所以一般还是通过Runnable接口来实现。

实现Runnable接口，覆写其中的run()方法，由于该接口中并没有start()方法来启动线程，所以要利用Thread类中的构造方法来接受Runnable的子类对象启动线程。Thread thr=newThread(new 子类名(String name));

由Runnable接口实现的多线程程序在实现类中属性资源被多个线程共享的时候，其资源可能因为同步问题而出现不符合实际的结果，此问题可以通过在代码块或方法前加上关键字synchronized来解决；但是在使用同步时，要避免因此而出现的由于程序互相等待对方响应而产生的死锁问题。

 

正则表达式可以更方便的对数据进行匹配，由Pattern类来进行正则规范，由Matcher类来执行规范，验证字符串是否符合其规范。

 

File类作为操作文件的类，要使用它，就必须向File类的构造方法中传递一个文件路径，文件路径中的分隔符注意要用File.separator表示，例：File f=newFile("d:"+File.separator+"text.txt")；对指定路径进行与文件相关的操作。

要相对文件内容进行操作，可以使用RandomAccessFile类，但是用此类实现对类的操作过于复杂，一般会使用字节流或字符流来操作文件内容。

字节流输出数据主要依靠OutputStream类完成，输入数据主要依靠InputStream类完成，要相对文件进行操作，需要使用各自的子类FileOutputStream类和FileInputStream类的构造方法，通过对象多态性来进行操作：

例：OutputStreamout=new FileOutputStream(newFile("d:"+File.separator+"text.txt"))；

字符流输出数据主要依靠Writer类完成，输入数据主要依靠Reader类完成，要相对文件进行操作，需要使用各自的子类FileWriter类和FileReader类的构造方法，通过对象多态性来进行操作：

例：Writer out=newFileWriter(newFile("d:"+File.separator+"text.txt"))；

文件内容的追加也可通过FileWriter类中的构造方法public FileWriter(File File，booleanappend)throws IOException 将append值设为true即表示可追加。

通过转换流OutputStreamWriter类和InputStreamReader类实现字节流到字符流的转换：

例：Writer out=newOutputStreamWriter(new FileOutputStream(new File("d:"+File.separator+"text.txt")))；

操作对象不是文件而是内存时，通过内存操作流ByteArrayInputStream和ByteArrayOutputStream来完成；

PrintStream类是OutputStream类的子类，属于装饰设计模式的类，可以实例化PrintStream类来方便的完成输出功能，

例：PrintStream ps=new PrintStream(new FileOutputStream(newFile("d:"+File.separator+"text.txt")));

System类中的属性out in err 都是PrintStream类的常量，所以System.outSystem.in System.err 都是PrintStream类的对象，它们可用来调用PrintStream类的方法进行输出操作，也可以利用此对象直接实例化OutputStream类的对象并利用此对象向屏幕输出信息。

通过System类还可以改变System.in的输入流来源及System.out和System.err输出流的输出位置，但是对于重定向的操作，在实际编程中，基本上都在System.out上使用，以把信息展现给用户看。

BufferReader用于从缓存中一次性读取字符流的实例。

Scanner类用于数据的接收。

 

 

Collection接口作为类集中最大单值操作的父接口，在一般开发中不会直接使用此类，常使用的子接口有List接口和Set接口。

List接口大量扩充了Collection接口，可以重复保存内容；常用子类为ArrayList和Vector，前者采用异步处理的方式，性能更高，后者采用同步处理的方式，性能较低。

Set接口与Collection接口一样，不能存放重复的内容；常用的子类为HashSet和TreeSet，前者散列存放，后者顺序存放。Set接口中依靠Object类中的equals()和hashCode()方法来区分是否为同一个对象来避免相同对象的存放。

集合的输出主要依靠Iterator接口实现，迭代输出集合中的内容；JDK1.5之后也可使用foreach的方式输出，输出格式为：

for(类 对象：集合){

                集合操作 // }

Map接口存放的是一对内容，所有内容都以“key—>value”的形式保存，而这每一对都是Map.Entry对象的实例；常用子类为HashMap、HashTable和TreeMao，HashMap和HashTable相比，前者采用异步处理的方式，性能更高，后者采用同步处理方式，性能较低；TreeMap可以按key值进行排序存放。弱引用类WeakHashMap当除了自身有对key的引用外，此key没有其他引用，那么此map会自动丢弃此值。

Map接口不能直接使用迭代输出Map中的内容，需要将Map接口的实例通过entrySet()方法变为Set接口对象，再通过Iterator或foreach输出Map。直接使用非系统类作为key时，要想向String那样通过匿名对象找到对应的value，要想实现这样的功能，就得靠Object类中的equals()和hashCode()方法来来判断是否为同一个对象。

 

InetAdress类主要表示Ip的操作类。

URL类可用来对想取得的网络资源进行定位，再用IO包中的操作流进行读取。

ServerSocket主要用在TCP协议的服务器程序开发中，使用accept()方法等待客户端连接，每一个连接的客户端都使用一个Socket表示。服务器加入多线程机制后，可以对连接的多个客户端同时进行操作。

与TCP相比，UDP属于不可靠的连接协议，采用数据报的形式发送信息，以DatagramPacket类包装要发送的信息，然后使用DatagramSocket类完成信息的发送，不过对于服务器发送的信息，客户端不一定能接收到。