【java特性_面向对象】抽象类 抽象方法 接口

抽象类 和 抽象方法

1. 两者关系：抽象类中可以定义0-n个抽象方法。
   抽象方法格式: abstract 方法名（）；注意：没有方法体！！！
2. 抽象类的作用：
   抽象类中定义的抽象方法，目的是提供一个子类通用模板，子类可以在模板上进行开发，先重写父类的抽象方法，在扩展子类自己的内容。
   抽象类的设计避免了子类的随意性，通过抽象类某种程度上限制类子类的设计，使子类更加通用。
3. 抽象类不能创建对象，那么抽象类中是否有构造器？
   抽象类中一定有构造器，
   构造器的作用是初始化子类对象时进行super调用父类的构造器。
4. 抽象类是否可以被final修饰？
   不可以 被final修饰不存在继承，没有子类。
5. 代码理解：

接口

jdk1.8之前

1.类是类，接口是接口，同一层次的概念
2.接口中没有构造器
3.接口中如何声明：interface
4.在jdk1.8中只有两部分：
（1）常量：固定修饰符：public static final（修饰符可省略，为了记忆，写）
（2）抽象方法：固定修饰符 public abstract（修饰符可省略，为了记忆 写）
5.类和接口的关系?
实现关系，类实现接口。
实现
6.类如果不是抽象类需要将接口的抽象方法全部重写。
如果类中没有实现全部的抽象方法，则这个类也是抽象类，需要用abstract修饰。
7.java中只有单继承 但是有多实现（接口多个实现）
8.必须先继承再实现。
9.接口不能创建对象,多态的应用举例：
（1）传参可以传实现类 类型（实参），接受接口类型（形参）
（2）返回值类型为接口类型，返回实现类 类型
10.接口访问常量：
（1）static修饰 则 接口.NUM访问
（2）继承关系的访问
（3）子类对象访问
（4）父类引用指向子类对象

/*1.类是类，接口是接口，同一层次的概念
  2.接口中没有构造器
  3.接口中如何声明：interface
  4.在jdk1.8中只有两部分：
    （1）常量：固定修饰符：public static final（修饰符可省略，为了记忆，写）
    （2）抽象方法：固定修饰符 public abstract（修饰符可省略，为了记忆 写）
  5.类和接口的关系?
    实现关系，类实现接口。
    实现
  6.类如果不是抽象类需要将接口的抽象方法全部重写。
    如果类中没有实现全部的抽象方法，则这个类也是抽象类，需要用abstract修饰。
  7.java中只有单继承   但是有多实现（接口多个实现）
  8.必须先继承再实现。
  9.接口不能创建对象
*/
public interface TestInterface01 {
    //常量
    public static final int NUM = 10;
    //方法
    public abstract void a();
    public abstract void b(int num);
    public abstract int c(String name);
}
interface TestInterface02{
    public abstract void e();
    public abstract void f();

}
class Student extends Person implements TestInterface01,TestInterface02{
    @Override
    public void a() {
        System.out.println("a...");
    }

    @Override
    public void b(int num) {
        System.out.println("b...");
    }

    @Override
    public int c(String name) {
        return 0;
    }

    @Override
    public void e() {
        System.out.println("e...");
    }

    @Override
    public void f() {
        System.out.println("f...");
    }
}
class Test{
    public static void main(String[] args) {
        //9.接口不能创建对象,多态的应用举例：（1）传参可以传实现类 类型（实参），接受接口类型（形参）（2）返回值类型为接口类型，返回实现类 类型
        TestInterface02 t = new Student();
        //10.接口访问常量：（1）static修饰 则 接口.NUM访问（2）继承关系的访问（3）子类对象访问（4）父类引用指向子类对象
        System.out.println(TestInterface01.NUM);
        System.out.println(Student.NUM);
        Student s = new Student();
        System.out.println(s.NUM);
        TestInterface01 t2 = new Student();
        System.out.println(t2.NUM);

    }
}

接口和继承

继承：子类对父类的继承 is-a
实现：实现类对接口的实现 has-a
ex:
(1)手机 emplements 拍照功能
(2)飞机 小鸟 风筝 定义一个接口 flyable
区别：

jdk1.8之后

相较jdk1.8之前增加非抽象方法：

1. 由public default 修饰的非抽象方法，注意default方法修饰符必须加上，否则出错：public default
2. 重写的非抽象方法不能带default关键字
3. 调用接口中的
   （1）非抽象方法：接口名.super.方法名。
   具体代码如下：

public interface TestInterface01 {
    public static final int NUM = 10;
    public abstract void a();
    public default void b(){
        System.out.println("TestInterface01");
    }

}
class Test implements TestInterface01{
    @Override
    public void a() {
        System.out.println("a方法重写");
    }
    public void b(){
        
    }
    public void c(){
        b();//Test类中的方法
//        super.b();  错误写法
        TestInterface01.super.b();//调用接口中的方法
    }
}

（2）静态方法
静态方法不能重写
static不能省略不写

public interface TestInterface02 {
    //常量
    public static final int NUM = 10;
    //抽象方法
    public abstract  void a();
    //非抽象方法
    public default void b(){
        System.out.println("TestInterface02---b");
    }
    //静态方法
    public static void c(){
        System.out.println("TestInterface02--static--c");
    };
}
class Demo implements TestInterface02{
    public void a(){
        System.out.println("main---a");
    }
    public static void c(){
        System.out.println("demo--static--c");
    };

}
class A{
    public static void main(String[] args) {
        Demo d = new Demo();
        d.c();//demo--static--c
        Demo.c();//demo--static--c
        TestInterface02.c();//TestInterface02--static--c
    }
}

为什么要在接口中加入非抽象方法？

如果接口只定义抽象方法，需要修改时，修改其他实现类工作量巨大，只需要在接口中加入非抽象方法即可。