JAVA总结

第2天：
1.3第一个JAVA程序HelloWord.JAVA
1.3.2在DOS命令窗口编译执行
  javac 编译java源文件，生成对应的字节码.class文件
            java  执行字节码文件 
2.1关键字、标识符
2.1.2标识符的命名规范
            首位置   字母、$ 、_
  其他位置  字母、$ 、_、数字
2.1.3JAVA关键字


2.2进制转换
2.2.1二进制转换十进制
            2 -》 10 ： 2的n次方相加
            10 -》2 ： 除2取余，从后向前
  2.4变量名的命名规范
2.4.1JAVA中的数据类型
2.4.2基本数据类型
 byte   short   int   long   float   double  char  boolean 枚举
存储位置：栈内保存值
2.4.3引用数据类型
类、接口、数组
存储位置：栈内保存地址，堆内保存对象中的属性


  2.5基本数据类型有哪些，数据类型的取值范围
            Java为每一种基本数据类型提供了对应的封装类
            int  Integer  char  Charecter

2.7数据类型的转换
2.7.1自动类型转换
            数据类型兼容时，系统可以进行自动类型转换
Byte -> short -> int -> long -> double
2.7.2强制类型转换
(强制转换的数据类型 ) 表达式


表达式的结果数据类型：兼容性最高的那个类型
2.8运算符
2.8.2算术运算符  + - * / % ++ -- 
/  左右两边都是int，则结果int
% 左右两边必须是int
++、-- 前缀 先自加或自减，再参加其他运算
++、-- 后缀 先参加其他运算，再自加或自减
Int k=5, l=1;
Int x = (k++ )- (-- l); x=5




2.8.3赋值运算符 = += -= *= %= /=
            复合赋值运算符可以自动类型转换
            Short i =(short)10;  i+=8; 无语法错误   i = i+8； 语法错误
  Int a = 5;
      a*= 2+3;  a=25
2.8.4关系运算符  > >= < <= == != 结果boolean
2.8.5逻辑运算符  ! > && > ||
其中有短路运算符： &&    ||
2.8.6三目运算符  表达式1 ? 表达式2 ：表达式3
2.8.7字符串连接运算符 +
2.9表达式的值和类型
位运算符  
& 位与  | 位或 ^ 异或 >> 右移（带符号） >>>  右移（补0） << 左移


第3天：


2.10转义字符
       \n \t  \\  %%
2.11运算符优先级********只提（）优先级最高，++及—-的复杂运算
       ! >  算数 > 关系 >  && > ||
3.1什么是JAVA语句的执行结构
3.1.1JAVA语句有哪些结构
3.1.2顺序语句
3.1.3分支语句  if switch
3.1.4循环语句  for  while do-while
3.2If语句
3.2.1简单if语句
3.2.2复杂if语句
3.2.3if-else语句
3.2.4多重if语句
3.2.5嵌套if语句
3.3switch语句
3.3.3.1switch语句用法
switch作用在String上。jdk1.7以上(20151214本次新增)
【注】1）switch（）中表达式类型 string int兼容
      2） case 后面必须跟常量，或常量表达式
      3）case后的常量值不能重复
     4）break的使用
3.3.3.2switch语句与if语句的区别
           Switch 等值判断， if可以等值也可以范围
3.1什么是循环语句
3.2循环语句有哪些
3.2.1for循环语句
          For(  初值; 条件；变化 ){ }
      【注】for中三个表达式均可省略，但分号不能省略
            初值->条件 -> 循环操作 -》变化


###第4天
4.1循环
4.1.1while循环语句
           For while 都是先判断后执行
  初值;
While(条件){
变化
}
4.1.2do-while循环语句
Do{
}while();
         先执行后判断
4.2跳转语句
4.2.1break语句的使用
结束循环
嵌套循环中使用break，终止所在循环的操作
4.2.2continue语句的使用
            结束本次循环，继续下一次循环的判断
4.3比较while和do-while的区别 


第5天
7.5面向对象的设计思想
7.5.1什么是面向对象

7.6面向对象和面向过程的区别
7.6.1面向对象
7.6.2面向过程
7.6.3区别总结

7.7类与面向对象的关系
7.7.1类的定义
public/ 默认 abstract/final class 类名  { 
private 属性；
方法
  } 
7.7.2对象的定义
  new  类名（）；
7.7.3类中成员变量的定义—变量的分类
7.7.4类中方法的定义
5.1 什么是方法
5.1.1 方法（函数）
                [ public / 默认/protected/ private ] [ static/ final/ abstract /synchronized ] 方法名( 参数列表 ){ }


5.1.2 方法中的参数
5.1.2.1形参： 定义方法时，参数列表中的参数
5.1.2.2实参：调用方法时，参数列表中的参数
通过形参是否能改变实参的值？
形参类型是基本数据类型，则无法修改
形参类型是引用类型，则可以修改
5.2 方法的声明和调用
5.2.1 声明方法的格式
5.2.2 调用方法的格式
通常方法通过对象. 方法名( 合法实参)
如果定义方法时使用了static，则可以（推荐）使用类名.方法名（合法实参）


2.3.4变量的作用域
7.8对象的创建以及内存分析

第一周测试(16:00--17:00)






第6天：(堆栈内存分析，可以在此处讲)
上午
更换开发工具：eclipse
7.4开发工具的介绍
7.4.1工作空间的概念
7.4.2工程的概念以及命名规范
7.4.3包的概念以及命名规范
作用：1）便于维护和管理，通过功能分类
      2）防止重名类冲突问题
7.4.1创建包  package
7.4.2导入包  import
Package 包
Import 包.类;
Class 类名{
}
7.4.3创建包的命名规范
7.4.4常用快捷键的介绍
7.4.5工程的导入导出
6.1一维数组的创建
6.1.1数组的声明
数据类型[]  数组名;
 数组名 = new 数据类型[大小];(推荐)


数据类型 数组名[] = new 数据类型[大小];


创建数组的同时，赋值, 无需指定数组大小，有几个值数组大小就是几
数据类型[]  数组名 = { };
数据类型[]  数组名 = new 数据类型[] {}  


数组操作注意有数组越界异常IndexOutOfBoundsException


6.1.2数组的创建
6.2数组的赋值
6.2.1静态赋值
6.2.2动态赋值 ： 通过下标访问数组元素，并赋值
6.3数组的访问
6.3.1通过下标访问指定元素
6.3.2循环访问
6.3.3增强for循环（使用该循环读取数据, 不要修改）
For(  数据类型 变量  :   数组名/集合名  ){
可以通过变量访问数组或集合中的每一个元素
}
6.4数组的排序
6.4.1冒泡排序(  临近2个元素比较  )
//循环几趟
For（int i=0; i < 个数-1; i++）{
//每一趟比较几次
For(int j=0;  j<个数-1-i; j++ ){
//交换的条件
If(  arr[j]   arr[j+1] ){
交换
}
}
}






********
6.4.2选择排序
6.4.3插入排序——建议删除，或者留成作业。
********
6.5数组的查找
6.5.1顺序查找
6.5.2二分法查找


6.6Arrays工具类
操作数组的类，提供了方法sort() 。。。。
6.7可变参数



###第7天：


7.1二维数组的创建
7.1.1数组的声明
数组类型[][] 数组名 = new 数组类型[ 大小 ][ 个数]
支持二维不一致
7.1.2数组的创建
  7.2数组的赋值
7.2.1静态赋值
7.2.2动态赋值
7.3二数组的访问
7.3.1通过下标访问指定元素
7.3.2循环访问数组
7.3.3增强for循环
下午：
练习或项目










第8天：
面向对象
封装  私有属性 公有方法 （数据的安全性）
继承  子类继承父类非私有的成员（属性和方法）
多态  重载 重写

7.9方法的重载
      同一类  方法名相同 参数列表不同（数量 类型 位置）
7.10构造方法的定义
  7.10.1构造方法的定义
作用:1 ) 创建对象  2）并初始化对象
访问修饰  类名( 参数列表 )  {    }
构造方法没有返回类型
  7.10.2构造方法的调用
            通过new 调用构造方法


  7.10.3构造方法重载
8.1封装性


8.2this关键字
this 定义类时，指本类的对象 
8.2.1this.属性：访问本类的成员属性
8.2.2this.方法：访问本类的成员方法
8.2.3this()：访问本类中的构造函数


8.3static关键字
8.3.1静态代码块 （存在静态代码块的类，被jvm编译后，执行改代码块）
static{
代码
}
8.3.2静态属性
            static 数据类型 属性名;  ( 当前属性的所有权归属于类，而不是某个对象 )
  
8.3.3静态方法
访问修饰 static 返回类型  方法名(  参数列表 ){ }
1) 当前方法的所有权归属于类，而不是某个对象
2) 在static方法中只能使用static的成员


8.4方法参数的传递(重点)
8.4.1参数类型：基本数据类型
在方法被调用时，形参保存实参的值，所以如果通过方法是不会改变实参的值
void add( int a){
a= a+10;
}
Int b=100;
Obj.add(b);   b=100


8.4.2参数类型：引用数据类型
在方法被调用时，形参保存实参的地址，所以如果通过方法可以改变实参的值
Class Test {   int  b ;  }
void  add ( Test t)  {
t.b = t.b + 10;
}
Test a= new Test();  a.b=100;
Obj.add (a) ;    a.b = 110




第9天
9.1继承
9.1.1继承的概念
一个类在另一个类基础上进行扩展，我们可以考虑使用继承
9.1.2类的继承的使用
extends  单一继承
9.2super关键字
  父类的对象
   super() 父类的构造方法，子类的构造方法中
   super.方法() 父类的普通方法


9.3继承中的构造方法
创建子类时，会先调用父类的构造方法，再调用子类的构造方法
在不指定的情况下，jvm会自动调用父类不带参数的构造方法
可以使用super( 参数 )指定调用子类构造函数之前，调用父类的哪一个构造方法，但是要注意super() 永远是构造方法的第一个句话
9.4访问权限
9.4.1 private
9.4.2 default
9.4.3 protected
9.4.4 public
本类 同一包 子类 任何类
public √ √ √ √
protected √ √ √
默认 √ √
private √


9.5方法重写
9.5.1方法重写的规则
1）子类中 重写父类的同名同参数的方法
2）访问权限不能小于父类的访问权限
3）子类不能抛出比父类更大的异常


9.4final关键字
9.4.1 final修饰的类  不能被继承
9.4.2 final修饰的方法 不能被重写
9.4.3 final修饰的属性及常量的概念 不能被修改
9.5抽象类和抽象方法
         抽象方法：用abstract修饰的方法，没有方法体，必须在抽象类中
抽象类： 用abstract修饰的类，可以包含抽象方法
抽象类一旦被继承，则其子类必需实现父类中的抽象方法，如果子类没有实现抽象方法，则子类也要用abstract修饰




###第10天
10.3Object类
10.3.1 equals()方法
如果要比较对象，则可以重写此方法
10.3.2 hashCode()方法
10.3.3 getClass()方法
返回对象所属的Class
10.3.4 toString()方法
            直接打印对象，返回的字符串
wait（） 当前线程让出cup
notify() 随机唤醒被wait()的线程
notifyAll() 唤醒所有被wait()的线程




12.2常用类（以大练习的方式讲）
12.2.1基本数据类型的包装类
12.2.1.1基本数据类型与其包装类
int  Integer  char  Character
12.2.2.2数据的装箱和拆箱
装箱： 值类型 - > 引用类型
拆箱：  引用类型 - > 值类型 


12.2.2Date类  （日期）
12.2.3Calendar类 （日历）
12.2.4SimpleDateFormat类 （日期格式）
12.2.5Math类 （数学  所有方法static）
12.2.6Random类（验证码的实现）（随机数）
12.2.7Runtime类 （运行时）
12.2.8System类 （系统类）
13.1字符串
13.1.1String类 （固定）
13.1.2StringBuffer类（可变  线程安全  对字符串反复修改推荐使用）
13.1.3StringBuilder类 （可变  线程不安全）
13.2正则表达式
  “” . match( 正则表达式 )
12.3枚举的简单使用
         Enum 定义一个范围，只能定义的值范围内选择


第11天
10.1接口
10.1.1 接口的概念
定义一组规范（方法声明）
10.1.2 接口的使用
10.1.2.1 接口的声明语法
Interface  接口名 { }
10.1.2.2 接口的实现类
Class 类名 implements 接口名 {}
10.1.2.3 接口的使用规则
                1）只能有方法的声明，不能方法体，方法的默认public，只能是public
2） 只能有常量属性
10.1.2.4 接口的使用用途
实现多态



10.2对象转型
10.2.1对象的多态性
10.2.2对象的向上转型
10.2.3对象的向下转型



10.4多态
10.4.1什么是多态
方法的多种形态
10.4.2多态的体现 （重载 重写）
10.4.3对象的多态性
10.4.4instanceof关键字
Animal an1 = new Dog();
Animal an2 = new Cat();

List<Animal> ans = new ArrayList<Animal>();
ans.add(an2);
ans.add(an1);

for (Animal animal : ans) {
animal.show();
if(animal instanceof Cat){
Cat c = (Cat)animal;
c.eat();
}else if(animal instanceof Dog){
Dog d = (Dog)animal;
d.dark();
}
System.out.println("---------------");
}




13.3集合的概念以及集合框架介绍
13.3.1集合的概念
13.3.2集合的框架结构介绍
13.3.3集合与数组的对比
13.4Collection接口
13.4.1集合对象的创建
13.4.2Collection中常用的方法
13.5泛型的使用
13.5.1泛型应用在集合上


1、（List   Set）  Map  常用实现类、常用方法（添加、移除、获得元素）、遍历集合
List   存放顺序和读取的顺序一致，数据可以重复
Set    存放顺序和读取顺序不一致，数据不可以重复
Map    存放键值对，要求键不能重复，值可以重复


2、List  add()  remove()  get()  for(下标) foreach()
   Set  add()  remove()  Iterator迭代器 foreach()
   Map  put()   remove()  get(key)  foreach()(遍历key集合或者value集合  )



13.6Iterator迭代器
13.6.1迭代器的工作原理
13.6.2迭代器的使用
     Iterator keyIter = 集合.iterator();
while(keyIter.hasNext()){
Object obj = keyIter.next();
}


第12天


14.1List接口
14.1.1List接口的存储特点
14.1.2List接口的实现类
14.1.2.1ArrayList实现类，实现原理( 适用于访问 )
14.1.2.2LinkedList实现类，实现原理  适用于删除和添加
14.1.1.3Vector  线程安全
14.1.2.4Stack   模仿栈的数据结构：先进后出
14.1.2.5ArrayList与LinkedList，Vector三种实现类存储的比较




14.2Set接口
14.2.1集合的存储特点
14.2.2HashSet的实现原理
14.2.2.1重写hashCode()
14.2.2.2重写equals()
14.2.3LinkedHashSet(添加)




###第13天：

15.1Map接口概述
15.2Map接口的常用方法：重点
15.3Map接口的常用实现类
15.3.1HashMap
15.3.2HashTable
15.4Map.Entry
15.5Collections：工具类
15.6集合的嵌套：List<Map>格式
15.7泛型应用在类上
15.7.1泛型应用在方法上
15.8集合的总结
练习：





第14天
12.1异常
12.1.1异常的概念
12.1.2异常的分类
12.1.3异常的处理方式
12.1.3.1捕获异常：try..catch..finally语句
try{  }  可能产生异常的代码
catch( 异常类型  名 ) {   }  产生异常后要做的操作
finally{   }  无论异常是否存在，都要执行的操作
12.1.3.2抛出异常：throws和throw
             throws 异常类型   ，使用在方法的声明部分，声明某个方法会产生某种类型的异常  
throw 异常对象;   抛出一个异常
12.1.4自定义异常
           自定义异常类必须要继承Exception 或Exception的子类
1）try不能单独使用，必须至少有一个catch或finally与其一起使用
2）catch必须有try一起使用
3）finally必须有try一起使用
Try-catch  try-finally   try-catch-fianlly
4）try可以跟多个Catch一起使用，但注意catch（）中的异常类型顺序必须子类到父类






16.1File类
16.1.1 File类作用
对文件进行操作
16.1.2 File类的构造方法
new File（“文件路径”）
new File(“路径”,”文件”)
16.1.3 File类文件属性方法


16.1.4 使用File类对文件进行操作
            
16.1.5 使用File类浏览目录中的文件和子目录
16.1.6 递归算法***********
定义一个方法，在方法中自己调用自己，并在某一个条件成立时结束调用


IO流：
方向：输入和输出
数据大小：字节和字符
功能：目标和过滤


第16天：
16.6字符输入流:
16.6.1Reader类的常用方法
16.6.2Reader类的子类:FileReader
16.6.3FileReader构造方法和常用方法
16.7字符输出流
16.7.1Writer类的常用方法
16.7.2Writer类的子类:FileWriter
16.7.3FileWriter构造方法和常用方法
17.2字符缓存流
17.2.1字符缓存流构造方法
17.2.2字符缓存流的常用方法:readLine()，  newLine()  
17.2.3字符缓存流对文件进行读写
17.4转换流(重点掌握)
17.4.1InputStreamReader的构造方法
17.4.2InputStreamReader的使用
17.4.3OutputStreamWriter的构造方法
17.4.4OutputStreamWriter的使用
第17天：

18.1内存流（重点掌握）
18.1.1什么是内存流
18.1.2内存流的构造方法写入到内存和读取内存数据
18.1.3写入到内存和读取内存数据
18.1.4常用方法:toByteArray(), toString()


17.5打印流（了解）
17.5.1打印流构造方法
17.5.2打印流的常用操作:print()， println()
18.2RandomAccessFile类（了解）
18.2.1RandomAccessFile类的构造方法
18.2.2RandomAccessFile常用操作:skipBytes()  seek()
18.2.3常用方法: getFilePointer()  writerUTF()   readUTF()
18.2.4向文件中随机写入键盘文字


      对象流: 用来读取对象数据或者写入对象数据
      要求 被操作的对象的类，实现一个可序列化的接口


18.3IO流练习：截取mp3


第18天



11.1内部类
11.1.1成员内部类  在一个类中定义一个类
11.1.2静态内部类  在一个类中定义的类用static修饰
11.1.3匿名内部类  new一个接口时，直接实现其要实现的所有方法
11.2设计模式
11.2.1单例设计模式
只能创建一个对象
1)  该类的构造方法是私有的
2)  该类中有个自己类型的属性，并static
3) 有个static的方法，返回类型为自己类型
   public static 自己类型 newInstance(){
If(  属性 == null){
   属性 = new 自己类型();
}
return 属性;
    }
11.2.2简单工厂设计模式
创建不同类型的对象，但这些对象都继承同一个类或实现同一个接口


多线程
18.4进程的介绍
18.4.1进程的概念
18.4.2线程的介绍
18.5.1线程的概念
18.5.1进程和线程的关系以及区别
18.6多线程的实现
18.6.1继承Thread类
实现Runnable 完成run() 推荐使用
启动  new Thread( new 自定义线程()).start()
继承Thread 重写run()
        启动 new 自定义线程().start()


五中状态：创建 就绪 运行 阻塞 销毁

18.7线程的启动
18.7.1调用start()方法启动线程
18.7.2调用start()与调用run()的区别
19.1线程的常用方法
19.1.1线程的名称
19.1.2线程的睡眠
19.1.3线程的中断
19.1.4线程的停止






第19天
19.1线程的实现
19.1.1实现Runnable接口
19.1.2两种实现方式的比较
19.2线程的生命周期

19.3多线程访问临界资源时的数据安全问题
19.3.1synchronized关键字
19.3.2同步代码块
19.3.3同步方法  锁住this
19.3.4同步静态方法
19.3.5锁对象
19.3.6死锁
20.2线程池：添加
第20天  网络编程
21.1网络通信协议介绍
21.1TCP/IP协议
21.2IP地址和端口号
21.3基于TCP的网络编程
21.4Socket和ServerSocket
ServerSocket  端口号
Socket  服务器 端口号  通过流方式传输数据
21.2UDP编程(了解)


第21天：HTML+Servlet
22.1HTML：
22.1.1form表单
22.1.2get/post请求的区别
速度：get快
数据量：post多
安全性：post安全


22.2Servlet简介：
22.2.1什么是B/S和C/S结构
22.2.2什么是Servlet？
22.2.3Servlet的生命周期
22.2.4doGet与doPost方法的区别




第22天：HTTP访问
23.1URL类的使用
23.1.1什么是URL类
23.1.2URL的构造方法
23.3.3URL类的常用方法
23.2HttpURLConnection类简介（重点）
22.2.1简单介绍HttpURLConnection类
22.2.2HttpURLConnection的常用方法
23.3HttpURLConnection类的应用
23.3.1HttpURLConnection类的下载本地服务器资源
23.3.2HttpURLConnection下载网络资源
23.4接口回调
23.4.1接口回调结合多线程的应用
23.4.2接口回调在HttpURLConnection的网络下载中的应用


23.5HttpClient类的应用（了解）
23.5.1HttpClient类的Get方法应用
23.5.2HttpResponse类的作用
23.5.3HttpClient类的Post方法应用
23.5.4HttpEntity方法的应用
23.5.5EntityUtils类的使用




第23天：json解析（重点）
24.1JSON解析简介
24.1.1什么是JSON
24.1.2JSON与XML之间的比较
24.1.3JSON解析在网络中的应用
24.2JSON的数据表示
24.2.1键值对的对象表示 {}
24.2.2数组的表示 []
24.3JSON解析
24.3.1一个对象的JSON解析
24.3.2多个对象的解析
24.3.3复杂对象的解析
24.3.4将集合转成JSON字符串
24.4官方JSON解析
24.5Gson解析
24.6fast-json解析
24.7官方JSON解析方式与Gson或者是Fast-json结合




第24天：
25.6反射（2课时）
xml解析
25.1XML简介（4课时）
25.1.1什么是XML
25.1.2XML语法结构
25.1.3XML元素定义
25.1.4XML属性使用
25.1.5自定义XML文件


25.2PULL解析
25.2.1PULL解析原理
25.2.2PULL解析XML文件
25.2.3网络XML文件解析