第十次 java作业

目录

第1章 课程大纲介绍

第2章 继承的应用

2-1 什么是多态

2-2 继承基本语法和使用场景

第3章 final和super关键字

3-1 final关键字

3-2 super关键字

第4章 方法重载与重写

第5章 接口和抽象类

5-1 抽象类和抽象方法

5-2 抽象类银行存款

5-3 接口基本语法操作

5-4 接口的应用

第6章 多态

6-1 多态概述

6-2 多态操作案例


第1章 课程大纲介绍

        Java是一门面向对象编程语言,不仅吸收了C++语言的各种优点,还摒弃了C++里难以理解的多继承、指针等概念,因此Java语言具有功能强大和简单易用两个特征。Java语言作为静态面向对象编程语言的代表,极好地实现了面向对象理论,允许程序员以优雅的思维方式进行复杂的编程。第十次 java作业_第1张图片

第2章 继承的应用

2-1 什么是多态

        同一操作作用于不同的对象,可以有不同的解释,产生不同的执行结果,这就是多态性。 简单的说:就是用基类的引用指向子类的对象。

第十次 java作业_第2张图片

2-2 继承基本语法和使用场景 

        继承是java面向对象编程技术的一块基石,因为它允许创建分等级层次的类。 继承就是子类继承父类的特征和行为,使得子类对象(实例)具有父类的实例域和方法,或子类从父类继承方法,使得子类具有父类相同的行为。 

继承的特征:

1.子类拥有父类非 private 的属性、方法。

2.子类可以拥有自己的属性和方法,即子类可以对父类进行扩展。

3.子类可以用自己的方式实现父类的方法。

4.Java 的继承是单继承,但是可以多重继承,单继承就是一个子类只能继承一个父类,多重继承就是,例如 B 类继承 A 类,C 类继承 B 类,所以按照关系就是 B 类是 C 类的父类,A 类是 B 类的父类,这是 Java 继承区别于 C++ 继承的一个特性。

 继承的优点:解决代码的重复性

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

第3章 final和super关键字

3-1 final关键字

  在Java中,final关键字可以用来修饰类、方法和变量(包括成员变量和局部变量)。

1.final成员变量必须在声明的时候初始化或者在构造器中初始化,否则就会报编译错误。final变量一旦被初始化后不能再次赋值。

2.本地变量必须在声明时赋值。 因为没有初始化的过程

3.在匿名类中所有变量都必须是final变量。

4.final方法不能被重写, final类不能被继承

5.接口中声明的所有变量本身是final的。类似于匿名类

6.final和abstract这两个关键字是反相关的,final类就不可能是abstract的。

7.final方法在编译阶段绑定,称为静态绑定(static binding)。

8.将类、方法、变量声明为final能够提高性能,这样JVM就有机会进行估计,然后优化。

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修饰的类

继承:单继承,突破访问限制  

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章 方法重载与重写

 重写的作用范围是父类和子类之间;重载是发生在一个类里面。

参数列表:重载必须不同;重写不能修改

返回类型:重载可修改;重写方法返回相同类型或子类

抛出异常:重载可修改;重写可减少或删除,一定不能抛出新的或者更广的异常。第十次 java作业_第3张图片

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

 第十次 java作业_第4张图片

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

第5章 接口和抽象类

5-1 抽象类和抽象方法

 抽象类:
抽象类定义的格式
【修饰符列表】 abstract class 类名{ }
 抽象类不能创建对象,不能实例化对象,所以它可以用来给子类继承
 final不能和abstract同时使用
抽象类的子类可以是抽象类  
抽象类虽然不能实例化,但是可以有构造方法,这个构造方法是供子类使用的
抽象类中有抽象方法也可以有非抽象方法,抽象方法特点:
1.抽象方法,没有方法体,以分号结尾
2.前面修饰符列表中有abstract关键字
父类中有抽象方法,抽象方法只能在抽象类中,所以子类也必须定义为抽象的类或者子类重写父类的方法,将其改为非抽象方法。

抽象类和抽象方法的特点:                                                                                                              1.一个抽象类里可以没有抽象方法但含有抽象方法的类必定为抽象类;                                      2.抽象类不能被实例化为对象,而只能作为其它类的超类,并且必须被继承;                                3.若某子类继承自一个抽象类,而该子类不是抽象类,则子类需用覆盖的方式来实例化超类中的所有抽象类方法.抽象方法可再与public、protect复合使用,但不能与final、private和static复合使用; 4 抽象方法只有方法声明,不能有方法体。

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-2 抽象类银行存款

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-3 接口基本语法操作

1.接口也是一种“引用数据类型”编译之后也是一个class字节码文件。

2.接口是完全抽象的(无法实例化)。(抽象类是半抽象)或者也可以说接口是特殊的抽象类。

[修饰符列表] interface 接口名{
}

3.接口支持多继承,一个接口可以继承多个接口。

4.接口中只包含两部分内容:

        一部分是:常量

        一部分是:抽象方法

接口中没有其它内容了。只有以上两部分。

5.接口中所有的元素都是public修饰的。(都是公开的。)

6.接口中的抽象方法定义时:public abstract修饰符可以省略。

7.接口中的方法都是抽象方法所以接口中的方法不能有方法体。

8.接口中的常量的public static final可以省略。

9.类和类之间叫做继承(extends),类和接口之间叫做实现(implements)。

11、当一个非抽象的类实现接口的话,必须将接口中所有的抽象方法全部实现(覆盖、重写)(和继承抽象类一样)。

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) {//重写方法
        return null;//返回null值
    }
}

第十次 java作业_第5张图片

5-4 接口的应用

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

 第十次 java作业_第6张图片

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

第十次 java作业_第7张图片

第6章 多态

6-1 多态概述

概念:同一操作作用于不同的对象,可以有不同的解释,产生不同的执行结果,这就是多态性。 简单的说:就是用基类的引用指向子类的对象。

多态的好处:

1.应用程序不必为每一个派生类编写功能调用,只需要对抽象基类进行处理即可。大大提高程序的可复用性。//继承 
2. 派生类的功能可以被基类的方法或引用变量所调用,这叫向后兼容,可以提高可扩充性和可维护性。 //多态的真正作用

6-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");//调用方法并传入值
    }
}

第十次 java作业_第8张图片

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作业_第9张图片

你可能感兴趣的:(java,开发语言)