【JavaSE】抽象类和接口

//1.抽象类：被abstract修饰的类
public abstract class Person {
    //2.抽象方法：被abstract修饰的方法，没有方法体
    public abstract void talk();
    public abstract void sleep();
    
    //3.抽象类也是类，可以有普通方法和属性
    public void eat(){
        System.out.println("一天吃四顿饭");
    }
    
    public String name;
}

3.抽象类特性

3.1抽象类不能直接实例化对象

Person person = new Person();//err

可以通过下面两种方式进行实例化

        //1.创建子类对象
        Student s = new Student();
        s.sleep();
        s.talk();

        //2.多态的写法：父类引用指向子类对象
        Person p = new Student();
        p.sleep();
        p.talk();

3.2抽象方法不能是private的

 private abstract void eat();//err因为private不允许子类访问，违背了抽象类的初衷

3.3抽象方法不能被final和static修饰

    final abstract void drink();//err
    static abstract void think();//err

1.final表示该类或方法不能被重写，继承或修改，而抽象方法必须要被子类重写或实现。

2.抽象方法和 static 方法的作用不同。抽象方法用于定义一个接口或抽象类，其目的是让子类实现该方法，使得子类具有相同的行为和属性；而 static 方法是为了实现类级别的操作，它们与特定的实例对象无关。

3.4抽象类必须被继承

class Student extends Person{
    @Override
    public void talk() {
        System.out.println("不说话能憋疯");
    }

    @Override
    public void sleep() {
        System.out.println("不睡觉会困");
    }
}

注意：

1.抽象类必须被继承，子类使用extends继承抽象类。

2.子类继承抽象类，必须重写所有的父类抽象方法。如果没有全部重写，子类会变成抽象类，必须用abstract修饰。

3.5一个抽象类可以有0-n个抽象方法

也就是说：一个抽象类中可以没有抽象方法，但是有抽象方法的类一定是抽象类。

3.6抽象类中可以有构造方法

作用：供子类创建对象时，初始化父类的成员变量。

—————————————————–分割线——————————————————————-

二接口

1.接口概念

在生活中，随处可见接口的例子：电源插座，USB接口等。接口是一种引用数据类型，可以看成多个类的引用规范。

2.接口语法规则

与定义类相似，把class关键字替换成interface关键字，接口名称用大写I来开头，接口的命名一般采用词性为”形容词“的单词。

在JDK1.8之前，接口只有两部分内容：

1.常量：固定修饰符public static final

2.抽象方法：固定修饰符public abstract

注：固定修饰符可省略

在JDK1.8之后，接口新增了非抽象类方法

3.被public default修饰的非抽象方法（这里的default不能省略）

4.静态方法（静态方法不能重写）

public interface ITestInterface01 {
    //1.常量
    public static final int NUM = 1;

    //2.抽象方法
    public abstract void a();

    //3.非抽象方法-->default不能省略
    public default void b(){
        System.out.println("------------b");
    }

    //4.静态方法
    public static void c(){
        System.out.println("ITestInterface2中的静态方法");
    }
}

3.接口的使用

接口不能直接使用，需要一个实现类来实现接口中的所有抽象方法，类与接口通过关键字implements实现。

class Demo implements ITestInterface2{
    @Override
    public void a() {
        System.out.println("重写了a方法");
    }

    @Override
    public void b() {
        ITestInterface2.super.b();
    }
    //需要自己重写静态方法
    public static void c(){
        System.out.println("Demo中的静态方法");
    }
}

4.接口的继承与实现

注意：

1.一个类实现多个接口时，每个接口的抽象方法都要实现，否则类就要设置成抽象类。

2.一个子类只能继承一个父类，但可以实现多个接口。顺序：.先继承再实现。

public interface ITestInterface02 {
    //常量
    public static final int NUM = 10;

    //抽象方法
    public abstract void a();
   
}
public interface ITestInterface03 {
     public abstract int e();
}

//一个子类可以实现多个接口
class Student extends Person implements ITestInterface02,ITestInterface03{
    @Override
    public void a() {

    }

    @Override
    public void e() {

    }
}

5.接口中类的实现

class Test{
    public static void main(String[] args) {
        //接口不能创建对象
        //ITestInterface01 t = new ITestInterface01();err

        //1.接口中的抽象方法如何访问
        ITestInterface01 t = new Student();
        t.a();
        

        //2.接口中的常量如何访问
        System.out.println(ITestInterface01.NUM);

        System.out.println(Student.NUM);

        Student s = new Student();
        System.out.println(s.NUM);

        ITestInterface01 t1 = new Student();
        System.out.println(t1.NUM);


    }
}

三抽象类与接口的区别

抽象类：

1.抽象类用abstract修饰

2.子类使用extends关键字继承抽象类

3.抽象类中除了抽象方法，还可以有非抽象方法和普通成员

4.抽象类中的抽象方法只有方法体，没有具体实现

5.一个类只能继承一个抽象类

接口：

1.接口用interface修饰

2.子类使用implements关键字实现接口

3.抽象类中的抽象方法固定修饰符为public static final，常量固定修饰符为public abstract

4.一个类可以实现多个接口。

原文链接：https://blog.csdn.net/w2022009105/article/details/131140045

一 抽象类

1.抽象类概念

2.抽象类语法