学习中的小码农

JAVA基础与高级学习笔记

/记录java基础与高级，除了较简单的内容，没有必要记录的没有记录外，其余的都记录了/
java初学者看这一篇就够了，全文 6万+ 字。

JAVA基础

java会出现内存溢出和泄露。
JDK与JRE的关系。

a. JDK（Java Development Kit Java开发工具包）
JDK是提供给JAVA开发人员使用的，其中包含了Java的开发工具，也包含了JRE，所以安装装了JDK就不用再单独安装JRE了。其中的开发工具：编译工具（javac.exe）,打包工具（jar.exe）、javadoc等。
b. JRE（Java Runtime Enviroment Java运行环境）
包括Java虚拟机（Java Virtual Machine，JVM）和Java程序所需的核心类库等，如果想要运行一个开发好的Java程序，计算机中只需要安装JRE即可。
总结：JDK = JRE + 开发工具集， JRE = JVM+Java SE标准类库。其中Java SE表示Java的标准版本(桌面和服务器)，Java EE表示企业版本。Java SE(之前为J2SE)是Java EE（之前为J2EE）的子集。
字节码文件是指以.class结尾的文件。
Java程序的终端运行。

• Java程序要想在终端运行，首先要使用 javac 文件名.java （这个叫做源文件）进行编译生成 .class文件（也称为字节码文件）
• 然后使用 java 文件名.class 进行运行。
• 字节码的文件名，是代码中的类名。

文档注释

/**
文档注释
@author 
@version 
作用是可以共javadoc 所解析
*/

主类用public修饰
javadoc解析可以查看程序信息

使用方法：javadoc -d 文件名 -version -author HelloJava.java
java注释不可嵌套使用，可嵌套单行
Java语言的特点

完面向对象性：
两个要素：类、对象
四个特征：抽象、封装、多态、继承。
健壮性：去除了c语言中的指针自动的垃圾回收机制 -->仍会内存溢出和泄露
JVM实现跨平台性。
java关键字和保留字

Java关键字

• Java保留字：goto、 const自己命名时避免使用。

Java标识符

• 由26个英文字母大小写，0-9，_或 $ 组成
• 数字不可以开头
• 不可以使用关键字和保留字
• Java中严格区分大小写，长度无限制
• 标识符不能包含空格
Java中的命名规范

• 包名：多单词组成时，所有字母都小写xxxyyyzzz
• 类名、接口名：多单词组成时，所有单词的首字母大写：XxxYyyZzz (大驼峰)
• 变量名、方法名：多单词组成时，第一个单词首字母小写，第二个单词开始每个首字母大写：xxxYyyZzz (小驼峰)
• 常量名：所有字母都大写。多单词时每个单词用下划线链接：XXX_YYY_ZZZ
Java变量的数据类型

基本数据类型
•整型：byte(1字节 = 8bit) \ short(2字节) \ int(4字节) \ long(8字节) byte范围：-128~127 long型变量要以L标明。
•浮点型：float(4字节，单精度，7位有效数字) \ double(8字节，双精度，14位有效数字) float表示的数值范围比long还要大，末尾必须要用f/F结尾。
•字符型：char(1字符，两个字节) 可以用Unicode码声明，c6 = ‘\u0043’相当于字符 c 。
•布尔型：boolean
引用数据类型
◇ 类(class)
◇ 接口(interface)
◇ 数组(array)
ASCII与Unicode的区别

ASCII码
• 一共包含128个字符，每个字符对应一个ASCII码，将字符转换为二进制需要进行的操作。
• 缺点是，不能表示所有字符，不同国家相同的编码表示的字符不一样，如130法语为6，在希伯来语中为Gimel。
• 会出现乱码问题，由于相同的二进制数字表示不同的字符，因此解码时，必须要知道编码方式。

Unicode码
• 一种编码，将世界上所有的符号都纳入其中，每个符号对应一个独一无二的编码，使用Unicode没有乱码问题。
• 缺点：Unicode只规定了符号的二进制代码，并没有规定这个二进制代码怎么存储，使其与ASCII码无法区别，
计算机无法区别三个字节表示的是一个符号还是三个符号。另外，我们知道英文字符只需要一个字节就够了，如
果Unicode规定，每个符号用三个或四个字节表示，那么每个英文字母前都必然有二到三个字节是0，极大的浪费
了存储空间。

UTF-8编码
• UTF-8是在互联网上最广使用的一种Unicode编码的实现方式。
• UTF-8是一种变长的编码方式。它可以使用1-6个字节表示一个符号，根据不同的符号而变化字节长度。
• UTF-8的编码规则：
◇ 对于单字节的UTF-8编码，该字节最高位为0，其余7位用来对字符进行编码（等同于ASCII码）
◇ 对于多字节的UTF-8编码，如果编码包含n个字节，那么第一个字节的前n位为1，第n+1位为0，
该字节的剩余各位用来对字符进行编码，在第一个字节之后的所有字节，都是最高位为“10”，其余6位
用来对字符进行编码。
数据之间的运算规则

自动类型提升
byte ，short，char -> int -> long -> float -> double。
容量小的与容量大的做运算，会自动转换成容量大的。
说明：此时的容量大小指的是表示数的范围的大小。
特别的：当byte、char、short三种类型的变量做运算时，结果为int型。

强制类型转换
由容量大的类型转到容量小的类型，可能会发生损失精度。
如：int a = (long)b;

整型常量默认类型为int，浮点类型默认为double。
char=‘’是错误的

String类型可以与基本数据类型做运算

   如:char c = ‘a’;   int num = 10;
   String str = “hello”;

   System.out.println(c + num + str); //107hello
   System.out.println(c + str + num); //ahello10
   System.out.println((c + num) + str); //107hello
   System.out.println(str + num + c); //hello10a

各个进制

二进制以0b或0B开头，八进制必须以0开头，十六进制必须以0x开头。
s += 2不会改变数据类型，s=s+2会改变

s += 2,会自动强制类型转换，而s = s + 2可能会报错
逻辑运算符&和&&、|和||

• &操作的是boolean类型则是逻辑运算符，否则是位运算符。|也一样
• 相同点1：&与&&的运算结果相同
• 相同点2：当左边为true时，二者都会执行右边的语句。
• 不同点：当左边是false时，&会执行右边，而&&（短路与）不会执行右边。
| 与 || 类似。
☐ 开发中推荐使用短路&&和短路||。
最高效的2*8？2 << 3 或8 << 1
m = (m ^ n)^n
Scanner

Scanner sc = new Scanner(System.in);
int a = sc.nextInt();
String s = sc.next();
double d = sc.nextDouble();
• 特别的String是sc.next()，别的大部分都是sc.nextMingZi(); 除此之外，没有nextChar()。
switch-case

格式：
switch(表达式){
case 常量1：
执行语句。。。
break;
case 常量2:
执行语句。。。
break;
default:
执行语句。。。
break；
}

说明:
1. 根据switch表达式中的值，一次匹配各个case中的常量，一旦匹配成功，则进入case结构中，调用其执行语句，
当调用完执行语句之后，则仍然向下继续执行其他case结构中的执行语句，直到遇到break关键字，或此switch-case结构末尾为止结束。
2. break关键字可以用在switch表达式中，表示一旦遇到就会跳出该结构。
3. switch条件判断句只能是如下的6种数据类型之一：byte，short、char、int、枚举类型(JDK5.0新增)、String(JDK7.0新增)。
4. 特别注意boolean类型不可以做判断句。
5. case之后只能是常量，尤其注意不能是范围。
6. default，相当于if-else中的else，是可选择有无的，而且位置是灵活的，不一定是尾部，开发时一般写到尾部。
7. 如果多个case语句执行的是相同的，case语句是可以合并的。
8. 如果既可以用if-else也可以用switch则优先使用switch，因为其执行效率较高。
continue只用在循环结构中：关键字之后不可以紧跟着写语句。
break、continue结束指定标签的循环，加标签，然后break或者continue
出现乱码是因为编码方式不一样，改一致可以解决。
数组

一维数组：
静态初始化：
int[] ids = new int[]{1001,1002}.数组的初始化和数组元素的赋值操作同时进行。

动态初始化：
String[] names = new String[5];
```
   注：int[] arr = {1,2,3}    //自动类型推断
```
二维数组：
静态初始化：
int[][] arr1 = new int[][]{{1，2}，{1，2}}

动态初始化：
int[][] arr1 = new int[3][4];
int[][] arr1 = new int[3][];

或者 int a[][],int [] a[];

二维数组里每一个一维数组可以变长。

Arrays工具类提供了一系列操作数组的方法。
其中Arrays.sort（）底层用的快排。
Arrays.binarySearch(),二分查找。
main()方法的使用说明

main()方法作为程序的入口
main()方法是一个普通的静态方法。
main()可以作为我们与控制台交互的方式（可以传入数据，编译完，运行时传）。

>>>表示处理的时无符号的右移运算，它不把最高位看作符号位。

JAVA面向对象

面向对象的三条主线

Java类及类的成员：属性、方法、构造器；代码块、内部类。
面向对象的四大特征：抽象、封装、继承性、多态性。
其他关键字：this、super、static、final、abstract、interface、pakage、import等。
面向对象与面向过程的差别

• 面向过程：强调的是功能行为，以函数为最小单位，考虑怎么做。
如：把大象放进冰箱，
1) 把冰箱门打开
2) 抬起大象，塞进冰箱
3) 把冰箱门关闭
• 面向对象：强调具备了功能的对象，以类/对象为最小单位，考虑谁来做。
人{ 打开冰箱{冰箱.open()} 抬起（大象）{} 关闭（冰箱）{} }
冰箱{ open（）{} ，关闭（）{}}
大象{ 进冰箱（）{} }
面向对象的两个要素

类：对一类事物的描述，是抽象、概念上的定义。
对象：是实际存在的该类事务的每个个体，因此也成为实例（instance）

面向对象程序设计的重点是类的设计。
类的设计，其实就是对类成员的设计。

如果一个类对应多个对象，则每个对象都拥有一套独立的属性。
类和对象的使用（面向对象思想落地的实现）
1.创建类、设计类成员
2.创建类的对象
3.通过“对象.属性” 或“对象.方法”调用对象的结构。

对象的内存解析：
类的成员

属性 = 成员变量 = field = 域、字段
方法 = 成员方法 = 函数 = method
1. 属性：
  对应类中的成员变量
  默认初始化
  显式初始化
  构造器中初始化
  有了对象以后，可以用对象.属性等初始化
  在代码块中赋值。
1. 方法：要描述类应该具备的功能。对应类中的成员方法。方法中不能定义方法。
1. 构造器（构造方法）
  类的默认的构造器的权限和类的权限是一样的。
  类如果显示定义了构造器，就不会再提供默认的构造器。
1. 代码块（或初始化块）
◇ 就是初始块，用来初始化类或对象，内部可以有输出语句。
◇ 代码块如果有修饰的话，只能使用static
◇ 分类：静态代码块 VS 非静态代码块
◇ 静态代码块（可以多个，根据定义的顺序执行，只能调用静态的属性和方法）：随着类的加载而执行，并且只执行一次，初始化类的信息。
◇ 非静态代码块（属性和方法都可以调用）：随着对象的创建而执行，每创建一个对象就执行一次，可以对对象的属性进行初始化。
◇ 静态代码块优先于非静态的代码块的执行。
就是大括号
{
}

5.内部类
a. Java中允许将一个类A声明在另一个类B中，则类A就是内部类，类B成为外部类。
b. 内部类的分类：成员内部类（静态的、非静态的） vs 局部内部类（方法内、代码块内、构造器内）。

成员内部类：一方面，作为外部类的成员，调用外部类的结构。
可以用static修饰。（外部类不用）
可以被四种不同的权限修饰符修饰。

另一方面，作为一个类。可以包括类的属性、方法、构造器、代码块、内部类。
可以用final修饰（表示不可以被继承了），
可以被abstract修饰。

所应该关注的问题：
如何实例化成员内部类的对象？
Person.Dog d = new Person.Dog(); //静态的
Person.Bird bird= (new Person()).new Bird();

如何在成员内部类中区分调用外部类的结构？
Person.this.name //类似

局部内部类的使用。
局部内部类使用的注意点：
在局部内部类的方法中，如果调用局部内部类所在方法中的局部变量时，需要其为final的。
面向对象三大特征

封装

只需要用功能，不需要去关注功能怎么实现的。

高内聚：类的内部数据操作细节自己完成，不允许外部干涉。
低耦合：仅对外暴露少量的方法用于使用。
把该隐藏的隐藏起来，该暴露的暴露出来，这就是封装性的设计思想。

继承

• 继承的好处：
减少了代码的冗余，提高了代码的复用性。
便于功能的拓展。
为之后多态的使用，提供了前提。
• 使用extends关键字，class A extends B{}。
◇A为子类，B为父类、基类、超类。
◇一旦子类A继承父类B，子类A中就获得了父类B中声明的结构、属性、方法（私有的虽不能访问，但是继承了）。
• 一个类只能有一个父类（单继承），一个父类可以有多个子类。
• 子类直接继承的类叫做直接父类，间接继承的是间接父类。
• public class Student extends Person{ }

多态

对象的多态性：父类的引用指向子类的对象。（不能去调用子类特有的方法）
2. 多态的使用：虚拟方法调用：只能调用父类中定义的方法，当调用子父类同名同参数的方法时，实际执行的是子类重写父类的方法。（编译看左边，执行看右边）
3. 多态性的使用前提：
1) 类的继承性 2）方法的重写
4. 多态性不适用于属性（用于属性的话是编译和运行都看左边）。
5. 多态性是运行时行为。
子类也可以重载父类的方法。
对于重载而言，在方法调用前，编译器就已经确定了所要调用的方法，这称为“早绑定”或“静态绑定”。
而对于多态，只有等到方法调用的那一刻，编译器才会确定所要调用的具体方法，这成为“晚绑定”或“静态绑定”。

向下转型
有了对象的多态性以后，内存中实际上是加载了子类持有的属性和方法的，但是由于变量声明为父类类型，
导致编译时，只能调用父类中声明的属性和方法，子类持有的属性和方法不能调用。
方法：向下转型：使用强制类型的转换，将父类引用转换成子类的。

Person p1 = new Man();
Man p = (Man)p1;
向上转型就是指多态，子类转成父类。
使用强转时，不一定都能转。

其它关键字
1. package关键字：
  声明类或者接口所属的包，放在源文件首行。
  包，属于标识符，要符合命名规则。包名小写。
  2. import
  如果遇到两个不同的包下的同名的类，至少有一个类，以全类名（带着包名）的形式显示。
  用import会出问题。
  3. this
  不能成为一个环调用。
  并且通过构造器的调用需要放在首行。再执行自己的代码。
  this可以用来调用构造器。如：
  public class Person{
  public Person(){
  }
  public Person(int age){
  this(); //可以有效的防止代码的冗余
  this.age = age;
  }
  public Person(int name){
  this(age);
  this.name = name;
  }
  }
4.super关键字
1) super理解为父类的
2) super可以调用属性、方法、构造器。
3) super的使用:
1- 我们可以在子类中，通过使用super.属性或super.方法的方式，显示的调用
父类中声明的属性或方法，但是，通常情况下，我们习惯省略“super”。
2- 特殊情况，当子类和父类中属性重名时，需要使用super去访问父类中的属性。
3- 当子类重写了父类中的方法以后，当想用父类中的方法时需要使用super.父类方法名。
4) super调用构造器:
1- 可以使用super(形参列表) ，调用父类中声明的制定的构造器。
2- super(形参列表) 必须写在首行
3- super(形参列表)和this(形参列表)只能二选一
4- 在构造器的首行没有显示的声明 super(形参列表)和this(形参列表)时，默认是 super()。父类中要有空参构造器。

5.instanceof
a instanceof A ：判断对象a是否是A的实例，如果是则返回true，否则返回false。
向下转型前，要先判断一下对象的类型。
假设A为B的父类，则B的对象b，使用 b instanceof A也返回true；反过来不可以。、

6.static
static可以用来修饰，属性、方法、代码块、内部类。
使用static修饰属性：成为静态变量（类变量）
1）属性：按照是否使用static修饰，又分为静态属性（类变量）和非静态属性（实例变量）。
2）实例变量：我们创建了类的多个对象，每个对象都独立的拥有一套类中的非静态属性，当修改其中一个
对象中的非静态属性时，不会导致其他对象中同样的属性值的修改。
3）静态变量：我们创建了类的多个对象，每个对象都共享一套类中的静态属性，当修改其中一个对象中的
静态属性时，会导致其他对象中同样的属性值的修改。
4）类变量随着类的加载而加载。可以通过“类.静态变量”来访问
静态变量的加载要早于对象的创建。
由于类只加载一次，所以类变量只加载一次。（存在方法区的静态域中）。
关于调用：
类变量实例变量
类是否
对象是是
静态结构可以用类来调用。

静态方法：
1）随着类的加载而加载，可以使用类来调用。
2）静态方法非静态方法
类是否
对象是是
3）静态方法中，只能调用静态的方法或属性。
非静态方法都快可以用。

静态的方法内，不能使用this关键字、super关键字。this指的的某个对象。

在开发当中，如何确定一个属性或者方法为static。
》属性是可以被多个对象所共享的，不会随着对象不同而不同。
》操作静态属性的方法，通常设置为static
》工具类中的方法，习惯上声明为static的。

7.final
1. final可以用来修饰：类、方法、变量。
2. final用来修饰一个类，则此类不能被其它类继承。如：String、System，StringBuilder类。
3. final用来修饰方法，表明方法不能再被重写。比如Object中的getClass。
4. final用来修饰变量，此时的“变量”就称为一个常量。
▪final修饰属性，可以赋值的位置有：显示初始化、代码块中初始化、构造器初始化（必须对变量初始化）。
▪ final修饰局部变量，尤其是final修饰形参时，表明此形参是一个常量，当我们调用此方法时，给常量形参赋值一个实参，一旦赋值不可更改。
▪ static final 用来修饰属性，全局常量。

8.抽象类（abstract）
1.abstract:抽象的
2.abstract可以用来修饰的结构：类、方法。
3.abstract修饰类：抽象类。
abstract class Person{ }
》此类不能够实例化（一定有构造器供子类用）。
》开发中，都会提供抽象类的子类，让子类实例化。
4.abstract修饰方法：抽象方法。
public abstract void eat()；
》只有方法的声明，没有方法体，不应该被调用。
》包含抽象方法的类，一定是抽象类。反之不一定。
》若子类重写了父类中的所有抽象方法后，则此类方可实例化。
若子类没有重写父类（直接间接的都算）中的所有的抽象方法，则此类一定是抽象类。
不能用来修饰属性、构造器等结构。
可以用多态。
5. 抽象类的匿名子类。
Person p = new Person(){
@Override
public void eat(){}
@Override
public void walk(){}
}
有名字的对象，匿名的类。
属性（成员变量）vs 局部变量
1. 相同点
  ◇定义变量的格式，数据类型变量名 = 变量值
  ◇先声明，后使用
  ◇变量都有其对应的作用域
1. 不同点
  ◇在类中声明的位置不同：
  1- 属性：直接定义在类的一段{}内。
  2- 局部变量：声明在方法内、方法形参、代码块内、构造器形参、构造器内部的变量。
  ◇关于权限修饰符的不同
  1- 属性：可以在声明属性时，指明其权限、使用权限修饰符。常用的有private、protected、缺省、public。
  2-局部变量是不可以使用权限修饰符的。
  ◇默认初始化情况
  1-类的属性，根据其类型，有默认初始化值
  2-局部变量是没有初始化值。特别的，形参在调用时，赋值即可。
  ◇在内存中加载的位置。
  1-类的属性，加载到堆。
  2-局部变量，加载到栈。
理解万事万物皆对象
1. 在Java语言范畴中，我们都将功能、结构等封装到类中，通过类的实例化。来调用具体的功能结构。
  2. 涉及到Java语言与前端html、后端的数据库交互时，前后端的结构在java层面都表现为类和对象。
匿名对象的使用

匿名对象：
new Phone().sendEmail();

1. 创建的对象没有一个变量名。
2. 匿名对象只能调用一次。
3. 开发中的使用：mail.show(new Phone());
方法的重载、方法详解

方法重载：
定义：在同一个类中，允许存在一个以上的同名方法，只要它们参数个数或者参数类型不同即可。
“两同一不同” 同一个类、相同方法名、参数列表不同（包括个数或类型、顺序）。
注：跟方法的权限修饰符、返回值类型、形参变量名、方法体都无关。
可变个数的形参

public void show(String … strs){ }
调用的时候，传入的参数个数可以是任意个。
他和 public void show（String[] s）{} 是一样的。

可变参数不能放在前面
public void show(String … strs，int i){ } //这是错误的。
并且最多只能声明一个可变形参。
在数据库中可能会用。
变量赋值
1. 如果变量是基本数据类型，此时赋值的是变量所保存的数据值。
  2. 如果变量是引用数据类型，此时赋值的是变量所保存的数据的地址值。

有趣的问题

  int[] a = new int[]{1,2,3};

  System.out.println(a);   //输出是一个地址

  char[] a = new char[]{'a','b','c'};

  System.out.println(a);  //输出的是a，b，c；

  原因是：调用的println不一样。

权限修饰符

Java规定的四种权限：

可以修饰类及类的内部结构、属性、方法、构造器、内部类。
MVC设计模式

MVC是常用的设计模式之一，将整个程序分成三个层次：视图模型层、控制器层、
与数据模型层。这种将程序数据的展示、输入输出、数据处理分离开来的设计模式使程序结构变的灵活而且清晰，同时也描述了程序各个对象间
的通信方式，降低了程序的耦合性。
1. 模型层：model主要处理数据
数据对象封装 model.bean/domain
数据库操作类 model.dao
数据库： model.db
2. 视图层： view显示数据
相关工具类：view.utils
自定义view：view.ui
3. 控制层 controller 处理业务逻辑
应用界面相关 controller.activity
存放fragment controller.fragment
显示列表的适配器 controller.adapter
服务相关的 controller.service
抽取的基类 controller.base
javaBean

定义：javaBean是一种java语言写成的可重用组件。

所谓javaBean，是指符合如下标准的java类：
1) 类是公共的
2) 有一个无参的公共的构造器（便于反射）
3) 有属性、且有对应的get、set方法。

用户可以使用JavaBean将功能、处理、值、数据库访问和其他任何可以用Java代码创造的
对象进行打包，并且其他的开发者可以通过内部的JSP页面、servlet、其他JavaBean、applet
程序或者应用来使用这些对象，用户可以认为JavaBean提供了一种随时随地的复制和粘贴的
功能，而不用关心任何改变。
Object类
1. 如果我们没有显示的声明一个类的父类的话，则此类继承于java.lang.Object类。
  2. 所有的java类（除Object类之外）都直接或间接的继承于java.lang.Object类。
  Object类的功能，函数和属性：
  无属性。
clone（）：复制一个对象。
equals（）：比较两个对象是否相等。
finalize（）：将对应的堆空间的对象回收。
getClass()：获取当前对象的所属类。
hashCode(): 返回对象的哈希值。
notify()
notifyAll()
toString()
wait()
方法重写

定义：在子类中可以根据需要对从父类中继承来的方法进行改造，也称为方法的
重置、覆盖。在程序执行时，子类的方法将覆盖父类的方法。

@override

应用：重写以后，当创建子类对象以后，通过子类对象调用子父类中的同名参数的方法时，
实际执行的是子类重写父类的方法。

方法重写注意点：

方法的声明：权限修饰符返回值类型方法名（参数列表） throws 异常的类型{
//方法体
}

1.子类重写的方法的方法名和形参列表与父类中被重写的方法的方法名和形参列表相同。
2.子类重写的方法的权限修饰符不小于父类被重写的方法的权限修饰符。
特殊情况：子类不能重写父类中private修饰的方法。
3. 父类中被重写的方法的返回值类型是void，则子类重写的方法的返回值类型只能是void，
父类被重写方法返回值类型是A类型，则子类重写的方法的返回值类型可以是A类或A类的子类。
父类被重写方法返回值类型是基本数据类型，则子类重写的方法的返回值类型必须是相同类型。
子类重写的方法的异常的类型不大于父类被重写方法的异常类型。
注：子类和父类中的同名同参数方法要么都声明为非static（考虑重写），要么都声明为static（不是重写）。
开发时：直接复制父类方法的声明，只写方法体。
子类对象的实例化过程

从过程上来看：
当我们通过子类的构造器创建子类对象时，我们一定会直接或者间接的调用其父类的构造器。
== 和equals

==和equals的区别。

一、是运算符(两边类型得一致)
1. 可以判断基本数据类型变量（判断值是否相等）和引用数据类型变量中。
2. 如果比较的是基本数据类型，比较两个变量保存的数据是否相等。（不一定类型相同）。
如果比较的是引用型变量，则比较的是地址值是否相等。
二、 equals()是一个方法。
1.只能适用于引用数据类型。
2.Object类中equals（）的定义：
public boolean equals(Object obj){
return (this == obj);
}
说明Object类中定义的equals（）和的作用是相同的。
3. 像String、Date、File、包装类等都重写了equals（）方法。重写以后比较的不是地址，而是比较两个对象实体内容是否相等。
4. 通常情况下，我们定义的类，如果使用equals方法，也是想比较内容，所以需要重写。
可以自动生成重写的equals（）方法和hashcode（）方法。
toString()方法
1. 当我们输出一个引用时，其实就是调用了当前对象的toString()方法。
  2. Object类中toString()方法的定义。
  public String toString(){
  return getClass().getName() + “@” + Integer.toHexString(hashCode());
  }
  3. 像String、Date、File、包装类等都重写了toString()方法，返回的是实体内容。
  4. 如果我们想获得内容的信息，则需要手动重写toString()方法。
Java重的JUnit单元测试

Java重的JUnit单元测试

步骤：
1.选中当前工程 -> 右键选择：build path -》 add libraries -》JUnit。
2. 创建Java类，进行单元测试。
1) 此时的Java类要求：此类是public的、此类提供公共无参的构造器。
3. 此类中声明单元测试方法。
此时的单元测试方法，方法的权限是public，返回值为void、没有形参。
4. 此单元测试方法上需要生命注解： @Test，并在单元测试类中导入：import org.junit.Test。
5. 声明好单元测试方法后，就可以在方法体内测试相关的代码。
6. 写完代码后，左键双击单元测试方法名，右键run as - JUint Test。
7. 如果执行方法正常则为绿，否则为红。
包装类

包装类：
• 正对八种基本数据类型定义相应的应用类型 - 包装类（封装类）。
• 有了类的特点，就可以调用类中的方法，Java才是真正的面向对象。
• byte —— Byte short——Short int——Integer long——Long
• float——Float double——Double boolean——Boolean char——Character
• 数值型的有一个共同的父类Number
• 基本数据类型 —— 包装类 ——String之间的转换。
◇基本数据类型 —— 包装类，通过调用构造器。（装箱）
◇包装类——基本数据类型，调用包装类的xxxValue(). （拆箱）
• 在JDK5.0中加入了自动装箱和拆箱操作。
如int b。Integer a = b；
转换为String，String str1 = num1 + “”
或者调用String.valueOf(f);
要String转为想要的，则：
调用包装类的parseXxx()方法，
如Integer.parseInt();
对于Boolean，只要不是标准的true，那就是false。
面试题
```
  1. Integer i = 1;
  	 Integer j = 1;

  	 i == j ?  //结果是true

  	 Integer i = 1;
  	 Integer j = 1;

  	 i==j？  //结果是false
```
原因：Integer内部定义了IntegerCache结构，IntegerCache中定义了Integer数组，
保存了从-128 ~ 127 范围的整数。如果我们使用自动装箱的方式，给Integer赋值的
范围在-128 ~127范围内时，可以直接使用数组中的元素，不用再去new了。
设计模式

单例设计模式：

• 设计模式：是在大量的事件中总结和理论化之后优选的代码结构、编程风格、以及解决问题的思考方式。
• 所谓单例设计模式，对某个类只能存在一个对象实例。并且该类只提供一个取得对象实例的方法。
• 如何实现：
• /饿汉式单例模式/（先造好了）
• 1.私有化类的构造器
• 2.内部创建类的对象
• 3.提供公共的静态方法，返回类的对象。
• 4.要求此对象必须声明为静态的。
• /懒汉式单例模式/（啥时候用啥时候造）
• 1.私有化类的构造器
• 2.声明当前类对象，没有初始化。
• 3.声明public 、static的返回类对象的方法。
• 4.此对象也必须声明为static的。
◇ 饿汉式：坏处：对象加载时间过长（先创建好）。好处：线程安全的
◇ 懒汉式：好处，延迟对象的创。坏处：线程不安全的（多线程改成安全的）。
单例模式的优点：
减少了系统性能开销，当一个对象的产生需要比较多的资源时，如读取配置、产生其他依赖对象时，
则可以通过在应用启动时直接产生一个单例对象，然后永久驻留内存的方式来解决。
如java.lang.Runtime.
应用：
网站的计数器
应用程序的日志应用
数据库链接池
项目中，读取配置文件的类。
windows的任务管理器
windows的回收站。

模板方法设计模式

当功能内部一部分实现时确定的，一部分实现是不确定的，这时可以把不确定的部分暴露出去，让子类去实现。
换句话说，在软件开发中实现一个算法时，整体步骤很固定、通用，
这些步骤已经在父类中写好了，但是某些部分易变，一边部分可以抽象出来，共不同子类实现，这就是一种模板模式。

代理模式

概述：
代理模式是Java开发中使用较多的一种设计模式。代理设计就是为其他对象提供一种代理，以控制对这个对象的访问。
代理类和被代理类要统一实现某一接口。然后，被代理类想要实现某一个功能，由代理类去代理执行。
应用场景：
1. 安全代理：屏蔽对真实角色的直接访问
2. 远程代理：通过代理类处理远程方法调用（RMI）
3. 延迟加载：先加载轻量级的代理对象，真正需要再加载真实对象。
4. 静态代理：（静态定义代理类）（专门针对某一接口）
5. 动态代理：JDK自带的动态代理，需要反射等的知识。

工厂模式

工厂模式：
实现创建者与调用者的分离，即将创建对象的具体过程屏蔽隔离起来。
达到提高灵活性的目的。
分类：
1. 简单工厂模式：用来生产同一等级结构中的任意产品。（对于增加新的产品，需要修改已有代码）
2. 工厂方法模式：用来生产同一等级结构中的固定产品。（支持增加任意产品）
3. 抽象工厂模式：用来生产不同产品族的全部产品。（对于增加新的产品，无能为力，支持增加产品族）。
xxxFactory（）：工厂。
接口

有时候，必须从几个类派生出一个子类。即多继承的实现，需要接口。
事物之间不是“is a”的关系。
某些事务具有共同的功能（接口）。

• 接口的使用
1. 接口使用interface来定义
2. Java中，接口和类时并列的两个结构。
3. 如何定义接口，定义接口中的成员：
3.1 JDK7及以前，只能定义全局常量和抽象方法
全局常量：public static final，但是书写时可以省略不写。
抽象方法：public abstract的
3.2 JDK8中，除了定义全局常量和抽象方法外，还可以定义静态方法、默认方法（略）。
4.接口中不能定义构造器，意味着接口不可以实例化。
5.Java开发中，接口都通过让类去实现使用（implements）。
如果实现类覆盖了接口中的所有抽象方法，则可以实例化。
如果实现类没有覆盖了接口中的所有抽象方法，则仍为接口。

6.Java类可以实现多个接口 -->弥补了Java中多继承的缺陷。
格式：class AA extends BB implements CC，DD，EE{
}

7.接口与接口之间可以继承，而且可以多继承。
格式 interface CC extends AA，BB{}

8.接口的具体使用，体现多态性（形参定义为接口）。
9. 接口，实际上可以看作是一个规范。
开发中，体验面向接口编程。

匿名实现类：
USB p = new USB（）{}；
面试题：

都重写了
ball是 public static final的
JDK8中接口的新特性：

JDK8中，除了定义全局常量和抽象方法外，还可以定义静态方法、默认方法（略）。
2. 默认方法：调用的话使用接口名.super.方法名（）.
public default void method2(){
System.out.println(“nihao”);
}
public 可以省略。
3. 接口中定义的静态方法，只能通过接口来调用。
4. 通过类的对象，可以调用接口中的默认方法。
5. 如果实现类，重写了默认方法，仍然调用的是重写以后的方法。
6. 如果子类继承的父类和接口中有同名的方法，并且尚未重写，优先调用父类中的方法。
7. 如果实现类实现了多个接口，接口中有同样的方法不都是抽象的，则没重写就报错。

异常

异常概述

Exception：其他因编程错误或偶然的外在因素导致的一般性问题，可以用针对性的代码来处理。
如：
空指针访问
试图读取不存在的文件
网络链接中断
数组角标越界。
异常的分类

一、异常的体系结构
顶级父类：java.lang.Throwable
|---- java.lang.Error: 一般不编写针对性的代码进行处理
|---- java.lang.Exception:可以进行异常的处理
|—编译时异常(checked)
|—IOException
|—运行时异常(unchecked)
异常处理机制概述

异常处理避免了大量的if-else判断。

Java中使用的是：抓抛处理。
过程一：“抛”，程序在正常执行的过程中，一旦出现异常，就会在异常代码处生成一个对应异常类的对象。
并将此对象抛出。
对象一旦抛出，后边的代码（异常括号内的）将不再执行。
过程二：“抓”，可以理解为异常的处理方式：
try-catch-finally 和 throws。

方式一：
try-catch-finally:(自己能解决)
try{
//可能出现异常的代码 }
catch(异常类型1 变量名1){
//。。处理异常的方式1
}
catch(异常类型2 变量名2){
//。。处理异常的方式2
}
catch(异常类型3 变量名3){
//。。处理异常的方式3
}
finally{
//一定会执行的代码
}

说明：
1. finally是可选的。
2. 使用try将可能出现异常代码包装起来，在执行过程中，一旦出现异常，就会生成一个
对应异常类的对象，根据此对象的类习惯去catch中进行匹配。
3. 一旦try中的异常对象匹配到某一个catch时，就进入catch中进行异常的处理，一旦处理完成，就跳出当前的
try-catch结构（在没有写finally的情况下），继续执行其后的代码。
4.catch中的异常类型如果没有子父类关系，则谁声明在上，没有关系。
catch中的异常类型如果有子父类关系，则子类要声明在上。
5. e.getMessage() 和 e.printStackTrace()可以看到各个结构;常用。
6. try{}中定义的变量，在外边不能用。
7. 处理编译时异常时，编译时不报错，运行时可能会报错。
8. try-catch可以嵌套。
9. 开发中由于运行时异常比较常见，我们通常不针对运行时异常编写程序，

•finally的使用：
◇finally中声明的是一定会被执行的代码，即使catch中又出现异常了，try中有return语句，catch中有return语句等情况。
◇像数据库链接、输入输出流、网络编程Socket等资源，JVM是不能自动回收的，我们需要自己手动回收进行资源的释放，
资源释放的代码放在finally里边，防止异常的产生。

方式二：
throws + 异常类型(报给上级处理，调用他的)
public void method1() throws 异常1，异常2{ }
1. throws + 异常类型写在方法的声明处，指明此方法执行时，可能会抛出的异常类型。
一旦当方法体被执行时，出现异常，仍会在异常代码处生成一个异常类的对象，此对象满足throws后异常
类型时，就会被抛出。异常代码后续的代码，就不再执行！
2. try-catch-finally ：真正的将异常给处理掉了。
throws的方式只是将异常抛给了方法的调用者，并没有将异常处理掉。
注：子类重写的方法抛出的异常类型不大于父类被重写的方法抛出的异常类型。

开发中，如何选择try-catch-finally，还是使用throws？
1. 如果父类中被重写的方法没有throws方式处理异常，则子类重写的方法也不能使用throws，意味着如果
子类重写的方法中有异常，必须使用try-catch-finally方式处理。
2.执行的方法a中，先后又调用了另外几个方法，这几个方法是递进关系执行的，我们建议这几个方法使用
throws的方法进行处理，而执行的方法a，可以考虑try-catch-finally
手动抛出异常

关于异常对象的产生：
1.系统自动生成的异常对象
2.手动的生成一个异常对象，并抛出（throw）。
throw new RuntimeException("…")
然后再处理。
用户自定义异常类

1.继承于现有的异常结构，RuntimeException、Exception
2.提供全局常量，serialVersionUID
3.提供重载的构造器。
throw和throws的区别

throw：生成一个异常对象，并抛出，使用在方法内部。相对的是自动抛出异常对象。
throws：处理异常的方式，使用在方法声明处的末尾。相对的是try-catch-finally。

JAVA高级编程

Java多线程

线程的创建

方式一：继承于Thread类：

1.创建一个继承于Thread类的子类
2.重写Thead类的run()，将此线程要做的事情，写在run里。
3.创建Thread子类的对象
4.通过此对象调用start()。 start()方法的作用，a. 启用当前线程 b.调用该线程的run()方法。

注：可以创建Thread的匿名子类，使得更加方便。

问题一：我们不能直接调用run()方法来启用线程。
问题二：再启动一个线程，遍历100以内的偶数。
不可以让已经start()的线程去执行，会报线程状态不合法的异常。
需要再new 一个线程对象来执行。

方式二：#### 实现Runnable接口
1. 创建一个实现了Runnable接口的类
2. 实现类去实现接口中的run()方法.
3. 创建实现类的对象
4. 将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象。
5. 通过Thread类的对象调用start()。->启动线程，调用了Runnable类型的targert的run方法。
6. 多个线程执行相同的操作时，不需要new两个Runnable，只需要new 两个Thread；

两种方式的比较：
开发中：优先选择实现Runnable接口的方式。
原因：1. 实现的方式没有类的单继承的局限性。
2. 实现的方式更适合来处理多个线程共享数据的情况。
联系：
Thread类本身也实现了Runnable接口。
相同点：两种方式都需要重写run()，将线程要执行的逻辑声明在run()中。

JDK5.0新增线程创建方式
方式三：实现Callable接口。
1.创建一个实现Callable的实现类
2.实现call方法，将此线程需要执行的操作写在call方法中。
3.创建Callable接口实现类的对象。
4.将此Callable接口实现类的对象传递到FutureTask构造器中，创建FutureTask对象。
5.将FutureTask对象作为参数传递到Thread类的构造器中，创建Thread对象，并调用start()方法。
6.获取Callable中call方法的返回值，使用“FutureTask对象.get()”。

如何理解实现Callable接口的方式比实现Runnable接口的方法更强大？
1.call()可以有返回值。
2.call（）可以抛出异常，被外面的操作捕获，获取异常的信息。
3.Callable是执行泛型的。

方式四：使用线程池
思路：提前创建好多个线程，放入线程池中，使用时直接获取，使用完
放回池中。可以避免频繁创建销毁、实现重复利用。类似正火中的公共交通工具。

好处：
1.提高响应速度(减少了创建新线程的时间)
2.降低资源消耗（重复利用线程池中线程，不需要每次都创建）。
3.便于线程管理
corePoolSize：核心池的大小
maximumPoolSize：最大线程数
keepAliveTime：线程没有任务时最多保持多长时间会终止。

代码实现：
1.提供指定线程数量的线程池。
ExecutorService service = Executors.newFixedThreadPool(10);
2.执行指定的线程的操作，需要提供实现Runnable接口或Callable接口
service.execute(new OddNumber()); //适用于Runnable接口。
service.submit(new numberThree()); //适用于Callable接口。
3.关闭线程池
service.shutdown().
注：实现管理的话，需要找到service对应的类，然后new 一个对应类的引用，将service强转为该类型，去设置。
线程的常用方法

Thread类中的常用方法：
1. start()：启动当前线程，并调用该线程的run方法。
2. run()：通常需要重写Thread类中的此方法，将创建线程要执行的操作声明再此方法中。
3. currentThread()：静态方法，返回执行当前代码的线程。
4. getName():获取当前线程的名字。
5. setName():设置当前线程的方法。
6. yield()：释放cpu的使用权。
7. jion()：在线程A中调用线程b的jion()，此时线程a就进入阻塞状态，直到线程b完全执行完以后，线程a才可以执行。
8. stop()：已过时，当执行此方法时，强制结束当前线程。
9. sleep(long millitime)：让当前线程睡眠指定的时间millitime毫秒。在指定的时间内，线程阻塞。
10. isAlive()判断线程是否存活。
线程的优先级设置

线程的优先级：
涉及到三个常量：
1. MAX_PRIORITY：10
2. MIN_PRIORITY：1
3. NORM_PRIORITY：5
获取和设置当前线程的优先级：
getPriority()
setPriority()

说明：高优先级会抢占低优先级的程序的运行，但并不意味着低优先级
一定在高优先级执行完之后执行。
线程的生命周期

状态：
1.新建：
2.就绪：
3.运行：
4.阻塞：
5.结束：
线程安全问题

出现了线程安全问题，即共享的数据出现了错误。
Java中通过同步机制，来解决线程的安全问题。
• 方法一：同步代码块 -->不能包含多了，也不能包含少了。
synchronized(同步监视器){
//需要被同步的代码，即操作共享数据的代码。
}
同步监视器：俗称锁。任何类的对象都可以充当锁。
要求，多个线程必须要共用同一把锁。
补充，在实现Runnable接口创建多线程的方式中，我们可以考虑使用this充当同步监视器。
在继承Thread类创建多线程的方式中，慎用this作为锁，可以考虑用当前类作为锁，类也是对象。

说明：同步的方式，解决了线程的安全问题。—好处
操作同步代码的同时，只能有一个线程参与，其他线程等待，相当于是一个单线程的过程。效率低 -----局限性

• 方式二：同步方法
访问共享数据的代码恰好在一个方法内。
使用 private synchronized void method(){}
1.同步方法仍然涉及到同步监视器，只是不需要我们显示声明
2.非静态方法时，同步监视器为：this
静态同步方法：同步监视器为当前类本身

• 方式三：Lock锁 — JDK5.0新增。
1.实例化ReentrantLock
ReentrantLock lock = new ReentrantLock()。构造器中如果传入true，则表示为公平锁。
2.在访问共享资源的代码块中，使用lock.lock(),用try环绕;
3.在finally中使用lock.unlock()释放锁。

synchronized锁与 lock 锁的异同：
synchronized机制在执行完相应的同步代码块以后，自动的释放同步监视器。
Lock锁需要手动的启动同步( lock() ),同时结束同步也需要手动的 unlock()。

三种方式（建议使用）：
Lock -> 同步代码块（已经进入了方法体，分配了相应资源）-> 同步方法（在方法体之外）
线程的通信

涉及到的三个方法：
1.wait()：一旦执行此方法，当前线程就进入阻塞状态，并释放同步监视器。
2.notify()：一旦执行此方法，就会唤醒被wait的一个线程，如果有多个线程被wait，就唤醒优先级高的那个。
3.notifyAll():一旦执行此方法，就会唤醒被wait的所有线程。

说明：
1.上述三个方法，必须使用在同步代码块或同步方法中。
2.上述三个方法的调用者，必须是同步代码块中的同步监视器。
否则会出现异常。
sleep()和wait()的异同

sleep() 和 wait()
1.相同点：
一旦执行方法，都可以使得当前的线程进入阻塞状态。
2.不同点：
◇两个方法声明的位置不同
Thread类中声明的sleep()，Object类中声明wait()；
◇调用的要求不同：sleep()可以在任何需要的场景下调用，wait()必须使用在同步代码块或者同步方法中。
◇关于是否释放同步监视器：如果两个方法都是用在同步代码块或同步方法中，sleep()不释放，wait()释放。

Java常用类

字符串相关的类

String

String的底层是数组。
String：字符串，使用一对“”引起来表示，
1.String声明为final的，不可被继承。
2.String实现了Serializable接口（表示字符串是支持序列化的）
实现了Comparable接口：表示String可以比较大小。
3.String内部定义了final char[] value用于存储字符串数据数组，
4.String：代表一个不可变的字符序列。简称：不可变性。
◇当对字符串重新赋值时，需要重新开辟内存区域赋值，不能使用原有的value进行赋值。
◇当对现有的字符串进行链接操作时，也需要重新指定内存区域赋值，不能修改原值。
◇当调用String的replace（）修改指定的字符和字符串时，也不是修改的原值。
5.通过字面量的方式（“abc”）给一个字符串赋值，此时的字符串值声明在字符串常量池中。
6.字符串常量池中是不会存储相同内容的字符串结构。

String a = “abc”；字面量和 String b = new Sting(“abc”)；构造器构造。两种方式的区别？

String s = new String(“abc”);方式创建对象，在内存中创建了几个对象？
两个：一个是对空间中new结构，另一个是char[]对应的常量池中的数据：“abc”

☐ 结论：
☐ 常量与常量的拼接结果在常量池。且常量池中不会存在相同内容的常量。
☐ 只要其中有一个是变量，结果就在堆中。
☐ 如果拼接的结果调用intern()方法，返回值就在常量池中。
String类中常用方法

int length(): 返回字符串的长度 return value.length。
char charAt(int index)：返回某索引处的字符return value[index]
boolean isEmpty()：判断是否是空字符串：return value.length == 0；
String toLowerCase()：转换为小写。
String toUpperCase(): 转换为大写。
String trim():去除字符串的首尾空格。
boolean equals(Object obj): 比较字符串的内容是否相同。
boolean equalsIgnoreCase(Object obj): 与equals方法类似，忽略大小写。
String concat(String str):将指定字符串连接到此字符串的结尾。等价于用”+“。
int compareTo(String anotherString): 比较两个字符串的大小。
String substring(int beginIndex): 返回一个新的字符串，它是此字符串的从beginIndex开始截取，到结尾。左闭右开
String substring(int beginIndex,int endIndex):返回一个新字符串，它是此字符串从beginIndex 到endIndex的截取。不包括endIndex。

boolean endsWith(String suffix): 测试此字符串是否以指定的后缀结束
boolean startsWith(String prefix):测试此字符串是否以指定的前缀开始
boolean startsWith(String prefix,int toffset):测试此字符串从指定索引开始的，是否以prefix开始的。
boolean contains(CharSequence s):当且仅当此字符串包含指定的char值序列时，返回true。
int indexOf(String str): 返回指定子字符串在此字符串中第一次出现处的索引。找不到则返回-1.
int indexOf(String str,int fromIndex)：返回指定子字符串在此字符串中第一次出现处的索引，从fromIndex开始。
int lastIndexOf(String str):从后往前找，找第一个出现str的位置。
int lastIndexOf(String str,int fromIndex):从指定位置开始，从后往前找第一次出现str的位置。

String replace(char oldChar,char newChar):返回一个新的字符串，它是用newChar来代替oldChar。
String replace(CharSequence target,CharSequence replacement):使用前面指定的字面值，代替后面指定的字面值。

☐ 将String转换为char[]。
char[] c = str.toCharArray();
☐ char[] 转换为String。
char[] str2 = new char[];
String s = new String(str2)；

String 与 byte[]之间的转换
String -> byte[] : 调用String的getBytes()。 //称为编码
byte[]->String ： String a = new String（bytes，【可以指定解码字符集】） //称为解码

byte[] bytes = str1.getByte(); //使用默认的字符集。
str1.getBytes(“gbk”); //指定特定的字符集
StringBuffer

String、StringBuffer、StringBuilder的异同：
String：不可变的字符序列；底层使用char[]数组存储，
StringBuffer：可变的字符序列；线程安全，效率低，底层使用char[]数组存储，
StringBuilder：可变的字符序列，jdk5.0新增的，线程不安全，效率高；底层使用char[]数组存储，

源码分析：
String str = new String()；//new char[0];
String str1 = new String(“abc”)；//new char[]{‘a’,‘b’,‘c’};

StringBuffer sb1 = new StringBuffer(); //char[] value = new char[16],底层创建了一个长度为16的数组。
StringBUffer sb2 = new StringBuffer(“abc”); //char[] value = new char[“abc”.length() + 16],底层创建了一个长度为16的数组。

问题一：System.out.println(sb2.length()) -> 3
问题二：扩容问题，如果要添加数据超过底层默认长度，需要扩容。
默认情况下，扩容为原来容量的2倍 + 2，同时将原有数组中的元素复制到新的数组中，
如果过长，直接将字符串的长度作为扩容长度。

指导意义：开发中建议大家使用StringBuffer(int capacity) 或 StringBuilder(int capacity);

StringBuffer的常用方法：
StringBuffer append(xxxx) //字符串的拼接
StringBuffer delete(int start,int end):删除指定位置的内容。
StringBuffer replace(int start, int end, String str): 把【start,end)位置替换为str。
StringBuffer insert(int offset,xxx):在指定位置插入xxx。
StringBuffer reverse(): 把当前字符序列逆转。
public int indexOf(String str)
public String substring(int start, int end) //返回字串，原字串不会变化。
public int length()
public char charAt(int n)
public void setCharAt(int n,char ch)

总结：
增：append(xxx)
删除：delete(int start,int end):删除指定位置的内容。
改：public void setCharAt(int n,char ch) / StringBuffer replace(int start, int end, String str)
查：charAt(int n)
插：insert(int offset,xxx):在指定位置插入xxx。
长度：public int length()
遍历：for + charAt()；/ toString。

StringBuilder 与 StringBuffer类似。
效率方面：String < StringBuffer < StringBuilder

日期Date类的使用

JDK8之前日期和时间的API测试。

System类中时间戳的使用。
long time = System.currentTimeMillis(); //返回当前时间与1970年1月1日0时0分0秒之间以毫秒为单位的时间差。称为时间戳。
2.Date类：
java.util.Date类
|—java.sql.Date类
◇两个构造器的使用
构造器一：
Date date1 =new Date();
date1.toString() //显示当前日期
date1.getTime() //返回的是一个毫秒，时间戳。
构造器二（创建一个指定毫秒数的日期）：
Date date2 = new Date(1515156515155L)；
◇两个方法的使用
date1.toString()
date1.getTime()
◇java.sql.Date的使用
实例化：java.sql.Date date3 = new java.sql.Date(544645645L);
sql.Date → util.Date对象。 //可以用多态
sql.Date <---- util.Date对象 //可以用毫秒数new一个
SimpleDateFormat

SimpleDateFormat的使用：SimpleDateFormat对日期Date类的格式化和解析。
1.两个操作：
1.1 格式化：日期->字符串
SimpleDateFormat sdf = new SimpleDateFormat();
System.out.println(sdf.format(t1));
SimpleDateFormat sdf1 = new SimpleDateFormat(“yyyy-MM-dd a hh:mm:ss”);
System.out.println(sdf1.format(t1));

1.2 解析：格式化的逆过程，字符串 -> 日期。
String s = “2020-02-03 下午 13:15:15”;
Date t2 = null;
try {
t2 = sdf1.parse(s);
} catch (ParseException e) {
e.printStackTrace();
}
System.out.println(t2.toString());
2.SimpleDateFormat的实例化
SimpleDateFormat sdf = new SimpleDateFormat();
SimpleDateFormat sdf1 = new SimpleDateFormat(“yyyy-MM-dd a hh:mm:ss”);

Calendar日历类(抽象类)的使用

1.实例化
方式一：创建其子类(GregorianCalendar)的对象
方式二：调用其静态方法getInstance()
Calendar calendar = Calendar.getInstance();

2.常用方法

 int days = calendar.get(Calendar.DAY_OF_MONTH); //今天是这个月的第几天

 calendar.set(Calendar.DAY_OF_MONTH,22)  //改成22天

 calendar.add(Calendar.DAY_OF_MONTH,22) //从22天的基础上加三天

 calendar.getTime();     //日历类---->Date
 Date date = calendar.getTime();

 calendar.setTime(date1);    //修改后的时间给date1.

JDK8中新日期时间API

LocalDate、LocalTime、LocalDateTime。

 实例化：
 	LocalDate localDate = LocalDate.now();
 	LocalTime localTime = LocalTime.now();
 	LocalDateTime locaDateTime = LocalDateTime.now();
 	LocalDateTime locaDateTime1 = LocalDateTime.of(2020,10,03);

 localDateTime.getDayOfMonth();  //当月的第几天

 //体现了不可变性：不会改变元对象
 LocalDateTime locaDateTime1 = localDateTime.withDayOfMonth(22); //改为这个月的第22天。
 LocalDateTime locaDateTime1 = localDateTime.plusMonths(3); //改为这个月的第25天，这是加操作。
 LocalDateTime locaDateTime1 = localDateTime.minusDays(3);  //减去三天 


 DateTimeFormatter：格式化或解析日期、时间。类似于SimpleDateFormat

 实例化：
 DateTimeFormatter formatter = DateTimeFormatter.ISO_LOCAL_DATE_TIME;
 DateTimeFormatter formatter1 = DateTimeFormatter.ofLocalizedDateTime(FormatStyle.SHORT)   //改变格式
 DateTimeFormatter formatter2 = DateTimeFormatter.ofLocalizedDate(FormatStyle.FULL)   //改变格式

 自定义格式：
 DateTimeFormatter formatter2 = DateTimeFormatter.ofPattern(“yyyy-MM-dd”)


 格式化：
 String formatter.format(localDateTime);

 解析：
 TemporalAccessor parse = formatter.parse(format); //接口的形式

JAVA的比较器

1.实现方式：
方式一：Comparable接口。（自然排序）
1.像String、包装类等实现了Comparable接口，重写了compareTo(obj)方法，给出了比较两个对象的方法。（默认从小到大）
2.重写compareTo(obj)的规则：
如果当前对象this大于形参对象obj，则返回正整数。
如果当前对象this小于形参对象obj，则返回负整数。
如果当前对象this等于形参对象obj，则返回零。
3.对于自定义的类来说，如果需要排序，我们可以让自定义类实现Comparable接口，重写compareTo（obj）方法。

方式二：定制排序Comparator。
1.背景：
当元素的类型没有实现java.lang.Comparable接口而又不方便修改代码。
或者是想了java.lang.Comparable接口的排序规则不适合当前的操作，
那么可以考虑使用Comparator的对象来排序。
2.重写compare(Object o1,Object o2)方法，比较o1和o2的大小。
如果方法返回正整数，则表示o1大于o2；
如果返回0，则表示相等；
返回负整数，表示o1小于o2.

System类、Math类、BigInteger类、BigDecimal类了解

枚举类与注解

枚举类的使用

枚举类的理解：
• 类的对象只有有限个，确定的。称为枚举类。
• 如：星期：星期一，…，星期五。
• 当需要定义一组常量时，强烈建议使用枚举类。
• 如果枚举类的对象只有一个，就是单例模式。

一.如何定义枚举类
方式一：jdk5.0之前，自定义枚举类。
1.私有化类的构造器。
2.声明对象的属性，需要用private final来修饰。
3.提供当前类的多个对象，用public static final来修饰。
4.其他诉求：获取枚举类对象的属性、toString。

方式二：jdk5.0之后，使用enum关键字。定义的枚举类，继承于java.lang.Enum类。
1.将class改为enum。
2.首先提供当前枚举类的对象，多个对象之间用“，”隔开，末尾对象用“；”结束。
如：SPRING（“春天”）。
3.声明对象的属性，需要用private final来修饰。
4.私有化类的构造器。
5.其他诉求：获取枚举类对象的属性、toString()(被重写过，返回对象名)

Enum类中的常用方法：
values()方法：返回枚举类型的对象数组，该方法可以很方便地遍历所有的枚举值。
valueOf(String str):可以把一个字符串转为对应的枚举对象，要求字符串必须是枚举类对象。如果名字写错则抛出异常
toString()：返回当前枚举类对象常量的名称。

Enum类实现接口。
情况一：实现接口，在enum类中实现抽象方法。
情况二：让枚举类的对象分别实现接口中的抽象方法。

注解的使用

• 注解（Annotation）（jdk50新增）：其实就是代码里的特殊标记，这些标记可以在编译，类加载，运行时被读取，并执行相应的处理。通过使用Annotation程序员可以在不改变原有逻辑的情况下，在源文件中嵌入一些补充信息。代码分析工具、开发工具和部署工具，可以通过这些补充信息进行验证或者进行部署。
Annotation可以像修饰符一样被使用，可用于修饰包、类、构造器、方法、成员变量、参数、局部变量的声明。这些信息被保存
在Annotation的“name = value”对中。
可以说：框架 = 注解 + 反射 + 设计模式。
例如：
@override 方法的重写。
@Deprecated：用于表示过时了。
@SuppressWarnings ：定义的变量没有用过。

• 如何自定义注解：
@interface 注解名{
String value() ; // 这是属性。
或者：
String value() default “hello”;
}
如果自定义注解没有成员，表明是一个标识作用。
如果注解有成员，在使用注解时需要给成员赋值。
自定义注解必须配上注解的信息处理流程（使用反射）才有意义。
• JDK中的4种元注解：用于修饰其他注解的注解。
@Retention（RetentionPolicy.RUNTIME）: 表明注解的生命周期。有SOURCE\CLASS(默认)\RUNTIME;
只有声明为RUNTIME生命周期的注解才能通过反射获取。
@Target({TYPE,FIELD}) : 标明所修饰的注解能够修饰的数据类型

上两个一般自定义的时候会指明。

@Documented:表示所修饰的注解，在进行javadoc解析时，会保留下来。
@inherited：表明注解修饰的类的子类会继承该注解。
• jdk8中注解的新特性：
jdk8 之前的写法：
@MyAnnotation({@My(“hi”),My(“hello”)})

1.可重复注解:
在My注解上声明：@Repeatable(MyAnnotations.class)
1.1.在MyAnnotation上声明@Repeatable(MyAnnotations.class)。
1.2.MyAnnotation的Target和Retention等元注解和MyAnnotations相同。
2.类型注解：
在Target中加入ElemmentType.TYPE_PARAMETER，TYPE_USE

集合

集合概述

一、集合框架的概述。
1.集合、数组都是对多个数据进行存储操作的结构，简称Java容器。
说明：此时的存储，主要指的是内存层面的存储，不涉及到持久化的存储（.txt）
2.数组在存储多个数据方面的特点
一旦初始化以后，其长度就确定了。
数组一旦定义好，其元素的类型也就确定了，只能操作指定类型的数据。
缺点:一旦初始化以后，其长度就不可修改
数组中提供的方法非常有限，对于添加、删除、插入等操作，非常不便，同时效率不高。
获取数组中实际元素个数的需求，数组没有现成的属性和方法可用。
数组存储数据的特点：有序、可重复，对于无序、不可重复的，不能满足。

java集合可以分为Collection和Map两种体系。
Collection接口：单列数据，定义了存取对象的方法的集合
List：元素有序、可重复的集合
Set：元素无序、不可重复的集合。
Map接口：双列数据，保存具有映射关系”key-value对“的集合。
```
 二、集合框架：
 		|----Collection接口：单列集合，用来存储一个一个的对象。
 			|----List接口：存储有序的，可重复的数据。   -->”动态数组“。
 				|----ArrayList、LinkedList、Vector
 		
 			|----set接口：存储无序的，不可重复的数据。 -->高中将的”集合“
 	    		|----HashSet、LinkedHashSet、TreeSet。

 		|----Map接口：双列集合，用来存储一对(key - value)一对的数据。   --->高中函数： y = f(x);
 		|---HashMap、LinkedHashMap、TreeMap、Hashtable、Properties。
```
三、Collection接口中的方法的使用
Collection coll = new ArrayList();
1.coll.add(Object e): 将元素e添加到集合coll中
2.coll.add(Collection coll1 = new ArrayList()); 将coll1集合中的元素加到当前集合。
3.coll.size() ; 返回集合长度。
4.coll.isEmpty(); 判断是否为空。
5.coll.clear(); 清空集合元素。
6.coll.contains(Obj) ; 判断的是是否包含该内容。会调用obj对象所在类的equals方法，看一下该对象有没有重写equals方法。
7.coll.contains(Collection coll1); 判断集合coll1中的元素是否都在coll中。
8.coll.remove(obj); 移除obj，仍然会调用equals方法。成功移除返回true，否则为false。
9.coll.remove(Collection coll1); 从当前集合中移除coll1中所有的元素。移除的是共有的元素。得到的是差集。
10.coll.retainAll(Colection coll1);得到两者的交集。
11.coll.equals(coll1); 比较两集合是否相同，调用equals方法。
12.coll.hashCode(); 返回当前对象的hash值。
13.Object【】 a = coll.toArray(); 集合转换为数组。
14.Collection c = Arrays.asList(new String[]{“AA”,“BB”}); 由数组到集合。整形要注意，要Arrays.asList(123,456).
Iterator迭代器

• Iterator对象称为迭代器（设计模式的一种），主要用于遍历Collection集合中的元素。只遍历Collection。

使用：
Iterator iterator = coll.iterator();
iterator.next(); //返回下一个元素。先下移，然后取数据，一气呵成。
iterator.hasNext(); //判断是否还有下一个元素。
iterator.remove(); //可以删除next当前指向的元素。
jdk5.0新增的foreach

jdk5.0 新增foreach循环，用于遍历集合和数组。内部仍然是迭代器。
for(Object obj : coll){
obj = new； //不会改变原数组。
}
List接口

☐ List接口：存储有序的、可重复的数据。 -》动态数组，替换原有的数组。
三个实现类：
ArrayList：作为List接口的主要实现类 jdk1.2出现，线程不安全的，效率高。底层使用Object[] 存储。
LinkedList：对于频繁的插入、删除操作，使用此比ArrayList效率高，底层使用的是双向链表存储，线程不安全。
Vector：作为List接口的古老实现类 jdk1.0 出现，线程安全的，效率低。底层使用Object[] 存储。

相同点都是List的实现类，存储有序的、可重复的数据。

• ArrayList源码分析。
jdk7情况下：
ArrayList array = new ArrayList(); //底层创建了一个长度为10的数组。
array.add(). //如果此次的添加导致底层elementData数组容量不够，则扩容。默认情况下扩容为原来的1.5倍，并将原有数组
中的数据复制到新的数组中。
结论：建议开发中使用带参的构造器。

jdk8中：
ArrayList array = new ArrayList(); 第一次中不会分配数组。
在第一次调用add时才创建长度为10的数组。后续操作一样。

小结：jdk7中的ArrayList的对象创建类似于单例模式的饿汉式，而jdk8中的ArrayList的对象创建类似于单例的懒汉式，延迟了数组
的创建，节省了内存。

• LinkedList源码分析。
LinkedList list = new LinkedList(); 内部声明了Node类型的first和last属性，默认为null。
list.add(); //将123封装到Node中，创建了Node对象。
• Vector源码
Vector v = new Vector();
线程安全的，初始为10，jdk8中也没变，一次扩容后为原来的2倍。
List接口中常用的方法

void add(int index,Object obj);
void addAll(list1);
void get(int index);
int indexOf(Object obj); 当前对象首次出现的位置。如果不存在返回-1.
int lastIndexOf(Object obj); 当前对象最后出现的位置。
Object remove(int index)；移除指定索引位置的元素，并返回此元素。可以按照索引删除，可以按照内容删除。首先匹配index。
Object set(inr index,Object ele):设置指定index位置的元素为ele。
List subList(int fromIndex,int toIndex);返回子序列前闭后开。

总结，常用方法：
增：add(Object obj);
删：remove(int index),remove(Object obj);
改：set(int index,Object ele);
查：get(int index)
插：add(int index,Object ele)
长度：size()
遍历：Iterator
foreach
普通for。

Set接口

 Set接口：存储无序的，不可重复的数据
 	|---HashSet：作为Set接口的主要实现类，线程不安全，可以存储null。
 		|-----LinkedHashSet：作为HashSet的子类：遍历其内部数据时，可以按照添加的顺序遍历。
 							对于频繁的遍历，效率要高一些
 	|---TreeSet：可以按照对象的指定属性，进行排序。

Set接口：存储无序的，不可重复的数据。Set中没有新定义的方法，都是Collection中的。
一、解释：
1.无序性：不等于随机性。存储的数据在底层数组中并非按照数组索引的顺序添加，而是按照哈希值存放。
2.不可重复性：保证添加的元素按照equals()判断时，不能返回true。

 二、添加元素的过程：以HashSet为例。
 • HashSet底层是数组+链表。其实底层是HashMap，jdk7，添加新元素七上八下。Object类中的hashCode()，每个对象随机返回一个值。
 Set删除的时候，会调用hashCode（）。计算hash值。
 我们向HashSet中添加元素a，首先调用元素a所在类的hashCode()方法，计算元素a的哈希值。
 此哈希值接着通过某种算法计算出在HashSet底层数组中的存放位置(即索引位置)，判断数组此位置上是否已经有元素：
 如果此位置上没有其他元素，则元素a添加成功   ---》情况1
 如果此位置上有其他元素b（或以链表形式存在多个元素），则比较元素a与元素b的hash值：
 		如果hash值不同，则元素a添加成功 --》情况2
 		如果hash值相同，进而需要调用元素a所在类的equals（）方法：
 				equals()返回true，则元素a添加失败。
 				equals()返回false，则元素a添加成功。 ---》情况3
 	对于添加成功的情况2和情况3而言，元素a与已经存在指定索引位置上数据以链表的方式存储。
 	jdk7中：元素a放到数组中，指向原来的元素。
 	jdk8中：原来的元素在数组中，指向元素a。
 	总结：七上八下。

• LinkedHashSet
作为HashSet的子类，在添加数据的同时，每个数据还维护了两个引用，记录此数据的前一个数据和后一个数据。
优点：对于频繁的遍历，效率要高一些。

• TreeSet
1.向TreeSet中添加的数据，要求是相同类的对象。
2.两种排序方式，Comparator（定制排序）和Comparable接口（自然排序）。
3.TreeSet判重复是，如果实现的Comparable接口，则用这个来判断会不会相同。
Comparator：
TreeSet set = new TreeSet（com）；com为Comparator对象。

三、要求：向Set中添加的数据，其所在的类一定要重写hashCode()和equals()
重写的hashCode()和equals()尽可能保持一致性：相等的对象必须具有相等的散列码。
重写技巧：直接用生成的。eclipse中生成的hashCode往往会将一个属性的值乘以31

Map接口
```
|----Map接口：双列集合，用来存储一对(key - value)一对的数据。key无序的、不可重复   --->高中函数： y = f(x);
		|---HashMap：作为Map的主要实现类。线程不安全的，效率高。可以存储null的key和value。
			|---- LinkedHashMap：保证遍历Map元素时，按照添加的顺序实现遍历。
										原因：在原有的HashMap底层结构基础上，增加了前后指针，在频繁遍历时效率高。
		|---TreeMap：保证按照添加key-value对进行排序。实现排序遍历，此时考虑key的自然排序或定制排序。
							底层使用红黑树。
		|---Hashtable：作为古老的实现类。线程安全的，效率低。不可以存储null的key和value。
			|---Properties：常用来处理配置文件，key和value都是String类。
```
1.HashMap的底层？
2.HashMap和HashTable的异同？
3.CurrentHashMap和HashMap、Hashtable？

一、Map结构的理解：
1.Map中的key：无序的、不可重复的，使用Set存储所有的key。
2.Map中的Value：无序的、可重复的，用Collection来存。
3.一个键值对key-value称为一个Entry对象，Map中的entry是无序的、不可重复的，用set存储所有的entry。
4.要求：一定要重写equals()和hashCode()方法。
```
二、HashMap的底层实现原理
	以jdk7为例：
	1.添加。
	HashMap map = new HashMap()。
	在实例化后，底层创建了长度是16的一维数组Entry[] table。
	----- 可能经过了多次put ------
	map.put(key1,value)。
	首先调用key1所在类的hashCode()方法，计算key1的hash值，然后通过某种算法，计算出该hash值要在数组中存放的索引，
	如果该位置为空，则此时key1，value添加成功  -- 情况1
	如果该位置不为空，（意味着此位置上有一个或多个数据，多个数据用链表存储）比较key1和已经存在的一个或多个数据的hash值。
		如果不同，则key1，value保存成功。
		如果相同，则继续比较key1.equals(key2)；
			如果不同，则保存成功。
			如果相同，则用value1替换value2.
	补充：关于情况2和情况3：此时key1-value1和原来的数据以链表的形式存储。
```
2.扩容
在不断的添加过程中，会涉及到扩容问题，当大于加载因子*容量时，或单个链表长度大于8，
默认的扩容方式：扩容为原来容量的2倍，并将原有的数据赋值过来。

jdk8 相较于jdk7在底层实现方面的不同。
1. new hashMap():底层没有创建一个长度为16的数组。
2. jdk8底层的数组是Node类型，不是Entry。
3. 首次调用put()方法时，底层创建长度为16的数组。
4. jdk7底层结构只有数组+链表，jdk8中底层结构：数组+链表+红黑树。
注：当数组的某一个索引位置上的数组以链表形式存在的数据个数 > 8，且当前数组的长度 > 64 时，链表变成红黑树。
此时索引位置上的所有数据改为使用红黑树存储。

三、LinkedHashMap底层结构。
加了一个前后指针，使得可以按照输入顺序打印。

四、TreeMap，按照key进行排序。
向TreeMap中添加key-value，要求key必须是由同一个类创建的对象。
排序方式，自然排序（类实现接口）、定制排序（往TreeMap的构造器中传比较器）。
TreeMap map = new TreeMap(new Comparator(){
@Override
compare
})
五、Properties：常用来处理配置文件，key和value都是String类。
Properties p = new Properties();
FileInputStream fis = new FileInputStream(“wenjianming.properties”);
p.load(fis);
String s1 = p.getProperty(“name”);

Map常用方法

 1. Object put(Object key,Object value):将指定key,value放入到map中。
 2. void putAll(Map map1);
 3. remove(key); //返回的是value。
 4. map.clear(); //清空map中的数据。
 5. map.get(key);
 6. map.containsKey();
 7. map.containsValue();
 8. size();
 9. isEmpty();
 10. equals(); //判断两个map是否相同。
 11. map的遍历：map.keySet(); //获得key的Set
 12. map.values(); //获得Collection的values()。
 13. map.entrySet(); //获得所有的key - value。然后再用entry.getKey() 和entry.getValue().

Collections工具类

 Collections：操作Collection、Map的工具类。
 1. reverse(List); //修改的List本身。
 2. shuffle(List); //将List中的数据随机排列。
 3.  sort(List); //自然排序、
 4. sort(List,Comparator); 或定制排序。
 5. swap(List, int ,int); //将指定list集合中的i处元素和j处元素进行交换。
 6. Object max(Collection);
 7. Object max(Collection, Comparator);
 8. Object min(Collection)
 9. Object min(Collection, Comparator)
 10. int frequency(Collection,Object); 返回指定集合中指定元素的出现次数。
 11. void copy(List dest,List src);   将src中的内容复制到dest中。   dest的size()要大于等于src的size()。List dest = Arrays.asList(new Object(list.size()));
 12. boolean replaceAll(List list,Object oldVal, Object newVal);  使用新值替换List中的旧值。
 13. synchronizedXXX(list); //将list转为线程安全的。

泛型

泛型定义

定义：把元素的类型设计成一个参数，这个类型参数叫做泛型，像数组一样。如：Collection,List,ArrayList,Iterator
这个就是类型参数称为泛型。（从jdk5.0之后增加的泛型）
1. 集合接口或集合类再jdk5.0时都修改为带泛型的结构。
  2. 在实例化时，可以指明具体的泛型类型。
  3. 指明完以后，所有的内部结构都要用泛型。
  4. 注意：泛型必须是类，不可以时基本数据类型。
  5. 如果不指定泛型，则是Object类型。
  6. 接口名. 泛型类、泛型方法.
jdk7新特性：类型推断：
Map map = new HashMap<>();
泛型方法

• 泛型方法：在方法中出现了泛型的结构，泛型参数与类的泛型参数没有任何关系。
• 换句话说，泛型方法所属的类是不是泛型类都没有关系。
public List copy(E[] arr){
}
泛型方法在调用时，指明泛型参数的类型。
Integer[] arr = new Integer[]{1,2,3}
List list = order.copy(arr);

泛型方法，可以生命为静态的。原因：泛型参数是在调用方法时确定的，并非在实例化类时确定。

泛型类和泛型方法的使用

 >DAO：data（base） access object。操作数据库中的数据，每个数据表对应一个类。
 public class DAO{
 	//zeng	
 	//shan
 	//gai
 	//cha
 }
 class StudentDAO extends DAO< Student>{	}

泛型在继承方面的体现。

 • List

JAVA基础与高级学习笔记

JAVA基础与高级学习笔记

JAVA基础

JAVA面向对象

面向对象三大特征

封装

继承

多态

单例设计模式：

模板方法设计模式

代理模式

工厂模式

异常

JAVA高级编程

Java多线程

方式一：继承于Thread类：

Java常用类

字符串相关的类

日期Date类的使用

JAVA的比较器

System类、Math类、BigInteger类、BigDecimal类了解

枚举类与注解

枚举类的使用

注解的使用

集合

泛型

IO流

网络编程

反射

JAVA8新特性

你可能感兴趣的:(java基础学习,反射,集合,socket,java,面向对象编程)