1. 设计时多态 重载

2. 运行时多态 重写

标记接口：实际应用案例序列化标记

sxsax

 我

而非的

instanceof 是 Java 的保留关键字。它的作用是测试它左边的对象是否是它右边的类的实例，返回 boolean 的数据类型。

接口声明用 interface

接口的名称通常以大写字母I开头

接口的默认修饰：public static final string 

接口的方法默认修饰为：public abstract

JDK7之前的版本 接口中只允许抽象的方法

一个接口可以继承另一个接口{单继承机制}

一个类型（可实例化）可以实现多个接口【多实现机制】

jdk8以后版本：静态方法

接口中的静态方法主要被接口名称调用

静态方法：不能被实现类继承 不能被子接口继承

1. 设计时多态【编译时多态】：即在编译时就能够确定调用哪个方法。

2. 运行时多态：只有在运行时才能确定调用哪个方法。
   

合法的大概多少

接口类和抽象类的语法区别：

* 接口类是完全抽象，抽象类是半抽象，

* 抽象类中有构造方法，接口类中没有

* 接口和接口之间支持多继承，类和类之间只能单继承

* 一个类可以同时实现多个接口，一个抽象类只能继承一个类

* 接口中只能有抽象方法，而抽象类里可以有方法体方法

接口：

* 接口是一个数据引用类型

* 接口是完全抽象的，（抽象类是半抽象的）也可以说接口是特殊的抽象类

* 接口定义：

* 【修饰符列表】 interface 接口名{}

* 接口可以多继承

* 接口中只包含两部分内容：常量和抽象方法

* 因为接口里面都是抽象方法，所以可以省略public abstract

* 因为接口里面都是常量，所以可以省略public static final

** is a和like a以及has a的说明：

   * is a：

cat is a Animal(猫是一个动物)

  凡是能满足is a 的表示“继承关系”

  例子：A 继承 B

   * like a：

cooker like a FoodMenu(厨师 像一个菜单一样)

  凡是能满足like a的关系的表示“实现关系”

  实现关系通常是类实现接口

  列子：A 实现 B

   * has a：

I has a pen(我有一支笔)

    凡是能满足 has a关系的表示“关联关系”

    关联关系通常以“属性”的形式存在

    列子：A 里面有 B

抽象类：

* 抽象类定义的格式

【修饰符列表】 abstract class 类名{}

* 抽象类不能创建对象，不能实例化对象，所以它可以用来给子类继承

* final不能和abstract同时使用

* 抽象类的子类可以是抽象类  

* 抽象类虽然不能实例化，但是可以有构造方法，这个构造方法是供子类使用的

* 抽象类中有抽象方法也可以有非抽象方法，抽象方法特点：

* 1.抽象方法，没有方法体，以分号结尾

* 2.前面修饰符列表中有abstract关键字

* 父类中有抽象方法，抽象方法只能在抽象类中，所以子类也必须定义为抽象的类

  或者子类重写父类的方法，将其改为非抽象方法

封装的步骤：

  1.使用关键字private进行修饰

2.对外提供简单的入口，也就是说以后外部想要访问age属性，

  必须通过简单的入口进行访问：

-对外提供两种方法 get和set方法

-set方法的命名规范：

public void setAge（int a）{

this.age = a;

}

-get方法命名规范：

public int getAge（）{

return age;

}

-set用于修改 get用于读取

package com.example.hibernate.pro4;

import com.example.hibernate.pro3.DeviceService;

/**
 * Hospital
 * @Remark:医院的类型
 */
public class Hospital {
    /**
     * @param patient  病人
     * @param dept  科室
     */
    public void register(Patient patient, Department dept){
        System.out.println("开始挂号到对应的科室：" + dept.name);
        dept.treatment(patient);
    }

    public static void main(String[] args) {
        //创建医院对象
        Hospital hs = new Hospital();
        //骨科
        Orthopaedics op = new Orthopaedics();
        //Orthopaedics op;
        //外科
        //Surgery sg = new Surgery();
        Surgery sg;
        //病人
        //Patient patient = new Patient();
        Patient patient;
        //挂号
        hs.register(patient, sg);
    }


    /**
     * 病人
     */
    class Patient{
        public int id;
        public String name;
        public String gender;
        public int age;
        public float health;
    }
    /**
     * 科室
     */
    class Department{
        public int id;
        public String name;
        public String intro;

        //接收病人的方法
        public void treatment(Patient patient){
            System.out.println(this.name + "接收病人，开始治疗");
        }


    }
    public class Orthopaedics extends Department{
        public void treatment(Patient patient){
            System.out.println(this.name + "骨科接收到病人，开始治疗");
        }
    }
    class Surgery extends Department{
        public void treatment(Patient patient){
            System.out.println(this.name + "外科接收到病人，开始治疗");
        }
    }
}

 Orthopaedics op = new Orthopaedics();

报错了

String类型的定义就加上了"final"关键字.

如果在..., 被final修饰的类型就是最终的类型.表示该类型不可以被继承.