一、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=http://www.mamicode.com/(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的时间