第十次java作业

已于 2022-05-02 17:52:48 修改
阅读量166 收藏 1
点赞数
文章标签： java
于 2022-04-23 00:27:36 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Hmaxbetter/article/details/124239717
版权
本文详细介绍了Java编程中的多态性，包括其三要素：继承、重写和父类引用指向子类对象。讨论了静态和非静态内部类的区别，并展示了如何使用接口实现多态。此外，还探讨了final关键字的作用，以及抽象类和接口的使用场景。通过实例代码，阐述了方法重载、重写以及重构的概念，强调了在实际编程中的应用。
摘要由CSDN通过智能技术生成

目录

1.什么是多态?

2.多态的三要素：

3.静态内部类

4.内部类的继承

5.接口的特点：

6.final关键字的功能概述

抽象类：

1.什么是多态?


程序运行过程中 , 对象角色的切换 , 对象行为的扩展

2.多态的三要素：

  1. 继承

  2. 重写

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

  • 多态性：多态性是指允许不同子类型的对象对同一消息作出不同的响应。简单的说就是用同样的对象引用调用同样的方法但是做了不同的事情。
  • 多态：程序运行过程中，对象角色的切换：如老师，在家是丈夫或妻子，在校是老师
  • 程序运行过程中，对象行为的扩展：如孵蛋器：把鸡蛋/鸽子蛋->孵出小鸡和鸽子

 

继承关键字extends 

代码

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();//自有
		}
		

}

 结果

3.静态内部类


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;//定义自己的属性


}

4.内部类的继承


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

代码： 

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

/**
 * 医疗项目中的采购清单
 * 采购方/联系方式/邮箱/传真/地址
 *提供方/联系方式/邮箱/传真/地址
 *采购单编号/采购类型/采购单位/采购数量/采购单价/交易时间/总计金额/备注/注意事项1~n
 *
 */
public 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修饰的类 

5.接口的特点：

  1. 接口是一种特殊的抽象类，只包含常量和方法的定义，而没有方法的实现。
  2. 通过接口可以指明多个需要实现的方法，而不需考虑这些类之间的层次关系。
  3. 在类体中可以使用接口中定义的常量，必须实现接口中定义的所有方法。
  4. 一个类可以实现多个接口，在implements字句中用逗号隔开。

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

单继承 

/**
	 * 基础类型
	 * @author 86157
	 *
	 */
	
public class SystemUser {//类名
	
	public int id;//定义一个公用的整型变量id
	public String name;//定义一个字符串类型变量name 
	public int age;//定义一个公用的整型变量age
	public String gender;//定义一个字符串变量gender
	 
	public boolean equals(Object obj){//定义一个方法传入一个参数
		if(!(obj instanceof SystemUser )){//判断obj是否属于User
			return false;//返回布尔类型
		}
		SystemUser  user=(SystemUser )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);//调用父类的方法并返回
	}
}
}

 经过修改无运行结果

6.final关键字的功能概述


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

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

1.直接赋值。

2.在构造方法中赋初值。

1、用来修饰一个引用

  1. 如果引用为基本数据类型，则该引用为常量，该值无法修改；

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

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

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

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

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

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

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

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

/**
 * 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+"外科接受到病人，准备给病人手术......");//输出信息
	}
}

结果

抽象类：

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

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

 代码

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);//调用方法
 
	}
 
}

结果

 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);//调用方法并传入参数
}

}

结果

代码

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);//输出信息
		
	}
	
}

结果 

安于时光荏苒
关注
JAVA 第十次作业
wsq15270489862的博客
04-28 270
一、 课程概述 课程大纲介绍 二、 继承的应用 什么是多态 继承基本语法和使用场景 三、final和super关键字 final关键字 super关键字 四、 方法重载与重写 方法重载和方法重写 五、 接口和抽象类 抽象类和抽象方法 抽象类银行存款 接口基本语法操作 接口的应用 六、 多态 多态概述 多态操作案例 ...
第十次 Java作业
weixin_65574414的博客
04-25 474
Java是一门面向对象编程语言，不仅吸收了C++语言的各种优点，还摒弃了C++里难以理解的多继承、指针等概念，因此Java语言具有功能强大和简单易用两个特征。Java语言作为静态面向对象编程语言的代表，极好地实现了面向对象理论，允许程序员以优雅的思维方式进行复杂的编程. ...
Java继承作业
lqqcnsd的博客
08-11 252
父类对象： package com.dodoke.homework; public class Parent { private String color; private String brand; private String type; private int wheel; private int seat; //无参构造方法： public Parent(){ } //创建setter/getter方法： public String getColor() {
java多态作业
06-16
java多态import java.awt.*; import java.awt.event.*; import javax.swing.*; public class ComplexListener implements MouseMotionListener,MouseListener,ActionListener{ JFrame f; JTextArea tf; JButton bt; int number = 1; public ComplexListener(){ JLabel label =new JLabel("click and Drag the mouse"); f=new JFrame ("Complex Listener"); tf=new JTestArea(); bt= new JButton("退出"); tf.addMouseMotionListener(this); tf.addMouseListener(this); bt.addActionListener(this); f.add(label,BorderLayout.NORTH); f.add(tf,BorderLayout.CENTER); f.add(bt,BorderLayout.SOUTH); f.setSize(300,200); f.setVisible(true); //MouseMotionListener的方法 public void mouseDragged(MouseEvent e){ String s=number+++""+"The mouse Dragged:x="+ e.getX()+"y="+e.getY()+"\n"; tf.append(s); } //MouseMotionListener的方法 public void mouseEntered(MouseEvent e){ String s=number+++""+"The mouse entered"+"\n"; tf.append(s); } public void mouseClicked(MouseEvent e){ String s=number+++""+"The mouse clicked."+"\n"; tf.append(s); } public void mouseExited(MouseEvent e){ String s=number+++""+"The mouse exit."+"\n"; tf.append(s); } //未使用的MouseMotionListener的方法 public void mouseMoved(MouseEvent e){ } //未使用的MouseListener的方法 public void mouseReleased(MouseEvent e){ } public void mousePressed(MouseEvent e){ } //ActionListener的方法 public void actionPerformed(ActionEvent e){ System.exit(0); public static void main(String args[]){ ComplexListener two = new ComplexListener(); } }
Java作业-多态
chengshan6596的博客
06-01 284
package org.jsoft.polymorphism; public abstract class Shape { //图形类 public abstract double area();//面积 public abstract double perimeter();//边...
java第二次作业.zip
12-09
这个“java第二次作业”很可能是一个学习者或学生在学习Java编程过程中完成的项目，旨在深化对Java语言的理解和应用。 在Java编程中，基础知识包括变量、数据类型、运算符、控制结构（如if语句、switch语句、for...
Java第三次作业 Java第三次作业
03-17
从描述中的“Java作业”可以推测，这次作业可能涉及到以下几个关键知识点： 1. **基础语法**：Java的基础语法是编程的基石，包括变量声明、数据类型、运算符、流程控制（如if语句、switch语句、for循环、while循环...
learn-java:这是我第一次尝试 Java，它主要包括我的 Java 作业
07-13
在这个项目中，我们可以期待看到一系列的Java作业，这些作业通常会涵盖Java语言的基础到进阶概念。 1. **基础概念**：初学者在学习Java时，首先要掌握的是基本语法，包括变量声明、数据类型（如整型、浮点型、字符...
基于Java语言的第十二天学习作业设计源码
最新发布
09-30
本项目为基于Java语言的第十二天学习作业设计，包含20个文件，其中包括16个Java源代码文件、2个Markdown文档、1个Xmind思维导图文件以及1个IntelliJ IDEA项目配置文件（.iml）。这些文件共同构成了一个用于巩固和...
java继承作业.pdf
10-07
java继承作业.pdf
Java课程作业-多态
balalinhq的博客
12-01 348
一、什么是多态 所谓多态就是指程序中定义的引用变量所指向的具体类型和通过该引用变量发出的方法调用在编程时并不确定，而是在程序运行期间才确定，即一个引用变量倒底会指向哪个类的实例对象，该引用变量发出的方法调用到底是哪个类中实现的方法，必须在由程序运行期间才能决定。因为在程序运行时才确定具体的类，这样，不用修改源程序代码，就可以让引用变量绑定到各种不同的类实现上，从而导致该引用调用的具体方法随之改变，即不修改程序代码就可以改变程序运行时所绑定的具体代码，让程序可以选择多个运行状态，即统一性和高效性。这就是多态
继承与多态 - 课后作业
weixin_30843605的博客
11-10 207
1 .继承条件下的构造方法调用 class Grandparent { public Grandparent() { System.out.println("GrandParent Created."); } public Grandparent(String string) { System.out.p...
第七周Java作业--继承
zb_tjw的博客
10-12 498
OC：Bus总定义capacity的时候会提示重复定义，改为了_capacity,文件中的capacity来着父类。 Vehicle.h文件// // Vehicle.h // // Created by Zb_tjw on 2017/10/11. // Copyright © 2017年 Zb_tjw. All rights reserved. //#import <Foundation/
java继承作业
llqq314的博客
04-20 817
一、选择 1.A 2.D 3.C 4.B 5.B 6.C 7.C 8.B 9.ABD 10.D 11.D 12.C 二、编程 1. 编程练习：某公司要开发“XX车行管理系统”，请使用面向对象的思想，设计自定义类描述自行 车、电动车和三轮车。 程序参考运行效果图如下： 任务分析； 第一步：分析自行车、电动车和三轮车的共性： 都是非机动车，具有非机动车的基本特征 都有运行的方法 第二步：根据共性，定...
练习-Java继承和多态之接口(19)
weixin_46075438的博客
02-13 5365
任务描述 本关任务： 编写一个学校接待方面的程序，招待不同身份的人的食宿问题。 /** * 编写一个学校接待方面的程序，招待不同身份的人的食宿问题 */ // 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码 /********** Begin **********/ // 定义一个接口类 Person interface Person{ // 定义 eat()，实现输出吃饭的功能，无返回值 public abstract void eat(); //
JAVA第十一次作业《类的继承》
夏佳怡的博客
04-13 955
什么是继承？ 多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么多个类无需再定义这些属性和行为，只要继承那个单独一个类即可。 多个类可以称为子类，单独这个类称为父类、超类或者基类。 子类可以直接访问父类中的非私有的属性和行为。 通过 extends 关键字让类与类之间产生继承关系。 class SubDemo extends Demo{} //SubDemo是子类，Demo是父类 继承有什么好处？ 提高代码的复用性。 让类与类之间产生了关系，是多态的前提。 继承的特点 1.Jav.
Java作业9—多态
lxtdw的博客
05-25 147
1.多态概述 ·多态是面向对象程序设计的一个重要特征，也是既对象、类、继承之后Java的又一个特征内容。 ·多态的体现为父类引用变量可以指向子类对象，前提是必须有父子类关系。 ·注意：在使用多态后父类引用变量调用方法时，会调用子类重写后的方法。 ·多态的定义和使用格式： 父类类型 变量名 = new 子类类型()； 2.多态中成员的特点 ·多态成员变量：编译运行看左边 ·多态成员方法：编译看左边，运行看右边 3.多态的转型 ·多态的转...
多态作业及答案
热门推荐
gaston的博客
06-28 1万+
 多态作业 一、 选择题 1.关于Java中的多态，以下说法不正确的为（ b  ）。（选择一项）    A多态不仅可以减少代码量，还可以提高代码的可扩展性和可维护性 B.把子类转换为父类，称为向下转型，自动进行类型转换 C.多态是指同一个实现接口，使用不同的实例而执行不同的操作 D.继承是多态的基础，没有继承就没有多态 2.编译运行如下Java代码，输出结果是（  d   ）。（选择一项） cla...
APCS第二阶段Java作业解析与指南
资源摘要信息:"APCS-HW-Fall: APCS 第二阶段作业是关于Java语言的硬件相关作业。在这一阶段，学生将深入学习Java编程，并将理论知识应用于实际硬件项目中，例如控制传感器和执行器。这通常涉及Java编程语言对硬件...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值