小怡分享之Java抽象类和接口

前言：

    🌈✨前面小怡给大家分享了Java的继承和多态，今天小怡给大家分享一下抽象类和接口。

1.抽象类

1.1  抽象类概念

          在面向对象的概念中，所有对象都是通过类来描述的，但是反过来，并不是所有的类都是用来描述对象的，如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。没有具体的实现的方法，我们可以把它设计成一个抽象方法，包含抽象方法的类我们称为抽象类 。抽象类不能实例化。抽象类和普通类唯一的区别就是抽象类中可以有抽象方法。

1.2  抽象类语法 

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

 

           注意：抽象类也是类，内部可以包含普通方法和属性，甚至构造方法。

1.3   抽象类特性 

1.抽象类不能直接实例化对象；

2.抽象方法不能是private的；

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

4.抽象类必须被继承，并且继承子类要重写父类中的抽象方法，否则子类也是抽象类，必须要使用abstract修饰。 如果一个普通类继承了这个抽象类，那么此时这个普通类必须重写这个抽象类当中的抽象方法；

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

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

1.4  抽象类的作用 

         抽象类本身不能被实例化，要想使用，只能创建该抽象类的子类，然后让子类重写抽象类中的抽象方法。

         但是，普通类也可以被继承呀，也可以被重写呀，为什么要用抽象类呢？

         确实如此，但是使用抽象类相当于多了一重编译器的校验。这在实际开发中是非常有意义的。 

2.接口 

        接口的出现解决了Java不能多继承的问题。 

2.1   接口的概念 

         在生活中，接口的例子很多,比如，笔记本上的usb口，电源插座等。 

          电脑的usb口，可以插：u盘，鼠标，键盘等所有符合usb协议的设备；

          电源插座插孔上，可以插：电脑，电视机，电饭煲等所有符合规范的设备；

          通过上述例子可以看出：接口就是公共的行为规范标准，大家在实现时，只要符合规范标准，就可以通用。 

          在Java中，接口可以看成是：多个类的公共规范，是一种引用数据类型。

2.2   语法规则 

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

public interface 接口名称{

       ...

}

注意：

1.创建接口时，接口的命名一般以大写字母I 开头；

2.接口的命名一般使用“形容词”词性的单词；

3.阿里编码规范中约定，接口中的方法和属性不要加任何修饰符号，保持代码的简洁性。 

4.接口中的成员变量，默认是public static final修饰的； 

public static final int a=1;

5.接口中的方法，都是默认抽象方法，默认都是public static修饰的。

public abstract void draw();

6. 如果接口当中的方法，被default/static修饰，那么可以有具体的实现。

default void test(){
    System.out.println("default方法");
}

7.接口是不可以进行实例化的；

8.类和接口之间可以使用关键字implements来实现接口（必须使用接口当中的抽象方法）；

public class Test implements USB{
     ...
}

9.一个接口对应一个字节码文件。

10.如果一个类不想实现这个接口中的方法，那么此时这个类就可以被定义为抽象类。但是这个类如果被继承，那么就得实现所有的没有被实现的方法。 

2.3   接口的使用 

           接口不能直接使用，必须要有一个“实现类”来“实现”该接口，实现接口中的所有抽象方法。

public class 类名称 implemengts 接口名称{

       //...

}

         注意：子类和父类之间是extends继承关系，类与接口之间是implements实现关系。

 2.4    接口特性

1.接口类型是一种引用类型，但是不能直接new接口的对象；

2.接口中每一个方法都是public的抽象方法，即接口中的方法会被隐式的指定为public abstract。

3.接口中的方法是不能在接口中实现的，只能由实现接口的类来实现；

4.重写接口中方法时，不能使用默认的访问权限；

5.接口中可以含有变量，但是接口中的变量会被隐式的指定为public static final变量；

6.接口中不能有静态代码块和构造方法；

7.接口虽然不是类，但是接口编译完成后字节码文件的后缀格式也是.class；

8.如果类没有实现接口中的所有的抽象方法，则类必须设置为抽象类。

2.5  实现多个接口

          在Java中，类和类之间是单继承的，一个类只能有一个父类，，即Java中不支持多继承，但是一个类可以实现多个接口。下面通过类来表示一组动物。

class Animal{
   protected string name;
   public Animal(String name){
       this.name=name;
   }
}

          另外我们再提供一组接口，分别表示会飞的、会跑的、会游泳的。 

interface Iflying{
    void fly();
}
interface IRunning{
    void run();
}
interface ISwimming{
    void swim();
} 

           接下来我们创建几个具体的动物。猫是会跑的。

class Cat extends Animal implements IRunning{
     public Cat(String name){
         super(name);
     }
     public void run(){
         System.out.println(this.name+"正在用四条腿跑");
     }
}

            鱼，是会游的。

class Fish extends Animal implements ISwimming{
     public Fish(String name){
         super(name);
     }
     public void swim(){
         System.out.println(this.name+"正在尾巴游泳");
     }
}

              青蛙，即能跑又能游（两栖动物）。

class Frog extends Animal implements IRunning,ISwimming{
     public Frog(String name){
         super(name);
     }
     public void run(){
         System.out.println(this.name+"正在往前跳");
     }
     public void swim(){
         System.out.println(this.name+"正在蹬腿游泳");
     }
}

注意：一个类实现多个接口时，每个接口中的抽象方法都要实现，否则类必须设置成抽象类。

 IDEA中使用 ctrl+i快速实现接口。

         上面的代码展示了Java面向对象编程中最常见的方法：一个类继承一个父类，同时实现多个接口。继承表达的含义是 is-a语义，而接口表达的含义是 具有xxx特性。

         这样设计的好处就是，类的使用者不必关注具体类型，而只关注某个类是否具备某种能力。

2.6    接口的继承 

          在Java中，类和类之间是单继承的，一个类可以实现多个接口，接口与接口之间可以多继承。即：用接口可以达到多继承的目的。

       接口可以继承一个接口，达到复用的效果，使用extends关键字。

interface IAmphibious extends IRunning,ISwimming{
      //...
}

2.7   接口使用实例 

给对象数组排序 

 

           谁调用方法，谁就是this。equals返回值是布尔型。 

 

缺陷：这个比较方式一般用于固定的比较，不适合非常灵活的比较。

用途：用在默认的比较上；

解决问题：换一个接口解决。 

结论：只要是自定义的类型，涉及到大小的比较，目前的一个结论是一定得实现Comparable接口。 

 

 

 2.8   Cloneable接口和深拷贝

            Java中内置了一些很有用的接口，Clonable就是其中之一。

            Object类中存在一个clone方法，调用这个方法可以创建一个对象的“拷贝”。但是要想合法调用clone方法，必须要先实现Cloneable接口，否则就抛出CloneNotSupportedException异常。

 

          执行结果：false 

          浅拷贝vs深拷贝

          Cloneable拷贝出的对象是一份“浅拷贝”；

          观察下面这一段代码。 

class Money{
    public double m=9.9;
}
class Person implements Cloneable{
    public Money money=new Money();
    protected Object clone() throws CloneNotSupportedException{
        return super.clone();
    }
}

public class TestDemo {
    public static void main(String[] args) throws CloneNotSupportedException{
    Person person1=new Person();
    Person person2=(Person)person.clone();
    System.out.println("通过person2修改前的结果");
    System.out.println(Person1.money.m);
    System.out.println(Person2.money.m);
    person2.money.m=13.6;
    System.out.println("通过person2修改前的结果");
    System.out.println(Person1.money.m);
    System.out.println(Person2.money.m);
    }
}

            如上代码，我们可以看到，通过clone，我们只是拷贝了Person对象。但是Person对象中的Money对象并没有拷贝。通过person2这个引用修改了m的值后，person1这个引用访问m的时候，值也发生了改变。这就是发生了浅拷贝。 

 

2.9   抽象类和接口的区别 

           抽象类和接口都是Java中多态的常见使用方法。同时要认清两者的区别。

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

No	区别	抽象类（abstract）	接口（interface）
1	结构组成	普通类+抽象方法	抽象方法+全局常量
2	权限	各种权限	public
3	子类使用	使用extends关键字继承抽象类	使用implements关键字实现接口
4	关系	一个抽象类可以实现若干接口	接口不能继承抽象类，但是接口可以使用extends关键字继承多个父接口
5	子类限制	一个子类只能继承一个抽象类	一个子类可以实现多个接口

 

 

3.Object类

        Object类是Java默认的一个类。Java里面除了Object类，所有的类都是存在继承关系的。默认继承Object父类。即所有的类的对象都可以使用Object的引用进行接收。

代码示例：使用Object接收所有类的对象。 

 

3.1   获取对象的信息

         如果要打印对象中的内容，可以直接重写Object类中的toString（) 方法,之前也给大家讲过了。

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

 

3.2    对象比较equals方法 

          在Java中，==进行比较时：

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

public boolean equals(Object obj){
     if(obj==null){
         return false;
     }
     if(this==obj){
         return true;
     }
     if(!(obj instanceof Person)){
         return false;
     }
     Person person=(Person)obj;
     return this.name.equals(person.name)&&this.age==person.aage;
}

 

3.3   hashcode方法 

          回忆刚刚的toString方法的源码：

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

        我们可以看到了hashCode （）这个方法，他帮我算了一个具体的对象位置，这里面涉及数据结构，我们暂时没学，所以我们只能说他是一个内存地址。然后调用了Integer.toHexString（）方法，将这个地址16进制输出。

结论：

1.hashcode方法用来确定对象在内存中存储的位置是否相同；

2.事实上hashcode（）在散列表中才有用，在其他情况下没用。在散列表中hashcode（）的作用是获取对象的散列码，进而确定对象在散列表中的位置。

 

 🌈✨今天的分享到这里结束啦，小怡和大家一起进步一起学习，“壮心未与年俱老，死去犹能作鬼雄”。