JAVA的知识点：

1. JAVA 概述：JDK、JRE、JVM、编译器和运行器、环境变量，以及一个简单的JAVA程序编辑到运行结束的整个过程。

   /*JDK:Java Development Kit*JRE:Java Run Enviroment,java运行环境，包括java的工具类库和编译器和运行java程序的虚拟机*JVM:Java虚拟机，是java程序的运行器*编译器和运行器：编译器将.java文件翻译成.class文件，运行器可以运行.class程序*环境变量：告诉系统到哪个路径下去查询程序需要的类库文件和编译器和虚拟机*简单的JAVA程序到运行结束过程：创建源文件.java、创建类（源文件名必须和类名一致，一个源文件里只*能有一个public类，类中可以有多个inner类）、编写main方法、编译成.class文件、虚拟机运行.class文件*/

    

2. 语法：变量与常量、简单数据类型、运算符、表达式、流程控制语句、数组

   //JAVA中没有：1、全局变量 2、goto语句 3、指针 4、内存管理int num; /*变量的声明会在内存区为变量开辟空间，当对变量进行初始化时会往分配的内存中写入初始值，         **int为数据类型,num为变量名，需要注意变量名的合法性，变量的值保存在内存中，         **需要通过变量名来访问*//*运算符：算数运算符、关系运算符、逻辑运算符、位运算符、*       其他运算符(1、 ?: 2、 [] 3、 . 4、new 5、instanceof)*表达式：变量、常量和运算符组成，此时需要考虑运算符的优先级*流程控制符：与其他语言一样（if-else switch-case while do-while for break continue return）*/int[] a = new int[10];   /*数组：java 的数组与其他语言有区别.下标从0开始，                         ** int[] a是声明一个int型的数组变量，new int[10];是                         ** 开辟一个可以存放10是int型数据元素的空间，通过 = 将a指向所开辟空间的                         ** 首地址此时并未对数组中元素进行赋值*/

   基本数据类型

   类型	所占内存(字节)	说明
   byte	1	字节型整数
   short	2	短整数
   int	4	整数
   long	8	长整数
   float	4	单精度浮点数
   double	8	双精度浮点数
   char	2	单字符
   boolean	true/false	布尔值

   除了简单的数据类型，还有引用类型：数组、类、接口。

3. JAVA的内存：寄存器、本地方法区、方法区、栈、堆、代码段、数据段

   /*寄存器：存取速度最快*栈：保存局部变量的值，如基本数据类型的值、对象的引用*堆：保存动态产生的数据，比如对象（此时对象仅包括对象的属性即成员变量，不包括成员方法，*因为成员变量是对象各自的，而成员方法则共享类的方法）*常量池：常量池是为每个数据类型用到的常用常量的一个集合，常量池位于堆内存中，在动态链接中很重要*代码段：用来保存从硬盘中读取到的源代码*数据段：用来保存static定义的静态变量*本地方法区：本地方法栈中执行的是本地方法的服务*方法区：方法区属于堆内存的一部分，也是线程共享的区域，用于存储已经被虚拟机加载的类信息，常量池，*static静态变量和即时编译器（JIT）编译后的代码等数据*/

   想更加具体地学习推荐：

4. JAVA的三大特性：封装、继承和多态

   //封装：属性可用来描述同一类事物的特征，方法可描述一类事物可做的操作。封装就是把属于同一类事物的//共性（包括属性与方法）归到一个类中//继承：一个类继承另一个类，则称继承的类为子类，被继承的类为父类。//多态：相同的事物，调用其相同的方法，参数也相同时，但表现的行为却不同。

   有封装才有类。有类才有继承，有继承才有多态。这里只要先理解封装就行，继承和多态在后面会进一步学习。

5. 类与对象：类的设计（构造方法、成员变量的声明、方法的声明、访问限定符、非访问限定符、方法的参数传递、从内存理解对象的创建撤销、引用、包、垃圾回收机制）、类加载器            类修饰符

   public	公共类，可以再任何地方使用，一个源文件中只能有一个public类，若没有public修饰，则只能被同一个包的程序使用
   abstract	抽象类，不能用来创建对象，不能有实现的方法
   final	不能被继承的类

   成员变量访问控制符  

   访问控制符	同一个类	同包	不同包，子类	不同包，非子类
   public	√	√	√	√
   protected	√	√	√
   defualt	√	√
   private	√

   static:类中的变量分为实例变量和类变量（静态变量，类的对象共有）；第一次调用静态变量时系统会为静态变量分配一次内存，此后所有对象共享该变量。

   方法非访问限定符

   abstract	修饰抽象方法，该方法只有声明，没有实现。抽象方法必须在抽象类中，有抽象方法的类都是抽象类。
   static	修饰类方法，静态方法。调用类方法时必须通过类名调用而不是对象名；非static方法属于对象，在对象内存中有专属代码段，而static方法属于类共有方法；static方法只能操作static域，不能访问非static域（对象属性），而非static方法可以访问实例变量也可以访问静态变量
   final	修饰最终方法，final方法不能被子类重写；private方法和final类中的方法都是final方法，都不能被重写；
   native	本地方法，没有方法体，用其他语言书写方法体
   synchronized	同步方法，synchronized修饰static方法时，系统会对当前类的全部对象加锁；synchronized修饰非static方法时系统会对当前对象加锁；用于线程同步

   方法的修饰符也有访问限定符（和成员变量的一样，public、protected、defualt、private，不再多说）和非访问限定符(abstract、static、final、native、synchronized，如上表)

   参数传递：JAVA只有值传递一种参数传递方式，对于基本数据类型会将值拷贝一份进行传递给方法，在方法内部（局部）对值进行改变不会影响方法外的值；对于引用类型，会将引用拷贝一份传给方法，引用所指向的对中的对象的地址和外面的引用是一样的，是因此在方法内通过引用改变对象的属性时，所指向的UI想属性发生改变，所以外部的引用所指向的对象也会发生改变。   垃圾回收器GC  System.gc（必考）、垃圾回收算法（了解）有引用计数法、标记-清除法、标记-整理法、复制算法、分代算法（年轻代、老年代、永久代）

6. 继承与多态： 继承机制、继承的实现、多态性、多态的实现、方法的重写与重载、构造方法的继承与重载。通过如下代码说明，把A.java放在前面，B.java放在后面（完全将代码复制过来了）

7. //继承：继承是从已有的类中派生出新的类，新的类能吸收已有类的数据属性和行为，并能扩展新的能力/*继承中的构造方法 *1、子类的构造过程中必须调用其基类的构造方法。*2、子类可以在自己的构造方法中使用super(argument_list）调用基类的构造方法。*   2.1、使用this(argument_list)调用本类的另外构造方法。*   2.2、如果调用super，必须写在子类构造方法的第一行。*3、如果子类的构造方法中没有显示的调用基类的构造方法，则系统默认调用基类的无参数构造方法。*4、如果子类构造方法中既没有显示调用基类构造方法，而基类又没有无参数的构造方法，则编译出错。*///A.java类文件package javatest;import java.lang.*;public class A {	A(){};     /*当类写了有参构造方法时，无参构造方法必须写才能调用，	            *否则在实例化时调用无参构造方法是非法的*/	/*构造方法可以进行重载，这样在创建对象时会根据参数列表来匹配并调用相应的构造方法*/	A(int i){		this.id = i;	}	public void f(){		System.out.println("A");	}	//测试public方法的访问限定	public String name;	public void setName(String in){		this.name = in;	}	public String getName(){		return this.name;	}	//测试private方法的访问限定	private int id;	private void setId(int in){		this.id = in;	}	private int getId(){		return this.id;	}	//测试protected方法的访问限定	protected int salary;	protected void setSalary(int in){		this.salary = in;	}	protected int getSalary(){		return this.salary;	}		public int sum(int a,int b){		return a+b;	}	public int sum(int a,int b,int c){  //sum方法的重载		return a+b+c;	}		//测试非访问限定符static修饰变量和方法的作用,静态变量，静态方法	public static String className = "A";	public  String className1 = "A";	public static void change(String in){		className = "C";	}		//实例变量和静态变量	public int i = 100;	public int j = 10;	public static int m = 200;	public static int n = 20;			public static int add1(int a,int b){		return a+b;	}		//测试非访问限定符final修饰方法的作用,最终方法，可以被子类继承但不能被重写	public final int add2(int a,int b){		return a+b;	}		public  final int k = 10;	public static final int q = 11;}//B.java类文件package javatest;import javatest.A;//import javatest.A;public class B extends A{     //B类继承（extends）A类		/*子类不会继承父类的构造方法， 但构造方法中会隐式调用，或者	 * 通过super(arg_list)来显示调用，此时super(arg_list)必须	 * 放在子类构造方法的第一行*/		B(int i,String str){      	    super(i);		this.name = str;	}	@Override	public void f(){            //重写f方法		System.out.println("B22");	}	public int id;	//如下代码若不注释就是非法的，add2方法继承自A类，是final的，不能被重写	/*@Override	public int add2(int a,int b){		return a+b;	}*/	public static void main(String[] args){		//创建A类引用并指向一个A类对象		A a1 = new A();		//创建A类引用并指向一个B类对象		A a2 = new B(2,"chen");				//A类（父类）的public方法和属性setName、getName、name可以在B类（子类）中使用		a1.setName("jfchen");		System.out.println(a1.getName());   //jfchen		System.out.println(a1.name);        //jfchen				//public方法和属性setName、getName、name可以被子类（B）继承		a2.setName("chenjf");		System.out.println(a2.getName());   //chenjf		System.out.println(a2.name);        //chenjf				/*以下两行代码若不注释是非法的，因为setId()方法和id属性		 * 是A类私有的,只能在类内使用*/		//a1.setId(1);	    //a1.id = 1;				/*本行代码若不注释就是非法的，因为private方法，		 * id属性是private私有的，都不能被子类继承*/		//a2.setId(2);		//a2.id = 2;				/*protected方法和属性setSalary、getSalary、salary可以在		 * 同一个包的子类中使用*/		a1.setSalary(10000);		System.out.println(a1.getSalary()); //10000		System.out.println(a1.salary);      //10000				/*protected 方法和属性setSalary、getSalary、salary可以被子类继承*/		a2.setSalary(20000);		System.out.println(a2.getSalary());  //20000		System.out.println(a2.salary);       //20000				System.out.println(a1.sum(49,50));   //99		System.out.println(a1.sum(49,50,100)); //199				System.out.println(A.className);  //A		System.out.println(a1.className1); //A		System.out.println(a2.className1); //A 子类继承父类的实例变量和值		A.change(A.className);     //静态方法可以改变静态变量		A.change(a1.className1); //静态方法不可以改变实例变量		A.change(a2.className1); //静态方法不可以改变实例变量		System.out.println(A.className); //C		System.out.println(a1.className1);//A		System.out.println(a2.className1); //A				System.out.println(A.add1(a1.i,a1.j));   //110  静态方法访问实例变量		System.out.println(A.add1(a2.i,a2.j));   //110  静态方法访问实例变量		System.out.println(A.add1(A.m,A.n));     //220				//final方法可以被继承但不能被重载		System.out.println(a1.add2(a1.i,a1.j));   //110  实例方法访问实例变量		System.out.println(a1.add2(A.m,A.n));     //220 实例方法访问静态变量		System.out.println(a2.add2(A.m,A.n));     //220 实例方法访问静态变量				System.out.println(a1.k);		/*System.out.println(A.k);这句代码是非法的，因为只有final修饰的变量是		 * 实例变量，只能通过对象名访问，不能通过类名访问，如上句*/ 		/*System.out.println(a1.q);这句代码是非法的，因为同时用static final		 * 修饰的属于静态变量，只能通过类名访问，如下*/		System.out.println(A.q);		/*A.q = 13;这句代码是非法的，因为q是A类的静态变量，不能改变值*/				/*同样是调用f方法，但是上一句调用的是A类的f，而后一句调用的是B类的f,即f的多态性*/		a1.f();  //A  		a2.f();  //B 	}}

    

8. 接口、接口内的成员变量与 成员方法设计、抽象类和接口的比较（语法区别、设计层面区别） 抽象类和接口比较

   抽象类	含有抽象方法（abstract修饰的方法）的类一定是抽象类（也必须用abstract修饰），但抽象类不一定含有抽象方法（说明可以有实现的方法）；抽象类必须用[public | protected]修饰，且只能被继承不能实例化对象；一个类继承抽象类，则子类必须实现父类的所有抽象方法；抽象类中可以有各种类型的成员变量；抽象类可以有静态代码块和静态方法；单继承；抽象类是对类的抽象，有行为有属性，所以有方法和变量；
   接口	用interface 以定义类的形式来定义接口；接口中的变量会被隐式地指定为public static final变量并且只能是public static final变量；一般情况下不在接口中定义变量；方法会被隐式地指定为public abstract方法且只能是public abstract方法；接口的继承使用implements关键字；接口中不能含有静态代码块以及静态方法；多继承；接口一般仅对行为抽象，所以一般只有抽象方法；

   //抽象类//抽象类Bird.java文件package javatest;public abstract class Bird {     //抽象类必须用abstract修饰	public float length;     //说明抽象类是事物的抽象，同样具备属性	public float weight;	public float height;	public String type;		//抽象方法必须用abstract修饰	public abstract void fly(float h);	public abstract void loseWeight(float w);		public void  migrate(){ //说明抽象类可以有非抽象方法（不考虑方法逻辑是否合理）		fly(height);	};		//抽象类可以有静态代码块和静态变量和静态方法	public static int id;	static{		id = 1;	}	public static int add(int a,int b){  //鸟也会做加法		return a+b;	}}//子类WildGoose.java文件package javatest;import javatest.Bird;        //导入需要继承的类，在同一个包中可以忽略public class WildGoose extends Bird{   //WildGoose继承Bird	public String color;         //子类有属于自己独立的实例变量	public void fly(float h){   //抽象类的子类必须实现父类的所有的抽象方法		this.height = h;	}	//若不实现从父类继承而来的loseWeight方法则会报错	public void loseWeight(float f){		this.weight -=f;	}		void main(String[] args){//		Bird b = new Bird();  若不注释则是非法代码，因为抽象类不能直接实例化		WildGoose w = new WildGoose();   	}}

   //接口//先写两个接口Fly.java 和Run.java//Fly.javapackage javatest;public interface Fly {     //接口的定义使用interface关键字		public void fly(float h);  //若写方法体会报错，因为接口	                           //中的方法是抽象（隐式定义成public abstract）		//以下两行代码说明接口可以定义实例变量和静态变量(不用去考虑这些方法定义的合理性)	public  int id = 2;   //变量会被隐式定义为public static final	public static float wingnum = 2;//说明接口中可以定义	//  private int leg = 2; 这行代码是非法的，说明接口中不许有私有的变量}//Run.javapackage javatest;public interface Run {    public void run(float f);  //另一个接口，为了说明类可以实现多个接口       //以下代码为了说明接口中不能有静态代码块    /*public static int a = 2;    public static int b = 3;    static{    	System.out.println(a+b);    }*/    //以下代码为了说明接口中不能有静态方法    /*public static int (int i,int j){    	return i+j;    }*/}//再写一个实现两个接口的类RunBird.java//RunBird.javapackage javatest;import javatest.Fly;import javatest.Run;public class RunBird implements Fly,Run{ //接口的可以实现多继承，implements	public float x;	public float height;		public void fly(float f){  //实现继承自Fly接口的抽象方法		this.height = f;	}	public void run(float f){  //实现继承自Run接口的抽象方法		this.x = f;	}}

    

9. 图形用户界面（JAVA Web的重点）：(java.awt)基本类和接口、事件处理、GUI组件和布局管理、菜单与对话框、图形。（任何时候都记住：JAVA是面向对象的语言，所有的功能实现代码编写都是基于类和对象的，所以首先要设计接口和类，然后实现类，然后再创建对象）
10. I/O:区分字节流和字符流、保存和读取字节流数据、保存和读取字符流数据、保存和读取对象数据。这部分主要是熟悉相关类的分类和用：https://my.oschina.net/jfchenhust/blog/776214

    字节流	1、字节流处理单元为1个字节，操作字节和字节数组；2、音频文件、图片、歌曲，就用字节流；主要用在处理二进制数据；
    字符流	1、字符流处理的单元为2个字节的Unicode字符，分别操作字符、字符数组或字符串；2、字符流是由Java虚拟机将字节转化为2个字节的Unicode字符为单位的字符而成；3、如果是关系到中文（文本）的，用字符流，它对多国语言支持性比较好；

     

11. 多线程和：线程概念、线程的分类、线程的状态、线程的实现、线程的使用；多线程、线程的同步、线程与进程

    /*个人认为学习多线程这章应该先介绍线程以及相关知识，*再介绍多线程，到线程同步，最后比较线程和进程*//*线程概念：线程是系统独立调度和分派CPU的基本单位，是程序执行流的最小单元*运行程序需要CPU资源，所以线程是能获得CPU独立独立运行的最小的单元*比它大的单元是进程，所以，一个进程中可以有多个线程（暂时不解释）*线程还叫做轻量级的进程，这就需要了解一下操作系统，学习一下进程*//*线程的分类：用户线程：用户通过继承Thread类或实现Runnable接口创建的线程*           守护线程：是为用户线程提供服务的线程，如JVM的垃圾回收、内存管理等线程，*                   setDaemon( )和 isDaemon()*///线程的状态及转换：如下图：图片来自http://www.cnblogs.com/lwbqqyumidi/p/3804883.html

    

    //解释线程的状态最好就CPU资源而言，且用面向对象的思维理解，且就上图进行说明，理解通就行//new:刚刚通过new关键字创建的线程对象Thread t = new MyThread();此时线程对象是不可运行的//Runnable:对处于new状态的线程调用start方法t.start(),线程则进入到Runnable状态，此时等待//         获得CPU资源一旦获得资源将进入Running状态，即执行状态;线程进入Runnable状态也有可能是处于//         Running状态的线程调用的yield()方法//Running:上面说到，处于Runnable的线程对象一旦获得CPU资源;//        Running状态的线程有三种去处：1、Runnable 2、Block; 3、Dead//Block:Block状态都是从Running转变过来的，种种原因（主动或被动），该线程失去CPU资源，就进入Block;//Block状态的线程有三种来源 1、Running线程调用sleep()/join()方法;当sleep()/join()/IO结束就会进入到Runnable//                      2、（等待）Running线程调用wait();此时线程调用//                          notify()/notifyAll()/interrupt()方法可以进入锁定状态//                      3、（锁定）Running线程获取synchronied同步锁失败,此时只要线程获得同步锁//                          就会转变成Runnable状态//最后，两种由Block状态转变成的Runnable状态的线程只要获得CPU资源即转成Running状态//Dead:处于Running状态的线程运行完或遇到异常都会转变成Dead状态，此时就只能等待垃圾回收器的回收了

    就JAVA来说线程有两种常用实现方式：1、继承Tread类，’并重写run()方法，即线程执行体，这是实现我们创建线程的目的方法   2、实现Runnable接口，并重写该接口的run()方法，该run()方法同样是线程执行体，创建Runnable实现类的实例，并以此实例作为Thread类的target来创建Thread对象，该Thread对象才是真正的线程对象。Thread类与Runnable接口的关系：Thread类实现了Runnable接口

    //通过继承Thread类构造和使用线程//MyThread.javapublic class MyThread extends Thread{	@Override 	public void run(){		System.out.println("run in mythread");	}}//ThreadTest.javapublic class ThreadTest {	public static void main(String[] args){		Thread t = new MyThread();		for(int i = 0;i<10;i++){			System.out.println(Thread.currentThread().getName() + " " + i);			if(i == 2){				t.start();			}		}			}}//控制台输出main 0main 1main 2   //此时t.start();线程转为就绪状态main 3main 4main 5run in mythread  //此时才获得CPU资源，说明进入就绪状态到进入运行状态是需要等待资源的main 6main 7main 8main 9

    //通过实现Runnable接口实现,好处是可以实现多继承//MyRunnable.javapublic class MyRunnable implements Runnable{	@Override 	public void run(){		System.out.println("run in myrunnable"+" "+Thread.currentThread().getId()+" "+Thread.currentThread().getName());	}}//RunnableTest.javapublic class RunnableTest {	public static void main(String[] args){		MyRunnable mr = new MyRunnable();		Thread t = new Thread(mr);   //此时运行的是MyRunnable的run();//      Thread t = new MyThread(mr);  此时运行的是MyThread的run();		for(int i = 0;i<100;i++){			System.out.println(Thread.currentThread().getId() +" "+Thread.currentThread().getName()+ " " + i);			if(i == 20){				t.start();			}		}	}}

    线程同步的方式：1、synchronied同步方法 2、synchronied同步代码块 3、ReentrantLoc对象同步锁 4、wait()/notify()/notifyAll()线程通信 5、volatile 6、ThreadLocal局部变量 7、BlockingQueue阻塞队列 8、原子操作

12. 异常处理：异常分类、异常的抛出和捕获
13. Applet(不用花太多时间)：没有main方法的小程序
14. 网络编程：基础概念（IP、端口、套接字、数据包、网络协议）、通过URL访问网络、基于Socket的C/S编程、基于Datagrame的C/S编程
15. Java与数据库连接：JDBC、SQL基本内容、 存储过程、JDBC工具使用
16. Servlet:Servlet生命周期、URL重定向、请求转发
17. JSP:9大对象（out、page、config、request、response、session、pageContext、application、exception）、4大共享变量(page、request、session、application)