抽象类与接口

抽象类

概念

1. 并不是所有的类都是用来描绘对象的如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。抽象类也是类，内部可以包含普通方法和属性，甚至构造方法 。

2. 在Java中，一个类如果被 abstract 修饰称为抽象类，抽象类中被abstract 修饰的方法称为抽象方法，抽象方法不用给出具体的实现体。

   // 抽象类：被abstract修饰的类
   public abstract class Shape {
   // 抽象方法：被abstract修饰的方法，没有方法体
   abstract public void draw();
   abstract void calcArea();
   // 抽象类也是类，也可以增加普通方法和属性
   public double getArea(){
   return area;
   }
   protected double area; // 面积
   }
   

特性

1. 抽象类只提供用于重写的接口函数，不能new实例化对象

2. 抽象类必须被继承，并且继承后子类要重写父类中的所有的抽象方法，否则子类也是抽象类，必须要使用 abstract 修饰

3. 抽象方法不能是private的，没有加访问限定符时，默认是public.

4. 抽象方法不能被final和static修饰，因为抽象方法要被子类重写

5. 抽象类中不一定包含抽象方法，但是有抽象方法的类一定是抽象类

6. 抽象类中可以有构造方法，供子类创建对象时，初始化父类的成员变量

抽象类的作用

1. 抽象类更多的是提供接口函数，供子类重写，不能new抽象类对象。
2. 抽象类可以作为函数参数，实现多态

接口

1. 接口是抽象类的进一步语法规范

2. 接口就是公共的行为规范标准，大家在实现时，只要符合规范标准，就可以通用。在Java中，接口可以看成是：多个类的公共规范，是一种引用数据类型。类似C++模板类，模板函数。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-xOMnUPCP-1689574269369)(./Java%E6%8A%BD%E8%B1%A1%E4%B8%8E%E6%8E%A5%E5%8F%A3.assets/image-20230716212820228-1689514101778-1.png)]

接口规则

1. 接口的定义格式与定义类的格式基本相同，将class关键字换成 interface 关键字，就定义了一个接口

   //. 创建接口时, 接口的命名一般以大写字母 I 开头.
   //2. 接口的命名一般使用 "形容词" 词性的单词.
   //3. 阿里编码规范中约定, 接口中的方法和属性不要加任何修饰符号, 保持代码的简洁性,推荐方式4，代码更简洁
   public interface 接口名称{
   // 抽象方法
   public abstract void method1(); // public abstract 是固定搭配，可以不写
   public void method2();
   abstract void method3();
   void method4();
   // 注意：在接口中上述写法都是抽象方法
   }
   

2. 接口中的方法默认是 public abstract,没有函数体;可以使用static修饰，但是static必须要有函数体

3. 从JDK1.8开始，可以使用deafult修饰，且必须添加函数体

    public  static  void fun1()
       {
           System.out.println("hello word");
       }
       default public void fun2() {
           System.out.println("hello word");
       }
   

4. 成员变量默认是 public static final修饰的

implement

1. 接口不能直接使用，必须要有一个"实现类"来"实现"该接口，实现接口中的所有public abstract修饰的方法,对于default或者static是可选择重写。

2. 子类的方法必须是public的

3. 接口可以作为基类参数，运行向上转换与向下转换

      
       public void useDevice(IUsb usb) {
           usb.openDevice();
           if (usb instanceof Mouse) {
               Mouse mouse = (Mouse) usb;
               //向下转型存在危险，还是要强制类型转换    
               mouse.click();
           } 
   

接口特性

1. 接口类型是一种引用类型，但是不能直接new接口的对象
2. 接口中每一个方法都是public的抽象方法, 即接口中的方法会被隐式的指定为 public abstract (只能是public abstract，其他修饰符都会报错 )
3. .接口中的方法是不能在接口中实现的，只能由实现接口的类来实现
4. 子类重写接口中方法时，只能使用public修饰函数
5. 接口中可以含有变量，但是接口中的变量会被隐式的指定为 public static final 变量
6. 接口中不能有静态代码块和构造方法
7. 接口虽然不是类，但是接口编译完成后字节码文件的后缀格式也是.class
8. 如果类没有实现接口中的所有的抽象方法，则类必须设置为抽象类，如果被其他类继承，必须重写
9. jdk8中：接口中还可以包含default方法。

抽象与接口的对比

1. 核心区别 ：抽象类中可以包含普通方法和普通字段, 这样的普通方法和字段可以被子类直接使用(不必重写), 而接口中不能包含普通方法, 子类必须重写所有的抽象方法

2. 抽象类与接口一样都是不能new的，但是却可以作为函数的参数，构成多态

3. 抽象类可以实现多个接口，接口继承多个接口

   1. 类不能多继承，最多是多层继承，但是可以实现多个接口，因此对于某些类可以定义为接口，用于类多实现接口
   2. 接口可以多继承接口

4. 方法默认是public，但是接口默认是 public abstract

5. 抽象类、接口不能是private，static，final

   [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-vUpy00g0-1689574269373)(./Java%E6%8A%BD%E8%B1%A1%E4%B8%8E%E6%8E%A5%E5%8F%A3.assets/image-20230717095924728-1689559168712-1.png)]

Object类

Object是所有类的父类，包括自定义类型

1. 使用Object接收所有类的对象

toString

用于对象的打印

public String toString() {
return getClass().getName() + "@" + Integer.toHexString(hashCode());
}

hashcode

1. 返回一个可以在底层通过转换确定对象在hash表中的位置的一个值
2. 有些地方需要重写hashcode

public int hashCode() {
return Objects.hash(name, age);
}

equals

对象的比较必须要重写equals

如果==左右两侧是基本类型变量，比较的是变量中值是否相同

2. 如果==左右两侧是引用类型变量，比较的是引用变量地址是否相同
3. 如果要比较对象中内容，必须重写Object中的equals方法，因为equals方法默认也是按照地址比较的：

Comparable

1. Comparable 是一个比较接口，用于子类继承，实现compareTo 函数，但是需要添加业务时，比较麻烦，使用comparator（比较器）

class Student implements Comparable<Student>  
{
public int compareTo(Object o) {
Student s = (Student)o;
if (this.score > s.score) {
return -1;
} else if (this.score < s.score) {
return 1;
} else {
return 0
}
}

comparator比较器

class  AgeComparator implements Comparator<Student>
{
    //Comparator中有equals，为什么不重写equals
    //Java中类都继承于Object类，而Object类默认实现了equals方法，所以子类实现了Comparator接口，不需要必须去实现equals方法，且equals只需要比较引用值
    public int compare(Student o1,Student o2)
    {
        return o1.compareTo(o2);
    }
}

Cloneable

1. 虽然Object中有clone函数，但是Java中必须要有类必须要有clone能力即实现Cloneable接口，重写clone函数

   public class Person implements Cloneable {
       public int _a;
       public Person(int a)
       {
           _a=a;
       }
       @Override
       protected Object clone() throws CloneNotSupportedException {
           Person o = null;
           try {
               //object类中实现过了clone方法
               o = (Person) super.clone();
           } catch (CloneNotSupportedException e) {
               e.printStackTrace();
           }
           return  o;
       }
       public static void main(String[] args) throws CloneNotSupportedException {
           Person p=new Person(10);
           Person p1=(Person) p.clone();
            System.out.println(p);
           System.out.println(p1);
       }
   }
   

深拷贝与浅拷贝

浅拷贝：拷贝的内容中有引用的，可能会出现问题

深拷贝：将拷贝中的引用内容重新clone

析构函数

Java中存在垃圾回收器（来源与object的protected类型的finalize()方法），什么时候释放释放堆中资源是不确定的

System.gc()