多态的三要素:
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);//输出信息
}
}