java第十次作业

多态的三要素：

1、继承

2、重写

3、父类引用指向子类对象。

继承关键字extends

package java第十次作业;
/**
*父类
*/
public class Father{//父类
public Integer regNo;//定义一个Integer类型的变量
public String name;//定义一个字符串
public String gender;//定义一个字符串
public Integer age;//定义一个Integer类型的变量
public String job;//定义一个字符串
public void working(){//定义一个方法
System.out.println(this.name+"在工作中....");//输出信息
}
}

运行结果：

public class Son extends Father {//定义一个子类并继承父类
public void playGame(){//定义一个方法
    System.out.println(this.name+"在游戏中....");//输出信息
}
    public static void main(String[] args) {//主方法
        Son son=new Son();//创建一个对象
        //操作属性
        son.name="李白";//继承
        //操作方法
        son.working();//继承
        son.playGame();//自有
    }
    
 
}

.静态内部类
1、一个静态内部类中可以声明 static成员，但是在非静态内部类中不可以声明静态成员
2、静态内部类有一个最大的特点，就是不可以使用外部类的非静态成员，所以静态内部类在程序开发中比较少见
3、静态内部类不可以直接调用外部类的非静态成员变量
4、进行程序调试时，如果在每一个 Java 文件中都设置一个主方法，将出现很多额外代码，而程序本身并不需要这些主方法，为了解决这个问题，可以将主方法写入静态内部类中
 

/**
 * 系统用户：父类
 * @author 86157
 *
 */
public class SystemUser {//类名
public String username;//账号
public String password;//密码
public String name;//姓名
public String gender;//性别
public Integer age;//年龄
public String regNo;//身份证号码
public String phone;//手机
public String email;//邮箱
public String address;//地址
public SystemUser(){}//一个方法
    public SystemUser(String username,String password,String name){//定义一个方法并传入三个字符串类型的参数
        this.username=username;//调用成员变量并赋值
        this.password=password;//调用成员变量并赋值
        this.name=name;//调用成员变量并赋值
    }
}
/**
 * 系统管理员
 * @author 86157
 *
 */
public class Manager extends SystemUser {//类名
 
 
}
/**
 * 医师
 * @author 86157
 *
 */
public class Doctor extends SystemUser {//类名
public String department;//部门
public String offices;//科室
}
/**
 * 医护
 * @author 86157
 *
 */
public class Nurse extends SystemUser{//定义一个类并继承父类
//部门
    public String department;//定义自己的属性
}

 继承：基于类型的控制

final关键字：最终的类型，不可以继承和重写 但可以重载

import java.util.Date;//导入Data方法
 

/**
 * 医疗项目中的采购清单
 * 采购方/联系方式/邮箱/传真/地址
 *提供方/联系方式/邮箱/传真/地址
 *采购单编号/采购类型/采购单位/采购数量/采购单价/交易时间/总计金额/备注/注意事项1~n
 *
 */
 
 
public final class Purchase{//购买类
 
    public String demanName;//采购方
 
    public String demanPhone;//联系方式
 
    public String demandEmail;//邮箱
 
 
    public String demandFax;//传真
 
    public String demandAddress;//地址
 
 
public String supplyName;//提供方
public String supplyPhone;//联系方式
public String supplyEmail;//邮箱
public String supplyFax;//传真
public String supplyAddress;//地址
 
 
public Integer purchaseId;//采购单编号
public String purchaseType;//采购类型[枚举]
public String purchaseBrand;//采购规格
public String purchaseUnits;//采购单位
public String purchasePrice;//采购单价
public Date  purchaseDeal;//交易时间
public Double purchaseTotal;//总结金额
public String purchaseRemark;//注意事项
public String purchaseRemark1;//注意事项
public String purchaseRemark2;//注意事项
public String purchaseRemark3;//注意事项
public String purchaseRemark4;//注意事项
public String purchaseRemark5;//注意事项

final不能被继承

final关键字的功能概述

final关键字可以用来修饰引用、方法和类。

给final关键字修饰的成员变量赋值有两种方式：

1.直接赋值。

2.在构造方法中赋初值

1、final用来修饰一个引用

        如果引用为基本数据类型，则该引用为常量，该值无法修改；
        如果引用为引用数据类型，比如对象、数组，则该对象、数组本身可以修改，但指向该对象或数组的地址的引用不能修改。

        如果引用时类的成员变量，则必须当场赋值，否则编译会报错。

2、用来修饰一个方法
        当使用final修饰方法时，这个方法将成为最终方法，无法被子类重写。但是，该方法仍然可以被继承。

        当类被final关键字修饰，表示这个类是不能被继承的。final关键字修饰类例子

3、用来修饰类
        当用final修饰类时，该类成为最终类，无法被继承，该类就不能被其他类所继承

        1、super表示超（父）类的意思，this表示对象本身

        2、super可用于访问父类被子类隐藏或着覆盖的方法和属性，使用形式为super.方法（属性）

        3、在类的继承中，子类的构造方法中默认会有super()语句存在(默认隐藏)，相当于执行父类的相应构造方法中的语句
 

内部类的继承
 必须要满足四个条件：
1、继承内部类的前面要跟随外部类名+"."
2、在某个类继承内部类时，必须硬性给予这个类一个带参数的构造方法
3、并且该构造方法的参数为需要继承内部类的外部类的引用4、在构造方法体中使用a.super()语句，这样才为继承提供了必要的对象引用
、

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

1、 final不能和abstract同时使用
 2、抽象类的子类可以是抽象类  
 3、抽象类虽然不能实例化，但是可以有构造方法，这个构造方法是供子类使用的
 4、抽象类中有抽象方法也可以有非抽象方法，抽象方法特点：
5、抽象方法，没有方法体，以分号结尾
6、面修饰符列表中有abstract关键字
 7、父类中有抽象方法，抽象方法只能在抽象类中，所以子类也必须定义为抽象的类
8、或者子类重写父类的方法，将其改为非抽象方法
 

 继承：单继承，突破访问限制

/**
 * 基础类型
 * @author 86157
 *
 */
public class Users {//类名
public int id;//定义一个公用的整型变量id
public String name;//定义一个字符串类型变量name 
public int age;//定义一个公用的整型变量age
public String gender;//定义一个字符串变量gender
 
public boolean equals(Object obj){//定义一个方法传入一个参数
	if(!(obj instanceof Users)){//判断obj是否属于User
		return false;//返回布尔类型
	}
	Users user=(Users)obj;//进行类型转换
	//if(this.age>=user.age){
		//return true;
	//}else if(this.age<user.age){
		//return false;
	//}
	//return this.age>=user.age?true:false;
	return this.age>=user.age;//返回布尔类型
}

}

改代码无运行结果

/**
 * 医师类型
 * @author 86157
 *
 */
public class Doc extends Users{//定义一个类并继承Users类
public String job;//定义一个字符串job
public int level;//定义一个整型变量level
public boolean equals(Object obj){//定义一个方法并传入一个参数
	if(!(obj instanceof Doc)){//判断obj是否属于Doc
		return false;//返回false
	}
	Doc dt=(Doc)obj;//进行强制转换
	if(this.level>dt.level){//判断成员变量level与dt引用里的level是否相等
		return false;//返回布尔类型
	}else if(this.level<dt.level){//判断成员变量level是否小于dt引用的level的值
		return false;//返回布尔类型
	}else{//扩展了父类中的对象比较的方法
		return super.equals(obj);//调用父类的方法并返回
	}
}

由于多继承中，多个父类的属性名和方法名重复，会导致无法正确渠道想要的值，所以Java不支持多继承，而采用接口的形式。
instanceof 是 Java 的保留关键字。它的作用是测试它左边的对象是否是它右边的类的实例，返回 boolean 的数据类型

接口的特点:
1.接口是一种特殊的抽象类，只包含常量和方法的定义，而没有方法的实现。

2.通过接口可以指明多个需要实现的方法，而不需考虑这些类之间的层次关系。

3.在类体中可以使用接口中定义的常量，必须实现接口中定义的所有方法。

4.一个类可以实现多个接口，在implements字句中用逗号隔开。
 

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

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

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

注意：如果一个类型实现了多个接口，多个接口中出现了同名的默认方法，此时就出现了接口冲突的问题。实现类中，必须重写这个和默认方法，解决冲突！！! 

/**
 * DeviceService
 * @author 86157
 *@Reamrk:设备服务类型
 */
public class DeviceService {//定义一个类
	/**
	 * 医师领取的设备
	 * @return返回领取到的设备
	 */
public String getDevice(){//定义一个方法
	return "医师领取的设备";//返回一个字符串
}
/**
 * 医护领取设备
 * @param notes 领取记录
 * @return返回领取到的设备
 */
public String getDevice(String notes){//定义一个方法并传入一个参数
	return"医护领取的设备";//返回一个字符串
}
/**
 * 病人领取的设备
 * @param offices治疗科室
 * @param notes领取记录
 * @return返回领取到的设备
 */
public String getDevice(String offices,String notes){//定义一个方法并传入两个参数
	return "病人领取到的设备";//返回一个字符串
}
public static void main(String[]args){//主方法
	DeviceService ds=new DeviceService();//创建设备服务对象
	String res=ds.getDevice();//调用方法并将该值赋予定义好的字符串
	System.out.println(res);//输出信息
    String res2=ds.getDevice("手术用品");//调用方法并传入参数的值并赋予给定义好的参数
    System.out.println(res2);//输出信息
    String res3=ds.getDevice("骨科", "固定带");//调用方法并给参数赋值，之后赋予给定义的字符串变量
    System.out.println(res3);//输出信息
    
}
}