Java 第十次作业
1、课程概述
本课程主要学习Java中的重要概念继承和多态，通过案例的方式进行讲解，让你对继承和多态在企业中的应用更加了解。
Java是一门面向对象编程语言，不仅吸收了C++语言的各种优点，还摒弃了C++里难以理解的多继承、指针等概念，因此Java语言具有功能强大和简单易用两个特征。Java语言作为静态面向对象编程语言的代表，极好地实现了面向对象理论，允许程序员以优雅的思维方式进行复杂的编程.
Java的继承和多态
2.继承的应用
2.1 什么是多态
前面我们了解了课程大纲，给大家介绍一下关于动态的概念，首先我们要认识到所有的软件都是为了解决生活中的问题而存在的，解决生活中的问题，首先要做到的是还原我们生活中的场景，而在我们生活中就存在着各种动态变化的事物以及操作行为，这些变化关系反映到程序代码中，我们就称呼为多态，多态呢，他能解决一些看上去相对比较复杂的关系以及流程业务，主要的通过两个方面来体现，第1个方面呢就是程序运行过程中，对象角色的一个切换，另外一个过程中，对象行为的一个扩展变化
多态性：多态性是指允许不同子类型的对象对同一消息作出不同的响应。简单的说就是用同样的对象引用调用同样的方法但是做了不同的事情。
多态：程序运行过程中，对象角色的切换：如老师，在家是丈夫或妻子，在校是老师
程序运行过程中，对象行为的扩展：如孵蛋器：把鸡蛋/鸽子蛋->孵出小鸡和鸽子
2.2 继承基本语法和使用场景
1.继承
2.重写
3.父类引用指向子类对象。
3.final和super关键字
3.1 final关键字
final变量有成员变量或者是本地变量(方法内的局部变量)，在类成员中final经常和static一起使用，作为类常量使用。其中类常量必须在声明时初始化，final成员常量可以在构造函数初始化。
final成员变量必须在声明的时候初始化或者在构造器中初始化，否则就会报编译错误。final变量一旦被初始化后不能再次赋值。
本地变量必须在声明时赋值。 因为没有初始化的过程
在匿名类中所有变量都必须是final变量。
final方法不能被重写, final类不能被继承
接口中声明的所有变量本身是final的。类似于匿名类
final和abstract这两个关键字是反相关的，final类就不可能是abstract的。
final方法在编译阶段绑定，称为静态绑定(static binding)。
将类、方法、变量声明为final能够提高性能，这样JVM就有机会进行估计，然后优化。
代码
package 十;
public class p1 extends Father {//定义一个子类并继承父类
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 void playGame(){//定义一个方法
System.out.println(this.name+"在游戏中....");//输出信息
}
public static void main(String[] args) {//主方法
p1 son=new p1();//创建一个对象
//操作属性
son.name="李白";//继承
//操作方法
son.working();//继承
son.playGame();//自有
}
}运行结果
3.2 super关键字
super 关键字是一个引用变量，用于引用直接父类对象。 每当创建子类的实例时，父类的实例被隐式创建，由 super 关键字引用变量引用。 super 可以用来引用直接父类的实例变量。
super 关键字的功能：
1.在子类的构造方法中显式的调用父类构造方法
2.访问父类的成员方法和变量。
代码
/**
* 基础类型
*/
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;//返回布尔类型
} /**
* 医师类型
* @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由于多继承中，多个父类的属性名和方法名重复，会导致无法正确渠道想要的值，所以Java不支持多继承，而采用接口的形式。
第4章 方法重载与重写
重写的作用范围是父类和子类之间；重载是发生在一个类里面。
参数列表：重载必须不同；重写不能修改
返回类型：重载可修改；重写方法返回相同类型或子类
抛出异常：重载可修改；重写可减少或删除，一定不能抛出新的或者更广的异常。
代码
package 十;
/**
* DeviceService
* @author 86157
*@Reamrk:设备服务类型
*/
public class p1 {//定义一个类
/**
* 医师领取的设备
* @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){//主方法
p1 ds=new p1();//创建设备服务对象
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 十;
/**
* Hospital
* @author 86157
*@Remark:医院的类型
*/
public class p1 { //创建类
public void register(Patient patient,Department dept){//定义一个方法并传入两个参数
System.out.println("开始挂号到对应的科室："+dept.name);//输出信息
dept.treatment(patient);//调用方法并传入参数
}
public static void main(String[]args){//主方法
p1 hs=new p1();//创建医院对象
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+"外科接受到病人，准备给病人手术......");//输出信息
}
} 运行结果
第5章 接口和抽象类
5.1 抽象类和抽象方法
抽象类：
抽象类定义的格式
【修饰符列表】 abstract class 类名{ }
抽象类不能创建对象，不能实例化对象，所以它可以用来给子类继承
final不能和abstract同时使用
抽象类的子类可以是抽象类
抽象类虽然不能实例化，但是可以有构造方法，这个构造方法是供子类使用的
抽象类中有抽象方法也可以有非抽象方法，抽象方法特点：
1.抽象方法，没有方法体，以分号结尾
2.前面修饰符列表中有abstract关键字
父类中有抽象方法，抽象方法只能在抽象类中，所以子类也必须定义为抽象的类或者子类重写父类的方法，将其改为非抽象方法。
抽象类和抽象方法的特点： 1.一个抽象类里可以没有抽象方法，但含有抽象方法的类必定为抽象类； 2.抽象类不能被实例化为对象，而只能作为其它类的超类，并且必须被继承； 3.若某子类继承自一个抽象类，而该子类不是抽象类，则子类需用覆盖的方式来实例化超类中的所有抽象类方法.抽象方法可再与public、protect复合使用，但不能与final、private和static复合使用； 4 抽象方法只有方法声明，不能有方法体。
代码
package 十;
public class p1 {//类名
/**
* 驱动器类型
* 类型使用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();//直接调用重写的方法完成具体的业务处理
}
}运行结果
5.2抽象类银行存款
代码
package 十;
public class p1 {//类名
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 p1.CashDesk();//创建对象
Service service2=new p1.ATM();//创建另一个对象
service.deposit(100);//调用方法
service2.deposit(200);//调用方法
}
}运行结果
5.3 接口基本语法操作
1.接口也是一种“引用数据类型”编译之后也是一个class字节码文件。
2.接口是完全抽象的(无法实例化)。(抽象类是半抽象)或者也可以说接口是特殊的抽象类。
[修饰符列表] interface 接口名{
}
3.接口支持多继承，一个接口可以继承多个接口。
4.接口中只包含两部分内容：
一部分是：常量。
一部分是：抽象方法。
接口中没有其它内容了。只有以上两部分。
5.接口中所有的元素都是public修饰的。（都是公开的。）
6.接口中的抽象方法定义时：public abstract修饰符可以省略。
7.接口中的方法都是抽象方法所以接口中的方法不能有方法体。
8.接口中的常量的public static final可以省略。
9.类和类之间叫做继承(extends),类和接口之间叫做实现(implements)。
11、当一个非抽象的类实现接口的话，必须将接口中所有的抽象方法全部实现（覆盖、重写）（和继承抽象类一样）。
代码
package 十;
public interface p1 {//定义一个公共的接口
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 p1.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=p1.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 p1{//定义一个类并继承接口
public String format_msg(String msg) {//重写方法
return "json 类型的数据 序列化操作";//返回一个字符串
}
public String format_msg2(String msg) {//重写方法
return null;//返回null值
}
}运行结果
5.4 接口的应用
代码
package 十;
public class p1 {//类名
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);//输出信息
}
}运行结果
代码
package 十;
/**
* 标记接口
*/
public class p1 {//定义一个类
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){//主方法
p1 da=new p1();//创建对象
Address addr=new Address();//创建对象
Person person=new Person();//创建对象
da.transfer("hello");//调用方法并传入参数
da.transfer(12);//调用方法并传入参数
da.transfer(addr);//调用方法并传入参数
da.transfer(person);//调用方法并传入参数
}
}运行结果
第6章 多态
6.1 多态概述
概念：同一操作作用于不同的对象，可以有不同的解释，产生不同的执行结果，这就是多态性。 简单的说:就是用基类的引用指向子类的对象。
多态的好处：
1.应用程序不必为每一个派生类编写功能调用，只需要对抽象基类进行处理即可。大大提高程序的可复用性。//继承
2. 派生类的功能可以被基类的方法或引用变量所调用，这叫向后兼容，可以提高可扩充性和可维护性。 //多态的真正作用
6.2 多态操作案例
代码
package 十;
public class p1 {//定义一个类
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){//主方法
p1 shopping=new p1();//创建对象
shopping.seckill("alienware",1, "15688889999");//调用方法并传入值
shopping.seckill("asua",2,"10.10.68.92");//调用方法并传入值
}
}运行结果
代码
package 十;
public class p1 {//定义一个方法
public void seckill(String name,Device device){//定义一个方法并传入两个参数
System.out.println("正在秒杀商品："+name);//输出信息
System.out.println("记录秒杀信息");//输出信息
device.record(name);//调用方法
}
public static void main(String[]args){//主方法
p1 shopping=new p1();//创建对象
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);//输出信息
}
}运行结果