Java复习笔记(一)

Java基础语法

1.预习

1. 计算机硬件 --冯诺依曼结构
2. CPU, Memor(内存) 主板 IO设备
3. 输入设备–存储器(运算,控制器)–输出设备
4. 计算机软件: 系统软件与应用软件–人机交互
5. Dos命令
6. Java 三大特性:

   简单性 面向对象 可移植性 高性能  分布式 动态性
   多线程  安全性  健壮性

7. JDK JRE JVM

 JDK:  Java Development Kit
 JRE:  Java Runtime Environment
 JVM: Java Virtual Machine

8. Java 开发环境搭建

 idea , JDK8, 环境变量 JAVA_Home

10. Java 程序运行机制

编译型    中文-->英文   效率更快  C++
解释型    用一次,执行一次  Java  javaScript
程序运行机制  字节码--字节码校验--解释器

11. IDEA安装开发

配置  快捷键   插件,  编码校验

2.Java基础知识点

1.注释

单行,多行,文档   平时写好规范  
 Empty空文档    有意思的注释

2.标识符

名字    关键字    命名规则   大小写敏感

3. 数据类型

1.强类型(Java)    弱类型 (JS)  
2.数据类型(基本类型,引用类型)
3.进制(二,十,八,十六)    浮点数运算安全问 
4.BigDecimal计算
5.字符 -->数字  ASCII码   所有字符本质还是数字
6.编码 Unicode  2字节 0~65536
7.转义字符 \t  制表符   \n  换行
boolean  flag=true;    if(flag==true){}  简写if(flag){}

4.类型转换

byte,short,char->int->long->float->double
强制转换    自动转换

5.变量

必须声明其类型   基本存储单元  变量名, 类型,作用域    变量可以基本类型,引用类型
变量名必须是合法标识符

命名规范:
 1. 所有变量,方法,类名:见名知意
 2. 类成员变量:首字母小写+驼峰规则
 3. 局部变量:首字母小写+驼峰规则
 4. 常量:大写字母+下划线
 5. 类名:首字母大写+大写驼峰原则
 5. 方法名:首字母小写和驼峰原则

6.运算符

1. 算术运算符:+ ,-, * ,/ ,% ,++, --
2. 赋值运算符: =
3. 关系运算符:>, < ,>=, <= ,==  ,!= ,instanceof
4. 逻辑运算符: &&, ||, !
5. 位运算符: &,|,^,~,>>,<< ,>>>
6. 条件运算符: ?:
7. 扩展运算符: +=,-=,*=,/=
8. 三元运算符 ? :
9. 优先级()

7.包机制

1. 文件夹 package import
2. 公司域名做为包名

8.Java DOC

用来生成自己的API文档  通过包名
1. @author
2. @version
3. @since
4. @param
5. 命令javadoc -encoding UTF-8 -charset UTF-8 Doc.java

9.Scanner对象

1. 实现程序和人之间交互
Scanner scanner=new Scanner(System.in);
2. next() 
  2.1. 一定要读取到有效字符后才可结束
  2.2. 对输入有效字符之间遇到空白 ,将会自动去掉
  2.3. 只有输入有效字符后才将其后面输入的空白作为分隔符或者结束符
  2.4. next() 不能得到带有空格的字符串
3. nextLine() 
  3.1 作为 Enter为结束符
  3.2 可以空白
4. scanner.close(); 关闭

10.顺序结构

11.选择结构

1. if 单选择结构
2. if 双选择结构  if(布尔表达式){} else{}
3. if 多选择结构  if(布尔表达式){} else{} 重复
4. switch 多选择 switch(表达式)  case value:    break;  表达式 long不能使用  JDK1.7后支持String   反编译class: 表达式的hashcode进行比较
5. while循环  while(布尔表达式)
6. do...while循环   do...while(布尔表达式)至少执行一次
7. for循环 for(初始化;布尔表达式;更新){ }
8. 增强for循环  for(声明语句: 表达式) 数组和集合
9. break 退出循环  continue 跳过本次循环

12.Java方法

1. System.out.println()调用系统out的一个方法
2. 实现某个功能的语句块,解决一类问题 被创建,被引用
3. 修饰符: 可选,定义方法的类型
4. 返回值类型:  可能有返回值 或无返回值 void
5. 方法名: 方法的实际名称,方法名和参数表共同构成
6. 参数类型:
 	 形参: 用于接收外界输入的数据
	 实参: 调用方法是实际传给方法的数据
7. 方法体:包含具体的语句,定义该方法的功能.
8. 方法的重载:相同名称,参数不同 
9. 命令行传参: 运行时传递给它消息 比如main函数
	for(int i=0;i<args.length;i++){sout(args[i])) javac com.msb...
10. 可变参数 (int...i)一个方法只含一个,必须是最后一个参数
11. 递归  阶乘  边界条件:边界  前阶段:  返回阶段n*(n-1) 方法--栈机制--内存压力

13.数组

1. 数组:有序集合  不可变, 下标访问   同类型(基本/引用) 存放堆中
2. 数组声明: int num[]; int[] arrays={...};
3. 内存分析:
   堆: new对象和数组 ,可被所有线程共享,不存放别的对象引用
   栈: 基本变量类型(包含基本类型具体数值),引用对象的变量
   方法区:包含所有class和static变量,线程共享
4. 数组边界: 元素相当于对象的成员变量,长度固定
5. 数组使用: for循环数组,   
6. 多维数组: 数组嵌套
7. Arrays工具类--静态一些方法  可以使用类名进行调用, 常用功能: 数组赋值(fill ) 数组排序(sort,返回排序的数组) 比较(equals) 数组查找(binarySearch)
8. 冒泡排序--八大排序
   两层循环,外层冒泡轮数,里层比较大小;
9. 稀疏数组

14.面向对象

1. 物以类聚,分类的思维,分类进行思考,最后细节面向过程, 抽象 三大特征 封装,继承(单继承),多态(多继承)
2. 面向对象的本质:以类的方式组织代码,以对象的组织封装数据
3. 认识的角度考虑:先有对象后有类,是具体的事物,类是抽象的,是对对象的抽象.
4. 从代码运行角度考虑,是先有类后有对象,类是对象的模板.
5. 创建与初始化对象: new关键字  分配内存,,对类中构造器的调用(必须和类名相同)
6. 封装: 数据的隐藏  高内聚,低耦合 高内聚:累的内部数据操作细节自己完成,低耦合:暴露少量方法给到外部访问---属性私有,get/set
7. 继承: 本质:对某一批类的抽象.从而实现对现实世界更好的建模, 只有单继承   类和类之间的关系,还有依赖,组合,聚合 子父关系:is a Object类 super 方法重写
8. super与this的区别: 
   super:调用父类构造,构造方法第一个,只能出现子类方法中,super和this不能同时调用构造方法!
   this: this调用者这个对象,super调用父类的对象的引用, this() 本类的构造 super() 父类的构造
9. 重写: 需要有继承关系,子类重写父类方法
    1. 方法必须相同
    2. 参数列表必须相同
    3. 修饰符:范围可以扩大但不能缩小
    4. 抛出异常,范围可以被缩小
10. 多态:  条件:继承+子类重写父类方法+父类引用指向子类对象  注意: 多态是方法的多态,属性没有多态性
    多态注意事项: 
    		 1. 多态是方法的多态,属性没有多态
    		 2. 父类和子类,有联系 类型转换异常
11. instanceof 类型转换(引用)
12. static关键字  静态只能调用静态  static{静态代码块}
13. 抽象类: abstract 修饰符可以用来修饰方法,也可以修饰类,不能new 对象,用子类继承 ;抽象方法只有声明,没有实现,子类实现;
14. 接口: 只有规范,定义一组规则, 如果你是天使,就必须能飞,  接口本质是契约,比如法律,需要遵守  OO的精髓,是对对象的抽象   面向接口编程
	抽象类: 具体实现和规范(抽象方法)都有   
	普通类: 只有具体实现  

15.异常机制

1. Throwable  异常的超类
2. Exception   有一个重要的子类RuntimeException 运行时异常  由程序逻辑造成
   ArrayIndexOutOfBoundsExeception NullPointException ArithmeticException
3. Error  错误致命的, java虚拟机会终止程序 Java虚拟机运行错误  OutOfMemoryError  NoClassDefFoundError 
4. 异常处理机制  try catch finally  throw throws
5. 自定义异常类 继承Exception 
   1. 创建自定义异常类
   2. 方法通过throw 关键字抛出异常对象
   3. 当前抛出异常方法中处理异常 try-catch,否则,方法声明throws 指明要抛出给方法调用者的异常
   4. 在出现异常方法的调用者中捕获并处理
6. 实际应用中的经验总结:
   1. 处理运行时异常时,采用逻辑去合理规避,同时辅助try-catch处理
   2. 多重catch块后,可以加一个catch(Exception)来处理可能被遗漏的异常
   3. 对不确定的代码,也可以try-catch
   4. 尽量去处理异常,切忌只简单调用printStackTrace()去打印输出
   5. 具体如何处理异常,根据不同业务需求和异常类型去决定
   6. 尽量添加finally语句块去释放占用的资源

16.注解

1. Annotation的作用: 
    1. 对程序作出解释
    2. 可以被其他程序读取  @注释名
2. 可以附在 package,class,method,field等上面使用
3. 内置注解:
    1. @Override 只适用于修辞方法,表示一个方法声明打算重写超类中的另一个方法声明
    2. @Deprecated 过时的,不推荐使用
    3. @SuppressWarnings("all") 警告信息
4. 元注解:只负责注解其他注解 4个标准
   @Target 注解的使用范围
   @Retention 表示需要在什么级别保存该注释信息,描述注解生命周期 Source<Class<RUNTIME
   @Document 被包含在javadoc中
   @Inherited 子类可以继承父类中的该注解
5. 自定义注解: 使用@Interface自定义注解 
   格式 public @ interface 注解名(定义内容)
   1. 其中一个方法实际上声明了一个配置参数
   2. 方法的名称就是参数的名称
   3. 返回值类型就是参数的类型(返回值只能是基本类型Class,String,enum)
   4. 可以通过default来声明参数的默认值
   5. 如果只有一个参数成员,一般参数名为value
   6. 注解元素必须要有值,我们定义注解元素时,经常使用空字符串,0作为默认值.

17.反射

1. 静态vs动态语言 运行时代码可以根据某些条件改变自身结构  
2. Java Refelecion 被视为动态语言的关键,反射机制运行程序在执行期,借助Reflection API 取得任何类的内部信息,并能直接操作人员对象的内部属性及方法
 Class c= Class.forName("java.lang.String");
 加载完-->堆内存产生一个Class类型对象(包含完整的类打的结构信息)-----就像一面镜子,透过镜子看到类的结构,称之为反射
  2.1. 正常方式: 引入包,类名称-->new实例化--取得实例化对象
  2.2. 实例化对象-->getClass()方法-->得到完整的包类
3. Class类:  对象照镜子后可以得到信息,某个类的属性,方法,构造器,某个类到底实现了哪些接口
   3.1. Class 本身也是一个类,Class对象只能由系统建立对象
   3.2. 一个加载的类在JVM中只会有一个Class实例
   3.3. 一个Class对象对应一个加载到JVM中的一个class文件
   3.4. 每个类的实例都会记得自己由那个Class实例所生产
   3.5. Class类是Reflection的根源,针对任何想动态加载,运行的类,唯有先获得相应的Class对象
4. 哪些类型可以有Class对象
   4.1. class 外部类,成员内部类,静态内部类,局部内部类,匿名内部类
   4.2. interface 接口
   4.3. [] 数组
   4.4. enum: 枚举
   4.5. annotation: 注解@interface
   4.6. primitive: 基本数据类型
   4.7. void
5. 类的加载与ClassLoader的理解
   5.1. 加载:将class文件字节码内容加载到内存中,并将这些静态数据转换成方法,然后生成一个代表这个类的java.lang.Class对象
   5.2. 链接: 将Java类的二进制代码合并到JVM运行状态之中的过程.
     a. 验证: 确保加载的类信息符号JVM规范,安全
     b. 准备: 正式为类变量,分配内存并设置类变量,默认初始值的阶段,将在方法中分配
     c.解析:虚拟机常量池内的符号引用(变量名)替换为直接引用地址的过程
   5.3. 初始化:
     a. 执行类构造器方法的过程,该方法是由编译期自动收集类中所有类变量的赋值动作和静态代码块中的语句合并产生的.
     b. 当初始化一个类的时候,如果发现其父类还没有进行初始化,则需要先触发其父类的初始化.
     c. 虚拟机会保证一个类的<clinit>()方法在多线程环境中被正确加锁和同步.
6. 什么时候会发生类初始化?
   6.1 类的主动引用(一定会发生类的初始化)
     a.当虚拟机启动先初始化main方法所有的类
     b.new 一个类的对象
     c.调用类的静态成员(除了final常量)和静态方法
     d.使用java.lang.reflect包的方法对类进行反射调用
     e.当初始化一个类,如果父类没有被其初始化,则初始化它的父类
   6.2 类的被动引用(不会发生累的初始化)
   	 a. 当访问一个静态域时,只有正在声明这个域的类才会被初始化,当通过子类应用父类的静态变量
   	 b.通过数组定义类引用,,不会触发此类的初始化
   	 c.引用常量不会触发
7. 类加载器的作用: 将class文件字节码内容加载到内存中,并将这些静态数据转换成方法区的运行时数据结构,然后再堆中生成一个代表这个类的java.lang.Class对象,作为方法区中类数据的访问入口
8. 类缓存: 标准的JavaSE类加载器可以按要求查找类,但一旦某个类被加载到类加载器中,它将维持加载(缓存)一段时间,不过JVM垃圾回收机制可以回收这些Class类.
9. 获取运行时类的完整结构: 通过反射获取运行时类的完整结构 Field, Method, Constructor, Superclass, inferface ,Anotation
   实现的全部接口--所继承的父类---全部的构造器--全部的方法--全部的Field--注解 
10. 有了Class对象,能做什么?
   10.1 创建类的对象,调用Class对象的newInstance() 方法: 类必须有一个无参构造器 ,类的构造器的访问权限需要足够
   10.2 只要在操作的时候明确调用类的构造器,并将参数传递进去之后,才可以实例化操作.
     a. 通过Class的getDeclaredConstructor(Class...parameterTypes)取得本类的hiding形参类型的构造器
     b.向构造器的形参中传递一个对象数组进去,里面包含了狗仔中所需的各个参数
     c.通过Constructor实例化对象
11. 调用指定的方法: 反射调用类中的方法,通过Method类完成
    11.1 通过Class类的getMesthod(String name,Class...parameterType)方法取得一个Method对象,并设置此方法操作时所需要的参数类型
    11.2 之后使用Object invoke(Object obj,Object[] args)进行调用,并向方法中传递要设置的obj对象的参数信息
      a.Object 对应原方法的返回值,若原方法无返回值,此时返回null
      b.若原方法若为静态方法,形参可为null
      c.若原方法形参列表为空,则Object[]args为null
      d.若原方法声明为private,则需要在调用此invoke()方法前,显示调用方法对象的setAccessible(true)方法,将可访问private方法
12. 反射操作泛型
   12.1 Java采用泛型擦除的机制来引入泛型,Java中的泛型仅仅是给编译器的javac使用的,确保数据的安全性和免去强制类型转换问题,但是一旦编译完成,所有和泛型有关的的类型全部擦除
   12.1 几种类型
     a.ParameterizedType: 一种参数化类型Collection<String>
     b.GenericArrayType: 一种颜色类型是参数化类型或者类型变量的数组类型
     c.TypeVariable:是各种类型变量的公共父接口
     d.WildcardType:代表一种通配符类型表达式.
13. ORM Object relationship Mapping 对象关系映射

Java Web

1.