什么是多态?
程序运行过程中。对象角色的切换
程序运行过程中,对象行为的扩展
继承关键字extends
package com.damu;//包名 /** *父类 */ 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();//自有 } }
运行结果:
/** * 系统用户:父类 * @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修饰的类
继承:单继承,突破访问限制
/** * 基础类型 * @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 的数据类型
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);//输出信息 } }
上面代码的运行结果:
/** * Hosipital * @author 86157 *@Remark:医院的类型 */ public class Hospital {//类名 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();//骨科 op.name="骨科";//给变量赋值 Surgery sg=new Surgery();//外科 sg.name="外科";//给变量赋值 Patient patient=new 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+"接受病人,开始治疗");//输出信息 } } class Orthopaedics extends Department{//定义一个类并继承Department类 public void treatment(Patient patient){//定义一个方法并传入参数 System.out.println(this.name+"骨科接受到病人,开始给病人进行治疗....");//输出信息 } } class Surgery extends Department{//定义一个方法并继承Department类 public void treatment(Patient patient){//定义一个方法并传入参数 System.out.println(this.name+"外科接受到病人,准备给病人手术......");//输出信息 } }
运行结果:
抽象类:
* 抽象类定义的格式
【修饰符列表】 abstract class 类名{}
* 抽象类不能创建对象,不能实例化对象,所以它可以用来给子类继承
* final不能和abstract同时使用
* 抽象类的子类可以是抽象类
* 抽象类虽然不能实例化,但是可以有构造方法,这个构造方法是供子类使用的
* 抽象类中有抽象方法也可以有非抽象方法,抽象方法特点:
* 1.抽象方法,没有方法体,以分号结尾
* 2.前面修饰符列表中有abstract关键字
* 父类中有抽象方法,抽象方法只能在抽象类中,所以子类也必须定义为抽象的类
或者子类重写父类的方法,将其改为非抽象方法
public class InheritSytax {//类名 /** * 驱动器类型 * 类型使用abstract声明:抽象类 * 使用过程中不能被实例化 */ abstract static class Device{//方法使用abstract声明:抽象方法,子类继承父类时必须重写的方法 public abstract void working();//抽象方法 public void showInformation(){//方法名 System.out.println("这是一个机械硬盘...");/输出信息 } } static class DeviceSystem extends Device{//定义一个静态类并继承父类 public void working() {//重写方法 System.out.println("系统盘正在工作中...");//输出信息 } } static class DeviceBackup extends Device{//定义一个静态类并继承父类 public void working() {//重写方法 System.out.println("备份盘正在工作中...");//输出信息 } } public static void main(String[]args){//主方法 //父类实例化测试:抽象类型不能被实例化 //Device device=new Device(); //子类实例化 DeviceSystem ds=new DeviceSystem();//创建对象 ds.working();//直接调用重写的方法完成具体的业务处理 DeviceBackup db=new DeviceBackup();//创建对象 db.working();//直接调用重写的方法完成具体的业务处理 } }
运行结果:
public class Bank {//类名 static abstract class Service{//定义一个静态的抽象类 public abstract String deposit(double money);//定义一个公用的抽象类方法并传入参数 } static class CashDesk extends Service{//定义一个静态的类并继承抽象类 public String deposit(double money) {//重写抽象类方法 System.out.println("柜台存款流程");//输出信息 return "柜台存款收据";//返回一个字符串 } } static class ATM extends Service{//定义一个静态类并继承抽象类 public String deposit(double money) {//重写抽象类方法 System.out.println("ATM存款");//输出信息 return "ATM存款小票";//返回一个字符串 } } public static void main(String[] args) {//主方法 Service service=new Bank.CashDesk();//创建对象 Service service2=new Bank.ATM();//创建另一个对象 service.deposit(100);//调用方法 service2.deposit(200);//调用方法 } }
运行结果:
1. 接口的使用方式:一个接口一个继承另一个接口[单继承机制]
一个类型(可实例化)可以实现多个接口[多实现机制]
2. jdk8以后的版本:默认方法和静态方法
静态方法:提供给所有的实现类使用的一种公共方法,访问公共数据,接口中的静态方法主要被接口名称调用。不能被实现类继承、不能被子接口继承。
默认方法:提供给所有的实现类的一种特殊的方法,提供了一种默认的处理方法,用于独立的基础功能的实现。默认方法可以被子接口继承,也可以被实现类继承和重写。默认方法只能通过实例化对象进行调用执行。
//注意:如果一个类型实现了多个接口,多个接口中出现了同名的默认方法,此时就出现了接口冲突的问题。实现类中,必须重写这个和默认方法,解决冲突!!!
Interface
1.接口定义通常类名以I开头
2.接口属性默认以public static final 修饰
3,方法默认以public abstract 修饰
Jdk7及以前的接口只允许存在抽象方法
4.接口使用方法
一个接口可以实现另外一个接口-单继承机制
一个类型(可实例化)可以实现多个接口_多实现机制
public interface IDataType {//定义一个公共的接口 String TYPE="JSON";//定义一个字符串 public static final String TYPE2="JSON";//定义一个全局常量并赋初值 String format_msg(String msg);//定义一个抽象类方法 public abstract String format_msg2(String msg);//定义一个抽象方法 static String getTypes(){//定义一个静态方法 return IDataType.TYPE;//返回调用的字符串 } default String transfer_msg(String msg){//定义一个默认的方法 String res=this.format_msg(msg);//调用抽象方法并将值赋予定义的字符串 System.out.println("数据开始传输...");//输出信息 return "数据传输结果";//返回一个字符串 } public static void main(String[]args){//主方法 String res=IDataType.getTypes();//静态方法 System.out.println(res);//输出信息 JsonData jd=new JsonData();//创建对象 jd.transfer_msg("hello tom!");//调用默认方法 String res2=jd.format_msg("hello jerry!");//调用普通方法 System.out.println(res2);//输出信息 } } class JsonData implements IDataType{//定义一个类并继承接口 public String format_msg(String msg) {重写方法 return "json 类型的数据 序列化操作";//返回一个字符串 } public String format_msg2(String msg) {//重写方法 // TODO Auto-generated method stub return null;//返回null值 } }
运行结果:
public class Produce {//类名 static interface IDataType{//定义一个静态接口 String transfer();//定义一个抽象的方法 } static class JsonData implements IDataType{//定义一个静态的类并继承接口 public String transfer() {//重写方法 System.out.println("传输JSON格式的数据");//输出信息 return this.prepareDate();//方法调用的字符串 } public String prepareDate(){//自己的方法 return "JSON格式的数据";//返回一个字符串 } } static class XmlData implements IDataType{//定义一个静态的类并继承接口 public String transfer() {//重写方法 System.out.println("准备传输XML格式的数据");//输出信息 return this.prepareData();//返回调用的字符串 } public String prepareData(){//定义一个方法 return "XML格式的数据";//返回一个字符串 } } static class Consumer{//定义一个静态的类 public String getData(IDataType dt){//定义一个方法并传入一个参数 System.out.println("客户端调用接口,获取数据");//输出信息 return dt.transfer();//返回调用的字符串 } } public static void main(String[]args){//主方法 IDataType dt=new JsonData();//创建对象 IDataType dt2=new XmlData();//创建对象 Consumer consumer=new Consumer();//创建对象 String res=consumer.getData(dt2);//将调用的值赋予给定义的字符串 System.out.println(res);//输出信息 } }
运行结果:
/** * 标记接口 * @author 86157 * */ public class DataApp {//定义一个类 static interface IDataFormat{}//定义一个静态的接口 public String transfer(Object obj){//定义一个方法并传入一个参数 if(obj instanceof IDataFormat){//判断该参数是否属于这个类 System.out.println("复杂数据。需要进行序列化处理和类型转换");//输出信息 } System.out.println("数据监测完成,数据开始传输...");//输出信息 System.out.println("数据传输完成");//输出信息 return"ok";//返回一个字符串 } static class Address{//定义一个静态的类 public int id;//编号 public String nation;//国家 public String province;//省份 public String city;//市区 } static class Person implements IDataFormat{//定义一个静态的类并继承父类 public int id;//编号 public String name;//姓名 public String gender;//性别 public int age;//年龄 public Address address;//地址 } public static void main(String[]args){//主方法 DataApp da=new DataApp();//创建对象 Address addr=new Address();//创建对象 Person person=new Person();//创建对象 da.transfer("hello");//调用方法并传入参数 da.transfer(12);//调用方法并传入参数 da.transfer(addr);//调用方法并传入参数 da.transfer(person);//调用方法并传入参数 } }
运行结果:
多态分为设计时多态和运行时多态 1.设计时多态主要是通过方法重载, 2.运行时多态主要通过父类引用指向子类对象public class Shopping {//定义一个类 public void seckill(String name,int deviceType,String deviceInfo){//定义一个方法并传入三个参数 System.out.println("正在秒杀商品:"+name);//输出信息 if(deviceType==1){//判断是否等于1 this.record(name, Long.parseLong(deviceInfo)); //调用方法并传入参数 }else if(deviceType==2){//判断是否等于2 this.record(name, deviceInfo);//调用方法并传入参数 } } private void record(String name,Long i){//定义一个私人的方法并传入两个参数 System.out.println("记录--秒杀商品:"+name+";移动终端信息:"+i);//输出信息 } private void record(String name,String url){//定义一个私人的方法并传入两个参数 System.out.println("记录--秒杀商品:"+name+";PC终端的信息:"+url);//输出信息 } public static void main(String[]args){//主方法 Shopping shopping=new Shopping();//创建对象 shopping.seckill("alienware",1, "15688889999");//调用方法并传入值 shopping.seckill("asua",2,"10.10.68.92");//调用方法并传入值 } }
运行结果:
public class Shopping2 {//定义一个方法 public void seckill(String name,Device device){//定义一个方法并传入两个参数 System.out.println("正在秒杀商品:"+name);//输出信息 System.out.println("记录秒杀信息");//输出信息 device.record(name);//调用方法 } public static void main(String[]args){//主方法 Shopping2 shopping=new Shopping2();//创建对象 Device dc=new PC();//创建对象 shopping.seckill("玩家国度", dc);//调用方法并传入值 Device dc2=new Phone();//创建对象 shopping.seckill("飞行堡垒", dc2);//调用方法并传入值 } } abstract class Device{//定义一个抽象类 public abstract void record(String name);//定义一个抽象方法 } class Phone extends Device{//定义一个类并继承父类 public void record(String name) {//重写方法 System.out.println("移动端发起的秒杀:商品名称:"+name);//输出信息 } } class PC extends Device{//定义一个类并继承父类 public void record(String name) {//重写方法 System.out.println("PC端发起的秒杀:商品名称:"+name);//输出信息 } }
运行结果: