Java进阶

1 抽象类

类和类之间有共有特征，将这些具有共同特征的类再进一步抽象形成了抽象类。抽象类无法创建对象
抽象类也属于引用数据类型
抽象类定义：

[修饰符列表] abstract class 类名
{
   
}

final无法与abstract同时使用

抽象类 的子类也可以是抽象类
抽象类虽然无法实例化，但是抽象类有构造方法，这个 构造方法供子类使用
抽象方法表示没有实现的方法，没有方法体的方法

• 抽象方法的特点：
• 没有方法体，以分号结尾
• 前面的修饰符列表中有abstract关键字

抽象方法一定出现在抽象类中，抽象类中不一定有抽象方法

2 接口

2.1 接口的基本语法

接口也是一种引用数据类型。编译之后生成class字节码文件
接口是完全抽象的（抽象类是半抽象的）

//接口定义
[修饰符列表] interface 接口名{
   }

接口中只包含两部分内容，一是常量，二是抽象方法，接口中没有其他内容
一个接口可以继承多个接口（支持多继承）

interface A{
   }
interface B{
   }
interface C exyends A,B{
   
int sum（int a,int b）;
}

接口中所有元素都是public修饰
定义时 方法的public abstract 可以省略
常量的public static final 也可以省略
接口中的抽象方法都是抽象方法，不能有方法体
接口是特殊的抽象类，完全抽象
类和类之间是继承，类和接口之间是实现
可以将实现看作继承，使用extends关键字完成
实现使用implements关键字实现

当一个非抽象类实现接口的话，必须将接口中所有的抽象方法全部实现（覆盖、重写）

面向接口编程

一个类可以实现多个接口

接口与接口之间的强制转换不需要继承关系，可以强制转换，但是运行时可能出现ClassCastException异常
向下转型前加上instanceof判断，可避免此类异常

extends和implements可以同时使用，继承在前，实现在后
使用接口写代码时候，可以使用多态（父类型引用指向子类型对象）

2.2 接口在开发中的作用

接口的作用类似于多态在开发中的作用

面向接口编程，可以降低程序的耦合度，提高程序的扩展力，符合OCP开发原则
接口的使用离不开多态机制

2.3 类与类之间的关系

继承关系
关联关系：通常以“属性”的形式存在
实现关系：类实现接口

2.4 抽象类和接口的区别

抽象类是半抽象的
接口是完全抽象的

抽象类中有构造方法
接口中没有构造方法

接口和接口之间支持多继承
类和类之间只能单继承

一个类可以同时实现多个接口
一个抽象类只能继承一个类

接口中只允许出现常量和抽象方法

3 Object

任何一个类默认继承object类

API 应用程序编程接口

3.1 toString方法

Object类默认的toString方法返回引用的地址，引用.toString
每次使用时重写

3.2 equals方法

判断两个基本数据类型相等，直接使用==
引用数据类型不能使用“ == ” 判断，引用数据类型保存的是内存地址，不能直接判断
equals方法使用的是“ == ”方法，判断使用的是引用的内存地址，使用时需要重写

3.3 finalize方法

finalize在java对象即将被垃圾回收器回收的时候，垃圾回收器负责调用finalize（）方法
如果希望在对象销毁时执行一段代码时，这段代码要写写到finalize（）方法里面

3.4 hashCode方法

获取对象哈希值

4 内部类

内部类是在类的内部定义了一个新类，称为内部类
内部类分类：

• 静态内部类：类似于静态变量
• 实例内部类：类似于实例变量
• 局部内部类：类似于局部变量

使用内部类编写的代码可读性差，能不用尽量不用

4.1 匿名内部类

匿名内部类是局部内部类的一种

5 数组

Java中数组是引用数据类型，不属于基本数据类型
数组对象都有length属性（java自带），用来获取 数组中元素的个数
优点：查询效率最高的的数据结构
缺点：数组中每个元素的内存地址连续，所以在增加或是删除数据元素时效率较低；数组不能存储大数据量，
因为很难在内存空间上找到一块特别大的内存空间

5.1 一维数组

int[] array1;
double []array2;
String [] array2;
// 静态初始化
int [] array={
   1,2,3,4,5};
//动态初始化
int [] =new int [5];

5.1.1 main函数参数

String[] 静态初始化数组，长度为0

5.1.2 数组扩容

先新建一个大容量的数组，然后将小容量数组中的数据一个一个拷贝到大数组中
数组扩容效率较低，创建对象时，先准确预估数组大小，尽量减少拷贝次数
System.arraycopy(源数组，起点，目标数组，起点，长度);

5.2 二维数组

int[][] a={
   {
   1,2,3},{
   4,5,6}};

5.3 Array工具类

二分法查找是建立在排序的基础上的，没有排序无法查找
java.util.arrays

6 String类

java.lang.String
java规定，双引号括起来的字符串是不可变的，都是直接存储在“方法区”的“字符串常量池”中

String s="123456";
s.charAt(1);//访问字符串特定位置的元素
String s1 =String.valueof(1234);//将其他数据类型转换为字符串

int a=s1.compareTo(s2);//比较s1和s2的大小，结果为0，两字符串相等，逐个比较每个字符，直到出现不一样的字符

//StringBuffer  拼接字符串 线程安全
//StringBuffer底层是byte[]  
 SStringBuffer stringBuffer=new StringBuffer();
 stringBuffer.append("a");
 stringBuffer.append("b");
//StringBuilder 非线程安全

6.1 日期

//Date转String
  Date date=new Date();
  System.out.println(date); //输出系统当前时间
  //转换时间输出格式 y代表年 M-月 d-日 H-小时 m-分 s-秒 S-毫秒
  SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss SSS"); 
  String s=sdf.format(date);
  System.out.println(s);
 

//String转DAte
 String time="2020-08-20 13:36:44 365";
 SimpleDateFormat sd=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss SSS");
 Date t=sd.parse(time);
 System.out.println(t);

7 异常

程序过程中发生了不正常的情况，这种不正常的情况就是异常
异常处理机制在程序出现异常时吧异常信息打印输出到控制台，供程序员参考，帮助程序员对程序进行修改

Java中异常以异常类和对象的形式存在
Object 下有Throwable（可抛出的）
Throwable有两个分支：Error（不可处理，直接退出JVM）和Exception（可处理的）
Exception下游两个分支：
Exception的直接子类：编译时异常
RuntimeException：运行时异常

7.1编译时异常和运行时异常的区别

两种异常都是发生在运行阶段。因为异常的发生就是new异常对象
编译时异常发生概率较高，程序员在编译时就可以预处理的异常，如果不处理，就会发生编译时异常
运行时异常发生概率较低

7.2 异常处理

1.方法声明位置使用throws关键字

class ExcetionTest
{
   
  public void dosome throws ClassNotFoundException
  {
   
  System.out.println("aaaaaaa");
  }
  
}
//处理方法
public class test01 {
   
    public static void main(String[] args)throws ClassNotFoundException {
   
        ExcetionTest t=new ExcetionTest();
        t.dosome();
    }
}

2.使用try.catch语句进行异常的捕捉

class Trytest
{
   
    void dosome() throws ClassNotFoundException {
   
        System.out.println("aaaaaaaaaaaaa");
    }
}
public class test01 {
   
    public static void main(String[] args) {
   
        try{
   
            Trytest t=new Trytest();
            t.dosome();
        }catch (ClassNotFoundException e){
   
            e.printStackTrace();
        }
    }
}

3.throws是上抛异常，将异常抛给上一级，并没有解决异常
catchs是捕捉异常，

如果希望调用者处理异常，使用throws，其他情况使用catch捕捉异常

7.3 异常的常用信息

获取异常的简单的描述信息
String msg=exception.getMessage（）；
打印异常追踪的堆栈信息：
exception.printStackTrace（）；

8 集合

集合是一个容器，可以容纳其他类型的数据，可以容纳多个对象
集合不能直接存储基本数据类型，也不能直接存储java对象
集合中存储的都是java对象的内存地址
在java中每一个不同的集合，底层会对应不同的数据结构
new ArrayList （）；底层是数组
new LinkedList（）；底层是链表
new TreeSet（）；底层是二叉树

Java中集合分为两大类：

• 一是单个方式存储元素，这一类集合中的超级父接口：java.util.Collection;
• 二是以键值对的方式存储元素，这一类集合中超级父接口：Java.util.Map

List集合存储元素特点：有序可重复，存储的元素有下标
Set集合存储元素特点：无序不可重复，没有下标

8.1 List

List集合存储元素特点：有序可重复，存储的元素有下标
ArrayList:数组，非线程安全的
LinkedList：双向链表
Vector：数组，线程安全的，Vector方法都有synchronized关键字修饰，线程安全，但是保证线程安全有别的方案，Vector使用较少

8.2 Set

HashSet:底层是HashMap结构，非线程安全
TreeSet底层是TreeMap

8.2.1 HashSet

无序不可重复

8.2.2 TreeSet

无序不可重复，但是存储的元素可以自动按照大小顺序排序，但是会从小到大自动排序
无序指的是存进的顺序和取出的顺序不同，没有下标

8.3 Map

8.3.1 HashMap

Map和Collection没有继承关系
以键值对的方式存储，key和value，存储的都是对象的内存地址，
所有Map集合的key特点：无序不可重复
HashMap底层是哈希表数据结构，是非线程安全
Hashtable底层是哈希表数据结构，线程安全，所有方法都带有synchronized关键字，效率较低，
TreeMap底层是二叉树，实现了SortMap接口，是无序不可重复的，集合key部分的元素会自动排序，称为可排序集合
Map集合的key就是一个Set集合，
放在HashMap集合key部分的，以及放在HashSet集合的元素，需要同时重写hashcode和equals方法

HashMap集合的默认初始化容量是16，默认加载因子是0.75

8.3.2 Hashtable

Hashtable集合的初始化容量是11，扩容是：原容量*2+1

8.3.3 Properties类

Properties是一个Map集合，继承Hashtable，Properties的key和value都是String类型
properties被称为属性类对象

8.4 foreach

foreach循环没有下标

int num[]={
   1,2,3,4};
foreach(int x:num)
{
   
   System.out.println(x);
}

ArrayList<Integer> nums=new ArrayList<>();
   for(int i=0;</