投稿
  1. 首页
  2. python

Java的第十次作业

code • 2022-5-5 • python • 阅读 44

Java的第十次作业,第1张

目录

什么是多态？

继承的应用（基本语法和使用场景）

 医疗项目——实体类的父类

方法的重载和方法的重写

方法的重写：运行多时态 

抽象类的基本概念  

1、抽象类定义的格式

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

抽象类应用 *** 作

接口基本语法 *** 作

接口的应用（ 接口即规范）

 多态的概述

运行时多态的实现

多态分为设计时多态和运行时多态 

总结

什么是多态？

1、程序运行过程中，对象角色的切换

2、程序运行过程中，对象行为的扩展

继承的应用（基本语法和使用场景）

 

package 作业10;

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+"在工作中....");//输出信息
	}
}

	
package 作业10;

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

}

运行结果：

 医疗项目——实体类的父类

图解如下：

 代码如下：

package 作业10;
/**
 * 系统用户：父类
 * @author Dejon_D
 *
 */
public class SystemUser {
	public String username;//账号
	public String password;//密码
	public String name;//姓名
	public String gender;//性别
	public Integer age;//年龄
	public String regNo;//身份z号码
	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 Dejon_D
	 *
	 */
	public class Manager extends SystemUser {//类名
	 
	 
	}
	/**
	 * 医师
	 *@author Dejon_D
	 *
	 */
	public class Doctor extends SystemUser {//类名
	public String department;//部门
	public String offices;//科室
	}
	/**
	 * 医护
	 *@author Dejon_D
	 *
	 */
	public class Nurse extends SystemUser{//定义一个类并继承父类
	//部门
		public String department;//定义自己的属性

 另外的类无法继承用final修饰的类。

package 作业10;

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?true:false;
		return this.age>=user.age;//返回布尔类型

	}
}

 

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

 由于多继承中，多个父类的属性名和方法名重复，会导致无法正确渠道想要的值，所以Java不支持多继承，而采用接口的形式。

方法的重载和方法的重写

方法的重载：设计多时态

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

package 作业10;
/**
 * DeviceService
 * @author Dejon_D
 *@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) {//主方法
		// TODO Auto-generated method stub
		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);//输出信息
	}

}

运行结果：

方法的重写：运行多时态  
package 作业10;
/**
 * Hosipital
 * @author Dejon_D
 *@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) {//主方法
		// TODO Auto-generated method stub
		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+"外科接受到病人，准备给病人手术......");//输出信息
	}
	

}

运行结果：

抽象类的基本概念   1、抽象类定义的格式

注意：定义到类中的类叫做内部类，这些类也可以不定义在类中，写成单独的类也是可以的。

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

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

（2）final不能和abstract同时使用

（3）抽象类的子类可以是抽象类  

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

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

（1）抽象方法，没有方法体，以分号结尾

（2）前面修饰符列表中有abstract关键字

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

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

package 作业10;

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) {//主方法
		// TODO Auto-generated method stub
		//父类实例化测试:抽象类型不能被实例化
				//Device device=new Device();
				//子类实例化
				DeviceSystem ds=new DeviceSystem();//创建对象
				ds.working();//直接调用重写的方法完成具体的业务处理
				DeviceBackup db=new DeviceBackup();//创建对象
				db.working();//直接调用重写的方法完成具体的业务处理
	}

}

运行结果：

抽象类应用 *** 作

 银行项目：存款流程

package 作业10;

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) {//主方法
		// TODO Auto-generated method stub
		Service service=new Bank.CashDesk();//创建对象
		Service service2=new Bank.ATM();//创建另一个对象
		service.deposit(100);//调用方法
		service2.deposit(200);//调用方法
 
	}

}

运行结果：

接口基本语法 *** 作

接口的意义和基本语法

接口中的属性和方法

 

接口的属性，默认修饰：public static final

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

jbk7- 版本，接口只允许存在抽象方法

接口的使用方法：

一个接口一个继承另一个接口[单继承机制]

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

（1）静态方法：提供给所有的实现类使用的一种公共方法，访问公共数据，接口中的静态方法主要被接口名称调用。不能被实现类继承、不能被子接口继承。

（2）默认方法：提供给所有的实现类的一种特殊的方法，提供了一种默认的处理方法，用于独立的基础功能的实现。默认方法可以被子接口继承，也可以被实现类继承和重写。默认方法只能通过实例化对象进行调用执行。

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

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值
	}
	}
接口的应用（ 接口即规范） 
package 作业10;

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) {//主方法
		// TODO Auto-generated method stub
		IDataType dt=new JsonData();//创建对象
		IDataType dt2=new XmlData();//创建对象
		Consumer consumer=new Consumer();//创建对象
		String res=consumer.getData(dt2);//将调用的值赋予给定义的字符串
		System.out.println(res);//输出信息
	}

}

运行结果：

package 作业10;
/**
 * 标记接口
 * 一旦一个类型被当前接口标记，这个
 *类型在进行数据传输时，就需要进行特殊处理
 */

public class DataApp {//创建类
	static interface IDataFormat{}//定义一个静态的接口
	public String transfer(Object obj){//ojb定义一个方法并传入一个参数
		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) {//主方法
		// TODO Auto-generated method stub
		 //数据传输对象
		DataApp da=new DataApp();
	        // 准备数据
		Address addr=new Address();//创建对象
		Person person=new Person();//创建对象
	        //数据输出
		da.transfer("hello");//调用方法并传入参数
		da.transfer(12);//调用方法并传入参数
		da.transfer(addr);//调用方法并传入参数
		da.transfer(person);//调用方法并传入参数
	}

}

 运行结果：

 多态的概述

对象行为的转换，方法重写实现的 *** 作

对象角色的转换，接口多实现的 *** 作

设计时多态的实现

package 作业10;
/**
*记录移动端秒杀信息的方法
*name 秒杀的商品
*phone 手机号码
*/
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);//调用方法并传入参数
		}
	}
	/**
	*记录PC端买啥信息方法
	*name 秒杀的商品
	*ur1 pc端地址[IP]
	*/
	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) {//主方法
		// TODO Auto-generated method stub
		Shopping shopping=new Shopping();//创建对象
	    //移动秒杀端
		shopping.seckill("alienware",1, "15688889999");//调用方法并传入值
	    //pc端秒杀
		shopping.seckill("asua",2,"10.10.68.92");//调用方法并传入值
	}

}

运行结果：

运行时多态的实现

 

package 作业10;
/**
*秒杀的方法
*name 秒杀的商品名称
*device 终端设备信息
*/
public class Shopping {//定义一个方法
public void seckill(String name,Device device){//定义一个方法并传入两个参数
	System.out.println("正在秒杀商品："+name);//输出信息
	System.out.println("记录秒杀信息");//输出信息
	device.record(name);//调用方法
}
public static void main(String[]args){//主方法
	Shopping shopping=new Shopping();//商城
    //pc端
	Device dc=new PC();//创建对象
    //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);//输出信息
		
	}
	
}

运行结果：

多态分为设计时多态和运行时多态 

1、设计时多态主要是通过方法重载。

2、运行时多态主要通过父类引用指向子类对象。

总结

Java面向对象三大特征：封装、继承、多态。

THE END !

💖💖💖

欢迎分享，转载请注明来源：内存溢出

原文地址: http://outofmemory.cn/langs/792521.html

赞 (0)
打赏 微信扫一扫 微信扫一扫 支付宝扫一扫 支付宝扫一扫
code code 管理员组
0 0
上一篇 2022-05-05
下一篇 2022-05-05

发表评论

登录后才能评论

评论列表（0条）

保存