OOP(3)

抽象类、接口、实现类

一、抽象类

1.1 概念

java中可以定义没有方法体的方法，该方法由其子类来具体实现，该没有方法体的方法我们称之为抽象方法，含有抽象方法的类我们称之为抽象类。
抽象类可以理解为一个只有方法声明没有方法体的特殊类
修饰符 abstract 返回值 方法名(参数列表);

//抽象类
 abstract class Father{
    int num=9;
    public void test1(){
        System.out.println("非抽象方法");
    }
    //抽象方法
    public abstract void test2();
}

1.2 抽象类的特点

1、通过java关键字abstract实现
2、abstract可以修饰方法或者类
3、抽象类中可以没有抽象方法（抽象方法有子类去实现）
4、如果类中有抽象方法，那么类必须定义为一个抽象类（abstract修饰）
5、子类继承抽象类之后还是一个抽象类，如果如果不是抽象类则需要将所有的抽象方法都重写
6、多用于多态中
7、抽象类不可以被实例化

• 当然如果抽象类里没有抽象方法，继承抽象类的子类可以是抽象类，也可以不是抽象类（不用实现抽线抽象方法）

//抽象类
 abstract class Father{
    int num=9;
    public void test1(){
        System.out.println("非抽象方法");
    }
    public void test2(){

    };
}
class children extends Father{
}
abstract class children1 extends Father{

}

1.3 抽象类的用法

1.3.1 构造函数

• 抽象类也有构造方法，但是本身不能实例化（构造方法是实例化的基础）
• 抽象类构造函数的作用一般用于给子类实例化

public class test116 {
    public static void main(String[] args) {
    /*
    *普通类默认会有一个构造方法，而这个构造方法在方法体
    *的第一行会有一个默认的super();这个函数会实例化继承的抽象类
    */
        Children children = new Children();
        children.test2();
    }
}

//抽象类
abstract class Father {
    public Father() {
        System.out.println("抽象父类的构造方法");
    }

    public abstract void test1();

    public void test2() {
        System.out.println("抽象父类的测试方法");
    }
}

class Children extends Father {
    @Override
    public void test1() {
        System.out.println("子类重写父类的抽象方法");
    }
}
//测试结果
抽象父类的构造方法
抽象父类的测试方法

1.3.2 抽象类的成员变量

• 既可以有变量，也可以有常量

1.3.3 抽象类里的成员方法

• 抽象类里既可以有普通方法，也可以有抽象方法。

---

2 接口

2.1 概念

• java里面不允许有多重继承，所以如果要实现多个类的功能，则可以通过实现多个接口来实现。
• java接口和java抽象类代表的就是抽象类型，就是我们需要提出的抽象层的具体表现。OOP面对对象编程，如果要提高程序的复用率，增加程序的可维护性和可扩展性，就必须是面向接口的编程，面向抽象的编程，正确的使用接口、抽象类这些大有用的抽象类型作为java结构层次上的顶层
  interface 接口名{ 代码… }

2.2 特点

1、接口中都是抽象方法
2、通过interface关键字创建接口
3、通过implements关键字让子类实现接口
4、可以理解成，接口是一个特殊的抽象类
5、接口突破了java单继承的局限性
6、接口和类之间可以多实现，接口和接口之间可以多继承
7、接口是对外暴露的规则，是一套开发规范
8、接口提高了程序的功能扩展，降低了耦合性

2.3 接口的用法

2.3.1 构造方法

接口里面是没有构造方法的。
在创建实现类的对象式，构造构造方法默认的super();调用的是Object父类的无参构造

2.3.2 成员变量

接口中没有成员变量，都是常量，定义时会默认加上了final和static两个关键字作为修饰符

2.3.3 接口的成员方法

接口里的方法，默认就都是抽象的，如果你不写明就默认是abstrct关键字修饰的，并且访问修饰符默认是public。

2.3.4 接口的复杂用法

Java中单继承的局限性通过接口可以解决
接口可以多继承也可以多实现，甚至可以继承的同时多实现

public class test116 {
    public static void main(String[] args) {
    }
}

//抽象类
interface Interface1 {
    void save();

    void update();
}

interface Interface2 {
    void get();

    void delete();
}

interface Interface3 {
    void count();
}

//多继承
interface Interface4 extends Interface1, Interface2 {
}

//多实现
class Implement1 implements Interface2, Interface1 {

    @Override
    public void save() {
    }

    @Override
    public void update() {
    }

    @Override
    public void get() {
    }

    @Override
    public void delete() {
    }
}

//如果继承的那个类实现了几口，那么新的这个类不用去重写对应的方法
class Implement2 extends Implement1 implements Interface1, Interface2, Interface3 {

    @Override
    public void count() {

    }
}

3、拓展

3.1 abstract关键字注意事项

• 抽象方法要求子类继承后必须重写。
• private：被私有化后，子类无法重写，和abstract违背。
• static：静态的，优先序对象存在，抽象方法需要子类重写，而静态的方法是无法被重写的，因此二者是矛盾的
• final：被final修饰后，无法重写，与abstrct相违背

3.2 接口和抽象类的区别

1. 抽象类和接口都不能被直接实例化，如果要实例化，抽象类应用变量必须指向实现了所有抽象方法的子类的对象，接口引用变量必须指向实现了所有接口方法的类的对象。
2. 抽象类要被子类继承，抽象类要被类实现
3. 接口只能做方法申明，抽象类中可以做方法申明，也可以做方法实现

interface Interface1 {
    void save();

    void update();
}
abstract class test1 implements Interface2{
    
}

4. 接口里定义的变量只能是公共的静态的常量，抽象类中的变量是普通变量
5. 抽象类中的方法必须被子类全部实现，如果子类不能全部实现父类的抽象方法，那么该子类只是抽象类。同样，一个实现接口的时候，如不能全部实现接口方法，那么该类也只能为抽象类
6. 抽象方法只能申明，不能实现，接口时设计的结果，抽象类时重构的结果
7. 抽象类里可以没有抽象方法，如果要扩展抽象类的新方法，子类将很容易得到这些新方法
8. 如果一个类里有抽象方法，那么这个类只能是抽象类
9. 抽象方法要被实现，所以不能是静态的，也不能是私有的。
   10.接口可继承接口，并可多继承接口，但类只能单继承

4 创建的对象时，采用接口声明变量的原因

点击查看