基本数据类型 也叫值类型。引用数据类型--引用类型
This。只能出现在方法中 ，this代表当前对象的引用。
匿名对象 : new 类名（）
Anonymous：匿名
Object
有索引的对象：可以通过索引，反复操作同一个对象
匿名对象因为没有引用变量，所以一般情况下只是用一次。
组合关系：
继承：关键字：extends
被继承的类叫做父类，继承的类叫子类。
继承之后：子类就可以直接使用父类的非私有成员（成员变量，成员方法）。
优点：1提高代码复用性。2提高了代码的可维护性（方便修改和维护）。
3，让类与类之间产生了关系（多态的前提）
父类：有的也叫跟类，基类，超类
父类：拥有子类的共同特点，公共部分的类。
子类：有的也叫派生类
所有的类都有父类,都直接或者间接继承（Object）
当父类的成员变量用private修饰时，有get/set方法访问和修改
点class类 f2键改名字；
一个子类不能拥有多个直接父类。只支持单继承。
继承可以多层继承。
Ctrl 加 T 查看继承树状关系
方法重写（方法复写，方法覆盖）：1子父类中出现方法声明出现一模一样的的方法，2子类的访问权限必须大于等于父类的访问权限，3private修饰的私有方法不能被重写。
这种现象叫做“方法重写”@Override
方法重载
权限关键字 public 公共的 > 默认的 （什么都不写）>private 私有的
子类的构造方法会先调用父类的空参构造，从而保证父类的相关内容会优于子类对象的产生。子类就可以使用父类的内容了。（因为在子类方法中 会先有一个supper（） ）；
Super():带括弧的一定是方法！
子类对象空间中包含了父类的对象空间
构造
This调用的是本类的成员变量。
在子类方法中：访问子类自身的成员，访问父类的成员。
This.成员变量 可以访问本类对象的成员变量
Super.成员变量 可以访问父类对象的成员变量
This.成员方法 可以访问本类对象的成员方法
Super.成员方法 可以访问父类对象的成员方法
This():找当前类的构造方法
Super（）：找父类的构造方法
public Dog （）{
} 调用父类无参构造方法 、
Public Dog（String name ，int age，【子】） String color{
Super(name， age)；
This.color = color；
}调用父类有参构造
成员变量：
1在没有this和 supper修饰的情况下，变量在使用时遵循就近原则（先找局部变量，再找成员变量，再找父类成员变量。）;
2局部变量和成员变量重名是用this区别开。
3子类成员变量和父类成员变量重名时用super区分，
方法调用方法
子类构造方法中第一行要么是super（）调用父类构造。要么是this调用子类构造，其最终原则是先有父类 的内容再有子类对象
包相当于文件夹，同一个包下面不能有相同的类名.
1抽象方法和抽象类：
抽象关键词：abstract
抽象方法 public abstract void methodName（）；【或者说是规则，子类必须重写】除非子类也是抽象类
抽象方法所在的类必须是抽象类。Abstract class Person{ }
抽象类的特点:
抽象类的所有抽象方法在子类必须重写。除非子类也是抽象类.
但是抽象类中有没有抽象方法也可以;
2抽象方法的定义格式：
abstract class Animal{
Public abstract void eat();
}
3父类构造方法存在的意义：
4抽象类常见疑惑：
抽象类本身的意义:抽象类不能创建对象;(不能实例化)
抽象方法所在的类必须是抽象类。但是抽象类中可以没有抽象方法;
抽象方法有构造方法,由来让子类调用.
5接口的概念：功能的集合,(只有抽象方法)
可以解决抽象类的单继承问题.
6接口的定义和使用格式:
接口关键词:interface
格式:public interface Drive{ }
使用格式:public class Manager extends Employee implements Drive{
}
Public class 类名 implements 接口名{} //类实现了接口
8接口的注意事项;
接口中没有构造方法.也不能创建对象.
实现了接口的子类必须重写接口中所有的抽象方法.除非子类也是抽象类.
9接口的固定修饰符:
在接口中,方法不管写不写abstract.修饰符都默认PUBLIC Abstract
接口中的变量都是常量,其默认修饰符都是 public static final.不管写不写都默认有.
Final ：最终修饰符
10抽象类与接口的辨析:
Public class 类名 implements 接口名1,接口名2{}
接口与类,可以多实现.也可以单实现
类与类:只可以单继承,但是可以多层继承
//接口与接口:继承关系,可以单继承,也可以多继承(没什么意义);
注意:
一个类可以继承一个类的同时,实现多个接口
在使用继承和接口时,必须先使用继承,再实现接口,
11多态的概念和格式:
面向对象 特征 封装 继承 多态
//父类引用.指向子类对象
多态的前提必须有子父类关系.或者是实现接口关系
多态:父类引用变量可以指向子类对象,只展现出父类的功能.（方法体调用的还是子类重写后的方法。但不能再调用子类特有的方法）
子类引用变量可以指向子类对象,展现出子类的功能.(包括父类的功能)
子类对象可以实现出多种形态,这多种形态叫做多态
多态的格式：
父类类型 变量名 = new 子类类型（）；
变量名.方法名（）；
12多态的使用场景及优点
使用场景：为变量赋值时使用多态，达到父类应用指向子类对象的赋值
13多态的类型装换
向上转换：多态本身就是子类型向父类类型转换
格式 ：父类类型 f = new 子类类型（）；
向下转换：（使用强制类型转换）
格式：子类类型 z = （子类类型）f；
14instanceof关键字
用于判断对象是否属于某个类型（对象与类型必须有子父类关系才可以判断，没有关系的两个类型不能判断）
格式：
Boolean b = a instanceof 类型；
判断a是够是这个类型的变量，如果是就返回true，如果不是就返回false
If（a instanceof Dog）{
Dog d = （Dog)a;
d.keepDoor（）；
}
1 static 简介：
Static是静态修饰符，一般修饰成员。
被static修饰的成员属于类，不属于单个这个类的某个对象。
被static修饰的成员又叫做类成员，不叫对象的成员。特点1被静态修饰的成员被类的所有对象共享
一般static修饰的成员，直接赋值，
类变量（类成员）：静态修饰的成员
实例变量（实例成员）：没有被静态修饰的成员
当被static修饰的成员被多个对象共享时，其中一个改变这个static成员，那么所有对象的这个成员都会被改变：
特点：被static修饰的成员可以直接通过类名直接访问
2 静态的使用方式及加载原理：
被static修饰的成员可以通过类名直接访问，类名,成员；
静态只能访问静态，想访问不是静态的就创建对象
3
4 5 final 关键字
Final：最终的，不可改变的
Final修饰的类，该类不能被继承；
Final修饰的方法，该方法不能被重写；
Final修饰基本类型的变量，无法被再次赋值，而且必须被赋值，（包括 局部变量和成员变量）该变量就变成了常量，不允许修改；
Final修饰的引用变量P不能第二次赋值，指的是P只能指向第一个地址，不能指向第二个地址，（内存地址不允许修改）（内存指向的东西可以更改）
6 包的概念及定义格式:
格式：一般是自己的域名倒着写。
必须写在有效代码的第一行。
在产生的类和对应的.class文件必须在同一个包下面（同一个文件夹下面）
7 包的全名访问：
impotr 包名加类名
8 带包的类的访问
9 10 11 访问权限：
权限修饰符：public 公共的——任何地方都可以访问
Protected 受保护的；继承的 ——有自称关系或者同一个包下面的
默认修饰符（什么都不写）：——只能在同一个包才能访问
Private 私有的——只能在本类内部访问
在本类当中：可以调用任何权限修饰的成员；
在同一个包下的其他没有关系的类：创建对象之后，除了private修饰的成员其他的都可以访问；
在同一个包下的有子父类关系的类：创建对象之后，除了private修饰的成员其他的都可以访问；
跨包下的没有关系的其他类：只能访问public的修饰的成员；
跨包下的是子父类关系的其他类：可以访问public修饰的以及protected修饰的成员
访问修饰符：
权限修饰符
public
protected
默认的
private
状态修饰符
static
final
Abstract
12 内部类的基本概念：（难点并非重点）
内部类：即在类中定义另外一个类。是一个相对概念
内部类可以直接访问外部类的所有成员
内部类分为 ：成员内部类和局部内部类（即一个方法内）
13 成员内部类：
就是放在成员位置的内部类：
创建格式：
外部类.内部类 对象名 = new 外部类（）.new 内部类（）；
内部类的意义：一个类放在一个类里面就可以用private修饰进行私有化
静态内部类，没有太大意义
14 局部内部类：局部内部类在一个方法中
A：“创建对象的语句”必须放在“类的定义”的下边
B：局部内部类访问“外部类的局部变量时。要求改变量必须用final修饰JDK1.8之后就不用手动加final了。系统后自动加上
15 匿名内部类：匿名内部类本质上是一个继承了父类或者实现了父接口的子类的对象。（它可以赋值给变量作为参数传递 也可以直接调用方法）
New 父类/接口（）{
重写父类或者父接口的方法
}
工具类：一般指的是：里面的方法全都是静态的方法，而且构造方法被私有化。
API:指得是java工程师给写好的类，为程序员提供的功能
1 Object的toString方法：
Java.long包下面的类不用导包。Object是类层次结构的根类@
输出一个对象就是默认输出这个对象的toString（）方法。
按住 Ctrl 点类名 可以进入该类
getClass（）；返回一个字节码文件对象（方法区存类的地址）
Integer.toHexString();返回指定参数的十六进制字符串形式
hashCode（）；返回该对象的哈希码值（内部地址对应的整数形式）
toString方法不重写打印的是地址值，所以我们一般重写toString方法，
右键Source ----toString 生成toString方法
快捷键：Alt+Shift+S+S 重写toString方法
String toString （）//默认返回的是”类的全名称@对象的哈斯码值的进制形式“所以一般要重写toString方法
2 Object的equals方法：
If不写大括号默认第一句话是执行语句
Obiect是一切类的根类
Boolean equals（Object obj）//判断”调用者“和”obj“是否相同
Boolean equals （Object obj ）：使用==来比较两个对象是否相等，则比较地址值是否相等。
Ctrl 加shift 加T 打开框输入类名。进入该类的源代码
Ctrl 加O 查看此类所有的成员（包括成员变量和成员方法）
Boolean equals（Object obj）//判断”调用者“和”obj“是否相同
使用==来比较对象是否相等，（引用数据比较地址值是否相等）
比较格式： boolean flag = p.equals(p2);
3 System类的概念和构造：
Static void arraycopy（Object arc原数组，int arcPos原数组的起始索引位置， Object dest目标数组，int destPos目标数组的起始索引位置，int length指定接收的元素个数）：复制数组
参数1：原数组 参数2：原数组的起始索引位置，参数3：目标数组
参数4：目标数组的起始索引位置 参数5：指定接收的元素个数
Static long currentTimeMillis（）：以毫秒值返回1970-01-01到当前系统时间的毫秒差。
格式：System.currentTimeMillis();(可以直接输出)
系统一般0表示正常，非0表示异常
停止java虚拟机（终止当前程序）：System.exit(0);
Static void gc（）：运行垃圾回收器，不一定全部回收，只是尽最大努力回收垃圾（finalize是真正回收垃圾的finaliz）
4 Date类的概述和构造：5 Date类的常用方法：
英语意思 Date ：日期
Date：表示特定的瞬间，精确到毫秒，可以通过方法来设定自己所便是的时间，时间可以是任意时间
构造方法：（）
Date（）：创建的是一个表示当前系统时间的Date对象
Date（long number）：根据“指定时间”（1970-0-0加上需要加的毫秒数number）
创建Date对象
D.tolocaleString();年月日格式
Thread.sleep(1000);每隔多少毫秒执行一次程序
6 SimpleDateFormat的概述：7 SimpleDateFormat的功能测试：
格式化： 日期到文本(字符串) Date ———String
格式：String format （Date date）；
解析：（字符串）文本到日期 String ——Date
格式：Date parse（String source）；
构造方法：
第一种 SimpleDateFormat（）；使用默认模式进行对象的构建
SimpleDateFormat sdf = new SimpleDateFormat（）；
Date date = new Date（）；
格式化 吧日期对象转换成字符串
String s = sdf.format(date);
解析 吧字符串转化成日期对象
Date d = sdf.Parse（“49-9-26 下午1：29”）
第二种 SimpleDateFormat（）；
SimpleDateFormat sdf = new SimpleDateFormat（“yyyy年MM月dd日”）；
Date date = new Date（）；
String s = sdf.format(date);
System.out.println(s);//2017年3月30日
带时分秒的 格式化
SimpleDateFormat sdf = new SimpleDateFormat（“yyyy年MM月dd日 HH：mm：ss”）；
创建对象：Date date = new Date（）；
格式化：格式
String s = sdf.format(date);
解析：格式
Date d = sdf.parse(“yyyy年MM月dd日 HH：mm：ss”);
System.out.println(d.tolocaleString());
8 Calendar的概述和测试：
Calendar：日历 提供了一些操作年月日时的方法
//创建Calendar对象 获取时间
Calendar c = Calendar.getInstance();
获取：int year = c.get(Calendar.YEAR);
修改：c.set(Calendar.DAY_OF_MONTH,20);
添加：c.add(Calendar.DAY_OF_MONTH, 2);
Date getTime（）；//把当前对象装换整Date对象
1API（前面的是返回值类型。后面的是参数类型）：Math类常用方法：abs 求绝对值、ceil天花板数：返回比该值大的最小的整数double类型 floor：地板数：返回比该值小的最大的整数double类型、random：返回带正号的【0.0-1.0）的数、pow（a，b）：求a的b次方
2：冒泡排序：（如果int数组里面有相同 的数值那么排序后相同的会连着排序（不管是从小到大，还是从大到小））（优化前）前后两个相邻 的相比，大的换到后面，重复数组（长度-1）轮（for循环的嵌套）
（优化后）前后两个相邻的相比，大的换到后面。外面的循环执行（长度-1）次控制的是循环论数，内循环每次循环（长度-第几轮）的次数就可以了。
3：Arrays类专门操作数组的类
sort排序方法：Array.sort（int【】 arr）将int数组从小到大排序
toString方法：String s = Arrays.toString（arr）；将数组转换成字符串数组形式[1, 2, 3, 4]
4：包装类的概述和基本使用：
把基本数据类型变为包装类，这种行为叫做“装箱”
八种基本数据类型都有对应的包装类
Char Char acter
Int Int eger
例如：Integer类：
String-——int：方式1 int intValue（）；需要创建对象
方式2：static int parseInt（String s）；直接用
最常用Int i = Interger。parseInt（String s）；
Int——String
方式1：int a+“”最常用
方式2：String toString （）；需要创建对象
方式3：toString（）；不创建对象
构造方法：Integer（int value）
Integer（String s）
5：JDK1.5特性之后：自动装箱和拆箱：
例如 Integer i = new Integer(10);
//自动装箱 之后
Integer i = 10；
//自动拆箱//相当于 int a = i.IntValue（）；
Integer i = 10；
Int a = i；
6：正则表达式：就是一套规则，可以用于匹配字符串(可以在API String的matches中)\\. 代表点
Boolean matches（String regex）；判断当前字符串是否符合指定的正则表达式，如果匹配返回true不匹配返回false
String s = s.replaceAll（）；支持正则表达式；替换
Split （）；支持正则表达式；分割
ArrayList：
集合的体系结构：
由于不同的数据结构（数据的组织，存储的方式），所以java为我们提供了不同的结合。
但是不用的结合他们的功能都是相似的，不断地向上提取，将共性抽取出来，这就是集合体系结构形成的原因。
体系结构：
学习？要从最顶层开始学习，因为最顶层包含了所有的共性
使用？使用最底层。最底层是具体的实现
Alt +shift+M 封装方法
Collection :类的方法（集合体系的根接口）
Collection c = new ArrayList()多态，父类引用指向子类对像
Boolean add（） ：永远可以添加成功，因为ArrsyList他允重复
Void clear（）： 清空集合
Boolean contains （）：判断集合是否包含指定元素（要在子类里面重写equals方法，）
Boolean isEmpty（）：集合是否为空
Boolean remove（）：删除集合元素
Int size（）：返回集合的元素个数
Object toArray（）：返回object类型的数组
C.getClass（）：获取文件的全名位置
迭代器：（遍历）
Iterator ：可以用来遍历集合
使用迭代器：Iterator it = c.iterator（）：
Object E next（）：返回下一个元素
Boolean hasNest（）：判断是否有元素可以获取
Remove（）：可以用iteraor 删除元素
修改异常：
添加元素需要用 List c = new ArrayList和ListIterator 迭代器
ListIterator ；
泛型：是一种广泛的类型，把明确数据类型的工作提前到 了编译时期，借鉴了数组的特点
泛型好处：
避免了类型转换的问题
可以简化我们的代码书写
可以减少黄色警告线
什么时候使用泛型：
当我们看到<E>就可以使用泛型了
Foreach：增强for循环，一般用于遍历集合或者数组
增强for循环： 1普通遍历底层就是普通for循环，就是普通for循环的简化写法
2遍历集合时。底层是“迭代器”加上普通for循环。
格式：for（元素的类型 变量 ：集合或者数组的对象）{
可以直接使用变量
}
注意：在增强for循环中不能修改集合，否则会出现异常
数组的特点：
数组的长度一旦定义则不能改变
数组中的元素都有整数索引
数组只能存储同一类型的元素
数组即可以存储基本数据类型，又可以存储引用数据类型
数组的使用：
获取元素。通过索引获取，arr[2];
添加元素（在元素3后面添加一个新元素8）：要先创建新的数组，长度为原先的数组长度+1；遍历原先的数组，并将要添加的元素插入到新的数组当中
当碰到元素3的时候，在元素3后面添加新的元素8，最后把剩余的元素添加到元素8的后面
数组的特点：查找快，增删慢。
链表：由链子链接起来的一堆结点
结点结构：地址值，值，下一个结点的地址值
获取结点：只能遍历链表，然后一个一个查看
添加结点（在结点2后面添加一个结点9）：
把结点2的下一个结点地址值修改为新结点9的地址值，把新结点9的下一个地址值改为结点3的地址值
链表特点：查询慢，增删快；
栈：先进后出（弹夹）， 队列：先进先出（）
List特点和特有功能：
要想用遍历集合的自定义对象必须在自定义对象的类中重写tostring方法才可以。
List：有序的（存储和读取的顺序是一致的）
有整数索引
允许重复
Set：无序的
无索引
元素不可以重复
List的特有功能：
Void add(int index, E slement);在指定索引位置添加指定元素，本来的元素向后排
E get(int index);根据索引返回元素，没有元素的时候会出现越界异常
E remove(int index);：删除指定索引的元素，返回被删除的元素
E set(int index, E element);：修改指定索引位置的元素，替换成指定元素，返回被体替换的元素
//创建对象 。使用特有功能
List list = new ArrayList();
List.add(1, “hello”)
List 的常用子类：
Arraylist：底层结构是数组，查询快，增删慢
LinkedList：底层结构是链表，查询慢。增删快
linkedList的特有功能：
Void addFirst（E e）;将元素添加到索引为0的为位置（最前位置）、
Void addLast（E e）：将索引添加到索引为size（）-1的位置（最后的位置）
E getFirst（）：获取索引为0 的元素
E getLast（）：获取索引为size（）-1的元素
E removeFirst（）：删除索引为0的元素，并返回被删除的元素
E removeLast（）：删除索引为size（）-1的元素，并返回被删除的元素
创建对象
LinkedLIST list = new linkdlist（）；
Alt+shift+R 改元素的名字 （可以将名字一样的一块改掉）
SET接口：
使用HashSet存储字符串并遍历：
Set的特点：无序（存储和读取的顺序可能不一样）；
不允许重复
没有整数索引
//创建对象
HashSet<String> set = new HashSet<String>();
//添加元素
Boolean boo = set.add(“hello”) 返回的是添加成功不成功
//遍历集合对象
增强for
For（String s ：set）{
Syso（s）；
}
使用HashSet存数自定义对象（不去重（先比hash值，自定义的hash值就是他们自己的地址值，他们地址值都不一样所以直接添加，不去重））并遍历：
//通过查看源码发现：
HashSET ADD()方法，首先会使用当前集合的每一元素和新添加的元素进行hash值进行比较，如果hash不一样，则直接添加元素。如果hash值一样，比较地地址或者使用equals方法进行比较，比较结果一样则认为是重复，不添加，所有的比较结果都不一样则添加
创建对象
HashSet<Student> set = new HashSet<Student>();
重写HashCode方法和equals方法实现HashSet存储自定义对象去重
在自定义的类中重写hashcode方法，返回相同值，让其运行重写的equals方法；
自动重写HashCode和equals方法是alt加shift加s加h
优化前（重写的方法1,2）
1重写equals方法时需要向下转型，获取子类特有的成员。（判断如果不同，return false；）
2重写HashCode方法，让其方法体返回相同内容即可（就可以继续比较运行equals方法），例如（return 1；）
优化后（hashCode的方法体，让基本数据类型直接相加，让引用数据的hashcode值进行相加）：
Collections：collection类的工具类。用来操作collection类
1：Static int binarySearch(List list, Object key);:二分查找，折半查找。（查找指定元素在指定类表的索引位置【必须有序】）；
使用格式：int index = Collections.binarySearch（list ,4）;[4的位置就是写想要查找的指定元素]
2:static void copy(List dest, List src):把源列表中的所有数据覆盖到目标列表（目标列表的长度必须大于等于源列表）：使用格式：Collections.copy（dest，src）；
添加整个集合内容：dest.addAll（src）；：将dest的内容全部添加到src中；
3：static void fill（List list，Object obj）；：使用指定对象填充指定列表的所有元素
使用格式：collections.fill（list，“android”）；
4：reverse ：反转 格式：collection.reverse（list）
5：static void shuffle（List list）：随机置换元素的位置 格式：collection.shuffle（list）；
6：static void sort（List list）； 按照升序的顺序排序。格式：collection.sort（list）；
7：static void swap（List list，int i， int j）;将指定列表中的两个索引对应的元素进行位置互换；
泛型：只能是引用数据类型，如果是基本数据类型，必须用基本数据类型封装的类
MAP接口：存储存在一对一关系的。
MAP：是一个双列集合，常用于处理处理有对应关系的数据，key是不可以重复的，我们也称之为夫妻对集合，collection：是单列集合，collection有不同的子体系，有的允许重复，有索引有序，有的不允许重复，无索引，无续。我们也称之为单身汉集合
MAP常用功能：
//创建对象
Map<String,String> map = new HashMap<String,String>():
Map.put(“itst001”, “zhangsan”);V put（K key， V value）；就是将key映射到value，如果key存在，则覆盖value，并将原来的值返回，如果key不存在，则添加value返回null；
Boolean containsKey （Object key）：判断指定的KEY是否存在
Bollean containsValue （Object Value）：判断指定的balue是否存在
Bollean is Empty（）；是否有对应关系
Map。Clear（）；清空所有关系
V remove（Object key）：根局指定的key删除对应关系，并返回key对应的值，如果没有删除成功，返回null
Int size（）；返回对应关系的个数
V get（Object key）：根据指定的key返回对应的值
Set<K> keyset（）；以set的形式返回所有的key
Collection <V > values（）：获取所有的value
遍历Map：第一种 先获取每一key用keyset（）；然后用增强for通过每一key获取value
第二种： Set 《Map。Entry<k,v>》 map.entrySet();
Map存储自定义对象为key时，如果需要实现去重，需要在自定义类中重写，hashcode和equals方法
自定义对象作为key时，在自定义的类中必须重写hashcode和equals方法，才可以实现去重。
所谓的异常处理，其实不是解决问题的，而是让这个问题跳过去，也就是即使发生了问题，也不影响后面其他程序的运行。
1 异常的概述和体系结构：
我们在写代码的时候，经常的出现一些小问题，那么为了方便我们处理这些问题，java为我们提供了异常机制。
异常包含了错误的类型，原因，以及位置
Throwable（最顶层） ：
Error：出现了不能处理的严重问题
Exception：可以处理的问题
异常：不正常，我们在代码的时候出现的编译或者运行时的错误。
2 jvm处理异常的方式和try。。。Catch处理异常：
Jvm处理异常的方式：如果出现异常我们没有处理，jvm会帮我们进行处理，他会把异常的类型，原因还有位置显示在命令行，并且还终止了程序，异常后面的代码就不再执行‘
异常的处理方式：1捕获处理。Try...catch语句
Try{
有可能出现问题的代码；
}catch（异常对象类型 变量）{
处理异常；
}catch的异常类型必须和可能出现问题代码出现的问题类型一样。
Try...catch 的执行顺序：如果发现异常，异常下面的代码不再执行，直接跳入catch语句中，catch语句结束后，真个try...catch结束。如果没有发现异常，tru语句执行结束后，try...catch直接结束，不再执行catch语句
3 异常的抛出：
抛出异常：当我们不想处理异常，或者没有能力处理异常的时候，我们可以选择抛出异常，谁调用方法谁处理异常，
使用关键字throws在方法的声明处抛出异常
在方法声明的最后 写上throws 和需要抛出的异常例如 throws IOException
访问修饰符 返回值类型 方法名（） throws 异常类型{ }
4 如何处理多个异常：
可以使用多个try...catch语句
也可以使用一个catch（Exception e）语句也可以，因为exception包括所有的可处理的异常
使用一个try...和多个catch
Catch 只会执行一个 执行完一个之后就直接结束了
多个catch之间的顺序：
多个catch之间会有子父类之间的关系。
平级之间没有顺序关系（catch的顺序可以随便放），有子父类关系的父类catch语句必须放在后面（因为父类异常更笼统，没有子类的异常具体）
5 Throwable的常用的方法：
String getMessage（）：输出之后显示 异常的原因
String toString（）：输出之后显示 异常的类型和原因
Void printStackTrace（）： 异常的类型 原因和位置
6 finally的概述和应用场景：
Finally：组合try...catch使用，用于释放资源等收尾工作，无论try...catch语句如何执行，finally的代码一定会执行
7 异常的分类：
运行时期异常：RuntimeException的子类就是运行时期的异常，在编译时期可以自由选择处理或者不处理
编译时期异常：是Exception的子类，非RuntimeException的子类在编译时期必须处理。（一种方式是抛出，一种是捕获try catch）
8 自定义异常：
写一个异常类：
写一个类去继承Exception或者RunTimeException，然后实现多个构造（一个无参构造一个字符串参数构造）即可；
Throws：处理异常的一种方式，把异常抛出，有调用者来处理
Throw:制造异常的方式，并且结束方法
注意：
9 递归的概述：
求5的阶乘。5！ = 5*4*3*2*1；//120
递归：把大问题拆成很多的小问题，然后再把小问题拆成更多的小问题。
当我们把很多小问题解决了，那么小问题就解决了。随着小问题的解决，大问题也就解决了（在方法本省不断的调用方法自己）
递归注意事项：递归一定要有出口，内存溢出
递归次数不宜过多，内存溢出
默认注意事项（一定要有规律猜可以使用递归）
求一个数的阶乘：
Public static int jiecheng（int n）{
if（n ==1）{
Return 1;
}else{
Return n *jiecheng(n-1);
}
10 递归求5阶乘图解:
11 使用Debug分析递归算法执行流程:
方法调用方法本身，会在内存中生成很多歌自己的方法，知道找到出口之后，在挨个执行生成的多个方法，然后执行过的方法消失。（先生成多个相同的方法，在倒着执行多个相同的方法 ）
12 斐波那契列数：
用递归的方法 算斐波那契列数的兔子数
Public static void main（String【】 args）{
Int result = method(20);
}
Public static int method(int x){
If(x==1){
Return 1;
}else if(x==2){
Return 2;
}else{
Return method(x-1)+method(x-2);
}
}
1File类的概述和常用功能：
File:文件和目录路径名的抽象表示形式，File 类的实例是不可变的
构造方法：
第一个 //File(String pathname) ：将指定的路径名转换成一个File对象
//File f = new File("D:\\a\\b.txt");（没有文件也不会 报错，但是也不会自己创建文件）
第二个//File(String parent, String child) : 根据指定的父路径和文件路径创建File对象
//File f2 = new File("D:\\a","b.txt");
（）
//File(File parent, String child) :根据指定的父路径对象和文件路径创建File对象
//File parent = new File("D:\\a");
//File f3 = new File(parent,"b.txt");
File f4 = new File(new File("D:\\a"),"b.txt");
2File类的创建和删除功能：
创建功能
* boolean createNewFile()
* boolean mkdir()
* boolean mkdirs()
* 删除功能
* boolean delete()
*
* 绝对路径：固定不可改变的路径，以盘符开头absolute
* 相对路径：相对某个参照物，不能以盘符开头
* 在eclipse中相对路径相对应当前项目的根目录
*
*
* 注意：删除一个文件夹，这个文件夹下面不能有其他的文件和文件夹
*/
public class FileDemo2 {
public static void main(String[] args) throws IOException {
File f = new File("d:\\a\\b.txt");//绝对路径
File f2 = new File（“a,txt”）;//相对路径
Syso （f2.createNamFile()） 生成一个文件，指定文件不存在时创建返回true，如果存在返回false
F2.mkdir（）；创建一个文件夹
F2.mkdirs();创建文件夹，如果文件夹所在的目录不存在，则一块创建多层文件夹。
F2.delete（）；当指定文件（或者文件夹）存在时，删除指定的文件（或者文件夹），并返回true，文件或文件夹不存在返回false（删文件夹时，一个文件夹里面不能有文件夹，否则删除不成功）
3File类的判断功能：
boolean exists():判断指定路径的文件或文件夹是否存在，存在返回true不存在返回false
boolean isAbsolute():判断当前路路径是否是绝对路径。如果是绝对路径如果是返回true 如果不是返回false
boolean isDirectory():判断当前的file对象指向的是否是一个文件夹如果是返回true
boolean isFile():判断当前路径是否是一个文件，如果是返回true
boolean isHidden():判断File对象指向的路径是否是隐藏文件，如果是隐藏文件返回true，
*判断功能
* boolean exists()
* boolean isAbsolute()
* boolean isDirectory()
boolean isFile()
boolean isHidden()
4File类的获取功能和修改名字功能：
File getAbsoluteFile():获取文件的绝对路径,返回File对象
String getAbsolutePath():获取文件的绝对路径,返回路径的字符串
String getParent():获取当前路径的父级路径,以字符串形式返回该父级路径
File getParentFile():获取当前路径的父级路径,以字File对象形式返回该父级路径M
String getName():获取文件或文件夹的名称
String getPath():获取File对象中封装时给的路径
long lastModified():以毫秒值返回最后修改时间
long length():返回文件的字节数
boolean renameTo(File dest): 将当前File对象所指向的路径 修改为 指定File所指向的路径（或者移动剪切文件）
5File的重要获取功能：
String[] list():以字符串数组的形式返回当前路径下所有的文件和文件夹的名称（只有指向文件夹的File才能调用该方法）
File[] listFiles():以File对象的形式返回当前路径下所有的文件和文件夹的名称（也是只能指向文件夹，但是它返回的file对象可以调用file的方法）
static File[] listRoots():获取计算机中所有的盘符
6输出指定目录下所有的java文件名（包含子目录）：
7删除指定目录（包含子目录）：
8IO流的分类：
输入流和输出流
字节流和字符流
9字符流复制文本文件：
10InputStream和outputStream的概述：
子类 FileInputStream
子类FileoutputStream
11分别使用字符流和字节流进行图片的复制：
字符 父类是 reader writer 常用子类是FileResder FileWriter
12字节流复制文本文件：
字节输入流：
FileInputStream
字节输出流：
FileOutputStream
缓冲流：
BufferedFileInputStream = FileInputStream+缓冲区
BufferedFileOutputStream=FileOutputStream+缓冲区
转换流：
OutputStreamWriter = FileOutputStream+编码表
InPutStreamReader = FileInputStream+编码表
字符流：
FileReader
FileWriter
字节打印流 PrintStream
字符打印流 PrintWriter
1.1 标准输
public static final InputStream in:标准输入流
public static final PrintStream out:标准输出流
OutputStreamWriter:将字节输出流转换为字符输出流
public class OutputStreamWriterDemo {
public static void main(String[] args) throws IOException {
//method2();
//创建输入流对象
BufferedReader br = new BufferedReader(new FileReader("SystemInOutDemo.java"));
//创建输出流对象
//OutputStream os = System.out;
//Writer w = new OutputStreamWriter(System.out);//多态，父类型引用指向子类对象
//BufferedWriter bw = new BufferedWriter(w);
BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
//进行数据的读写
String line;//用于存储读取到的数据
while((line = br.readLine()) != null) {
bw.write(line);
bw.newLine();
}
InputStreamReader:将字节输入流转换为字符输入流
public class InputStreamReaderDemo {
public static void main(String[] args) throws IOException {
//创建输入流对象
InputStream is = System.in;
Reader r = new InputStreamReader(is);
//创建输出流对象
FileWriter fw = new FileWriter("a.txt");
//读写数据
char[] chs = new char[1024];
int len;
while((len = r.read(chs)) != -1) {
fw.write(chs,0,len);
fw.flush();
}
1.2 打印流
打印流添加输出数据的功能，使它们能够方便地打印各种数据值表示形式.
字符打印流 PrintWriter
void print(String str): 输出任意类型的数据，
void println(String str): 输出任意类型的数据，自动写入换行操作
* PrintStream
* PrintWriter
* 可以自动换行，println()
* 不能输出字节，但是可以输出其他任意类型
* 通过某些配置，可以实现自动刷新（只有在调用 println、printf 或 format才有用）* 也是包装流，不具备写出功能
* 可以把字节输出流转换成字符输出流*
* 注意：只能输出不能输入
public class PrintWriterDemo {
public static void main(String[] args) throws IOException {
//创建打印流对象
PrintWriter pw = new PrintWriter("b.txt");
//写出数据
pw.write("hello");
pw.write("world");
pw.write("java");
1.2.1 案例代码四:利用打印流实现自动换行与自动更新
1.2.2 案例代码五:
利用打印流将根目录下的SystemInOutDemo.java复制到
1.3 概述用于从流中读取对象的
1.4 ObjectInputStream 称为 反序列化流,利用输入流从文件中读取对象
ObjectOutputStream 称为 序列化流,利用输出流向文件中写入对象
特点：用于操作对象。可以将对象写入到文件中，也可以从文件中读取对象。
}
第2章 Properties集合
2.1 Properties介绍
Properties 类表示了一个持久的属性集。Properties 可保存在流中或从流中加载。属性列表中每个键及其对应值都是一个字符串。
特点：
1、Hashtable的子类，map集合中的方法都可以用。
2、该集合没有泛型。键值都是字符串。
3、它是一个可以持久化的属性集。键值可以存储到集合中，也可以存储到持久化的设备(硬盘、U盘、光盘)上。键值的来源也可以是持久化的设备。
4、有和流技术相结合的方法。
2.2 利用Properties存储键值对
2.2.1 案例代码九:
public class PropertiesDemo2 {
public static void main(String[] args) {
//创建属性列表对象
Properties prop = new Properties();
//添加映射关系
prop.put("CZBK001", "zhangsan");
prop.put("CZBK002", "lisi");
prop.put("CZBK003", "wangwu");
//遍历属性列表
//获取所有的key，通过key获取value
Set<Object> keys = prop.keySet();
for (Object key : keys) {
Object value = prop.get(key);
System.out.println(key + "=" + value);
}
System.out.println("------------------");
//获取所有的结婚证对象
Set<Map.Entry<Object,Object>> entrys = prop.entrySet();
for (Map.Entry<Object, Object> entry : entrys) {
Object key = entry.getKey();
Object value = entry.getValue();
System.out.println(key + "=" + value);
}
}
}
2.3 Properties与流结合使用
2.3.1 案例代码十:
package com.java_08;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.Properties;
/*
* Properties和IO流结合的功能：
void load(Reader reader)
void list(PrintWriter out)
void store(Writer writer, String comments)
*
*/
public class PropertiesDemo2 {
public static void main(String[] args) throws IOException{
//创建属性列表对象
Properties prop = new Properties();
//添加映射关系
prop.setProperty("CZBK001", "zhangsan");
prop.setProperty("CZBK002", "lisi");
prop.setProperty("CZBK003", "wangwu");
//创建输出流对象
FileWriter fw = new FileWriter("e.txt");
//void store(Writer writer, String comments)
prop.store(fw, "hello world");
//释放资源
fw.close();
}
1多线程的概述：
进程：当前正在运行的程序，一个应用程序在内存中的执行区域（一块内存空间）。
线程：进程中的一个执行控制单元，执行路径（做的每一件事情可以看做一个线程）
一个进程可以有一个线程，也可以有多个线程（多线程）
单线程：安全性高，但效率低
多线程：安全性低，效率高（同时进行多个线程）如迅雷同时下载多个电影
2多线程（创建多个线程实例，并启动多个线程）的实现方式：
Thread类
写一个类继承Thread的子类，重写Thread的run方法（被测试类运行的方法），
测试类，创建线程实例：（和普通类一样new）子类名 变量名 = new 子类名（）；
启动线程：变量名.start（）；
String getName（）；获取线程的名字
Void setName（String name）；修改线程的名字为name
多线程：cpu在执行顺序上不确定，在多个线程之间随机执行
3主方法是单线程的：
主方法在运行 的时候是单线程运行的
4多线程的实现方式：
Runnable接口
写一个子类实现Runnable接口，并重写public void run方法。
实现Runnable接口，不能直接用[getName好似静态方法]getName（）方法；
必须先创建和获取线程Thread对象，用Thread对象调用getName方法。
//Static Thread currentThread（） 返回当前线程对象：Thread t = Thread.currentThread();
T.getName（）；
测试类：创建线程实例：MyRunnable mr = new MyRunnable（）；
将子类创建的对象 传给Thread ： Thread t = new Thread（mr）；
//用 线程Thread对象调用getName方法。t.setName（）
启动线程： t.start（）；
5多线程模拟火车站售票出现问题：
Static void sleep(long millis):让当前线程暂停一会，时间单位是毫秒
6分析火车站售票出现问题原因：
是因为不同的线程在进入if之后 Thread.Sleep方法让它休息一会，并没有卖出票，那下一个线程也会通过if判断，所以会出现-1 -2的情况
7使用同步代码块解决多线程案例中出现的问题：
问题出现的原因：1要有多个线程2要被多个线程所共享的数据3多个线程并发的访问共享的数据
同步：安全性高，效率低
不同步：效率高，但是安全性低
Synchronized：同步（修饰符），可以修饰代码块和方法，被修饰的带玫瑰和方法一旦被摸个线程访问，则直接锁住，其他的线程将无法访问
同步代码块：
Synchronized（锁对象）{
需要锁住运行的代码
}
注意：锁对象要被所有的线程锁共享。
8同步方法：
Synchronized :使用关键字synchronized修饰的方法，一旦被一个线程访问，则整个方法全部被锁住，其他的线程无法再访问
Synchronized：注意
非静态同步方法的锁对象是this
静态的同步方法的锁对象是当前类的字节码对象（文件）
Get.class（）；获取字节码文件对象 或者类名.class（）；
9线程的声明周期：
生命周期：一个对象的从生到死的过程
新建 就绪 运行 死亡
创建线程对象 ——》具备了执行条件——》具备了执行条件——》线程对象变成了垃圾
没有具备执行权力 具备了执行权力
等待方法：等待wait（）；让当前的线程对象等待
唤醒notify（）；让等待的线程继续执行（是让线程回到就绪步骤）
1 网络编程的概述：
Socked（套接字）：用于描述IP地址和端口，是一个通信链的句柄。在Internet上的主机一般运行了多个服务软件，同时提供几种服务。每种服务都打开一个Socket，并绑定到一个端口上，不同的端口对应于不同的服务。
Socket就是为网络编程提供的一种机制；童鞋的两端都有Socket；网络通信其实就是Socket间的通信；数据在两个Socket间通过IO传输
2 网络通信中的三要素：
IP地址：InetAddress （在网络中的 位移地址）（网络中设备的表示，不易记忆，可用主机名）；
端口号：用于表示进程的逻辑地址，不同进程的标识(编号)
传输协议(网络协议)：通讯的规则，常见协议：TCP 可靠协议，需要连接，效率会稍低 没有大小的限制UDP 不可靠协议，不需要建立连接，速度快,最大传输包为64KB
3 InetAddress的概述和测试：
InetAddress类:此类表示互联网协议（IP）地址。
Static InetAddress getByName（String name）；通过主机名获取ip地址
getHostAddress（）；返回IP地址
getHostName（）；返回主机名
getLocalName（）；获取本地主机名
4 UDP协议发送数据：
DatagramSocket：是发送和接收的类
DatagramPacket:此类表示数据报包（）
DatagramSocket();创建Socket对象并随机分配端口号
DategramSocket（int port）；创建Socket对象并指定端口号
先创建发送端Socket对象：
DategramSocket ds = new DategramSocket():
创建数据并打包:
String s = “hello udp”; 创建字符串数据
Byte[] bys = s.getBytes(); 转换成byte类型数组
Int length = bys.length(); 接收的长度
InetAddress address = InetAddress.getByName(“java”);//发送给的主机名字
Int port = 88888； //端口号
//打包 byte类型信息 长度 目的地ip地址值 目标端口号
DatagramPacket dp = new DatagramPacket(bys,length,address,port);
发送数据:
调用dategramSocket的发送方法
ds.send(dp);
释放资源:
ds.close();
5 UDP协议接收数据:
//创建接收对象 （在收件的时候要给出端口号，为了让发送端找到指定的接收端）
DategramSocket ds = new DatagramSocket(88888);
//接收数据：
Byte[] bys = new byte[1024];
DatagramSocket dp = new DatagramSocket(bys，bys.length);
ds.receive(dp);//阻塞
//解析数据:
InetAddress address = dp.getAddress();
Byte[] date = dp.getDate();
Int length = dp.getLength();
//输出数据
Syso(“sender——》”+address.getHostAddress());
Syso(new String(date,0,length));
//释放资源
6 UDP协议收发数据注意事项
127.0.0.1 地址一直指的是自己的ip地址
端口号错误，数据可以正常发出，不会出现异常，但是收不到数据
Address already in use ：端口号已经被绑定了，端口号不能重复（自己运行两个会造成重复，也不能和系统的其他进程的端口号重复）
7 TCP协议发送数据:
注意：tcp的是 客户端和服务端。客服端可以主动访问服务端，服务端不能主动访问客户端。 但是在建立联系之后，就可以互相访问了。
创建发送端Socket对象（创建对象,并且需要指向服务器的ip地址和端口号）：
Socket s = new Socket(InetAddress.getByName(“java”),10000);
Socket s2 = new Socket(“127.0.0.1”, 9999);(也可以直接给)
//想其他对象（服务器）发数据，用Socket的getOutputStream（）获取输出流，向外输出数据。获得输出流对象
OutputStream os = s.getOutputStream();
发送数据
String str = “hello java”;
Os.write(str.getBytes());
释放资源
S.close();
8 TCP 协议接收端(服务端)数据
创建接收端Socket对象：接收需要表明端口号
ServerSocket ss = new ServerSocket(10000);
监听//阻塞: 调用ServerSocket的accept方法获取一个Socket对象
Socket s = ss.accept(); 只有在有客户端访问服务端的时候，这个方法再会执行，否则一直等待
接收输入流对象
InputStream is = s.getInputStream();
获取数据
byte[] bys = new byte[1024];
Int len;//用于存储读到的字节个数
Len= is.read(bys);
输出数据
Syso(new String(bys,0,len));
释放资源
S.close();
Ss.close();//关闭服务端，也可以不关闭
9 用TCP协议发送数据并将接收到的数据转换成大写返回
10 模拟用户登录
11 模拟用户登录案例改写
作业 模拟用户登陆。While循环
1反射机制的概述和字节码对象的获取方式：
在运行时，我们可以获取任意一个类的所有方法和属性
在运行时，让我们调用任意一个对象的所有方法和属性
反射的前提：要获取类的对象（Class对象）字节码对象
第一种：创建对象，对象.getClass（）；获取
第二种：可以通过类名获取字节码对象：class cla = student.class；
第三种：Static class = forName(String className);通过类的全名获得字节码对象，
Class.forName(“类地址的全名称”)；
2通过反射获取构造方法并使用：
获取构造可以创建对象；
字节码对象.getConstructors();获取所有的public修饰的构造方法 返回的是数组
字节码对象.getConstructor();不给参数是获得无参构造
无参构造。newInstance(); ，输出的是成员变量
带参构造。newInstance(给出参数就行);
字节码对象。getDeclaredConstructor（参数的类型1，参数的类型2）；获取成员变量带参的构造方法
字节码对象。newInstance（）；获取构造对象
3通过反射获取成员变量并使用：
Fileld【】 fs = 字节码对象。getFields（）；获取所有的public修饰的成员变量
Filed fs2 = 字节码对象。getField（String）；获取public修饰的成员变量（根据字段的名称获取公共的成员变量对象）
Filed fs3 = 字节码对象。getDeclaredFields（）；获取所有的成员变量
Filed 的方法：get（对象） 通过对象获取成员变量的值
set（对象，修改的值）； 通过成员变量对象，修改为指定的值
4 通过反射获取私有成员变量并使用：
字段对象（私有成员变量）。setAccessible（true）；//（ture）就是设置反射时取消Java的访问检查，（暴力访问）
5通过反射获取成员方法并使用：
getMethod（类的全名，方法对应的参数名）。没有参数时，方法对应的参数不写就行
Object obj = Invoke（对象，参数名）；
6 javaBean的概述和规范：
JavaBean：用于封装数据（标准的类）
1类使用公共进行修饰，2提供私有修饰的成员变量3为成员变量提供公共的getset方法4提供公共无参的构造5 实现序列号接口；序列号接口是 Serializable
7 BeanUtils的概述：Apache commons主要功能是为了简化javaBean封装数据的操作
Void setProperty（）；设置属性
String getProperty（）；获取属性
Void populate（）；
8 BeanUtils的常用方法：
Void setProperty（javaBean的对象，成员变量名，想赋的值）；设置属性，给javaBean对象的成员变量进行赋值
String getProperty（javaBean对象，成员变量名）；获取对应的成员变量的值，
setProperty 和getProperty方法底层并不是直接操作成员变量，而是操作和成员变量名有关的get和set方法
Void populate（javaBean对象，map k对应成员变量的名字，value对应成员变量对应的值）；把map中的映射关系，添加到javabean中，map中有多余的也不会出错
9 自定义BeanUtils的赋值和获取方法实现：
10 自定义BeanUtils的populate方法实现
A：获取类的字节码文件（class对象）
类的对象.getClass（）；
类名.class；
Class.forName（“类的全名称”） // 格式：Class clazz = Class.forName(“类的全名称”)；
B:获取构造方法 getDeclaredConstructor
Constructor[] getConstructors()//获取类的所有的公共的构造方法
Constructor getConstructor( .class)//获取类的指定的公共的构造方法
Constructor[] getDeclaredConstructors()//获取类的所有构造方法包括私有的
Constructor getDeclaredConstructor( .class)//获取指定的构造方法，包括私有
newInstance（）；//使用构造方法，创建对象（获取的是无参就不给参数，获取的是有参构造就给参数）
C:通过类的构造方法获取成员变量 Field fl = 字节码对象.gerDeclaredField（）；
Field [] getFields();//获取公共的成员变量
Field getField(String); 获取指定的成员变量
Field [] getDeclaredFields();//获取所有成员变量。包含私有
Field getDeclaredField();//获取指定的成员变量，包含私有
使用成员变量
Object get(Object obj)//获取对象obj的当前变量的值
Void set(Object obj .Object value)；//设置对象obj的当前变量的值为value
D：暴力访问 setAccessible（true）
setAccessible（true）//当参数为true的时候不检查访问权限，成员变量成员方法构造方法都可以使用这个方法
E:获取成员方法(class)类的方法
Method getMethod（String naem, .class）
Method的方法】
\
通过字节码对象.getMethod（“getName”） 获得方法
Method m = clazz.getMethod("getName");
然后用 方法。Invoke（stu）对象；
Object obj = m.invoke(stu);
Invoke（obj， value）；
善意分享，欢迎点赞，不喜勿喷；
可以转载，互帮互助，注明出处。
4115
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
