1.抽象类&抽象方法

1.1抽象类的分析：

  • 酒店中有经理，服务员，厨师之类的员工，他们之间是什么关系？
  • 员工类：定义了其他类的共性内容
  • 成员变量：工号，姓名，年龄，工资···
  • 成员方法：工作的方法（work），父类中的方法就是给子类去重写的

  • 结果：
  • 1.员工的work方法是一定会被子类重写的，此时这个方法可以被定义为抽象方法

  • 2.员工类（父类）不需要被创建，所以可以定义为抽象类

    1.2抽象类（abstract）

  • 抽象类：不能被实例化

  • 用来描述一种应该具备某种功能和特征，具体去完成这些功能的行为由子类重写方法去完成的类，
  • 不需要去实现自己的方法

  • 抽象方法：
  • 用于封装父类的功能，不需要实现方法，只需要写上功能即可

  • 抽象定义为：abstract—-定义抽象类，在类class前加上abstract
  • 定义抽象类的具体子类（普通类）必须实现父类的抽象方法 ```java package com.igeek_01;

/**

  • @author Lynn
  • @create 2020-12-01-9:45 */

/**

  • 抽象类——父类 *

  • 在类class之前加上abstract */ public abstract class Employee {

    //定义抽象方法—-不需要写方法体—在返回值的前面加上abstract public abstract void work(); } java package com.igeek_01;

/**

  • @author Lynn
  • @create 2020-12-01-9:47 */

/**

  • 这是一个子类—-实现类—实现父类的方法 *
  • 定义抽象类的具体子类（普通类）必须实现父类的抽象方法 */ public class Waiter extends Employee{ @Override public void work() {
    1.  System.out.println("接客，上菜，招待，结账");
    } } java package com.igeek_01;

/**

  • @author Lynn
  • @create 2020-12-01-9:38 */

/**

  • 抽象类的分析：
  • 酒店中有经理，服务员，厨师之类的员工，他们之间是什么关系？
  • 员工类：定义了其他类的共性内容
  • 成员变量：工号，姓名，年龄，工资···
  • 成员方法：工作的方法（work），父类中的方法就是给子类去重写的 *
  • 结果：
  • 1.员工的work方法是一定会被子类重写的，此时这个方法可以被定义为抽象方法
  • 2.员工类（父类）不需要被创建，所以可以定义为抽象类 *
  • 抽象类：不能被实例化
  • 用来描述一种应该具备某种功能和特征，具体去完成这些功能的行为由子类重写方法去完成的类，
  • 不需要去实现自己的方法 *
  • 抽象方法：
  • 用于封装父类的功能，不需要实现方法，只需要写上功能即可 *

  • 抽象定义为：abstract */ public class AbstractorDemo { public static void main(String[] args) {

    1.  //测试实例化抽象类--不能实例化

    // Employee e=new Employee();

    1.  //实例化子类
    2.  Waiter w=new Waiter();
    3.  //调用了子类中重写父类的方法
    4.  w.work();

    } } ```

    1.3抽象类2

    tips1：抽象类不能被实例化，但是构造函数是有的
    tips2：抽象父类的方法，可以完成类似于成员变量初始化的功能，从而使这个成员变量可以被子对象使用

tips3：抽象类中的构造方法不能被程序直接调用，因为该类是一个抽象类，不能被实例化；但是在创建子类（普通类）的时候，子类构造函数会默认调用父类的构造函数，为了子类对象的父类存储空间赋值

tips4：重要！！！如果一个类在继承父类（抽象类）的时候，没有实现父类中的所有抽象方法，那么这个子类还是抽象类

  1. package com.igeek_02;
  3. /**
  4.  * @author Lynn
  5.  * @create 2020-12-01-10:13
  6.  */
  8. /**
  9.  * 抽象类--父类
  10.  * 可以设置构造函数
  11.  */
  12. public abstract class Employee {
  13.     //属性
  14.     private String name;
  16.     public String getName() {
  17.         return name;
  18.     }
  20.     public void setName(String name) {
  21.         this.name = name;
  22.     }
  24.     /**
  25.      * 抽象类中的构造方法不能被程序直接调用，因为该类是一个抽象类，不能被实例化
  26.      * 但是在创建子类（普通类）的时候，子类构造函数会默认调用父类的构造函数，
  27.      * 为了子类对象的父类存储空间赋值
  28.      */
  29.     //无参构造
  30.     public Employee() {
  31.     }
  32.     //有参构造
  33.     public Employee(String name) {
  34.         this.name = name;
  35.     }
  37.     //定义成员方法--抽象方法
  38.     public abstract void work();
  40.     //抽象类中可以保存普通方法
  41.     public void test(){
  42.         System.out.println("这是一个普通方法");
  43.     }
  44. }
  1. package com.igeek_02;
  3. /**
  4.  * @author Lynn
  5.  * @create 2020-12-01-10:22
  6.  */
  8. /**
  9.  * 定义一个普通类，去实现父类（抽象类）中的所有抽象方法
  10.  */
  11. public class Waiter extends Employee{
  12.     @Override
  13.     public void work() {
  14.         System.out.println("接客，上菜，招待，结账");
  15.     }
  17.     public Waiter() {
  19.     }
  21.     /**
  22.      * 子类的构造方法可以调用父类的构造方法
  23.      * 这里，一个参数的子类构造，调用了父类的一个参数的构造，为父类中的成员赋值
  24.      * 但是最终还是子类对象自己使用了这个成员变量
  25.      * @param name
  26.      */
  27.     //子类的有参构造
  28.     public Waiter(String name) {
  29.         super(name);//调用的是父类的有参构造
  30.     }
  31. }
  1. package com.igeek_02;
  3. /**
  4.  * @author Lynn
  5.  * @create 2020-12-01-10:20
  6.  */
  8. /**
  9.  * 子类---抽象类
  10.  *
  11.  * 重要！！！
  12.  * 如果一个类在继承父类（抽象类）的时候，没有实现父类中的所有抽象方法，那么这个子类还是抽象类
  13.  */
  14. public abstract class Cook extends Employee{
  16. }
  1. package com.igeek_02;
  3. /**
  4.  * @author Lynn
  5.  * @create 2020-12-01-10:11
  6.  */
  8. /**
  9.  * 抽象类不能被实例化，但是构造函数是有的
  10.  *
  11.  * 抽象父类的方法，可以完成类似于成员变量初始化的功能，从而使这个成员变量可以被子对象使用
  12.  */
  13. public class AbstractDemo {
  14.     public static void main(String[] args) {
  15.         //实例化的是子类，但是子类中的成员属性还是从父类中继承过来的！
  16.         //父类（抽象类）中的构造函数是有意义的
  17.         Waiter w=new Waiter("Rose");
  18.         w.work();
  20.         //直接输出属性
  21.         System.out.println(w.getName());
  22.     }
  23. }

2.接口（interface）

2.1接口的分析

接口：是抽象类上一级的封装存在

  • 功能：具备开车考试的功能的接口
  • 具体的方法：理论，场地，路考

  • 接口可以理解为是一个思想，具体的实现不用管，由实现整个接口的类来实现

    2.2接口

  • 接口语法：

  • 使用interface替代原来的class，其他的步骤与类的定义相同
  • 1.接口中的方法均为公共访问的抽象方法—jdk7.0之前，之后有所改动（先知道）
  • 2.**接口无法定义普通的成员变量和成员方法**
  • 3.接口不可以创建对象（即不能被实例化）

  • 接口其实是一个特殊的类，在经过jvm编译后，还是会生成一个.class文件

  • 接口是一个只包含了功能声明的一个特殊类

  • 接口定义的是规则：

  • 使用接口：就是实现接口，实现接口的关键字implements，重写方法 ```java package com.igeek_01;

/**

  • @author Lynn
  • @create 2020-12-01-10:38 */

/**

  • 引入接口： *
  • 接口：是抽象类上一级的封装存在 *
  • 功能：具备开车考试的功能的接口
  • 具体的方法：理论，场地，路考 *
  • 接口可以理解为是一个思想，具体的实现不用管，由实现整个接口的类来实现 *
  • 接口语法：
  • 使用interface替代原来的class，其他的步骤与类的定义相同
  • 1.接口找那个的方法均为公共访问的抽象方法—jdk7.0之前，之后有所改动（先知道）
  • 2.接口无法定义普通的成员属性 *

  • 接口其实是一个特殊的类，在经过jvm编译后，还是会生成一个.class文件 */ public interface Driverable { //定义成员属性—在这里声明的是一个常量 //隐藏了public static关键字 String name=”王嘉尔”; // public static String name=”嘎嘎”;

    //定义成员（抽象）方法 public abstract void theoryTest();

    public abstract void filedDriver();

    public abstract void roadDriver();

    //不能写普通方法 /*public void test(){

    }*/ } ``` image.png

    2.3接口中的注意点：

    1.java中的类只支持单继承—一个类同时只能继承一个类
    2.java接口中支持多继承（单根性的拓展）—一个接口可以同时继承多个接口，之间用，隔开
    3.接口也支持多层继承
    4.java中一个普通类同时继承一个父类以及实现多个接口，多个接口之间用，隔开
    5.在一个java普通类同时继承父类和实现接口的时候，先继承父类再实现接口（接口可以多实现）
    6.一旦继承或是实现接口和父类，那么父类和接口中的方法都可以使用

    2.4接口中成员特点：

    A：接口中可以定义变量，但是变量必须有固定的修饰符修饰，public static final 所以接口中的变量也称之为静态常量，其值不能改变。
    后面我们会讲解static与final关键字
    B：接口中可以定义方法，方法也有固定的修饰符，public abstract
    C：接口不可以创建对象。
    D：子类必须覆盖掉接口中所有的抽象方法后，子类才可以实例化。否则子类是一个抽象类。

    3.抽象类和接口的异同点

    接口和抽象类的区别：
    （1）抽象类可以有构造方法，接口中不能有构造方法。
    （2）抽象类中可以有普通成员变量，接口中没有普通成员变量
    （3）抽象类中可以包含静态方法，接口中不能包含静态方法
    （4） 一个类可以实现多个接口，但只能继承一个抽象类。
    （5）接口可以被多重实现，抽象类只能被单一继承
    （6）如果抽象类实现接口，则可以把接口中方法映射到抽象类中作为抽象方法而不必实现，而在抽象类的子类中实现接口中方法

    接口和抽象类的相同点：
    (1) 都可以被继承
    (2) 都不能被实例化
    (3) 都可以包含方法声明
    (4) 派生类必须实现未实现的方法
    image.png

    4.形参和返回值

    4.1类名作为形参和返回值

    方法的形参是类名，其实需要的是该类的对象
    方法的返回值是类名，其实返回的是该类的对象

    4.2抽象类名作为形参和返回值

    方法的形参是抽象类名，其实需要的是该抽象类的子类对象
    方法的返回值是抽象类名，其实返回的是该抽象类的子类对象

    4.2接口名作为形参和返回值

    方法的形参是接口名，其实需要的是该接口的实现类对象
    方法的返回值是接口名，其实返回的是该接口的实现类对象