第十次 Java 作业

最新推荐文章于 2024-07-28 19:41:52 发布

栽呸

最新推荐文章于 2024-07-28 19:41:52 发布

阅读量63

点赞数

文章标签： java

本文链接：https://blog.csdn.net/weixin_67208871/article/details/124362844

版权

第1章课程概述

第2章继承的应用

2.1 什么是多态

什么是多态?

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

程序运行过程中,对象行为的扩展

2.2 继承基本用法和使用场景

继承:面向对象特征

继承基本语法结构

首先构造一个父类

pubLic class Father {
    public  Integer regNo;
    public String name;
    public String gender;
    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();  //自有
               }

/**
*  父类
*/
public class SystemUser {
     public String username; //账号
     public String password; //密码
     public String gender;  //性别
     public String  name; //姓名
     public String  regNo;//身份证号
     public String   phone;  //手机
     public String  email; //邮箱
     public String   address;//地址
     public SystemUser() {}
     public SystmUser(String username,String password,String name) {
        this.username = username;
        this.password = password;
         this.name = name;
         }
         }
       /**
      *医师
      */
     public class Doctor extends SystemUser {
         public String department; //部门
         public String offices;  //科室
         }

第3章 final和super关键字

3.1 final关键字

继承:基于类型的控制

final关键字:最终类型

继承关系的限制

/**

*医疗项目中的采购清单

*   采购方/联系方式/邮箱/传真/地址

*  采购单编号/采购类型/采购单位/采购数量/采购单价/交易时间/总计金额/备注/注意实现1~n

*/

  public final class Purchase {

  public String demandName;   //采购方

public String demandPhone; //联系方式

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; //采购单位

...

}

/**
 * 医师类型
 * @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);//调用父类的方法并返回
    }
}
}
该代码无运行结果

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

3.2 super 关键字

第4章方法重载与重写

4.1 方法重载和方法重写

第5章接口和抽象类

抽象类：
 
* 抽象类定义的格式
 
【修饰符列表】 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();//直接调用重写的方法完成具体的业务处理
    }
}

5.1 抽象类和抽象方法

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

5.2 抽象类银行存款

5.3 接口基本语法操作

接口的使用方式：一个接口一个继承另一个接口[单继承机制]
 
                          一个类型（可实例化）可以实现多个接口[多实现机制]
 
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.运行时多态主要通过父类引用指向子类对象

5.4 接口的应用

第6章多态

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

6.1 多态概述

6.2 多态操作案例

第7章课程总结

栽呸

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
第十次 Java 作业

第1章课程概述第2章继承的应用2.1 什么是多态什么是多态? 程序运行过程中,对象角色的切换程序运行过程中,对象行为的扩展2.2 继承基本用法和使用场景继承:面向对象特征继承基本语法结构首先构造一个父类pubLic class Father { public Integer regNo; public String name; public String gender; public String jo...
复制链接

扫一扫