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

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

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

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

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

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

接口：

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

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

* 接口定义：

* 【修饰符列表】 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修饰的类型就是最终的类型.表示该类型不可以被继承.

子类继承父类，方法名称相同，参数名称个数和类型相同，执行的结果不同，方法的重写。

根据传递数据的不同，执行不同的行为~

public String getDevice(){}  //名称相同，空参数方法

public String getDevice(String notes){}  //名称相同，有参数

public String getDevice(String offices,String notes){} //名称相同,参数个数不同

方法名称返回类型相同，但参数个数不同，参数类型不一致，是方法的重载

final关键字：不允许进行扩展，不允许被继承

super

1231321

1233333333333333333333123333333333333333333312333333333333333333331233333333333333333333123333333333333333333312333333333333333333331233333333333333333333123333333333333333333312333333333333333333331233333333333333333333123333333333333333333312333333333333333333331233333333333333333333123333333333333333333312333333333333333333331233333333333333333333123333333333333333333312333333333333333333331233333333333333333333123333333333333333333312333333333333333333331233333333333333333333123333333333333333333312333333333333333333331233333333333333333333123333333333333333333312333333333333333333331233333333333333333333123333333333333333333312333333333333333333331233333333333333333333

aaaaa