java输出：system.out.print()
在类中变量用private同时采用get,set函数的原因：（封装）（见博客园收藏）
1.可以将变量设置为只读，而不可写
2.对象.set/get就可以看到类的全部变量
3.若变量有范围限制，利用set/get更容易实现（比如分数需要在1-100之间）
package packageName;//必须放在第一句
引入 import package1.[package2].(className|*)//必须清楚的指定每一个子包，.*意思是引入该目录下所有的class文件
this:1.访问自己 2.局部变量与域变量同名时 this.x=x;//第二个x可以是该方法的形参
3.构造方法中，用this调用另一构造方法 this(0,0)
注意事项：使用this调用构造方法(注意这里是构造方法)：
1.只能在构造方法中调用其他构造方法，在成员方法中无法调用构造方法
2.在构造方法中，使用this调用构造方法的语句必须放在第一行，且只能出现一次
3.不能在一个类的两个构造方法中使用this相互调用
super 用来访问/调用当前对象的父亲的（被隐藏的变量）/（父类被重写的方法）/（父类的构造方法）
1.super.成员变量 super.成员方法（参数）
2.调父类构造方法super(参数)//必须位于子类构造方法的第一行
在子类的构造方法中一定会调用父类的某个构造方法
break和continue的区别：
break 跳出整个循环，后续还有循环都不再执行
continue 跳过这一次循环，进入下一次循环
接口和类的区别：
一、接口只是一个协议，继承接口了就必须实现接口内的所有方法。接口比抽象类更抽象。
二、类包含方法，是对一个过程具体实现。
三、接口可以继承多个接口，类可以实现多个接口，类不可以继承多个类。
接口和抽象类的区别
接口是对动作的抽象，而抽象类是对根源的抽象
1.抽象类和接口都不能被直接实例化，如果二者要实例化，就涉及到多态。如果抽象类要实例化，那么抽象类定义的变量必须指向一个子类对象，这个子类继承了这个抽象类并实现了这个抽象类的所有抽象方法。如果接口要实例化，那么这个接口定义的变量要指向一个子类对象，这个子类必须实现这个接口所有的方法。
2.抽象类要被子类继承，接口要被子类实现。
3.接口里面只能对方法进行声明，抽象类及可以对方法进行生命也可以对方法进行实现。
4.抽象类里面的方法必须全部被子类实现，如果子类不能全部实现，那么子类也必须是抽象类。接口里面的方法也必须全部被子类实现，如果子类不能实现那么子类必须是抽象类。
5.接口里面的方法只有声明，不能有具体的实现，这说明接口是设计的结果，抽象类是重构的结果。
6.抽象了里面可以没有抽象方法。
7，如果一个类里面有抽象方法，那么这个类一定是抽象类。
抽象类可以没有抽象方法，但是如果你的一个类已经声明成了抽象类，即使这个类中没有抽象方法，它也不能再实例化，即不能直接构造一个该类的对象。
如果一个类中有了一个抽象方法，那么这个类必须声明为抽象类，否则编译通不过。
接口
1.接口中的方法都是抽象的，不能实例化对象
2.当一个类实现接口时，如果这个类是抽象类，则实现接口中的部分方法即可，否则需要实现接口中的所有方法
3.一个类通过implements关键字实现接口时，可以实现多个接口，被实现的多个接口之间要用逗号隔开。
4.一个接口可以通过entends关键字继承多个接口，接口之间用逗号隔开。
5.一个类在继承另一个类的同时还可以实现接口，此时extends关键字必须位于implements关键字之前
实现Runnable接口相对于继承Thread类的好处：
1.适合多个相同程序代码去处理同一个资源的情况，把线程同程序代码、数据有效的分离，很好的体现了面向对象的思想。
2.可以避免由java的单继承带来的局限性，在开发中经常碰到这样一种情况，就是使用一个已经继承了某一个类的子类创建线程，由于一个类不能同时拥有两个父类，所以不能用继承Thread类的方式，只能采用实现Rnnable接口的方式。
新建线程默认是前台线程，线程调用setDamon(true)语句后进程中只有后台线程运行时，进程就会结束。变成后台线程。setDamon(true)必须在start()方法之前调用
Thread的子类必须实现run方法
创建并开启线程：new Thread的子类("线程名").start();//Thread的子类 线程名=new Thread的子类();线程名.start();
xxx.setPriority(number);//设置xxx现成的优先级 ，优先级较高的线程先运行
xxx.sleep(50)；//当前线程休眠50毫秒
Thresd.tield();//线程让步
xxx.join();//线程插队
同步机制：
1.同步代码块
synchronized(lock){
//操作共享资源代码块
}
2.同步方法
修饰符 synchronized 返回值类型 方法名(参数们){
//使用sunchronized修饰的方法在某一时刻只有允许一个线程访问，访问该方法的其他线程都会发生阻塞
}
挂起：等待或阻塞，暂时被淘汰出内存的过程
& 右边的表达式也要运算
&& 短路与，如果左边的表达式为假，则不再计算右边表达式的值
同理，||为短路或，当左边表达式为真时，不再进行右边表达式的计算
&、|还可作二进制数的为运算符，>>,<<,>>>(无符号右移),^(按位异或),~
定义数组
int[] x=new int[100];
或者 int []x; x=new int[100];//初始值为全0
数组的静态初始化
1. 类型[] 数组名=new 类型[]{元素,元素，......};
2.类型[] 数组名={元素,元素，......}
java中char占两个字节 可以存储中文汉字（一个中文汉字是两个字节）
c中不可以
java垃圾回收
1.当一个对象在内存中被释放时，它的finalize()方法会自动被调用，虚拟机自动回收
2.调用System.gc()方法来通知java虚拟机立即进行垃圾回收
static关键字(不会影响变量作用域)
1.static变量
static只能用来修饰成员变量，不能用来修饰局部变量
静态变量是随着类加载时被完成初始化的，它在内存中仅有一个，且JVM也只会为它分配一次内存，同时类所有的实例都共享静态变量，
可以直接通过类名来访问它[类名.static变量名]。//对象之间共享数据，访问方便，也可以通过变量访问
实例变量(无static修饰的变量)则不同，它是伴随着实例的，每创建一个实例就会产生一个实例变量，它与该实例同生共死。
2.static方法
可以不用创建对象就使用[类名.static方法名()]
没有this，不依赖于对象
static方法必须被实现，不能是abstract
使用注意（1）它们仅能调用其他的static 方法。
（2）它们只能访问static数据。
（3）它们不能以任何方式引用this 或super。
3.static代码块
static块可以置于类中的任何地方，类中可以有多个static块。
在类初次被加载的时候，会按照static块的顺序来执行每个static块，并且只会执行一次。
单例模式（在整个程序运行期间该类只存在一个对象）
class Single{
//自己创建一个对象
private static Single INSTANCE=new Single();
private Single(){}//私有化构造方法
public static Single getInstance(){//提供方返回该对象的静态方法
return INSTANCE;
}
}
不能在类的外部新建对象，外界用类名.方法名访问
内部类
1.成员内部类（在类内部定义）
通过外部类去访问内部类，创建内部类对象 ： 外部类名.内部类名 变量名=new 外部类名().内部类名();
2.静态内部类（在类内部定义，前面加上static关键字）
创建静态内部类对象 ：外部类名.内部类名 变量名=new 外部类名.内部类名();
3.方法内部类
在成员方法中定义的内部类，只能在该成员方法中使用
final关键字
1.final修饰的类不能被继承
2.final修饰的方法不能被子类重写
3.final修饰的变量（成员变量和局部变量）只能被赋值一次。（一旦被赋值，其值不可改变），使用final关键字修饰的成员变量虚拟机不会对其进行初始化
多态(由于参数类型不同而导致执行效果各异的现象)
允许一个父类类型的变量来引用一个子类类型的对象，根据被引用子类对象特征的不同，得到不同的运算结果。
instanceof关键字 判断一个对象是否为某个类（或接口）的实例对象或者子类实例
格式： 对象(或者对象引用变量) instanceof 类(或接口)
//如果是的话可以将该对象类型转化为子类类型,进而调用子类中的方法
if(animal instanceof Cat){
Cat cat=(Cat)animal;
cat.sleep();}
匿名内部类
格式：new 父类(参数列表)或父接口(){
//匿名类内部实现部分
}
可以作为某个方法的参数 xx.xxx(new 匿名类)
异常
Throwable常用方法
String gerMessage() //返回此Throwable的详细消息字符串
void printStackTrace() //将此Throwable及其追踪输出至标准错误流
void printStackTrace(String s) //将此Throwable及其追踪输出至指定错误流
try{
//程序代码段
}catch(ExceptionType e){ //ExceptionType 指的是Exception类及其子类类型
//对ExceptionType 的处理
}finally{
//
}
注：在try代码块中，发生异常语句后面的代码是不会被执行的。
catch代码块中有return语句时，finally代码块[后面的代码就不会再被执行了]，但是无论程序发生一场还是使用return语句结束，finally代码块都会被执行。只有一种情况下finally代码块不会被执行：在try catch语句中执行了System.out.exit(0);语句
throws关键字
声明抛出异常语法格式：
修饰符 返回值类型 方法名(参数) throws ExceptionType1 [,ExceptionType2]{
//方法体
}
如果不知道如何处理异常，也可以(在异常代码块的主调函数中)继续使用throws关键字将异常进行抛出
处理编译时异常
1.try...catch...
2.throws抛出 //(该语句放在函数体外，函数名后)
运行时异常，一般由程序的逻辑错误引起（比如数组下标越界）
自定义一个继承自Exception类的异常类，在构造方法中使用super()调用Exception类的构造方法
自定义异常类的使用
throw Exception 异常对象//[注意这里的throw没有s]
在函数体内使用throw关键字抛出异常对象时，需要使用try...catch...语句对抛出的异常进行处理，或者在使用该方法时，由该方法的调用者进行处理
声明
throw new (自定义)异常类名 (参数){}
在JDK中，不同功能的类放在不同的包中，其中java的核心类主要放在java这个包及其子包下，java扩展的大部分类都放在javax及其子包下。java常用包如下：
java.lang: 包含Java的核心类，包括String、Math、System、和Thread类等，系统会自动导入
java.util:包含Java中大量工具类、集合类等，包括Arraylist、List、Set等
java.net:包含Java网络编程相关的类和接口
java.io:包含Java输入输出相关的类和接口
java.awt:包含用于构建图形界面(GUI)的相关类和接口
java.sql:数据库编程
javax.swing:编写GUI
给java应用打包的好处：安全(可以对jar文件进行数字签名)/节省空间(.class->.jar节省空间，在网络上传输速率高)/可移植性
访问控制级别由小到大：private(类访问级别)——>default(包访问级别)——>protected(子类访问级别)——>public(公共访问级别)
***********************JAVA API*******************************
String类
1.初始化
使用字符串常量初始化：String s="abc";
使用String类的构造方法初始化 String()//创建一个空字符串
String(char[] value)//根据指定字符数组创建对象
String(String value)//根据指定的字符串内容创建对象
2.常见操作***查API
char charAt(int index);//返回指定位置的字符
char[] toCharArray();//将此字符串转化为一个字符数组
String substring(int beginIndex,int endIndex);//返回一个新字符串，它包含beginIndex-endIndex之间所有的字符
String valueOf(int i);//将int类型参数转换为字符串类型，可以重载float,double等
其他功能：字符索引、判断是否以指定字符串结尾、是否包含指定字符串、大小写转化、分割成子字符串、判断两个字符串是否相等、替换、去空格
注：equals()用于比较两个字符串中字符的值是否相等
==比较两个字符串对象的地址是否相同
StringBuffer类[它的内容和长度都是可以改变的]
常用方法
StringBuffer append(char c)//添加参数到StringBuffer对象中 添加到末尾
StringBuffer insert(int offest,String str)//在offest位置插入str 添加到指定位置
StringBuffer deleteCharAt(int index)//删除index位字符
StringBuffer delete(int start,int end)//删除左闭右开区间
StringBuffer replace(int start,int end,String s)//替换字符序列
void setCharAt(int index,char c)//替换字符
String toString()//返回StringBuffer缓冲区中的字符串
StringBuffer reverse()//反转
StringBuffer和String区别
1.String类标识的字符串是常量，一旦创建后内容和长度都是无法改变的，StringBuffer类内容和长度都可以改变。如果只是表示数据类型，用String，如果要进行增删操作，用StringBuffer类
2.String类覆盖了Ogject类的equals()方法，而StringBuffer没有
String s1,s2;内容相同 s1.equals(s2)结果是true
StringBuffer sb1,sb2;内容相同 sb1.equals(sb2)结果是false
3.String对象之间可以用+号连接而StringBuffer不可以。
System类
常用方法
static
void exit(int status)//用于中止当前运行的虚拟机，status状态码，非0表示异常终止
static long gc()//运行垃圾回收器，并对垃圾进行回收
static long currentTimeMillis()//返回以毫秒为单位的当前时间
static void arraycopy(Object src,int srcPos,Object dest,int destPos,int length)//将一个数组中的元素快速拷贝到另一个数组
static Properties getProperties()//取得当前的系统属性
static String getProperty(String key)//获取指定键描述的系统属性
Runtime类
用于表示虚拟机运行时的状态，该类采用单例模式，对象不可以直接实例化，只能通过以下方式：
Runtime run=Runtime.getRuntime();
获取处理器个数、内容容量、空闲内存数量等参数
其中exec()方法用于执行一个dos命令，从而实现和命令行窗口中输入dos命令同样的效果
Math类 查API 没有构造方法，所有方法都是静态方法
Random类
构造方法：1.Random()//产生随机数
2.Random(long seed)//当希望创建的Random实例对象产生相同数列的随机数，可以在创建对象时传入相同的seed
xxx.nextInt(100);产生一个从 0到100的整数其他类型见API
包装类
很多类的方法需要接收引用类型的对象，此时无法将一个基本数据类型的值传入，为解决这样的问题引入包装类，通过这些包装类可以将基本数据类型的值包装为引用数据类型的对象。每种基本数据类型都有对应的包装类。byte----Byte char-----Character int---Integer
short---Short long---Long float---Float double---Double boolean--Boolean
例如：Innteger类常用方法
toBinaryString(int i)//以二进制无符号整数形式返回一个整数参数的字符串
intValue()//将Integer类型的值以int类型返回
使用包装类时注意：
1.包装类都重写了Object类中的toString()方法，以字符串形式返回被包装的基本数据类型的值
2.除了Character类以外，其他包装类都含有valueOf(String s)方法，可以根据String类型的参数创建包装类对象，s不能为null且必须为可以解析为相应基本类型的数据
3.除了Character类以外，其他包装类都含有parseXXX(String s)的静态方法，将字符串转为为对应基本类型的数据。s不能为null且必须为可以解析为相应基本类型的数据
自动拆箱装箱的特性使得基本类型和包装类习惯可以进行混合数学运算
Date类(除了两个构造方法外其余方法声明为已过时)
Date date=new Date();//创建表示当前时间的date对象
Date date1=new Date(99999999999999999)；//创建表示指定时间的date对象99999999999表示从1970年1.1日到指定时间的毫秒数
Calender类是一个抽象类不能被实例化。
使用方法：Calender calender=Calender.getInstance();//常用方法见API，包括get/set等
DateFormat类专门用于将日期格式化（完整格式、普通格式、长格式、短格式）为字符串或者用特定格式显示的日期字符串转化成一个Date对象
SimpleDateFormat类自己创建日期格式模板
switch语句支持字符串类型
集合类
见集合体系架构图
Arraylist集合
import java.util.*;
Arraylist list=new Arraylist();//Arraylist在查询元素时速度很快，但在增删元素时速度很慢，此时使用Linkedlist
list.add(元素);//添加元素
Linkedlist集合(该集合内部维护了一个双向循环列表)add();addFirst();addLast();getFirst();getLast();removeFirst();
for each循环不需要获得容器长度，也不需要根据索引访问容器中的元素
for(容器中元素类型 临时变量:容器变量){
//
}
只能访问集合中的元素，不能对集合中的元素进行修改
Integator接口(主要用于迭代访问collection中的元素) Integator对象也称为迭代器
Iterator接口(遍历用)迭代器
Iterator it=list.iterator();//其中list是ArrayList接口对象
while(it.hasNext()){
XXX xx=it.next();
//}
在使用Iterator迭代器对集合中的元素进行迭代时，如果调用了集合对象list的remove()方法删除元素，会出现异常。
原因是删除元素会导致迭代器预期的迭代次数改变。
解决方法1.如果不关心要删除的元素后面的元素，可在remove()后break;
2.迭代期间可以使用迭代器本身的删除方法。即it.remove();
ListIterator接口
方法 void add(Objection obj);
boolean hasPrevious()//反向迭代元素时用，判断是否有上一个元素
Object previous()//返回列表的前一个元素
void remove()
Vector集合是List接口的一个实现类，用法与ArrayList完全相同
区别：
Vector集合是线程安全的，而ArrayList集合是线程不安全的
Vector类中提供一个elsments()方法用于返回Enumeration对象
Enumeration接口
Enumeration en=v.elements();//其中v是Vector对象
while(en.hasMoreElements()){
//XXX xxx=en.nextElement();}
Set接口与List接口一样继承自Collection接口，Set接口并没有对Collection接口进行功能扩充，只是比Collection接口更加严格。
Set接口元素无序（打印的顺序和存储的顺序可能不一致，重复存储的元素被删除），并且都会以某种该规则保证存入的元素不出现重复。
主要有两个实现类HashSet和TreeSet
见HashSet存储流程图，
TreeSet内部采用自平衡[存储的元素会按照大小排序会自动调用Comparable接口中的compareTo()方法]的二叉树存储元素，
TreeSet集合中没有重复的元素并且可以对元素进行排序（整数按大小，字符按字母顺序（当需要按别的标准排序时，重写compareTo()方法），JDK中大部分类都实现了Comparable接口）
在TreeSet中存储Student类，必须实现Comparable接口
Map接口
是一种双列集合，他中的每个元素都包含一个键对象Key[是唯一的，不能重复]和一个值对象Value,两者之间存在映射关系
void put(Object key,Objecct value)//将指定的key和value进行关联
Object get(Object key)//返回键所映射的值
方法见API，常用实现类HashMap、TreeMap
HashMap必须保证不能出现重复的键
遍历Map中键值对的方法:
1.遍历Map中所有的键，再取出相应的值
2.调用Map集合的entrySet()方法获得存储在Map中所有的映射的Set集合，然后迭代Set集合，获得每一个映射对象，并分别getKey()、getValue().
HashTable与HashMap类似，HashTable是线程安全的
HashTable的一个子类Properties重要，经常用来存储应用的配置项
TreeMap原理同TreeSet
泛型（参数化类型）指定该集合类中方法操作的数据类型 ，格式如下：
ArrayList<参数化类型> list=new ArrayList<参数化类型>();//其中参数化类型可以是String,Integer等
自定义泛型
class AAA<T>{//在创建类时，声明参数类型为T
//}
Collection工具类(用于对集合中的元素提供排序、查找、修改等操作)
1.排序操作
static <T> boolean addAll(Collection <? super T> c,T...elements);//将所有指定元素添加到指定的collection中
static void reverse(List list)//反转
static void shuffle(List list)//对list集合中的元素进行随机排序，类似于扑克牌中的洗牌操作
static void sort(List list)//根据元素的自然顺序对list集合中的元素进行排序
static void swap(List list,int i,int j)//将ilist集合中i处元素和j处元素进行交换
2.查找、替换操作
static int binarySearch(List list,Object obj)//使用二分法查找obj在list中的索
static Object max(Collection col)//返回给定集合中最大的元素
static Object min(Collection col)//返回给定集合中最小的元素
static boolean replace(List list,Object oldval,Objecct newval)//用newval替换list集合中所有的oldval
Arrays工具类
static void sort(参数)//根据元素的自然顺序对list集合中的元素进行排序
static int binarySearch(Object[] a,Object key)//使用二分法查找obj在list中的索
static Object[] copyOfRange(int[] original,int from,int to),将original从from到to中的元素们复制到新的数组中
fill(Object[] a,Object val)//填充元素
toString(int[] arr)//把数组转化为字符串
输入输出IO
见IO流分类图
IO流处理文件 文件需放在工程根目录下 文件路径要用\\而不是\
在类中变量用private同时采用get,set函数的原因：（封装）（见博客园收藏）
1.可以将变量设置为只读，而不可写
2.对象.set/get就可以看到类的全部变量
3.若变量有范围限制，利用set/get更容易实现（比如分数需要在1-100之间）
package packageName;//必须放在第一句
引入 import package1.[package2].(className|*)//必须清楚的指定每一个子包，.*意思是引入该目录下所有的class文件
this:1.访问自己 2.局部变量与域变量同名时 this.x=x;//第二个x可以是该方法的形参
3.构造方法中，用this调用另一构造方法 this(0,0)
注意事项：使用this调用构造方法(注意这里是构造方法)：
1.只能在构造方法中调用其他构造方法，在成员方法中无法调用构造方法
2.在构造方法中，使用this调用构造方法的语句必须放在第一行，且只能出现一次
3.不能在一个类的两个构造方法中使用this相互调用
super 用来访问/调用当前对象的父亲的（被隐藏的变量）/（父类被重写的方法）/（父类的构造方法）
1.super.成员变量 super.成员方法（参数）
2.调父类构造方法super(参数)//必须位于子类构造方法的第一行
在子类的构造方法中一定会调用父类的某个构造方法
break和continue的区别：
break 跳出整个循环，后续还有循环都不再执行
continue 跳过这一次循环，进入下一次循环
接口和类的区别：
一、接口只是一个协议，继承接口了就必须实现接口内的所有方法。接口比抽象类更抽象。
二、类包含方法，是对一个过程具体实现。
三、接口可以继承多个接口，类可以实现多个接口，类不可以继承多个类。
接口和抽象类的区别
接口是对动作的抽象，而抽象类是对根源的抽象
1.抽象类和接口都不能被直接实例化，如果二者要实例化，就涉及到多态。如果抽象类要实例化，那么抽象类定义的变量必须指向一个子类对象，这个子类继承了这个抽象类并实现了这个抽象类的所有抽象方法。如果接口要实例化，那么这个接口定义的变量要指向一个子类对象，这个子类必须实现这个接口所有的方法。
2.抽象类要被子类继承，接口要被子类实现。
3.接口里面只能对方法进行声明，抽象类及可以对方法进行生命也可以对方法进行实现。
4.抽象类里面的方法必须全部被子类实现，如果子类不能全部实现，那么子类也必须是抽象类。接口里面的方法也必须全部被子类实现，如果子类不能实现那么子类必须是抽象类。
5.接口里面的方法只有声明，不能有具体的实现，这说明接口是设计的结果，抽象类是重构的结果。
6.抽象了里面可以没有抽象方法。
7，如果一个类里面有抽象方法，那么这个类一定是抽象类。
抽象类可以没有抽象方法，但是如果你的一个类已经声明成了抽象类，即使这个类中没有抽象方法，它也不能再实例化，即不能直接构造一个该类的对象。
如果一个类中有了一个抽象方法，那么这个类必须声明为抽象类，否则编译通不过。
接口
1.接口中的方法都是抽象的，不能实例化对象
2.当一个类实现接口时，如果这个类是抽象类，则实现接口中的部分方法即可，否则需要实现接口中的所有方法
3.一个类通过implements关键字实现接口时，可以实现多个接口，被实现的多个接口之间要用逗号隔开。
4.一个接口可以通过entends关键字继承多个接口，接口之间用逗号隔开。
5.一个类在继承另一个类的同时还可以实现接口，此时extends关键字必须位于implements关键字之前
实现Runnable接口相对于继承Thread类的好处：
1.适合多个相同程序代码去处理同一个资源的情况，把线程同程序代码、数据有效的分离，很好的体现了面向对象的思想。
2.可以避免由java的单继承带来的局限性，在开发中经常碰到这样一种情况，就是使用一个已经继承了某一个类的子类创建线程，由于一个类不能同时拥有两个父类，所以不能用继承Thread类的方式，只能采用实现Rnnable接口的方式。
新建线程默认是前台线程，线程调用setDamon(true)语句后进程中只有后台线程运行时，进程就会结束。变成后台线程。setDamon(true)必须在start()方法之前调用
Thread的子类必须实现run方法
创建并开启线程：new Thread的子类("线程名").start();//Thread的子类 线程名=new Thread的子类();线程名.start();
xxx.setPriority(number);//设置xxx现成的优先级 ，优先级较高的线程先运行
xxx.sleep(50)；//当前线程休眠50毫秒
Thresd.tield();//线程让步
xxx.join();//线程插队
同步机制：
1.同步代码块
synchronized(lock){
//操作共享资源代码块
}
2.同步方法
修饰符 synchronized 返回值类型 方法名(参数们){
//使用sunchronized修饰的方法在某一时刻只有允许一个线程访问，访问该方法的其他线程都会发生阻塞
}
挂起：等待或阻塞，暂时被淘汰出内存的过程
& 右边的表达式也要运算
&& 短路与，如果左边的表达式为假，则不再计算右边表达式的值
同理，||为短路或，当左边表达式为真时，不再进行右边表达式的计算
&、|还可作二进制数的为运算符，>>,<<,>>>(无符号右移),^(按位异或),~
定义数组
int[] x=new int[100];
或者 int []x; x=new int[100];//初始值为全0
数组的静态初始化
1. 类型[] 数组名=new 类型[]{元素,元素，......};
2.类型[] 数组名={元素,元素，......}
java中char占两个字节 可以存储中文汉字（一个中文汉字是两个字节）
c中不可以
java垃圾回收
1.当一个对象在内存中被释放时，它的finalize()方法会自动被调用，虚拟机自动回收
2.调用System.gc()方法来通知java虚拟机立即进行垃圾回收
static关键字(不会影响变量作用域)
1.static变量
static只能用来修饰成员变量，不能用来修饰局部变量
静态变量是随着类加载时被完成初始化的，它在内存中仅有一个，且JVM也只会为它分配一次内存，同时类所有的实例都共享静态变量，
可以直接通过类名来访问它[类名.static变量名]。//对象之间共享数据，访问方便，也可以通过变量访问
实例变量(无static修饰的变量)则不同，它是伴随着实例的，每创建一个实例就会产生一个实例变量，它与该实例同生共死。
2.static方法
可以不用创建对象就使用[类名.static方法名()]
没有this，不依赖于对象
static方法必须被实现，不能是abstract
使用注意（1）它们仅能调用其他的static 方法。
（2）它们只能访问static数据。
（3）它们不能以任何方式引用this 或super。
3.static代码块
static块可以置于类中的任何地方，类中可以有多个static块。
在类初次被加载的时候，会按照static块的顺序来执行每个static块，并且只会执行一次。
单例模式（在整个程序运行期间该类只存在一个对象）
class Single{
//自己创建一个对象
private static Single INSTANCE=new Single();
private Single(){}//私有化构造方法
public static Single getInstance(){//提供方返回该对象的静态方法
return INSTANCE;
}
}
不能在类的外部新建对象，外界用类名.方法名访问
内部类
1.成员内部类（在类内部定义）
通过外部类去访问内部类，创建内部类对象 ： 外部类名.内部类名 变量名=new 外部类名().内部类名();
2.静态内部类（在类内部定义，前面加上static关键字）
创建静态内部类对象 ：外部类名.内部类名 变量名=new 外部类名.内部类名();
3.方法内部类
在成员方法中定义的内部类，只能在该成员方法中使用
final关键字
1.final修饰的类不能被继承
2.final修饰的方法不能被子类重写
3.final修饰的变量（成员变量和局部变量）只能被赋值一次。（一旦被赋值，其值不可改变），使用final关键字修饰的成员变量虚拟机不会对其进行初始化
多态(由于参数类型不同而导致执行效果各异的现象)
允许一个父类类型的变量来引用一个子类类型的对象，根据被引用子类对象特征的不同，得到不同的运算结果。
instanceof关键字 判断一个对象是否为某个类（或接口）的实例对象或者子类实例
格式： 对象(或者对象引用变量) instanceof 类(或接口)
//如果是的话可以将该对象类型转化为子类类型,进而调用子类中的方法
if(animal instanceof Cat){
Cat cat=(Cat)animal;
cat.sleep();}
匿名内部类
格式：new 父类(参数列表)或父接口(){
//匿名类内部实现部分
}
可以作为某个方法的参数 xx.xxx(new 匿名类)
异常
Throwable常用方法
String gerMessage() //返回此Throwable的详细消息字符串
void printStackTrace() //将此Throwable及其追踪输出至标准错误流
void printStackTrace(String s) //将此Throwable及其追踪输出至指定错误流
try{
//程序代码段
}catch(ExceptionType e){ //ExceptionType 指的是Exception类及其子类类型
//对ExceptionType 的处理
}finally{
//
}
注：在try代码块中，发生异常语句后面的代码是不会被执行的。
catch代码块中有return语句时，finally代码块[后面的代码就不会再被执行了]，但是无论程序发生一场还是使用return语句结束，finally代码块都会被执行。只有一种情况下finally代码块不会被执行：在try catch语句中执行了System.out.exit(0);语句
throws关键字
声明抛出异常语法格式：
修饰符 返回值类型 方法名(参数) throws ExceptionType1 [,ExceptionType2]{
//方法体
}
如果不知道如何处理异常，也可以(在异常代码块的主调函数中)继续使用throws关键字将异常进行抛出
处理编译时异常
1.try...catch...
2.throws抛出 //(该语句放在函数体外，函数名后)
运行时异常，一般由程序的逻辑错误引起（比如数组下标越界）
自定义一个继承自Exception类的异常类，在构造方法中使用super()调用Exception类的构造方法
自定义异常类的使用
throw Exception 异常对象//[注意这里的throw没有s]
在函数体内使用throw关键字抛出异常对象时，需要使用try...catch...语句对抛出的异常进行处理，或者在使用该方法时，由该方法的调用者进行处理
声明
throw new (自定义)异常类名 (参数){}
在JDK中，不同功能的类放在不同的包中，其中java的核心类主要放在java这个包及其子包下，java扩展的大部分类都放在javax及其子包下。java常用包如下：
java.lang: 包含Java的核心类，包括String、Math、System、和Thread类等，系统会自动导入
java.util:包含Java中大量工具类、集合类等，包括Arraylist、List、Set等
java.net:包含Java网络编程相关的类和接口
java.io:包含Java输入输出相关的类和接口
java.awt:包含用于构建图形界面(GUI)的相关类和接口
java.sql:数据库编程
javax.swing:编写GUI
给java应用打包的好处：安全(可以对jar文件进行数字签名)/节省空间(.class->.jar节省空间，在网络上传输速率高)/可移植性
访问控制级别由小到大：private(类访问级别)——>default(包访问级别)——>protected(子类访问级别)——>public(公共访问级别)
***********************JAVA API*******************************
String类
1.初始化
使用字符串常量初始化：String s="abc";
使用String类的构造方法初始化 String()//创建一个空字符串
String(char[] value)//根据指定字符数组创建对象
String(String value)//根据指定的字符串内容创建对象
2.常见操作***查API
char charAt(int index);//返回指定位置的字符
char[] toCharArray();//将此字符串转化为一个字符数组
String substring(int beginIndex,int endIndex);//返回一个新字符串，它包含beginIndex-endIndex之间所有的字符
String valueOf(int i);//将int类型参数转换为字符串类型，可以重载float,double等
其他功能：字符索引、判断是否以指定字符串结尾、是否包含指定字符串、大小写转化、分割成子字符串、判断两个字符串是否相等、替换、去空格
注：equals()用于比较两个字符串中字符的值是否相等
==比较两个字符串对象的地址是否相同
StringBuffer类[它的内容和长度都是可以改变的]
常用方法
StringBuffer append(char c)//添加参数到StringBuffer对象中 添加到末尾
StringBuffer insert(int offest,String str)//在offest位置插入str 添加到指定位置
StringBuffer deleteCharAt(int index)//删除index位字符
StringBuffer delete(int start,int end)//删除左闭右开区间
StringBuffer replace(int start,int end,String s)//替换字符序列
void setCharAt(int index,char c)//替换字符
String toString()//返回StringBuffer缓冲区中的字符串
StringBuffer reverse()//反转
StringBuffer和String区别
1.String类标识的字符串是常量，一旦创建后内容和长度都是无法改变的，StringBuffer类内容和长度都可以改变。如果只是表示数据类型，用String，如果要进行增删操作，用StringBuffer类
2.String类覆盖了Ogject类的equals()方法，而StringBuffer没有
String s1,s2;内容相同 s1.equals(s2)结果是true
StringBuffer sb1,sb2;内容相同 sb1.equals(sb2)结果是false
3.String对象之间可以用+号连接而StringBuffer不可以。
System类
常用方法
static
void exit(int status)//用于中止当前运行的虚拟机，status状态码，非0表示异常终止
static long gc()//运行垃圾回收器，并对垃圾进行回收
static long currentTimeMillis()//返回以毫秒为单位的当前时间
static void arraycopy(Object src,int srcPos,Object dest,int destPos,int length)//将一个数组中的元素快速拷贝到另一个数组
static Properties getProperties()//取得当前的系统属性
static String getProperty(String key)//获取指定键描述的系统属性
Runtime类
用于表示虚拟机运行时的状态，该类采用单例模式，对象不可以直接实例化，只能通过以下方式：
Runtime run=Runtime.getRuntime();
获取处理器个数、内容容量、空闲内存数量等参数
其中exec()方法用于执行一个dos命令，从而实现和命令行窗口中输入dos命令同样的效果
Math类 查API 没有构造方法，所有方法都是静态方法
Random类
构造方法：1.Random()//产生随机数
2.Random(long seed)//当希望创建的Random实例对象产生相同数列的随机数，可以在创建对象时传入相同的seed
xxx.nextInt(100);产生一个从 0到100的整数其他类型见API
包装类
很多类的方法需要接收引用类型的对象，此时无法将一个基本数据类型的值传入，为解决这样的问题引入包装类，通过这些包装类可以将基本数据类型的值包装为引用数据类型的对象。每种基本数据类型都有对应的包装类。byte----Byte char-----Character int---Integer
short---Short long---Long float---Float double---Double boolean--Boolean
例如：Innteger类常用方法
toBinaryString(int i)//以二进制无符号整数形式返回一个整数参数的字符串
intValue()//将Integer类型的值以int类型返回
使用包装类时注意：
1.包装类都重写了Object类中的toString()方法，以字符串形式返回被包装的基本数据类型的值
2.除了Character类以外，其他包装类都含有valueOf(String s)方法，可以根据String类型的参数创建包装类对象，s不能为null且必须为可以解析为相应基本类型的数据
3.除了Character类以外，其他包装类都含有parseXXX(String s)的静态方法，将字符串转为为对应基本类型的数据。s不能为null且必须为可以解析为相应基本类型的数据
自动拆箱装箱的特性使得基本类型和包装类习惯可以进行混合数学运算
Date类(除了两个构造方法外其余方法声明为已过时)
Date date=new Date();//创建表示当前时间的date对象
Date date1=new Date(99999999999999999)；//创建表示指定时间的date对象99999999999表示从1970年1.1日到指定时间的毫秒数
Calender类是一个抽象类不能被实例化。
使用方法：Calender calender=Calender.getInstance();//常用方法见API，包括get/set等
DateFormat类专门用于将日期格式化（完整格式、普通格式、长格式、短格式）为字符串或者用特定格式显示的日期字符串转化成一个Date对象
SimpleDateFormat类自己创建日期格式模板
switch语句支持字符串类型
集合类
见集合体系架构图
Arraylist集合
import java.util.*;
Arraylist list=new Arraylist();//Arraylist在查询元素时速度很快，但在增删元素时速度很慢，此时使用Linkedlist
list.add(元素);//添加元素
Linkedlist集合(该集合内部维护了一个双向循环列表)add();addFirst();addLast();getFirst();getLast();removeFirst();
for each循环不需要获得容器长度，也不需要根据索引访问容器中的元素
for(容器中元素类型 临时变量:容器变量){
//
}
只能访问集合中的元素，不能对集合中的元素进行修改
Integator接口(主要用于迭代访问collection中的元素) Integator对象也称为迭代器
Iterator接口(遍历用)迭代器
Iterator it=list.iterator();//其中list是ArrayList接口对象
while(it.hasNext()){
XXX xx=it.next();
//}
在使用Iterator迭代器对集合中的元素进行迭代时，如果调用了集合对象list的remove()方法删除元素，会出现异常。
原因是删除元素会导致迭代器预期的迭代次数改变。
解决方法1.如果不关心要删除的元素后面的元素，可在remove()后break;
2.迭代期间可以使用迭代器本身的删除方法。即it.remove();
ListIterator接口
方法 void add(Objection obj);
boolean hasPrevious()//反向迭代元素时用，判断是否有上一个元素
Object previous()//返回列表的前一个元素
void remove()
Vector集合是List接口的一个实现类，用法与ArrayList完全相同
区别：
Vector集合是线程安全的，而ArrayList集合是线程不安全的
Vector类中提供一个elsments()方法用于返回Enumeration对象
Enumeration接口
Enumeration en=v.elements();//其中v是Vector对象
while(en.hasMoreElements()){
//XXX xxx=en.nextElement();}
Set接口与List接口一样继承自Collection接口，Set接口并没有对Collection接口进行功能扩充，只是比Collection接口更加严格。
Set接口元素无序（打印的顺序和存储的顺序可能不一致，重复存储的元素被删除），并且都会以某种该规则保证存入的元素不出现重复。
主要有两个实现类HashSet和TreeSet
见HashSet存储流程图，
TreeSet内部采用自平衡[存储的元素会按照大小排序会自动调用Comparable接口中的compareTo()方法]的二叉树存储元素，
TreeSet集合中没有重复的元素并且可以对元素进行排序（整数按大小，字符按字母顺序（当需要按别的标准排序时，重写compareTo()方法），JDK中大部分类都实现了Comparable接口）
在TreeSet中存储Student类，必须实现Comparable接口
Map接口
是一种双列集合，他中的每个元素都包含一个键对象Key[是唯一的，不能重复]和一个值对象Value,两者之间存在映射关系
void put(Object key,Objecct value)//将指定的key和value进行关联
Object get(Object key)//返回键所映射的值
方法见API，常用实现类HashMap、TreeMap
HashMap必须保证不能出现重复的键
遍历Map中键值对的方法:
1.遍历Map中所有的键，再取出相应的值
2.调用Map集合的entrySet()方法获得存储在Map中所有的映射的Set集合，然后迭代Set集合，获得每一个映射对象，并分别getKey()、getValue().
HashTable与HashMap类似，HashTable是线程安全的
HashTable的一个子类Properties重要，经常用来存储应用的配置项
TreeMap原理同TreeSet
泛型（参数化类型）指定该集合类中方法操作的数据类型 ，格式如下：
ArrayList<参数化类型> list=new ArrayList<参数化类型>();//其中参数化类型可以是String,Integer等
自定义泛型
class AAA<T>{//在创建类时，声明参数类型为T
//}
Collection工具类(用于对集合中的元素提供排序、查找、修改等操作)
1.排序操作
static <T> boolean addAll(Collection <? super T> c,T...elements);//将所有指定元素添加到指定的collection中
static void reverse(List list)//反转
static void shuffle(List list)//对list集合中的元素进行随机排序，类似于扑克牌中的洗牌操作
static void sort(List list)//根据元素的自然顺序对list集合中的元素进行排序
static void swap(List list,int i,int j)//将ilist集合中i处元素和j处元素进行交换
2.查找、替换操作
static int binarySearch(List list,Object obj)//使用二分法查找obj在list中的索
static Object max(Collection col)//返回给定集合中最大的元素
static Object min(Collection col)//返回给定集合中最小的元素
static boolean replace(List list,Object oldval,Objecct newval)//用newval替换list集合中所有的oldval
Arrays工具类
static void sort(参数)//根据元素的自然顺序对list集合中的元素进行排序
static int binarySearch(Object[] a,Object key)//使用二分法查找obj在list中的索
static Object[] copyOfRange(int[] original,int from,int to),将original从from到to中的元素们复制到新的数组中
fill(Object[] a,Object val)//填充元素
toString(int[] arr)//把数组转化为字符串
输入输出IO
见IO流分类图
IO流处理文件 文件需放在工程根目录下 文件路径要用\\而不是\