一、javaSE
1、java生成字节码（.class运行在JRE上）文件，所以具有跨平台性。
.java->.class（编译） .class运行在虚拟机是解释过程
一种半编译，半解释语言，编译效率更高（一齐翻译）
编译命令javac 执行命令java
2、编码规范：变量、方法：首单词字母小写，之后单词首字母大写
类、接口：每个单词首字母大写
包名全部小写，全局变量全部大写
局部变量：必须有初始值，方法被调用是产生，调用结束消失
//System.out.println("i="+i)
3、布尔值只能用true and false不能用0和1
4、控制语句
if(){} if(){}else{}<==>..?..: if..else if...else 或者三种的嵌套
String result=score==100?"看世界杯"：“在宿舍反省”
int age=23;
if(age<0||age>250)
{
System.out.println("不可能年龄")；
}
else{
if(){}
else if(){}
else{}
}
Switch中只能是常量或常量表达式或枚举类型
Char c=’Y’; String result=””;
Switch(c)
{
Case ‘Y’:
Case ‘y’:
Result=”YES”;
Break;`
}
For(初始化：条件部分：迭代部分){//循环体}
For的增强版 for(元素类型:集合)
For(int item : arr){system.out.print(item+”\t”)}
5、堆中的数据需要垃圾回收机制回收
二、面向对象
1、类：
字段：
将字段封装，用get，set
方法
声明：[访问权限] 返回值 方法名（参数） {方法体}
Public void ran() { system.out.println();}
Public String eat(String tools,double money){}
构造方法（构造器）
与类同名，没有任何返回值
Java只有值传递，无引用传递（一种是传值，一种是传引用）
2、封装
三、java高阶
1、类之间的关系
继承、泛化（is—a）
Extends
子类中的成员：
1、 继承父类中的可见的成员（字段、方法）（构造器不能继承）
2、 子类中所特有的成员（字段、方法）
3、 重载父类的成员（方法）
重载的条件
a、 方法名称相同，参数的列表不同（参数的类型、个数、顺序）
b、 返回值无所谓
c、 访问权限无所谓
d、 发生在同一个类当中，或者父子类（前提）
避免歧义重载（否则报编译错误）
Void int ma（int a ,double b）
Void int ma（double a ,int b）
Ma(23,24);
构造器重载
4、 覆盖父类的成员（方法）
覆盖的条件：
A、 方法名称相同，参数列表相同
B、 返回值必须相同
C、 子类的访问权限大于等于父类的访问权限
D、 子类只能抛出父类的异常类或者父类的异常类的子类
E、 覆盖只能发生在父子类之间（前提）
Class Person{
Int age;
String name;
Public String show()
{
Return age+”\t”
}
}
Class Student extends Person
{
Double score;
Int id;
String school;
}
Main(){
Student stu=new Student;
}
This用法
This.成员（方法）
This（参数列表）调用本类的其他构造方法 ,必须放在第一句
Super.方法（成员）调用父类的构造方法
Super（参数列表）必须位于子类构造方法的第一句
多态：父类的变量指向一个子类的实例
Animal dog =new dog（）；
自动转换：小—>大 子—>父
强制转换： 父à子
Parent p=new Child();
Parent p1=new parent();
Child c=(child)p;
Child c1=(child)p1;报错，以为p1原来是parent类型，类的强转只针对于多态 （可以用insteadof判断）
Static:（类名.静态成员调用）与对象无关，只与类有关，所以不能用this，super关键字，不能修饰局部变量，也就是方法里面不能用static关键字
字段：所有对象共享这个字段
方法：静态方法能够访问静态成员，不能直接访问非静态成员
非静态的成员可以直接访问静态成员和非静态成员
代码块：
只执行一次
内部类：
Final：（基于数据的保护）
变量：必须有初始值，并且不能第二次赋值
方法：不能被重写（覆盖）
类：不能被继承
组合（has---a）
合成：个体和整体，生命周期相同
聚合：个体和整体的关系，生命周期不同
关联
实现、接口（is---a）
依赖（use---a）:一个类作为了另一个类的参数或者返回值
抽象方法：abstract
只有方法声明，没有方法的实现，抽象方法只能在抽象类中
抽象类有构造器，但抽象类没有对象，但只有在子类产生对象时，调用父类的构造器
抽象类能有父类，且可以有非抽象父类
Abstract:
与Static private final关键字永远不能同时使用
Interface：（接口是规范）有变数的地方都应该加接口
不能产生对象，没有构造器
弥补了单继承的不足
类和接口之间可以是多继承
接口和接口之间也可以多继承
Interface m1;interface m2;
Public interface m3 extends m1,m2{}
字段：公开的静态的常量字段
方法：公开的方法，默认字段都是public
Public interface Runner{
Int i=12;
Void ma();//默认是public,在接口中
}
Class Person implements Runner{
Void ma(){};//类中默认是private
改成public void ma（）{}；
}
Object类：
Equals：除了包装类，string，date判断数值之外，其他都是引用判断，判断是否指向同一块内存地址。
如果重写了equals就必须重写hashcode（）
==：可以判断数据也可以判断引用
1、异常处理
Throwable：（类）常见的接口，jsp9个内置。。。
Exception：（异常）
1、RuntimeException(运行异常)：JVM可以自动捕获
2、检查异常：JVM不能自动捕获，需要显示的处理
3、throws：//跟在方法后面
4、throw//跟在句子后面
if(age<0||age>250)
{throw new Exception("年龄异常")}
5,、自定义异常
extends Exception
extends
class AgeOutBoundsException extends Exception
{
public AgeOutBoundsException(){}
public ......
}
Error：（错误）
a、 try。。。catch
try{
system.out.println(a/b)
}
catch(ArithmeticException ex)//一个try可以有多个catch，越详细的类越写在前面
{
ex.printStackTace();
//return;//即使有return，finally中代码也执行
}
finally{ //有无异常finally都执行
system.out.println("finally");
}
b、throws谁调用谁处理，main方法也可以抛出异常，抛给虚拟机
异常抛出时，父类抛出的异常更大一些，子类不能抛出比父类更大的异常，父类抛异常，子类可以不抛（ 只限运行异常）
2、常见类
String
Stringbuffer线程安全的，效率低，需要加锁
Stringbuilder 线程不安全的
split：按照一定规则切割字符串
substring：取字串
toCharArray：转换成数组
trim：可以去掉字符串前后的空格
valueof（）所有的类型都能转换成字符成类型
append：追加字符串 str.append("1212").append("2333")可以连续追加
delete（）：删除也可以联系删除
insert（）：插入，也可以连续插入
3、集合（只能存引用类型，即都是对象）
Set:集 无序的，不允许重复（）
HashSet（无序的） 、TreeSet（有序的） 只能通过迭代器进行遍历
List：列表 有序的，允许重复的
ArrayList（物理内存是连续的，线程不安全的）、LinkedList（类似于C++中的链表，物理内存是不连续的） 、Vector（底层存储也是数组，线程安全的）
List list=new Arraylist();
list.add(12);//这个步骤自动将12装箱成integer类型
for（Object obj:list）遍历
或者用迭代器遍历
Map：字典 键值对的形式
Map map=new HashMap();//Hashtable()是线程安全的，但不能使用null作为键和值
map.put(1,"aaa"); Map<integer,String> map=new HashMap<integer,String>();
map.put("a","bbb");
map.put(12.34,"ccc");
map.put(null,null)
Set set=map.keyset();
Iterator it=set.iterator();
while(it.hasNext())
{
Object key=it.next();
String value=(String)map.get(key);
system.out.println(key+":"+value);
}
集合和数组的区别：数组大小是固定的，里面存的可以是基本数据类型也可以是类对象，集合只能存引用对象，不能存数据
4、泛型:类型参数化
泛型类
泛型接口 List<String> List=new ArrayList<String>();
Iterator<String> it=set.iterator();
泛型方法
class GenericDemo
{
public <T>void swap(T obj1,T obj2)
{
T temp=obj1;
Obj1=obj2;
Obj2=temp;
}
}
GenericDemo gd=new GenericDemo();
gd.swap(1,2);
泛型类：
class GenericClass<T>
{
private T name;//类中的数据类型不确定
public T getName();
}
GenericClass<String> gc=new GenericClass<String>();
5、多线程
线程：
a、extends Thread
b、implement Runnable（一般常用这个）
public ThreadDemo implements Runnable
{
void run();
}
synchronized 用锁防止多线程改变同一个内存域
6、数据库，Oracle
java.sql.Date包下对应Oracle的时间
原文地址：http://www.cnblogs.com/carraydream/p/3820367.html
