oop笔记

JAVA

java技术特征

1、简单性

​ (1)Java由C++衍生而来，其语言风格与C,C++十分类似。
​ (2)Java比C++简单，抛弃了C++中一些不是绝对必要的东西，如头文件、指针、结构、联合、隐式的类型转换和操作符重载等。
​ (3)Java提供了丰富的类库，可以帮助我们很方便的开发Java程序

2、面向对象的语言（OO）

​ 万物皆对象，通过对象解决实际问题

3、一种与平台无关的语言(跨平台)

​ 如何实现跨平台：
​ JVM：java虚拟机
​ jvm工作原理：
​

一次编译随处运行		

4、健壮性和安全性

​ 健壮：GC垃圾回收机制
​ 安全性：通过Java的安全体系架构来确保Java代码的安全性。

5、多线程

​ 多线程应用程序能够同时运行多项任务。

java平台的分类：

JavaSE(Java Platform, Standard Edition)

​ java平台标准版：做PC应用程序开发

JavaEE(Java Platform, Enterprise Edition)

​ java平台企业版：做web应用程序开发

JavaME(Java Platform, Micro Edition)

​ java平台微小版：做小型设备的嵌入式开发

环境变量配置：

​ JAVA_HOME C:\Program Files\Java\jdk1.8.0_60
​ PATH ：%JAVA_HOME%\bin

cmd跳转到对应源文件路径
将源文件编译成字节码文件：javac 源文件名称.java
运行字节码文件: java 字节码文件名称

HelloWorld显示：
public class HelloWorld{
public static void main(String[ ] args){
System.out.println(“Hello World.”);
}
}

public：访问修饰符，公共的，该项目都可以访问该类
class：类的关键字
HelloWorld：类名，类名跟源文件名称一致
public class HelloWorld{} :创建一个共有的类，名称叫HelloWorld，
类中只有属性跟行为

static：特殊访问修饰符，静态的
void：无返回值
main：主方法名称，程序的入口，从主方法开始执行代码
(String[ ] args)：方法的参数，字符串数组
public static void main(String[ ] args){} ：创建一个公共的静态的主main方法

System.out.println(“Hello World.”);输出:Hello World.

标识符：

​ 系统标识符：关键字
​ 自定义标识符：类名、变量名、方法名
​ 标识符由字母、下划线“_”、美元符“$”或数字组成。
​ 标识符应以字母、下划线、美元符开头。
​ Java标识符大小写敏感，长度无限制。
​ “见名知意”
​ 约定俗成的规则

java 数据类型：

​ 基本数据类型、引用数据类型
​

基本数据类型：
	整形、浮点型、字符型、布尔型
	整形：byte 字节型\short 短整型\int 整形\long长整型 数值后添加L\l，默认的是int类型
	浮点型：float 单精度，添加F\f,\double 双精度,默认是double类型
	字符型：char,数据添加单引号，只能赋值一个字符
	布尔型：boolean 
引用数据类型： 所有的对象都是引用数据类型
基本型数据和引用型数据的区别：
	1、基本型数据在内存中占用一个存储空间，
	而引用型数据占用两个存储空间
	2、基本型数据在内存中占用的空间大小是固
	定的，而引用型数据在内存中占用的空间大小不固定

声明变量：
	格式：数据类型 变量名称=值;
		据类型 变量名称；
		变量名称=值;

	变量分类：
		全局变量：声明在方法外部，类中，任何方法都可以使用
		局部变量：声明在方法内部，只能在当前方法中使用


	注意：java中的变量，必须声明之后才能使用，
	         局部变量，必须赋值后才能使用
	        全局变量，不需要赋值，有默认值
		int :0
		char:' '\a
		double:0.0
		float:0.0
		boolean:false
		引用数据类型：null

	2进制
	8进制
	10进制
	16进制

常量：

​ 数据初始化后，在程序运行期间不可改变，值固定
​ final 数据类型 常量名称 = 值;
​
特点：
​ a、给常量具体的业务含义名称，方便识别
​ b、如果在程序中需要修改常量值，可以做到一处修改，处处改变

常量、类(对象)、变量的命名规则：

​ 常量：名称全字母大写
​ 类(对象)：首字母大写，驼峰命名法
​ 变量：首字母小写，驼峰命名法
​

&& 、|| 与 & 、|区别

双个的&&两边条件都满足才为true,只要一个不满足
就为false,双个的&&当第一个条件为false的时候，第
二个条件就不需要再去判断，结果直接为false,单个的
&是先将两个条件都判断，再去取与的结果
单个的|与双个||，区别同上。

^:异或，相同的就为false,不同的就为true
int x = 5, y, z;
y=x++; y=5;
z=++y; z=6;
?=(x++)+(–y)+(++z);

boolean b = ((x + 3 > y) ^ (z >= y)) && !(x == 5 | ++x == y);

基本数据类型转换:

​ 由小到大
​ byte—short—int----long----float—double
​ char跟int可以互相转换
​ char---->int 自动转
​ int----->char强制转
​ 转换分类：
​ 小转大自动转
​ 大转小强制转 数据类类型 小的变量名称 = (小的数据类型)大的变量
​ int num1 = 1000;
​ byte num = (byte)num1；
​ 大转小，超出的部分，又从小的数据最小值开始继续计数；
​ int以下的数值做运算值为int;
​ int以上的数值做运算，结果为大数值的类型；
​ byte num =10;
​ short num1 = 20;
​ ?=num+num1;
​ 为什么long可以不加l\L，float必须加f\F
​

单行注释

​ //注释内容，某一条语句

多行注释

​ /*
​ 注释内容，注释的是某一块语句
​ */

文本注释

​ /**
​ 注释内容，注释的类、属性、方法
​ */

JAVA中的输出：

​ System.out.println(); 输出带换行符的信息
​ System.out.print();输出不带换行的信息

JAVA中的输入：

​ JAVA中的输入是由类库中的一个基本类完成的
​ 引入外部类：
​ 在类的public class语句之前加入：import java.util.Scanner;
​ 创建输入对象
​ 引用数据类型 对象名称 = new 引用数据类型();
​ System.in：输入流
​ Scanner sc = new Scanner(System.in);
​ 常用输入方法：
​ 输入对象.nextInt();//接收整型输入
​ 输入对象.nextDouble();//接收浮点型输入
​ 输入对象.next();//接收不带空格的字符串输入
​ 输入对象.nextLine();//接收带空格的字符串输入

面向过程：侧重在功能实现的角度思考问题

分析出解决问题所需要的步骤，然后用方法把这些步骤一步一步实现，使用的时候一个一个依次调用就可以了。

面向对象：侧重在功能的整体构成角度思考问题

把构成问题事务分解成各个对象，建立对象的目的不是为了完成一个步骤，而是为了描叙某个事物在整个解决问题的步骤中的行为。
面向对象比面向过程的好处：
对功能进行了统一，从而保证了程序的可维护性增强。程序的可维护性增加保证了程序的可扩展性的提高

面向对象分析：OOA（Object Oriented Analysis）

面向对象设计：OOD（Object Oriented Design）

面向对象编程：OOP（Object Oriented Programming）

万物皆对象:
具有明确状态和行为的实体，
即为对象
具有相同状体和行为的一组对象的集合，我们就称为类
类是具有相同属性和行为的一组对象的集合
类是对象的模版，对象是类的实例
一个类可以创造无数个对象，每个对象都必须属于一个特定类

创建类：
public class 类名{

}
注意：1、Java中的类用关键字class声明。
        2、Java源代码文件中只能包含一公共（public）类，
       3、文件名必须与公用类的类名相同，文件扩展名为“.java”
       4、类名首字母大写，驼峰命名法

创建人类：	
	public class Person{

}

创建属性\成员变量\全局变量：
访问修饰符 [特殊的访问修饰符] 属性的数据类型 属性的名称;
public String name;
创建方法\行为\成员方法：
访问修饰符 [特殊的访问修饰符] 方法的返回值类型 方法名称(参数列表) [异常]{

}
public void eat(){
	
}
注意：没有返回值用void;

通过类创建对象：实例化对象
类型 实例化对象名称 = new 类型();
Person p = new Person();
给对象的属性赋值：
对象.属性名称 = 值；

static：
1、静态的，可以修饰属性、方法，
2、修饰的属性跟方法又称类属性、类方法，
3、static修饰的属性跟方法可以通过类名.属性\类名.方法名称()调用，
不用通过实例化对象。
原因？
程序在编译时，jvm就会将static修饰的属性跟方法创建，在类加载
的时候jvm会创建一个类对象，类名.属性\类名.方法()实质是通过类
对象去调用的。
4、static 修饰的属性跟行为共用一个对象：类对象
类属性、类方法与成员属性、成员方法之间的区别：
1、类属性、类方法在程序编译时就创建，
成员属性、成员方法程序运行时创建
2、类属性和类方法可以直接通过类名调用，
也可以通过对象调用；而成员属性和成员
方法只能通过对象调用
3、类属性和类方法所有对象都是共享同一份；
而成员属性和成员方法则每个对象都具有独立的一份，
彼此不互相影响

方法的返回值：
public 返回值类型 方法名称(){

}
特点	
1、返回类型可以是任何一种数据类型或对象类型
2、return后跟的数据是什么类型，返回值类型就是什么
3、没有返回值就void
4、返回值是指方法执行以后具体返回的结果值，
     没有条件语句、循环语句时，return只能放在代码块的末尾
     有条件语句、循环语句时，return可以放在该语句中，
     使用条件语句、循环语句时,要保证有返回结果
5、一个方法中可以有多条return语句，但此时必须与
     条件语句、循环语句配合
6、无返回的方法体中也可以出现return，但此时return
     后不能有返回值
7、调用方法后获取返回结果，使用的变量类型一定与方
      法的返回值类型一致

创建一个计算器，两个属性，做运算的两个数据
四个方法：加减乘除，每个方法返回计算机结果，
调用方法获取结果并输出

方法的签名：

​ 方法签名由方法名和形参列表共同组成
​ 1、一个类不能出现完全相同的方法签名
​ 2、方法签名中的方法名命名规范与变量名相同，
​ 注意的是方法名以动词开头
​ 3、方法签名中的形参列表可以是0到N个参数，每个
​ 参数之间用逗号分隔，参数的语法就是变量的声明
​ 语法，参数的含义是该方法执行所需要调用者传入的前提数据
​

方法名称（参数列表）{}
method(int a,String b,...N){}

方法调用栈：

​ 1、方法调用方法，先进后出，后进先出
​ 2、方法调用时，调用的方法执行完会回到方法调用的地方，
​ 程序继续往下执行

静态方法、属性与非静态方法属性之间的调用：

1、本类的静态方法调用静态方法

​ public static void test() {
​ System.out.println(“test”);
​ test1();
​ }
​ /**
​ * 静态方法1
​ */
​ public static void test1() {
​ System.out.println(“test1”);
​ }

2、本类的非静态方法调用非静态方法

3、本类的静态方法调用非静态方法

​ 实例化对象

4、本类的非静态方法调用静态方法

​ 直接调用

5、不同类的静态方法调用静态方法

​ 类名.方法()
​ 实例化对象

6、不同类的非静态方法调用非静态方法

​ 实例化对象

7、不同类的非静态方法调用静态方法

​ 类名.方法()
​ 实例化对象

8、不同类的静态方法调用非静态方法

​ 实例化对象

方法的递归：

​ 就是方法自己调用自己
​ 什么时候使用递归：
​ A、一个问题可以分解为若干个小问题
​ B、每个小问题的解决方案是相似的
​ 注意：一定要定义方法的结束，否者会循环

1、输出1+2+3....+10的结果
2、5！

创建对象：

​ 类型 名称; //对象的声明，对象的引用，存放对象的地址
​ new Employee(); 实例化对象
​ 声明并创建对象
​ Employee e = new Employee();
​

内存空间：

​ 堆、栈、常量池
​ 堆：容量大，查询效率底
​ 栈：容量小，查询效率高
​ 常量池：数据不重复，存放具体的数据
​

参数的值传递：参数是基本数据类型

1、值传递的本质是将实参的副本传入方法的形参中
2、所以在方法中对形参做出的任意改变都不会影响方法之外的实参数据

参数的引用传递：参数是引用类型

1、引用传递的本质是将对象的引用(地址)传入方法的参数中，
所以方法中的形参与方法外实参参引用一致，在内存中都
指向同一个对象，那么此时方法中对形参对象做出的任何
操作，方法之外实参对象也会受到影响

通过在类文件的第一行添加package语句完成，语法：
package 包名;//表示当前类在哪一个包中

import java.util.Scanner
import test.Test
如何导入某个包中的类？
通过在类前，package语句添加import导入包中的类，语法：
import 包名.类名; (推荐写法) import 包名.*;(不推荐)

this：当前对象

​ 1、可以调用当前对象的属性、行为
​ 2、this只能在类中使用，代表这个类的当前对象
​ 3、在类中调用本类的属性跟行为时，可以不用写this.属性名，
​ 系统会默认添加；但是在参数名称跟属性名重名的情况下，
​ 必须添加this区分

类的方法重载：

​ 在同一个类中，方法名称相同，参数列表不同
​ (参数的个数不同、参数的类型不同)

注意要点：
1、重载的要件是方法名和参数列表，返回值不是重载的要件
2、参数列表不同含义为：参数个数不同或者类型不同，或者参
数个数类型相同的情况下，顺序不同
3、重载方法的调用时通过传入的实参在运行时动态绑定要执行
的方法
4、重载方法体现但是同一个对象的同一行为具有不同的表现形

体现：构造器

构造器：

​ 一种特殊的方法，用于实例化对象；
​ new 类名();
​ 格式：
​ public 类名(参数列表){
​ 代码块…
​ }

作用：1、创建对象

​ 2、初始化对象的成员属性
​ 3、返回对象的内存地址

注意：

​ 1、在没有写其他构造器时，
​ 系统会默认的创建一个无参构造器
​ 2、写了其他的构造器，
​ 系统不会默认的创建一个无参构造器
​ 3、一般在写构造器时，不管无参构造
​ 器有没有使用，都自己手动创建一个

构造器调用构造器：

​ this();
​ 1、构造器调用时，this()；只能放在构造器的第一行
​ 2、构造器调用构造器只能在构造器中调用

########java 的三大特征########

封装、继承、多态

封装？
封装属性\行为
为什么封装？
保护属性\行为

封装的概念：
一般只对属性封装
将一个类的属性私有化，提供公有的方法访问即为封装

访问修饰符：
public：公共的，只要在同一个项目中就可以访问
private：私有的，属性只能在本类中使用
protected：受保护的，本类，同包的类或本类的不同包子类可以访问
默认的\缺省值(什么也不写):
不写修饰符即为默认，只有本类或同包的类可以访问

共有的方法：
访问器、修改器

访问器：
	格式：
		public 属性的类型 get属性名称首字母大写(){
			return this.属性;
		}

修改器：
	格式：
		public void set属性名称首字母大写(属性值){
			this.属性 = 属性值；
		} 

继承：
什么是继承？
类与类之间出现的一种关系，父子关系
为什么要继承关系？
1、A继承B类，拥有父类的所有属性跟行为，减少代码量
2、增强代码的可扩展性
关键字
extends
格式：
public class 子类类名 extends 父类名{

		}

重写：

​ 在继承关系中，子类继承父类的属性、行为，
​ 并且可以修改父类的行为(修改方法的方法体)
​ 方法名相同，参数列表相同，方法体不同/相同
​ 注意：
​ 1、子类的方法的返回值的类型、方法名和形式参数列表，
​ 必须和父类中的是相同的。
​ 2、访问修饰符必须不小于父类中的访问修饰符。
​ 3、子类中重写的异常不能抛出比父类更多的异常

父类：(基类) 指继承关系中被继承的类
子类：(派生类) 指继承关系中继承的类

java类与类之间的关系：
1、has-a（组合）有一个
2、is-a（继承）小时工 是一个 员工

继承的优点
代码的可重用性
父类的属性和方法可用于子类
设计应用程序变得更加简单
子类可以扩展父类的属性和方法
子类可以重写父类的方法

继承的特点：
java：单根继承，一个类只能有一个父类
弥补单根继承：接口

java中所有的类都直接或者简介继承Object类，
Object类被认为是所有java类的祖类

构造器与继承：
构造器是否能继承？
不能继承，只能调用
子类调用父类的构造器：
super：父对象，可以调用父类的属性、行为、构造器
super();

1、子类创建对象时，会默认调用父类的无参构造器，
     如果人为调用后，系统就不会默认调用
2、super调用父类构造器，只能在子类构造器中使用，
并且只能写在子类构造器的第一句
3、super调用父类的属性跟行为，可以在子类任何地
方使用，并且可以简写
4、先创建父对象，再创建子对象 

final :
修饰常量：在运行时不能更改，值固定，全字母大写
final修饰类：
public final class 类名{}
终态类，不能被继承
final修饰方法：
public final void 方法名(){}
终态方法，不能被重写

多态:
什么是多态？
生物学，是指一个生物或物种可以有多种不同的形式或阶段。
OOP中，多态是指一个对象有多种形式的能力。
java的多态：相同的行为不同实现
为什么使用多态？
灵活性高，扩展性强，耦合度低
多态的分类：
静态多态：
程序编译时，系统可以区分所调用的重载方法
重载方法，我们把这种实现方式称之为静态多态。
缺陷：
1、使用静态的多态会让程序设计变得死板，灵活性和扩展性差。
2、灵活性差：如果要驾驶员更换驾驶的汽车，则必须修改驾驶
员调用驾驶行为的代码
3、扩展性差：如果要增加新的汽车让驾驶员驾驶，则必须修改
驾驶员类，增加新的重载行为

	向上转型、向下转型（引用数据类型）:
		注意：1、两个引用数据类型之间的转换必须是在继承关系中
		          2、父类只能使用自己的方法，无法调用子类扩展的方法
		         3、向下转型时注意，只能转型成动态绑定子对象	，否则就抛异常	
		向上转型：子类转换成父类，自动转
		向下转型：父类转换成子类，强制转


	动态多态：
		向上转型+动态绑定
		父类的引用指向子类的对象
		动态绑定：
			是指程序在运行期间，由虚拟机自动判断传入
			对象的真实类型，并去调用真实类型行为的方式。

​

抽象类和接口

抽象类：

​ 不是一个具体存在的类，是我们人为想象出来的。
​

为什么使用抽象类？

汽车类---通过具体的实体抽象出来的

	宝马、奔驰、奥托、摩托......
抽象类：
	1、共有的方法，有没有方法体？
		不用写方法体直接写方法名
	2、共有的方法，没有方法体，方法体在哪儿？	
		子类必须重写父类的方法..
	3、抽象出来的类，有没有具体的对象？
		抽象类是没有具体的对象

抽象关键字：
	abstract
	抽象类：public abstract  class 类名{}
	抽象方法：public abstract void 方法名(参数列表);

抽象的特点：
	1、一个类中如果有一个抽象方法，该类就一定是抽象类
	2、抽象方法，子类继承父类时，必须重写
	3、抽象方法，不用写方法体
	4、抽象类中可以有普通方法
	5、抽象类不能实例化对象
	6、抽象类中有构造器

接口：

​ 为什么使用接口？
​ 实现维修工给车加油、换胎；
​ 问题?我才买的车需要，换胎？
​ 问题车才会换台胎
​ 我车油满的车需要加油吗？
​ 问题车才会加油
​ 具体的车类需要继承车类又要继承问题车类
​ java单根继承，无法实现多继承
​ 1、使用接口解决多继承
​ 2、使用接口为外部类添加功能
​ 3、以面向对象的角度考虑,将一个类与身自来的
​ 特征和行为和依赖于外部的可选的特征和行为分
​ 离,让类尽可能的单纯,即解耦

使用接口：
	创建接口
		interface
	public interface 接口名称{}
	实现接口：
		implements
	public class 类名  implements 接口名称{}
接口的特点：
	1、接口里边只能有抽象方法，实现接口，子类
	必须重写接口里的抽象方法
	2、接口里可以声明属性,必须都是public static final
	3、接口中的抽象方法可以省略 abstract 
	4、接口不能实例化
	5、接口没有构造器
	6、接口不能实现接口，只能继承接口
                      普通类只能实现接口，不能继承接口
	7、接口继承接口，不能重写抽象方法
	8、接口与接口，可以多继承
		extends 接口1,接口2,....N
	9、普通类可以实现多个接口
		implements  接口1，接口2，...N

静态块：
static{
代码块…
}
程序只运行一次，启动的时候只执行一次
初始化块：
{
代码块…
}
每一次实例化对象的时候执行一次。在调用构造器之前先调用

先执行父类构造器还是先执行子类的初始化块

异常

程序由于认为编写所导致错误，异常

程序中出现的问题：

​ 错误、异常
所有的异常跟错误继承：Throwable
错误：
​ Error
​ 语法错误\格式错误;不可捕获的严重问题
异常:
​ Exception
​ 程序在编译时或者运行时出现的问题,可以捕获处理
​ 分类：
​ 检查时异常、运行时异常
​ 检查时异常：
​ 编写的时候代码出现异常，必须捕获、处理，
​ 编译时系统会判断，程序运行时有可能或出
​ 现不可避免的问题。只要不继承RunTimeException
​ 都是检查时异常
​ 运行时异常：
​ 编译时不报错，在程序运行时出现问题，所有
​ 的运行时异常继承RunTimeException
​ ClassCastException
​ NullPointerException
​ IndexOutOfBoundsException
​ ArithmeticException

在Java语言中，异常（Exception）是被一个方法抛出的对象。
当一个方法抛出异常时，该方法从调用栈中被弹出，同时产生
的异常对象抛给了栈中的前一个方法。出现异常后会终止程序。

对于异常的处理，方法有三种选择：
		1、捕获这个异常，不让它沿着调用栈继续向下抛出；
		2、捕获这个异常，并继续向下抛出；
		3、不捕获这个异常，从而导致方法从调用栈中被弹出，
		异常对象继续抛给调用栈下面的方法。 
		建议：捕获处理异常，保证程序的健壮性

捕获处理异常：
	try{
		有可能会出现异常的代码
	}catch(异常类型  异常对象名称){
		处理异常....
	}
注意：所谓的处理异常，不是解决异常，而跳过异常代码，
          不执行，直接执行匹配的catch
	try{
		有可能会出现异常的代码
	}catch(异常类型  异常对象名称){
		处理异常....
	}catch(异常类型  异常对象名称){
		处理异常....
	}catch(异常类型  异常对象名称){
		处理异常....
	}catch(异常类型  异常对象名称){
		处理异常....
	}
注意多个catch块，
	1、异常对象由小到大写
	2、catch块只执行一个，后边catch不会再执行

	try{
		有可能会出现异常的代码
	}catch(异常类型  异常对象名称){
		处理异常....
	}catch(异常类型  异常对象名称){
		处理异常....
	}catch(异常类型  异常对象名称){
		处理异常....
	}catch(异常类型  异常对象名称){
		处理异常....
	}finally{
		执行代码
	}

finally：不管怎样都执行,在有return的情况下，先执行finally，再返回

当发生了异常，而我们又不想捕获的时候，咋办？
----把它抛出去！
方法抛出异常：throws
	格式：
		访问修饰符   特殊的访问修饰符  返回类型  
			方法名称(参数列表) throws 异常类型{

			}
方法内部抛异常：throw
	格式：
		方法(){
			throw new 异常对象;
		}
throws/throw区别：
	1、throws是在方法声明的时候抛异常，throw运行方法的时候抛异常
	2、throws可以抛出多个异常，用逗号隔开，throw只能抛一个异常	

抛异常时，注意：
	抛出异常要比处理时的异常小或者相同
自定义异常步骤：
	第一步：创建一个类继承于Exception、RuntimeException
	第二步：添加构造方法和普通方法
	第三步：在一个方法中抛出异常
	第四步：在另一个方法中捕获并处理异常

​

常用类

String :
	String类包含了一个不可变的字符串。一旦一个String对象被创建，
	包含在这个对象中的内容就是不可改变的，直至这个对象被销毁。
	“he”+“llo”  在JDK1.5以后的版本中都是在内存字符串池中
	产生一个对象
StringBuffer:
	线程安全的可变字符序列。效率低
StringBuilder 
	线程不安全的可变字符序列。效率高

​

集合

什么是集合？

​ 将数据存放在一起，提供查询方式，
​ 用于存、取、传递数据，是一种数据结构
数组：
​ 存放相同数据、长度固定
集合：
​ 存放任意数据、长度不固定

Iterator：所有集合的迭代器,提供方法遍历集合
Collection：是set\list的父接口
Map:是所有map集合的父接口

Collection、Map区别：
Collection：以列表的形式存放数据，数据结构不同
Map：以键值对的形式存放数据，数据结构不同

Collection：
list：有序、数据可以重复、通过索引快速访问，不会排序
set：数据不可以重复、可以排序，可以放null,只能有一个null

list接口的实现类：
ArrayList、LinkedList

ArrayList：使用最广泛，集合元素增加或删除操作不
	频繁时使用。最适合查询。
LinkedList：当需要在集合的中间位置，频繁增加或
	   删除元素时使用。

​

泛型：

​ 给集合定义存储的类型，
​ 格式：
​ ArrayList<数据类型> 名称 = New ArrayList<数据类型>();
​

遍历集合的方式：

​ 1、for
​ 2、迭代器Iterator
​ 3、foreach
​ for(集合中存放的数据类型 名称 : 集合){
​ 执行代码…
​ }
​

set:

​ HashSet\TreeSet

HashSet：1、不能自定义排序，
	2、哈希表（实际上是一个 HashMap 实例）支持
	3、此类允许使用 null 元素。 
	4、数据不能重复

hashset如何去重复的？
	引用数据类型，默认根据每个对象的hash码去重复
通过对象的属性去重复？
	1、重写hashcode方法
	2、重写equals方法

TreeSet：

​ 可以排序、效率比HashSet低
​ 排序：
​ 自然排序、自定义排序
​

自然排序：
	1、实现接口Comparable
	2、重写排序方法compareto，自然排序方法
		比较此对象与指定对象的顺序。如果该对象小于、
		等于或大于指定对象，则分别返回负整数、零或正整数
		升序
		this>obj  ---> 1
		this=obj  ---> 0
		this<obj  ---> -1
		降序
		this>obj  ---> -1
		this=obj  ---> 0
		this<obj  ---> 1
自定义排序：
	1、实现接口Comparator
	2、重写compare方法、equals方法
	
Comparable、Comparator区别：
	1、TreeSet集合创建不同，Comparable是TreeSet默认的排序规则，
	创建TreeSet时不需要重新定义排序规则，只需要排序的类实现接口
	Comparator是我们自己定义一个排序规则，创建TreeSet的时候需
	要对TreeSet的默认规则经行改写。
	2、Comparable不用重写equals，Comparator需要重写equals；
	3、Comparable 重写compareTo()方法，Comparator重写compare()方法

Map

JDBC

java应用程序想要发送sql语句操作数据库：
JDBC：
JAVA与数据库的连接

IO流

File类

IO流：

​ 什么是IO流？
​ IO：input\output
​ 流：数据流，数据的载体，可以数据的传递
​ IO流：输入输出数据流，输入数据、输出数据
​ 输入数据：从目标地址输入到Java程序
​ 输出数据：从Java程序输出到目标地址
​ 特点：数据先进先出，后进后出
IO分类：
​ 流向：
​ 输入流、输出流
​ 按类型分：
​ 字节流：InputStream,OutputStream
​ 二进制文件、图片、音视频

	字符流：Reader和Writer
	纯文本文件，例如.txt
	
	节点流（低级流）：FileInputStream、FileOutputStream
		InputStreamReader/OutputStreamWriter
	处理流（高级流）：
	转换流：InputStreamReader/OutputStreamWriter
	缓冲流：BufferedInputStream/BufferedOutputStream
		BufferedReader/BufferedWriter		
	作用：给低级流添加新的功能，在创建高级流的时候需要低级流的对象


字节流：
	InputStream,OutputStream
	FileInputStream/FileOutputStream
	文件字节输入、输出流
	缓冲流：BufferedInputStream/BufferedOutputStream
	
字符流：
	Reader和Writer
	FileReader\FileWriter	
	文件字符输入、输出流
	 PrintWriter
	文件字符输出流，可以输出一行数

OutputStreamWriter\InputStreamReader
ObjectInputStream\ObjectOutputStream

对象流

​ ObjectInputStream\ObjectOutputStream
​ 在文本中存放对象数据
​ Serializable接口：序列化数据
​ 序列化：对数据进行编码，将对象转化文本的形式存放到目标文件
​ 反序列化：对数据进行编码，将目标文件中存放的对象字节或者
​ 字符转换成java对象
​ transient：阻止序列化

反射

​ 创建对象：
​ 1、new
​ 2、对象序列化

什么是反射？

​ 程序自我反省的过程，java中的反射，程序编译时创建模板对象，运行时
​ 通过模板对象获取对象的属性、行为、构造器，从而创建新的对象。
​ 模板对象：类对象class，在程序类加载的时候创建，该对象对应一个类，且唯一 。
​

获取类class对象：
	三种：
		方法一：通过类路径获取类对象
			Class c = Class.forName(“类名字符串”);
		 备注：类名字符串是完全类名(包名.类名)

		方式二：通过类名称获取类对象
		Class c = 类名.class;
		 备注：八个包装类也可以通过TYPE属性获取
		
		方式三：通过已有的对象获取类对象
		Class c = 对象名.getClass(); 
 			备注：getClass()方法继承Object

通过类对象获取：
	属性对象Field、方法对象Method、构造器对象Constructor

	Filed : 
	 	不能获取私有的属性：class.getField(String name) 
		能获取私有的属性：class.getDeclaredField(String name) 

通过类对象实例化对象

线程

线程：
同一时间完成相同、不同的任务，提高效率

为什么使用线程？
	同一时间完成多个任务，效率高，用户体验度好
如何实现同意时间执行多个任务：
	线程
	进程
什么是进程？
	进程就是计算机内存中正在执行的一个应用程序整体。
什么是线程？
	线程是进程中某个单一工作的工作任务，
	负责执行一个独立的工作任务
	存在应用程序的一个进程中，一个进程可以有多个线程，
	多个线程共享一个进程的内存资源
线程的生命周期
	1、创建
	2、就绪
	3、运行      阻塞
	4、死亡
线程阻塞
	1、sleep()方法
	线程休眠
	让执行的线程暂停一段时间，进入计时等待状态
	在休眠的时间内，线程释放内存，不在运行，
	一直等到休眠结束
	线程sleep()结束后会重新进入就绪状态
	2、join()方法
	表示这个线程等待另一个线程完成后（死亡）才执行，
	join 方法被调用之后，调用该方法的线程对象所在的
	线程对象处于阻塞状态(WAITING/TIMED_WAITING)。
	写在哪个线程中(线程对象调用join方法的代码在那个线
	程中)，哪个线程阻塞，且阻塞的线程不会释放同步锁	
	join()方法常用于将一个线程放入另一个线程中统一执
	行，这也被称为联合线程。
	3、IO造成的阻塞
	在线程中，如果出现IO操作，在IO未完成前，当前线
	程也会进入阻塞状态，一直到io操作完成
	4、yeild()
	从运行状态返回到就绪状态，而不是阻塞状态(锁定，等待)
	所以调用此线程的方法有可能会继续执行，不会等其它线
	程执行完再执行(因为准备就绪就有可能让CPU在线程等
	待队列中重新将该线程提取出来执行)

线程的同步？
	多个线程依次执行，为什么线程添加同步？
添加同步为了避免线程的冲突？
	多个用户同时对一个数据经行操作，一个数
	最开始10，张三变为12，李四变为13，王五变为14
	最后张三获取数据14，该的是12，所以需要线程同步，
解决线程冲突的方法？
	在共享资源上添加一把锁，保证一个线程在使用资源时
	，其它线程必须进行等待。这样在一个时间点只能一个
	线程使用共享资源，从而防止线程出现冲突，这把锁也
	称为同步锁。	

同步锁
	synchronized关键字
	可以修饰方法（同步方法）、代码块（同步块）

	同步块：
		synchronized(锁名) {
			同步代码块
		}
	同步方法：
		访问修饰符 synchronized  返回值 方法名称（参数）{
			同步代码块
		}
	
	//黑白双方下棋，交替落子