1.JAVA简介

1.1java体系结构：j2se,javaweb,j2ee

1.2java特点：平台无关（虚拟机）,垃圾回收(使得java更加稳定)

1.3 JDK与JRE,JDK:java开发环境，JRE：java运行环境

1.4第一个java程序：HelloWorld，java的入口是main(public static void main(String[] args))

1.5java程序的开发步骤：.java编译（javac）成.class运行(java).class文件

2.基本数据类型

2.1标志符：自己可以取名字的地方称为标志符

*标志符的规则：1，只能是字母，数字，下划线，$;不能以数字开头;严格区分大小写；不能使用关键字作为标志符

2.2关键字：关键字都是小写

2.3常量：如123，“hello”

*也可以使用final定义常量（请参照Math.PI），如public static final int SLOW_SPEED=1;

2.4变量：变量的本质是内存中的一小块区域，用这个区域保存数据

*变量申明：类型变量名字

*变量必须先声明，再赋值，再使用

*注意区分基本数据类型的变量与引用数据类型的变量

*变量的作用域，局部变量与成员变量：变量在哪个大括号里定义，就在哪里有效，出了大括号无效

2.5基本数据类型：java数据类型分为两大类：基本数据类型，引用数据类型

*基本数据类型分为4类8中：boolean,char,byte,short,int,long,float,double

*boolean类型只有true，false

*char是Unicode编码

*float,double是有精度的（不是绝对精确的）

2.6基本数据类型之间的转换

*123字面常量是int型，12.3字面常量是double型,8888888888888这个字面常量有问题（因为它已经超出int的范围，改成8888888888888L）

*boolean与其他类型不兼容

*byte,short,char之间相互运算的时候，先转换为int，再进行运算

*小容量的数据类型可以自动转换为大容量的数据类型:byte,short,char——>int——>long——>float——>double

*大容量转换为小容量的数据类型，要进行强制转换

*多种数据类型进行运算的时候，先转换为容量最大的数据类型再进行运算，整个表达式的类型是容量最大的数据类型

*必须掌握PPT上的习题

3.运算符与流程控制3.1运算符：算术，关系，赋值，逻辑（着重注意）,位运算符

*自加自减++,--，注意顺序

*关系运算符的结果是boolean类型

*逻辑运算符注意短路与&&，短路或||

*三元运算符(逻辑表达式) ?表达式一:表达式二

3.2流程控制语句：条件（if,switch）,循环(for,while,do while),break与continue

3.3 switch的规则：

*switch只能探测:byte,short,char,int类型的值（case后面也只能是这4种）

*switch中小心case的穿透(代码会一直运行，直到遇到break停止，建议每个case写一个break)

*default：如果没有找到匹配的case，则执行default

3.4 for，while，do while搞清楚代码的执行流程（PPT上有图，必须记住）

3.5 break,continue

*都可以用在循环里面，break还可以用在switch中

*break跳出单前的代码块（结束循环）

*continue:跳过本轮循环，继续下一轮循环(循环会继续，仅仅跳过本次)

3.6流程控制代码编写：可以灵活的组合这些流程控制代码，注意一定要写{ }

4.面向对象基本语法

需要大家掌握：类与对象的区别，如何定义一个类，如何实例化一个对象

4.1定义一个类

*使用class关键字定义类，注意类名大写

*成员属性：成员属性不赋值会有默认值（默认值规则参考PPT）

*成员方法

*构造方法：没有任何返回值，名字与类名一样，构造方法的本意是用来初始化对象（初始化对象的属性值）

4.2实例化对象：Student s = new Student();

*使用new +构造方法实例化对象

*new在堆中开辟了对象的空间，并且给属性赋上默认值

*接下来调用构造方法，执行构造方法中的代码

*最后返回对象的引用

4.3区分引用类型与基本数据类型

*引用类型的变量在内存中有两块区域，一块是引用本身，另一块是引用所指向的对象

*基本数据类型在内存中只有一块空间：里面存着值

4.4如何操作对象：使用.操作符

*使用对象名.属性操作对象的属性（如:stu.age = 18;）

*使用对象名.方法调用对象的方法(如：stu.study());

*this：每个对象都有this，this是指向本身的引用，代表本身

4.5.必须能够独立写出Point3D的代码(题目在PPT上)

5.访问控制，方法定义与调用，重载，方法重写5.1访问控制5.1.1 package包的使用

*使用package定义包：package只能放在代码的第一行

*import：导包，可以到入包下所有import java.io.*;可以导入具体的一个类import java.io.Reader;

*包的作用:1,分类；2，隐藏（封装的作用），3,便于管理

*java本身提供了一些包：java.lang(核心类，此包如需要引入),java.util(集合框架以及其他常用类)，java.io(输入输出),java.awt,javax.swing(图形)

5.1.2继承（简单概念）：使用extends关键字表示继承

*子类继承父类的所有属性

*子类继承父类除private（非同包的时候也除默认的方法）外的所有方法

*子类对象拥有super引用，表示父类的引用,可以使用super明确的调用父类的方法或属性

5.1.3四个访问级别，从大到小：public，protected，默认，private

*注意访问级别是针对类来讲的，不是针对对象！！！！！！！

*注意类的访问修饰符只能使用public或默认

*学了访问控制后：类的属性都写private，通过set/get方法对属性进行赋值，取值

5.2重载与重写

1.判断是否是重载，或者是否是重写，如果不是重写或者重载，就不受重写重载规则的约束

5.2.1重载：一个类当中，有方法名相同，参数不同的方法，称为重载

*不能只改返回值：不能根据方法的返回进行重载

5.2.2重写：在继承当中，子类将父类的方法重新写了一遍：重写的方法与被重写的方法拥有相同的方法签名（返回值类型，方法名，参数列数）

*.重写的方法能够改变被重写的方法的访问级别,注意只能是相等或者扩大

*.重写的方法不能抛出比被重写方法更多的异常，注意只能缩小异常的范围

*.如果被重写的方法是具体的，重写之后不能改为abstract

5.3类与对象的生命周期

5.3.1类与对象的初始化过程：

*静态属性先初始化，而且仅仅初始化一次

*首先给静态属性进行声明，并赋默认值，然后代码从上往下执行静态代码块或静态赋值

*每创建一个对象，就先实例化成员属性：首先给成员属性声明，赋默认值，然后.执行赋值语句

*成员属性初始化后再调用构造方法

5.3.2垃圾回收机制

*java虚拟使用垃圾回收机制进行垃圾回收

*垃圾回收本身是一个线程(当内存不够用的时候，一般会进行垃圾回收)

*垃圾回收不能通过程序来调用，仅仅能够通过System.gc()建议虚拟机进行垃圾回收

*当进行垃圾回收时，会调用对象的finalize方法

5.4单例模式：一个类仅仅能有一个实例(设计模式的一种)

*构造方法必须为私有的

*提供静态的方法来获得对象

*提供静态的属性，该属性是该类的一个对象

6.继承，抽象类，接口6.1继承：

6.1.1继承的语法：使用extends关键字表示继承

*子类继承父类所有的属性

*私有方法不能被继承

*super关键字表示父类的引用，可以用super来调用父类的方法或属性

6.2.2继承中的构造方法:了解下面的知识点以及实例化对象时代码的执行过程

*子类的构造过程必须调用其基类的构造方法

*子类可以在自己的构造过程中使用super (arg_list）来调用基类的构造方法

*如果调用super，必须写在子类构造方法的第一行

*可以使用this(argument_list)调用本类的另外的构造方法

*如果子类的构造方法中没有显示的调用基类的构造方法，系统默认调用基类无参数的构造方法

*如果子类构造方法中既没有显式的调用基类构造方法，基类中又没有无参数的构造方法，编译出错

6.3.3对象的转型

*一个基类的引用类型变量可以指向其子类的对象

*一个基类的引用不可以访问其子类对象新增的成员

*可以使用instanceof关键字来判断一个引用类型变量所指向的对象是否是制定的类型

*子类的对象可以当作基类的对象来使用称作向上转型，反之称为向下转型

*子类可以当成父类来使用，无需显示转换

*父类引用转换为子类引用要进行强制转换

*注意：不兼容的类型之间不能进行相互转换（只有具有直接或间接父子关系的类才是兼容的类型），否则编译时会报错

*注意：兼容类型之间的转换要看对象的实际类型，因此向下转化时最好先用instanceof来判断是否是某个类型，在转换，以免报报错

6.4.4多态：也称运行时绑定：一般是指父类的引用指向子类对象，通过父类的引用调用被子类重写的方法，这个时候执行的是子类的方法

*一句话总结多态：对象实际是什么类型就调用什么类型的方法

*多态成立的条件：1，要有继承。2，要有重写。3，必须有父类引用指向子类对象。

6.2抽象类：用abstract修饰的类称为抽象类（抽象的本意是不具体）

1.抽象方法不能有方法体

2.抽象类不能被实例化。

3.含有抽象方法的类必须被声明为抽象类，

4.子类继承抽象类，必须被重写父类的抽象方法，否则本身也必须被声明为抽象类

5.抽象类中的方法和属性没有其他规则来约束，抽象类中没有抽象的方法是可以的，抽象类中可以有非抽象的方法和属性

6.3 static:静态关键字

6.3.1static属性：在类中，用static申明的成员变量叫静态变量，他为该类的公用变量，在第一使用时被初始化，对于该类的所有对象来说，static成员变量只有一份

6.3.2 static方法：用static声明的方法为静态方法，在调用该方法时，不会将对象的引用传递给它，所以static方法中不可以访问非static的成员。

*静态方法中不能访问非静态成员

*静态成员方法没有this引用

*可以通过类名（不需要实例化）或对象引用来访问静态成员

6.4 final关键字:

final表示最终的意思

*final的变量的值不能够被改变

*final的成员变量

*final的局部变量(形参)

*final的方法不能够被重写

*final的类不能够被继承

6.5接口：interface

1.使用interface定义一个接口，使用implements实现一个接口

2.接口中的属性只能为public static final类型（静态常量）

3.接口中的方法只能为public abstract类型

4.一个类可以实现多个接口，但只能继承一个类

5.接口也可以继承接口

7.异常处理

java的异常处理机制

异常的关键字Exception

try,catch,finally,throw,throws关键字

7.1什么是异常，为什么要引入异常

*java程序运行时出错，java就抛出异常,程序立即终止（也可以说程序崩溃）

*java将错误信息封装在异常对象里抛出

*学会查看异常的信息：异常的名字，异常的信息，程序抛异常的位置

*java引入异常处理机制，是防止程序出错崩溃

7.2java的异常的分类

*java的抛出的错误用异常类来表示,java拥有一个异常体系（有许多异常类，并且相互之间具有关系）

*java里面的所有异常都是Throwable的子类

*java虚拟机的异常是Error的子类，一般不需进行处理(因为没法进行处理)

*除Error之外还有Exception，Exception分为两类：RuntimeException(运行时异常)，被检查异常（除了RuntimeException都是被检查异常）

*RuntimeException(运行时异常，可以不捕获或声明抛出，编译不会报错,一般是控制不当造成的)，可检查异常（必须捕获或声明抛出，这类异常通常需要检测并处理，一般使用资源时造成的）

*几个常见的异常：NullPointerException(空指针),IndexOutOfBoundsException(索引越界),SQLException(数据库异常),IOException(文件异常)

7.3异常的处理方式

*使用try,catch,finally进行处理

*不处理，使用throws,throw交给别人来处理

7.4try,catch,finally中程序的运行过程

*尝试执行try里面的语句

*一次运行当中最多执行一个catch块，如果没有抛出异常，catch块不执行

*finally总会执行，不管有没有抛出异常

*如果try块里面有return语句，finally也会执行

7.5区分RuntimeException与被检查异常

*RuntimeException不需要捕获或声明抛出（但是如果你捕获或声明抛出也不会有错）

*被检查异常必须要捕获或者声明抛出

8.数组

数组是引用类型，有长度length的属性

声明，创建，赋值

*数组声明时要指定数组元素的类型，数组的维度，不需要指定数组的长度，如：int[] a;(a是引用)

*数组的创建必须new关键字，并且必须给出数组的长度;new int[5]

*如果数组的类型是引用类型的数组，数组里面保存的是引用，而不是对象本身

New int[] { 1,3,4,5}

{1,4,5,6}

数组的常用操作类

Arrays提供了数组的常用操作的方法（这些方法都是静态的）

*排序：sort

*返回数组的字符串表示：ToString

二维数组

*二维数组的内存分析

*数组的拷贝使用System.arrayCopy方法

9.常用类

常用类:lang包不需要导入，其他的包都需要

1.Object:所有类的根类

*对象的标识：hashCode()

*对象的信息:toString()，默认情况下返回对象类型@地址信息

*对象是否一样：equals,默认情况下根据地址比较相等。==比较的是对象的地址，而equals在语义上提供相等的含义

*重写equals与toString方法，参照Money类

2.String:不可变字符串，类，继承Object

*String重写toString，返回字符串的类容。重写了equals根据字符串的内容进行比较

*字符串常量"1234"与new String("1234")。常量只有一个，new String（）每new一次就一个新的对像\

*字符串的不变性,字符串一旦创建，内容不能改变

*字符串的常用操作

*字符串的长度：length

*搜索一个字符串:indexOf()

*字符串的字串:substring(3，8)

*取得指定位置的字符:charAt(8);

*判断字符串以什么开头(结尾):startsWith(),endWith()

*改变字符串的大小写,toUpperCase(),toLowerCase()

*去掉字符串两边的空格：trim()

*替换字符串里面的某些内容:replace("")

*分割字符串：

StringBuffer:字符串缓冲，可变字符串，提供对字符串进行更改的方法(其他的方法基本与String类似)

*从StringBuffer得到String

*追加append（"abc"）;

*在字符串中间插入insert(3,"插入的字符串‘)

*删除字符串delete(3,6);//不包括6

包装类：提供与字符串之间的转换。Integer是int类型的包装类

Math类：提供数学上的常用操作，注意：里面的方法都是静态的

Random：随即类，产生随机数，另外Math.random()也能产生0～1之间的随机数

日期：Date,SimpleDateFormat(日期格式化) ,日历Calendar

获得控制台输入：

*Scanner sc = new Scanner(System.in);

*String str = sc.next();

10.集合框架

集合框架:概念上分为：Set(数学集合)，List（列表），Map（字典）

1.Collection接口，Iterator接口

*Set,List继承Collection，采用Iterator进行迭代(参考testCollection)

2.Set:元素不能重复，没有顺序

*HashSet:根据hashCode判断对象是否重复(重写equals和hashCode)

*TreeSet:里面的元素按顺序排列（元素必须实现Comparable接口）

2.List：元素能够重复，有顺序即索引位置，在Collection的基础上提供了按照索引位置进行操作的方法

*ArrayList:内部使用数组实现list

*LinkedList：在List的基础上提供了对首，尾元素进行操作的方法:入getLast（），addFirst(Object o)

*数组，AarryList，LinkeList有区别

3.map：键值对的集合，key不能重复，value可以重复

*两次put同一键，后面一个会覆盖前面一个

*遍历map的方式：先取得keySet，或者entrySet，再用Set的方式(Iterator)进行遍历

4.泛型：List<Integer> list = new ArrayList<Integer>

*存入的元素只能是指定类型,如：<Integer>

*取出来不需要强制转换,自动是指定类型，如：<Integer>

5.List的常用操作类Collections，不同于Collection，提供对List的排序，随机排列，倒序的方法

*Arrays使用在数组里面，提供对数组的常用操作，跟Collections有相似之处，

6.Comparable接口

*compareTo()

*如果需要进行排序(Collections.sort())，或者放到排序的集合里面(TreeSet,TreeMap),必须实现Comparable接口

11. JDBC

JDBC:java操作数据库的一组API(注意模仿)

1.JDBC驱动方式：

*JDBC-ODBC桥驱动（必须先建立数据源,性能比较低，不推荐使用）

*JDBC纯驱动：必须把JDBC的jar包加入到构建路径,一般使用JDBC纯驱动

2.JDBC操作数据库的流程

*使用Class.forName("")加载驱动程序

*使用DriverManager.getConnection（）获得Connection(连接)\

*使用Connction创建语句（语句有Statement,PreparedStatement）

*执行语句

*关闭Connection

3.执行数据库操作在JDBC分为两种

*更改数据库:executeUpdate(),返回所影响的数据库的行数。包括insert，update,delete

*执行查询：executeQuery(),返回结果集ResultSet。包括select

4.ResultSet的常用操作：

*ResultSet代表查询出的结果集，并且包含游标的概念

*ResultSet.getMetaData可以取得每一列的元信息：列名，列的类型，列的长度

*rs.next()使得游标往下移一行，并且返回是否还有下一行的boolean值

*rs.getXXX可以取得游标当前所指向的行里面的信息

*在只进的ResultSet里，取数据不允许倒退

*常用遍历结果集的方式:while(rs.next()) {  rs.getString(1) }

5.PreparedStatement

*可以对sql语句里的占位符进行设值setXXX

*执行executeUpdate()时不需要传sql语句，因为在创建PreparedStatement的时候就指定了sql语句

*注意PreparedStatement与Statement

6.使用事务的方式

*禁止自动提交：设置Connection.setAutoCommit(false);

*在最后手动提交：Connection.commit();

*可以在数据操作中捕获异常，一旦捕获异常，使用Connection.rollBack();

7.批处理sql

*对于一个语句来将，可以使用addBatch（）添加多个sql语句

*可以使用executeBatch一次执行所有加入的sql语句

8.建议大家使用Dao这中方式访问数据库

*实体类

*实体类的DAO

9.建议大家使用DBUtil管理取得连接与关闭连接

12.图形-布局，常用Swing组件

图形用户界面（Swing常用组件，布局管理器，事件模型，绘图）

1.AWT与Swing

*AWT是重量级的组件,Swing是轻量级别组件,Swing是从awt的基础上发展过来的

*swing依然使用awt里面的布局与事件模型

*组件：每一个界面元素都称为一个组件，如按钮，文本框

*容器的概念：可以容纳其他元素的组件，通过add()往容器里面加入组件，每一个容器都可以设置自己的布局管理器(Layout)

2.常用组件

*框架：JFrame（有一个默认的内容面板）,一般来将，所有的其他组件都放在JFrame的默认面板上。通过JFrame.getContentPane()获得默认内容面板

*面板：JPanel

*标签：JLabel

*文本输入框：JTextField

*文本域(多行文本):JTextArea

*单选按钮:JRadioButton

*复选框：JCheckBox

*下拉列表：JComboBox

*按钮:JButton

3。布局管理器（流布局Flowlayout,边框布局BorderLayout,网格布局GridLayout）

*使用setLayout(new FlowLayout())方法设置容器的布局管理器

*Flowlayout:当拖动界面的时候，元素的大小不会改变，仅改变元素的位置，可以指定居中对齐，左对齐，右对齐等对齐方式

*BorderLayout：将界面分为东西南北中五部分.:元素大小会发生改变，但是相对位置不变。除中间区域（自动填充）之外，区域里面不加组件，默认大小为0.如果往区域里加入多个组件，只显示最后添加的组件。

*GridLayout:每个网格的大小相等，位置不发生改变，大小随容器大小变化而变化

13.图形-事件处理，绘图

图形用户界面

1.内部类:在一个类的里面再定义一个类称为内部类

*内部类可以访问外部类的所有的成员变量与成员方法

*如果想在外部实例化内部类，必须使用全名:外部类.内部类

2.事件模型：

*java事件采用委托模型(授权模型),即事件源本身不处理事件，交给事件监听器来处理,因此需要把事件监听器绑定到事件源里面

*事件源，事件，事件监听器。事件有许多种，不同的事件使用不同监听器来处理

*事件触发后，系统自动调用事件处理方法（不需要手动调用事件处理方法），并传递事件信息作为方法参数

*事件编写步骤：1.实现监听器接口(完成事件处理方法)；2.实例化实现监并绑定到事件源

3.事件实现方式

*外部类

*内部类

14.多线程

线程：

1.线程的概念

*程序里面不同的执行路径，每一个执行路径称为一个线程

*对于单cpu来讲，某一具体的时刻，只会有一个线程在运行，但是CPU的速度非常快，表面上看起来是许多个线程并行执行

2.java中线程的创建与启动

*两种实现线程的方式:继承Thread，实现Runnable接口

*线程的启动：start.启动线程，运行线程的run方法，run方法运行完线程就结束(注意，start只在Thread里面有，start不同于run)

*注意一个Thread对象，只能一次调用start方法

*Thread与Runnable的区别：1：Runnable是接口，比Thread灵活（因为java只能单继承，可以同时实现许多接口）;2.一个Runnable对象可以启动许多个线程，线程之间共享对象（Thread不能共享对象）

3.线程的状态：new ,可运行，运行中，阻塞，死亡

4.线程的调度

*Thread.sleep,使该线程睡眠

*join：线程合并(结果类似与方法调用)

*yield:线程让出当前CPU，留给其他线程运行

*线程优先级:setPriority设置线程优先级

*后台线程:setDaemon,必须在线程运行前设置为后台线程.当所有的前台线程都结束了，后台线程自动结束

*线程可以指定名字，取得当前线程的方法Thread.currentThread();

5.线程同步

*synchronized:同一时刻，只会有一个线程执行synchronized代码块

6.线程间通讯

*wait(),notify(),notifyAll是Object类中定义的方法

*wait()：使得运行该代码的线程进入对象的等待池进行等待，线程进入阻塞状态，wait的线程一直阻塞，指导其他线程调用该对象的notify方法唤醒它。

*notify()：唤醒对象等待池中的一个线程，使得被唤醒的线程进入可运行状态，如果等待池中没有线程，notify什么也不做。

*notifyAll()：唤醒对象等待池中的所有线程

*wait(),notify,notifyAll都必须放在同步代码块里面(Synchronized代码块).

*wait()的线程会释放对象的锁，而Thread.sleep的线程不会释放对象的锁

7.线程安全的类：多线程的环境下使用类或者调用类的方法不会造成同步问题的类称为线程安全的类

*JDK1.1以前，java的集合框架中有一些线程安全的类：如Vector(被ArrayList代替),HashTable(被HashMap代替)

15. IO{C}16.{C}网络{C}17.{C}类与对象的生命周期18.补充知识点

代码书写规范

代码跟踪调试

有时候需要知道程序的具体执行过程，这时候跟踪程序很有用

跟踪调试程序

*设置断点

*调试，跟踪程序的运行

*程序的运行过程，变量的值

java基础知识点总结，是java学java学习必须要熟悉和掌握的，希望本篇博文对你学习有帮助

JAVA基础知识点总结（全集）