java 从入门到精通(第四版本)

java 重入门到精通 的学习笔记 把最有用的整理出来，方便新手学习 和自己开发时候遇见问题进行查看

java 从入门到精通

• 第一篇 基础知识
  • 第一章 初识 java
    • 1.1 Java简介
      • 1.1.1 什么是 Java语言
        • 是一种通过解释方式执行的Java语言
        • 跨平台的程序语言
        • 是编译型的 又是解释型的
        • javaJVM 对字节码进行解析和运行
        • 编译 只运行一次 而解析在每次运行都启用
        • 虚拟机将字节码解释为机器码 然后在运行
      • 1.1.2Java的应用领域
        • 应用领域
          • 桌面应用系统的开发
          • 嵌入式系统的开发
          • 电子商务应用
          • 企业应用开发
          • 交互式系统开开发
          • 多媒体系统开发
          • 分布式系统开发
          • Web应用系统开发
      • 1.1.3 Java的版本
        • Java SE
          • java基础版
          • 包含
            • Java的基础语言
            • JDBC
            • IO
            • 网络通信
            • 多线程技术开发
        • JavaEE
          • Java企业版
          • 作用
            • 企业级分布式网络程序
        • JavaME
          • 嵌入式系统开发
      • 1.1.4 怎么学好 Java
        • 明确目标
        • 找本书 系统的学习
        • 了解设计模式 代码必须有高度的可读性 维护性 和升级的价值 学习设计模式掌握整体结构
        • 掌握基本语法 了解一些功能即可 不要死记硬背
        • 多动手 多思考 多请教
        • 遇见问题 不急躁 冷静思考
        • 多查阅资料
        • 多阅读源代码
      • 1.1.5 Java API 文档
        • API:
          • 应用程序编程接口
        • 是编程 词典
    • 1.2 Java 语言的特性
      • 1.2.1 简单
        • 面向对象的编程语言
        • java 对 C++ 进行了简化和提高
        • java 提供丰富的类库 和第三方开发包 有大量的开源项目 JDK已经开源代码 分析项目源码提高自己的编程水平
      • 1.2.2 面向对象
        • java 语言最外部的数据类型是对象 所有元素都通过类对象访问
      • 1.2.3 分布性
        • 操作分布
          • 不同的主机上布置相关操作
        • 数据分布
          • 数据可以存在不同的机器上
        • 原理
          • 这些主机是网络中的不同成员 java可以通过URL 对象访问网络对象 访问方式与访问本地相同
      • 1.2.4
        • 可以把程序移植到不同的电脑上
        • 实现针对不同平台的接口 使类库可以移植
      • 1.2.5 解释性
        • 任何移植了java解释器的计算机 都可以对字节码进行解释
      • 1.2.6 安全性
        • 删除指针 内存释放的语法 避免非法操作内存
        • 不能出现损系统平台的事情
      • 1.2.7 健壮性
        • 编译时就能检查错误
        • 运行时候也能检查错误
      • 1.2.8 多线程
        • 同一时间执行多个任务
      • 1.2.9 高性能
        • 编译后的字节码 在解释器中运行 字节码在运行时 被翻译成特定的机器指令
      • 1.2.10 动态
        • 可以动态的调整方法 和变量 客户端不需要做人和操作
    • 1.3 搭建 Java环境
      • 1.3.1 JDK 下载
      • 1.3.2 Windosws系统的JDK 环境
    • 1.4 第一个Java程序
  • 第二章 熟悉 Eclipse开发工具
    • 2.1 熟悉 Eclipse
      • 2.1.1 Eclipse 简介
      • 2.1.2 下载Eclipse
      • 2.1.3 安装 Eclipse的中文语言包
      • 2.1.4 Eclipse的配置与启动
      • 2.1.5 Eclipse 工作台
      • 2.1.6 透视图和视图
      • 2.1.7 菜单栏
      • 2.1.8 工具栏
      • 2.1.9 "包资源管理器"视图
      • 2.1.10 控制台视图
    • 2.2 使用Eclipse
      • 2.2.1 创建 Java项目
      • 2.2.2 创建 Java类文件
      • 2.2.3 使用编译器编写程序代码
      • 2.2.4 运行Java代码
    • 2.3 程序测试
  • 第三章 Java语言基础
    • 3.1 Java 主类结构
      • 基本组成单位是类
      • 3.1.1 包声明
        • package 为包的关键词
      • 3.1.2 声明成员变量 和局部变量
        • 类的属性为成员变量
        • 方法的属性为局部变量
      • 3.1.3 编写主方法
        • main方法是程序执行的位置
      • 3.1.4 导入API类库
        • import关键词来导入
      • 子主题
    • 3.2 基本数据类型
      • 3.2.1 整数类型
        • byte
        • short
        • int
        • long
      • 3.2.2 浮点类型
        • float
        • double
      • 3.2.3 字符类型
        • char
        • String
      • 3.2.4 布尔类型
        • boolean
          • true
          • flase
    • 3.3 变量与常量
      • 3.3.1 标识符和关键字
        • 标识符
        • 关键字
          • 在java中被赋予特殊意义的关键字
      • 3.3.2 生命变量
        • int age;
      • 3.3.3 声明常量
        • final double p1=3.1465;
      • 3.3.4 变量的有效范围
        • 成员变量
          • 类中有效
        • 局部变量
          • 方法中有效
    • 3.4 运算符
      • 3.4.1复制运算符
        • =
      • 3.4.2 算数运算符
        • +
        • -
        • *
        • /
        • %
      • 3.4.3 自增和自减运算符
        • ++a
          • 先自增在运算
        • a++
          • 现运算在自增
        • --a
          • 先自减在运算
        • a--
          • 现运算在自减
      • 3.4.4 比较运算符
        • >
        • <
        • ==
        • >=
        • <=
        • !=
      • 3.4.5 罗技运算符
        • &&
          • 并且
        • ||
          • 或
        • !
          • 非
      • 3.4.6 位运算符
        • 不会
      • 3.4.7 三元运算符
        • 条件是?1:2
      • 3.4.8 运算符优先级
        • 1 自增 自减
        • 2 算数运算符
        • 3 比较运算符
        • 4 逻辑运算怒
        • 5 赋值运算
    • 3.5 数据类型的转换
      • 3.5.1 隐式类转换
        • 重低级转换成高级
        • int x=0;
        • float y=x;
      • 3.5.2 显式类型转换
        • 高精度赋予给低精度
        • 注意有可能会损失精度
    • 3.6 代码注释和编码规范
      • 3.6.1 代码注释
        • 1,单行注释
          • //
        • 2,多行注释
          • /**/
        • 3.文档注释
          • /** */
      • 3.6.2 编码规范
        • 每条语句要单独占一行 结束后用分号结束
        • 声明变量 要单独占一行
        • 关键字和关键字中间只能有一个空格 如果多个也视为一个
        • 不要使用技术很高,难懂容易混交的判断语句
        • 对于关键字尽量多加注释
  • 第四章 流程控制
    • 4.1 复合语句
      • {}
        • 真个块为一个单位
    • 4.2 条件语句
      • 4.2.1 if条件语句
        • if(布尔表达式){执行体}
      • 4.2.2 switch 多分支语句
        • switch(表达式){case 常量值 1 语句体 break default 语句体 break}
        • 表达式里的值 去跟各个常量比对 如果都不是就走 deaeult语句
    • 4.3 循环语句
      • 4.3.1 while 循环语句
        • while(条件表达式){执行体}
        • while(x<=10){sum=sum+x; x++}
        • 如果x<10就进入循环体 因为本身没有判断语句 所有每次我们自己让他++
      • 4.3.2 do...while循环语句
        • 特点
          • 先执行一次 在进行循环
        • do{执行体}while(){}
      • 4.3.3 for 循环语句
        • for(表达式1,表达式2,表达式3){执行体}
          • 表达式1
            • 初始化表达式 负责变量初始化
          • 表达式2
            • 循环表达式 值为boolean 制定循环条件
          • 表达式3
            • 循环后操式 否则修正变量,改变循环条件
          • 循环方式
            • 首先执行表达式1 初始化 然后执行表达式2 整个循环结束然后执行 表达式3 在此循环从第二表达式开始 如果第二个表达式 为 flase那么就不执行跳出
            • 注意: 如果跳出就等于第二个表达式没执行
        • foreach 语句 for(元素变量x:便利对象 obj){引用x的java语句}
    • 4.4 循环控制
      • 4.4.1 break 语句
        • 可以跳出所有循环语句
        • break 标签名称
          • 跳出当前标记的循环体
      • 4.4.2 continue 语句
        • 重新开始条件判断不再往下执行
  • 第五章 字符串
    • 5.1 String 类
      • 5.1.1 声明字符串
        • 在java语言中用双引号""之内
      • 5.1.2 创建字符串
        • String s = new String();
    • 5.2 连接字符串
      • 5.2.1 连接多个字符串
        • 用+连接字符串返回一个新的字符串
      • 5.2.2 连接其他数据类型
        • 一个字符串都其他类型连接 那么也变成一个字符串
    • 5.3 获取字符串信息
      • 5.3.1 获取字符串长度
        • int size=Str.length();
      • 5.3.2 字符串查找
        • str.indexof("x")
          • 返回x 在str的位置 重0 开始 返回值为int
        • str.lastindexof("x");
          • 返回x 在str的最后位置
      • 5.3.3 获取指定索引位置的字符串
        • str.charAt(int index);
          • 返回当前位置的字符
    • 5.4.字符串操作
      • 5.4.1 获取子字符串
        • substring(int index)
          • 返回 重指定索引出截取截取到结尾
        • substring(beginindex,endindex)
          • 返回 重beginindex 开始 一直到 endindex结束
      • 5.4.2 去除空格
        • trim()
          • 取出字符串前后空格
      • 5.4.3 字符串替换
        • replace('a','b');
          • 把该字符串里的a全部替换成b
      • 5.4.4 判断字符串的开始与结束
        • str.startsWith(s);
          • 返回boolean 判断是否是s开始的字符串
        • str.endWith(s)
          • 返回boolean 判断是否是s结束的字符串
      • 5.4.5判断字符串是否相等
        • ==
          • 判断两个字符串地址是否相等 是否是同一个字符串
        • str.equals(str1)
          • 判断两个字符串是否有相同的字符跟长度,顺序
      • 5.4.6 按照字典顺序比较两个字符串
        • a.compartTo(b)
          • 返回1 调换位置返回-1
      • 5.4.7 字母大小写转换
        • toLowerCase()
          • 全部转为小写
        • toUpeerCase()
          • 全部转为大写
      • 5.4.8 字符串分割
        • str.spit("-")
          • 用-分割返回个数组
          • 如果参数是空 则直切切分
    • 5.5 格式化字符串
    • 5.6 使用正则表达式
    • 5.7 字符串生成器
      • str.append(z);
        • 返回字符串加上z
  • 第六章 数组
    • 6.1 数组概述
      • 相同数据类型的数据集合
      • 6.2 一维数组的创建跟使用
        • 6.2.1 创建一维数组
          • 数组元素类型 数组名称 []
          • int arr[]=new int[]{}
          • 注意
            • 创建数组的时候必须左测有接受 否则报错
        • 6.2.2 初始化一位数组
          • int arr[]=new int[]{1,2,3}
        • 6.2.3 使用一维数组
      • 6.3 二维数组的创建及使用
        • 6.3.1 二维数组的创建
          • 数组类型 数组名称 [][]
        • 6.3.2 二维数组的初始化
          • type a[][]=={v,v,v}
        • 6.3.3 使用二维数组
      • 6.4 数组的基本操作
        • 6.4.1 遍历数组
        • 6.4.2 填充替换数组元素
          • Arrays.fill(arr,8)
            • arr 替换的数组
            • 8 替换完的元素
          • 还有一个一样的方法 四个参数没看懂
        • 6.4.3 对数组进行排序
          • Arrays.sort(arr);
            • 默认升序
        • 6.4.4 复制数组
          • copyOf(arr,int newlength)
            • 赋值数组 并指定长度
          • • Arrays.copyOfRange(arr,int Fromindex,Int,toIndex)
              • 复制 制定起始位置 和结束位置
        • 6.4.5 数组查询
          • Arrays.binarSerch(arr,vl)
            • 返回该值的位置
          • Arrays.binarSerch(arr,起始索引,结束索引,要搜说的值)
            • 返回位置
            • 注意:如果值在开始或者结束位置不建议使用
      • 6.5 数组的排序方法
        • 6.5.1 冒泡排序方法
          • 1 基本思想
            • 相邻比对 如果条件满足就交换
          • 2 算法事例
            • 1 双曾循环实现
            • 2 外层长度减去1
            • 3 交换次数随排序顺序减少
          • 3 算法实现
            • 双层for 内层长度减去一 内层做判断 如果当前循环的值大于喜爱一个的值
            • 就做个中间值 把这两个值调换 就可以了
        • 6.5.2 直接选择排序
          • 6.5.2 直接选择排序
            • 1 基本思想
              • 满足条件后直接放到指定位置\
            • 2 算法示例
              • 63 4 24 13 15
              • 15 4 24 1 3 63
              • 15 4 3 1 24 63
              • 1 4 3 15 24 63
            • 3 算法实现
              • 双层for循环 外层做一个计数器 0 第二层长度减去1 进行对比如果数字大于上一个计数器替换
              • 外层循环 用外层循环的常去减去 循环变量I 得到这个值
              • array[array.length-i]array.length-i=array[index]
              • array[index]=temp;
          • 6.5.3 反转排序
            • 1 基本思想
              • 第一个和到最后一个替换 一次类图
            • 2 算法示例
              • 1 2 3 4 5 6
              • 6 2 3 4 51
            • 3 算法实现
              • 一次循环就行了 用 循环变量替换 就可以
  • 第七章 类和对象
    • 7.1 面向对象的概述
      • 7.1.1 对象
        • 对象是类抽象出来的一个实例
      • 7.1.2 类
        • 对同一类事务的统称
      • 7.1.3 封装
        • 将对象的属性和行为进行封装就是类
      • 7.1.4 继承
        • 两个类有包含关系
          • 子类的属性 和动作都可以是父类的实例 但反过来不行
      • 7.1.5 多态
        • 父类 去接受子类 有多种形态就叫多态
    • 7.2 类
      • 7.2 1 成员变量
        • 类的大户型 成为成员变量
      • 7.2.2 成员方法
        • 类里的方法 叫做成员方法
      • 7.2.3 权限修饰符
        • private
          • 本类
            • 可见
          • 同包其他类 或子类
            • 不可见
          • 其他包的类 或子类
            • 不可见
        • protected
          • 本类
            • 可见
          • 同包其他类 或子类
            • 可见
          • 其他包的类 或子类
            • 不可见
        • private
          • 本类
            • 可见
          • 同包其他类 或子类
            • 可见
          • 其他包的类 或子类
            • 可见
      • 7.2.4 局部变量
        • 在成员方法内定义的变量叫做局部变量
        • 存活时间
          • 方法执行时创建 结束时候销毁
      • 7.2.5 局部变量的有效范围
        • 在成员方法内
      • 7.2.6 this 关键字
        • this引用的是当前类的一个对象
        • 防止方法内参数与成员变量重复无法区分
    • 7.3 类的构造方法
      • 无参构造
      • 有参构造
    • 7.4 静态变量,常量和方法
      • staic
        • 用staic 修饰的变量 常量 方法 称之为静态的变量常量 方法
        • 作用
          • 通常是为了提供共享数据和方法
        • 注意
          • 静态方法中不能使用this 关键字
          • 静态方法不能调用非静态方法
    • 7.5 类的主方法
      • main
        • 特性
          • 主方法是静态的所以只能调用其他的静态方法
          • 没有返回值
          • 形参为数组
    • 7.6 对象
      • 7.6.1 对象的创建
        • new text()
        • new text(a)
        • 特性
          • 创建就是一个对象的引用
          • 内存中分配存储空间
          • 每个对象是互相对立的 对立的内存地址
          • 生命周期结束就变成了垃圾 java虚拟机进行回收处理 不能在使用
      • 7.6.2 访问对象的属性和行为
      • 7.6.3 对象的引用
        • BOok book
      • 7.6.4 对象的比较
        • ==
          • 比较两个对象的引用是否一致
        • equals
          • 比较两个对象是否相等
      • 7.5.5 对象的销毁
        • 对象生命周期结束 内存地址将被回收
        • 垃圾的定义
          • 对象的引用超过其作用范围
          • 将对象赋值为null
  • 第八章 包装类
    • 8.1 Integer
      • int的包装类
      • 1 能在Sting interger 类型中互相转换
      • 2 常用方法
        • i.byteValue
          • 返回值
            • byte
          • 亿byte 类型返回 integer 的值
        • i.compareto(integer anotherIntger)
          • 返回值
            • int
              • 0 相等
              • -1 括号的大
              • 1 括号的小
          • 功能描述
            • 两个intger进行大小比较
        • equals( object object)
          • 返回值
            • boolean
          • 功能描述
            • 比较两个对象是否相等
        • intValue()
          • 返回值
            • int
          • 功能描述
            • int类型返回此值
        • short()
          • 返回值
            • short
          • 功能描述
            • 以 short类型返回此对象
        • valueOf(String s)
          • 返回值
            • short
          • 功能描述
            • 以String类型返回此对象
          • 参数
            • String
        • tostring()
          • 返回值
            • String
          • 功能描述
            • 以 String类型返回此对象
        • parseInt(String s)
          • 返回值
            • int
          • 功能描述
            • 以 short类型返回此对象
          • 参数
            • 返回字符串包含的int值
      • 3 常量
        • Integer.MAX_VALUE
          • 获取int类型最大值
        • Integer.MIN_VALUE
          • 获取int类型最小值
        • Integer.SiZE
          • 二进制补码方式表示int值的位数
    • 8.2 Boolean
      • 1 构造方法
        • Boolean b =new Boolean(true);
      • 2 常用方法
        • booleanValue()
          • 返回值
            • 将Boolean 对象的值对应的Boolean 值返回
          • 功能描述
            • 将Boolean 对象的值对应的Boolean 值返回
        • equals()
        • Boolean.paseBoolean(String s)
          • 返回值
            • boolean
          • 功能描述
            • 将字符串解析成boolean 值
        • toString()
          • 返回值
            • String
          • 功能描述
            • 返回表示该boolean值的字符串
        • Boolean.valueOf(String s)
          • 返回值
            • boolean
          • 功能描述
            • 返回一个用制定字符串表示的boolean值
      • 3.常量
        • Boolean.TRUE
          • true
        • Boolean.FALSE
          • FALSE
        • Boolean.TYPE
          • 返回booleanclass对象
    • 8.3 Byte
      • 1 构造方法
        • Byte byte=45;
        • Byte b= new Byte(mybyte)
        • Byte c =new Byte("12")
      • 2 常用方法
        • Byte.byteValue()
          • 返回值
            • byte
          • 功能描述
            • 用byte 值 返回一个byte 值
        • byte.compareTo(Byte anybyte)
          • 返回值
            • int
          • 功能描述
            • 比较两个byte的值大小
        • byte.doubleVlaue()
          • 返回值
            • double
          • 功能描述
            • 转成double类型
        • byte.intValue
          • 返回值
            • int
          • 功能描述
            • 转成int类型
        • byte.parseByte(String s)
          • 返回值
            • byte
          • 功能描述
            • String 转成 Byte
        • byte.toString()
          • 返回值
            • String
          • 功能描述
            • 返回一个String值
        • byte.valueOf(String s)
          • 返回值
            • byte
          • 功能描述
            • String 转成 byte
        • byte.equals(Obejct obj)
          • 返回值
            • boolean
          • 功能描述
            • 判断两个值是否相等
    • 8.4 Character
      • 1 构造方法
        • Character mychar=new Character9('a');
        • 注意
          • 放入但引号的一个字符
      • 2 常用方法
        • char.charvalue();
          • 返回值
            • char
          • 功能描述
            • 返回此CharActer 的对象值
        • char.compareTo(Character another angchar)
          • 返回值
            • int
          • 功能描述
            • 返回两个char的比较结果
        • char.equals(Object o)
          • 返回值
            • boolean
          • 功能描述
            • 比较两个值是否相同
        • char.toUpperCase(char ch)
          • 返回值
            • char
          • 功能描述
            • 将字符全部转为大写
        • char.toLowerCase(char ch)
          • 返回值
            • char
          • 功能描述
            • 将字符全部转为小写
        • char.toString();
          • 返回值
            • String
          • 功能描述
            • 转换成String类型
        • char.charValue();
          • 返回值
            • char
          • 功能描述
            • 没有啥用
        • char.isUpperCase(Char ch)
          • 返回值
            • boolean
          • 功能描述
            • 判断是否是大写
        • char.isUpperCase(Char ch)
          • 返回值
            • boolean
          • 功能描述
            • 判断是否是小写
      • 3 常量
    • 8.5 Double
      • 1 构造方法
        • Double doube=new Double();
      • 2 常用方法
        • d.byteValue()
          • 返回值
            • byte
          • 功能描述
            • Double 转成byte类型
        • d.dompareTo(Double d)
          • 返回值
            • int
              • -1
              • 0
              • 1
          • 功能描述
            • 两个double比较大小
        • d.equals()
          • 返回值
            • boolean
          • 功能描述
            • 比较两个值是否一致
        • d.intValue()
          • 返回值
            • int
          • 功能描述
            • 转成int值
        • d.isNaN()
          • 返回值
            • boolean
          • 功能描述
            • 判断这个值是不是数字
        • d.toString()
          • 返回值
            • String
          • 功能描述
            • 转换成字符串
        • d.valueOf(String s)
          • 返回值
            • Double
          • 功能描述
            • 把字符串转为 Double
        • d.doubleValue()
          • 返回值
            • double
          • 功能描述
            • 以double形式放回Double对象
        • d.longValue()
          • 返回值
            • double
          • 功能描述
            • 转换成double
      • 3 常量
    • 8.6 Number
      • 返回各种数据类型的方法
  • 第九章 数字处理类
    • 9.1 数字格式化
    • 9.2 数字运算
      • 9.2.1 Math 类
        • 1个工具类 里边放了许多数学方法
      • 9.2.2 常用的数学方法
        • 1 三角函数方法
          • Math.sin(Double d)
            • 返回该数的三角正炫
          • Math.cos(Double d)
            • 返回该数的三角余弦
          • Math.tan(Double d)
            • 返回该数的三角正切
          • Math.asin(Double d)
            • 返回该数的三角反正弦
          • Math.acos(Double d)
            • 返回该数的三角反余弦
          • Math.atan(Double d)
            • 返回该数的三角反正切
          • Math.toRadias(Double d)
            • 角度转为弧度
          • Math.toDegress(Double d)
            • 弧度转为角度
        • 2 指数函数方法
          • Math.exp(double a)
            • 用于获取e的a次方
          • Math.long(double a)
            • 取自然数的对数
          • Math.long10(double a)
            • 底数为10 的对数
          • Math.sqrt(double a)
            • a的平方根
              • a 不能是负数
          • Math.cbrt(double a)
            • 取a的立方根
          • Math.pow(double a,double b)
            • 取a的b次方的跟
        • 3 取整函数方法
          • Math.double(double a)
            • 返回大于等于当前数的最小整数
          • Math.foor(double a)
            • 返回小于等于当前树的最小整数
          • Math.rint(double a)
            • 返回最接近当前数的整数 如果两头相等取偶数
          • Math.round(double a)
            • 将参数加0.5后返回最接近的整数
          • Math.round(double a)
            • 将参数加0.5后返回最接近的整数
            • 返回类型
              • long
        • 4 取最大值,最小值, 绝对值函数的方法
          • Math.max(double a,double b)
            • 获取a b 中的大值
            • 方法重载
              • int
              • long
              • double
              • floart
          • Math.min(int a,int b)
            • 获取两个数中小的那个值
            • 方法重载
              • int
              • long
              • double
              • floart
          • Math.abs(int a)
            • 返回绝对值
            • 方法重载
              • int
              • long
              • double
              • floart
    • 9.3 随机数
      • 9.3.1 Math.random() 方法
        • 生成0 到1之间的随机数
      • 9.3.2 Random 类
        • 创建无参构造
          • Random r=new Random(seedValue)
          • 返回一个创建的随机数
        • 方法
          • r.nextInt(int n)
            • 返回一个大于0 切小于n的随机整数
          • r.nextLong(Long 0)
            • 返回一个随机长整数类型
          • r.nextBoolean()
            • 返回一个随机布尔型
          • r.nextFloat()
            • 返回一个随机浮点型值
          • r.nextDouble()
            • 返一个双精度型
          • r.nextGaussian()
            • 返回一个概率密度为高斯分布的双精度值
    • 9.4 大数字运算
      • 9.4.1 Biginteger
        • 最大值
          • 2的31次方 -1
        • 方法
          • big.add(Binginteger val)
            • 加法运算
          • big.subtract(BigInteger val)
            • 减法运算
          • big.multiply(BigInteger val)
            • 做乘法运算
          • big.divide(Biginteger val)
            • 做除法运算
          • big.remainder(Biginteger val)
            • 做取余运算
          • big.diveAndRemainder(BigInteger val)
            • 用数组返回余数 和上结果数组中第一个值为商 第二个值为余数
          • big.pow(int exponet)
            • 进行取当前数的exponet次方
          • big.negate()
            • 取相反数
          • big.equals(Object o)
            • 看看两个数值是否相同
          • big.min(Biginteger val)
            • 返回较小的数值
          • big.max(Bigintger val)
            • 返回较大的数值
      • 9.4.2 BigDecimal
        • 特点
          • 加入小数概念
        • 方法
          • b.(double val)
            • 强制转换成大数据类型
          • b.(String val)
            • 强制转换成大数据类型
          • b.add(BigDecimal val)
            • 加法
          • b.subtact(BigDecimal val)
            • 减法
          • b.multiply(BigDecimal val)
            • 乘法
          • b.divide(BigDecimal val,int scale ,int roundingModel)
            • 除法
              • divsor
                • 除数
              • scale
                • 保留小数点位数
              • rounding
                • 处理模式
• 第二篇 核心技术
  • 第十章 接口,继承和多态
    • 10.1 类的继承
      • 继承父类的所有方法 并可以重写
      • 用super 直接调用父类的方法
    • 10.2 Object 类
      • 所有类的父类
      • 方法
        • getClass()
          • 获得当前对象的实例
        • toString()
          • 返回一个字符串
        • equals()
          • 比较两个值
    • 10.3 对象类型的转换
      • 10.3.1 向上转型
        • 子类对象转换成父类对象
      • 10.3.2 向下转型
        • 像下转型有可能出现问题 因为鸽子都是鸟 而鸟不都是鸽子
        • 必须使用显示转换 像编译器指明该对象属于哪个子类
    • 10.4 使用instanceof 操作符判断对象的类型
      • 方法
        • myobject instanceof Exampleclass
          • myobject
            • 实力对象
          • exampeclas
            • 判断这个对象是否属于这个子类
      • 注意
        • 方法必须在if里使用
    • 10.5 方法的重载
      • 同名方法
        • 参数或类型不同即可
    • 10.6 多态
      • 优点
        • 使程序有更好的扩展性
    • 10.7 抽象类与接口
      • 10.7.1 抽象类
        • abstact
          • 抽象的关键词
          • 放在类上就是抽象类
          • 放在 方法上就是抽象方法
            • 特点
              • 没有方法体
        • 特点
          • 有一个抽象的方法就是抽象类
      • 10.7.2 接口
        • 抽象类的延伸 全部方法都是抽象的
        • interface
        • 接口的继承
          • 一个 class 类可以继承多个接口
          • implements 是实现接口的关键词
  • 第十一章 类的高级特性
    • 11.1 Java类包
      • 11.1.1 类名的冲突
        • 类名是不可以重复的 所以用包来区分
      • 11.1.2 完整的类路径
        • 包.包.包.类
      • 11.1.3 创建包
      • 11.1.4 导入包
        • 1 使用import关键词导入包
        • 2 可以导入静态成员
          • import stacic 位置 成员
    • 11.2 final 变量
      • 特点
        • 最终 不可改变
      • 实例
        • final double p =3.14 不可变
    • 11.3 final 方法
      • final 方法不能被覆盖
    • 11.4 final 类
      • 如果一个类被final 了 那么默认其所有方法都是如此 不能在被继承
    • 11.5 内部类
      • 一个类在定义一个类叫做内部类
      • 11.5.1 成员内部类
        • 1 成员内部类简介
        • 2 内部类像上转型为接口
        • 3 使用this 关键词获取内部类和外部类引用
      • 11.5.2 局部内部类
        • 一个类定义到方法中
      • 11.5.3 匿名内部类
      • 11.5.4 静态内部类
        • 类前加载static
      • 11.5.5 内部类的继承
        • exends 主类.内部类
  • 第十二章 异常处理
    • 12.1异常概述
      • 程序运行中出现的错误叫内部类
    • 12.2 处理程序异常错误
      • 12.2.1 错误
        • 异常出现后不坐处理程序就会暂停
      • 12.2.2 捕捉异常
        • try{} cath(E e) {}finally
        • 1 try catch 语句块
          • try 里的语句进行判定如果出现错误 cath进行判定
          • catch(exception e){e.printStackTrace()}
            • e.printStackTrace()
              • 输出异常信息
            • e.getMessage()
              • 输出错误性质
            • e.toString()
              • 给出异常的类型和性质
        • 2 finally 语句块
          • 前边不论什么结果后边都会执行
    • 12.3 Java 常见异常
      • ClassCastException
        • 类型转换异常
      • ClassNotFoundException
        • 没找到相应的类异常
      • ArithmeticException
        • 算数异常
      • ArrayIndexOutBoundsException
        • 数组下表越界异常
      • ArrayStoreException
        • 数组包含不兼容的值
      • SQLException
        • 操作数据库异常
      • NUllpointerException
        • 空指针异常
      • NoSuchFieldException
        • 字段没找到异常
      • NoSuchMethodException
        • 方法没找到异常
      • NumberFormatException
        • 字符串转成数组异常
      • NegativeArraySizeException
        • 数组元素为负数异常
      • StringIndexOutOfBOundsException
        • 字符串索引超出范围
      • IOException
        • 输入输出异常
      • IllegalAccessException
        • 不可以访问某类异常
      • Instantiationexception
        • 创建摸个class 实体类 无法被实现异常
      • EOFException
        • 文件已经结束一场
      • FileNOtFoundException
        • 文件没找到异常
    • 12.4 自定义异常
      • 在程序中使用自定义异常类的步骤
        • 1 创建一场类 继承Exception
        • 2 在方法中通过throw关键词抛出异常对象
        • 3 可以用try catch 处理异常也可以给使用者 调用
    • 12.5 在方法中抛出异常
      • 12.5.1 使用throws关键字抛出异常
        • 放在方法上 说明名方法可能会抛出异常
        • public void p() throws 异常名称{}
      • 12.5.2使用throw 关键字抛出异常
        • 一般放在方法体中,并且抛出一个方法对象 如果如果执行到了throw 则程序立即中止
        • 使用
          • if(1=1){ throw new Exception()}
        • 注意
          • 如果需要网上抛 就必须在当前方法上 thorows 解决就是try cath
    • 12.6 运行是异常
      • 关键词
        • RuntimeException
      • 所有异常类的父类
        • throwable
      • 常见的异常
        • NUllpointerException
          • 空指针异常
        • ArrayIndexOutBoundsException
          • 数组下标约界
        • ArithmeticException
          • 算数异常
        • ArrayStoreException
          • 数组不包含制定的数值
        • IllegalAccessException
          • 非法参数异常
        • securtyException
          • 安全性异常
        • NegativeArraySizeException
          • 数组常数为负异常
    • 12.7 异常的使用原则
      • 当法相某个方法可能发生异常时
        • 使用try-catch 语句捕获异常
        • 一个方法被覆盖时候 必须抛出相同的异常和异常的子类
        • 如果一个父类抛出多个异常 则覆盖的方法必须抛出多个异常的子集,不能抛出新异常
  • 第十三章 Swing程序设计
    • 13.1 Swing 概述
      • 13.1.1 Swing 特点
        • 允许开发人员跨平台制定统一外观跟峰哥
        • Swing 轻量级组建
        • 可插入外观组建
      • 13.1.2 Swing 包
  • 第十四章 集合类
    • 集合类的概述
      • 集合类存放对象的引用
    • Collection 接口
      • Collection常用方法
        • 添加一个对象到集合
          • add( String string )
        • 在集合中移除一个对象
          • removed(String string )
        • 判断集合是否为空
          • isEmpty() return boolean
        • 返回次对象的迭代期
          • iterator();
        • 返回元素个数
          • size() return int
        • 迭代的应用
          • duixiang.iterator.next return 对象
    • Collections工具类常用方法
      • 降序
        • Collections.reverse(list);
      • 升序
        • 子主题
    • List集合
      • 特点 可以重复 顺序就是插入顺序 通过索引访问集合中的元素
        • List集合的索引重0开始
      • List 接口
        • 继承 Collection 类 并追加了两个方法
          • get(int index) 通过索引返回对象
          • set(int index Object obj) 将指定索引的对象修改值
      • List 接口的实现类
        • ArrayList
          • 可以保存所有元素 包括 null 根据索引快速访问
          • 缺点: 像指定位置 插入对象 或删除对象速度比较慢
        • LinkedList
          • 特点: 采用链表结构
          • 优点:插入和删除速度快 效率高 但对于所及访问没有 ArrayList 快
    • Set集合
      • 特点：不按特定方式排序 不包含重复对象 继承Collection
      • Set 接口
      • Set 接口的实现类
        • HashSet
          • 由hash表支持 不保证迭代顺序 支持null
        • TreeSet
          • 还实现了SortedSet接口
          • 遍历按照自然顺序递增排列
          • TreeSet 新增方法
            • fitst(); 返回第一个元素
            • last() 返回最后的元素
            • compartor() 返回元素排序的比较器 如果是自然顺序 则返回null
            • subSet(E e,E e)返回一个新的Set但是 是包含第一个元素 不包含第二个元素 中间的所有元素
            • tailSet(String s)返回一个新集合包含s对象之后的所有元素
    • Map集合
      • Map 接口
        • 内置方法
          • put( K,key,V value) 放入一个键值对
          • containkey(K key) 是否包含该键值对
          • headSet( E e) 返回一个新的Setj集合 获取 e之前的所有元素
          • containValue(V value) 是否包含一个或多个键值对
          • get(K key) 通过key取值
          • KeySet() 获取所有的key
          • Values( ) 获取所有的值
      • Map 接口实现类
        • HashMap
          • 优点：添加删除速度快
          • 特点：可以有NUll 建 但必须保证唯一性
          • 缺点： 不保证顺序 很久不变
          • 线程安全的
        • TreeMap
          • 优点 : 有一定的顺序
          • 特点：实现了SortedMap接口 key不可以null
          • 缺点：添加 删除 定位映射关系慢
  • 第十五章 I/O流
    • 15.1 流概述
      • 通过程序吧数据传送到目的地
      • 输入流
        • 吧程序读到内存中去
      • 输出流
        • 数据要传送的目的地
    • 15.2 输入/输出流
      • 15.2.1输入流
        • IntputStream
          • 是一个抽象类所有输入流的父类
          • 抽象方法
            • read(byte[]b)
              • 从输入流中读一个长度的字节,亿整数的形式返回字节数
            • mark(int redlimst)
              • 在输入流当前位置放入个标记 ,redimt 参数告知此输入流在标志位置是小钱润许读取的字节数
            • rest()
              • 将输入指针返回到当前标记出
            • skip(long n)
              • 跳过输入流的n个字节 并返回实际跳过的字节数
            • markSuported()
              • 判断当前流是否支持 标记 和rest() 方法
            • close()
              • 关闭输入流释放所有关联的系统资源
      • 15.2.2 输出流
        • OutputStream
          • 是一个抽象类 所有输出流的接口
          • 抽象方法
            • write(int b)
              • 将制定的字节写入此输出流
            • write(byte[] b)
              • 将制定的数组写入输出流
            • write(byte[]b int off,int len )
              • 从偏移量off 开始llen 个字节开始读取到输出流
            • flush()
              • 清空缓存区
            • close()
              • 关闭输入流
      • 15.3 File 类
        • IO 包中唯一能代表磁盘文件本身的对象
        • 15.3.1 文件的创建与删除
          • 新建一个文件
            • new File("d:/1.txt")
            • new File("D:/","1.txt")
            • new File("D:/doc/","a.txt")
          • 执行创建这个文件
            • file.createNewFile();
          • 删除这个文件
            • file.delete();
        • 15.3.2 获取文件信息
          • 内置的方法
            • file.getName();
              • 获取文件名称
            • file.canRead();
              • 判断文件是否可读
            • file.canWrite()
              • 说明
                • 判断文件是否可写
              • 返回值
                • boolean
            • file.exits()
              • 说明
                • 判断文件是否存在
              • 返回值
                • boolean
            • file.length();
              • 说明
                • 查看文件长度
              • 返回值
                • long
            • file.getAbsolutPath()
              • 说明
                • 获取文件的绝对的绝对路径
              • 返回值
                • String
            • file.getParent();
              • 说明
                • 获取文件的父路径
              • 返回值
                • String
            • file.isFile();
              • 说明
                • 判断文件是否存在
              • 返回值
                • boolean
            • file.isDirectory();
              • 说明
                • 判断文件是否是一个文件夹
              • 返回值
                • boolean
            • file.isHidden()
              • 说明
                • 判断文件是否是一个隐藏文件
              • 返回值
                • boolean
            • file.lastModified();
              • 说明
                • 获取文件的最后修改时间'
              • 返回值
                • long
      • 15.4 文件输入/输出流
        • 15.4.1 FileInputStram FileOutStream 类
          • FileInPutStream
            • 构造方式
              • new FileInputStream(String name)
              • new FileInputStream(File file)
            • 读取文件的实现方法
              • File file = new File("D:/1.txt"); FileInputStream fileInputStream = new FileInputStream(file); byte[] b = new byte[1024]; int read = fileInputStream.read(b);String string = new String(b, 0, read);
        • 15.4.2 FileReader 和 FileWriter
          • new FileRead(File file)
      • 15.5 带缓存的输入/输出流
        • 15.5.1 BufferedInputStream与BufferendOUtputStream类
          • 构造方式
            • new BufferedOutPUtStream(OutputStream in)
            • new buffereOutputStream(OutputStream in,in,int size)
        • 15.5.2 BufferedReader 与BufferedWriter 类
          • BufferedRead 类的常用方法
            • .read()
              • 读取单个字符
            • .read.link();
              • 读取一个问本行
          • BufferWriter 的常用方法
            • .write(String)
              • 写入
            • .flush()
              • 刷新该流的缓存
            • .newLine()
              • 写入一个行的分割符号
      • 15.6 数据输入/输出流
        • DataInPutStream
          • 构造方法
            • DataInputStream(InputStream in)
        • DateOutPutStream
          • 构造方法
            • DataOutPutStream(OutPutStream out)
          • 常用方法
            • writeByte(String s);
              • 写入
            • writeChars(String s)
              • 写入
            • writeUTF(String s)
              • 写入
      • 15.7 ZIP 压缩输入/输出流
        • 15.7.1
          • 常用方法
            • z.putNextEntry(ZipEntry)
              • 写一个压缩文件
            • z.finsh()
              • 关闭流
            • setComment(String comment)
              • 设置注视文件
          • ZipOutputStream(OutputStream out)
            • z.write(byte[]b,int off,int len)
              • 数组的方式写入
          • ZipInputStream(inPutStream in)
            • 方法
              • z.read(byte[]不,int off,int,len)
                • b 读取
              • z.available()
                • 判断是否读完制定的数据
              • z.closeEntry()
                • 关闭当前压缩条 并取吓一跳
              • z.skip(long n)
                • 跳过压缩条中制定的数据
              • z.getNextEntry()
                • 读取下一个压缩
              • z.createZipEntry(String name)
                • 新建一个ZipEntry 对象
  • 第十六章 反射
    • 16.1 Class类与Java反射
      • 可以反问构造方法JVM中包含的java对象
      • 可以实现对象大访问 检测和修改描述 本身嘻嘻等
      • 通过反射可以访问的主要描述信息
        • a.getPackage()
          • 返回值
            • Package对象
          • 功能描述
            • 获得该类的存放路径
        • a.getName()
          • 返回这
            • String 对象
          • 功能描述
            • 获得该类的名称
        • a.getSuperClass()
          • 返回值
            • Class 对象
          • 功能描述
            • 获得该类继承的所有类
        • agetInterFaces()
          • 返回值
            • class 对象
          • 功能描述
            • 获得该类实现的所有接口
        • a.getConstructors()
          • 功能描述
            • 获取所有权限为public 构造方法
          • 返回值
            • ConStructor 数组
        • a.getConstuctor(Class<?>....parameterType)
          • 返回值
            • ConStructor 数组
          • 功能描述
            • 获取所有权限为public 制定的 构造方法
        • a.getDeclaredConstuctors()
          • 返回值
            • ConStructor 数组
          • 功能描述
            • 获取所有构造方式
        • a.a.getDeclaredConstuctors(Class<?>....parameterType)
          • 返回值
            • 获取所有的构造方式
          • 返回值
            • Cotructor
  • 第十七章 枚举类型和泛型
    • 17.1 枚举类型
      • 17.1.1 使用枚举类型设置常量
        • 常量
          • 一般情况下 接口中定义常量 因为
        • 关键词
          • enum
          • public enum Constants{constants1,constab}
        • 使用方式
          • 放在接口中
      • 17.1.2 深入了解枚举类型
        • 1 操作枚举类型成员方法
          • values()
            • 具体含义
              • 1️⃣数组的方式返回枚举
            • 使用方法
              • 枚举类型名称.values()
          • valuesof()
            • 具体含义
              • 将普通字符串转为枚举类型那
          • compareTo()
            • 具体含义
              • 定义两个美剧对象的顺序
          • ordinal()
            • 得到枚举成员位置
      • 17.1.3 使用枚举类型的优势
        • 特点
          • 类型安全
          • 紧凑有效数据定义
          • 可以程序其他部分完美交互
          • 运行效率高
    • 17.2 泛型
      • 17.2.1 回顾向上转型与向下转型
      • 17.2.2 定义泛型类
        • 类名<T>
      • 17.2.3 泛型的常规用法
        • 1 定义泛型类型声明多个类型
          • MuitOverClass<T1,T2>
        • 2 定义泛型类声明数组类型
          • privet T[] array;
        • 3 集合类生命容器的元素
          • Map<k,v>
      • 17.2.4 泛型的高级应用
        • 1 限制泛型可用类型
          • class 雷名称<T extends anyClass>
        • 2 使用类型通配符
        • 3 继承泛型类与实现泛型接口
  • 第十八章 多线程
    • 18.1 线程简介
      • 一个线程的执行流程,一个进程可以包含多个线程
      • 单线程
        • 程序代码顺序执行,如果一个代码同时需要多段代码操作 就需要多线程
    • 18.2 实现多线程的两种方式
      • 18.2.1 继承Thread类
        • 在类中继承Thread
      • 18.2.2 实现Runnable接口
        • 在类中继承 Runnable 接口
    • 18.3 线程的生命周期
      • 县城生命周期的七种状态
        • 出生状态
          • 就是现场创建出来的状态 在start()之前都是出生状态
        • 就需状态
          • start() 之后是就绪状态 又被成为可执行状态
            • 一旦到了就绪状态线程就有可能进入其他状态互相转换
          • 使线程处于就绪状体的几个方法
            • 调用sleep()
            • wait()
            • 等待输入/输出完成
        • 运行状态
          • 当线程得到系统资源时候进入运行状态
          • 线程处于就绪状态后 使其在进行运行状态的几个方法
            • notify
            • nirfyall
            • interrupt
            • 休眠时间结束
            • 输入/输出结束
        • 等待状态
          • 线程调用 wait() 进入等待状态
            • 必须用 notify 才能唤醒
            • notifyAll() 唤醒所有处于等待状态
        • 休眠状态
          • sleep()
            • 调用这个线程进入休眠状态可以设置时间
        • 阻塞状态
          • 如果一个线程在运行状态发出输入输出请求 线程就会阻塞
    • 18.4 操作线程的方法
      • 18.4.1 线程的休眠
        • sleep( 毫秒)
          • 通常在run() 方法内使用
      • 18.4.2 线程的加入
        • b.jion()\
          • b线程加入
          • 注意
            • B线程结束后在执行原有线程
      • 18.4.3 线程的中断
        • interrupt()
      • 18.4.4 线程的礼让
        • yield()
          • 替班很少用
    • 18.5 线程的优先级
      • t.setPrioityz(int 级别)
        • 线程级别1 10
    • 18.6 线程同步
      • 18.6.1 线程安全
      • 18.6.2 线程同步机制
        • synchroized(){}
          • 同步块
            • 同步块中有个标志 分别是 0 1 如果是0 表面用其他线程运行 这时候该线程处于就需状态
        • 同步方法
          • sybcgronized void f(){}
            • 该对象在器同步繁重必须等待其他方法执行后才能执行
            • 注意: 每个访问方法都得都必须使用synchronied 修饰
  • 第十九章 网络通信
    • 19.1 网络程序设计基础
      • 19.1.1 局域网与因特网
        • 局域网
          • 一群机器因为一定形式连接在一起
        • 因特网
          • 延伸更广的范围所以叫广域网
      • 19.1.2 网络协议
        • 1 IP协议
          • internet地址 就是 IP
            • IPv4
              • 192.16.81.1.
            • Ipv6
              • 192.1.5.2.3.2
        • 2 TCP 与UDP协议
          • TCP
            • 固定连线为基础的协议
          • UDP
            • 无连接通信协议
              • 不保证数据的可靠传输
              • 可以像多人传输 也可以获取多人
      • 19.1.3 端口和套接子
        • 端口
          • port0 -65535
    • 19.2 TCP程序设计基础
      • 分为 服务器程序 客户端程序
      • 19.2.1 inetAddress 类
        • java 分装的d地址类
          • 方法
            • getbyname()
              • 获取inetaddress对象
            • gethostaddress
              • 获取对象的ip地址
            • gethost name
              • 获取ip 地址的主机名]
            • getlocalhost()
              • 返回本机的inetaddress对象
      • 19.2.2 ServerSocket 类
      • 19.2.3 TCP 网络协议
    • 19.3UDP程序设计基础
      • 特点 传输数据块 但不提供有效的保证
      • 19.3.1. DatagramPacket 类
        • 子主题
      • 19.3.2 DatagramSocket 类
      • 19.3.3 UDP 网络协议
        • 类似于广播
  • 第二十章 数据库操作
• 第三篇 高级应用
• 第四篇 项目实战