第十四天 面向对象-eclipse导jar包&修饰符&自定义数据类型【悟空教程】

第十四天 面向对象-eclipse导jar包&修饰符&自定义数据类型【悟空教程】

第14天 面向对象

第1章 面向对象补充

1.1 不同修饰符使用细节

• 权限修饰符一般放于所有修饰符之前
• 不同访问权限不能共用
• abstract与private不能共用 abstract抽象的子类必须实现，private私有化子类继承看不到这个方法，所以根本不能重写。
• abstract与static不能共用 abstract抽象的子类必须实现，static静态的属于这个类的，如果两者可以共用，不创建这个对象就可以调用这个方法，这个方法有方法体吗？没有方法体调用没有意思；static修饰的方法可以直接用类名调用，不创建对象就可以调用，这个方法是抽象的不能有方法体，那么调用这个方法就是无意义的。
• abstract与final不能共用 被final修饰的方法不能被重写，abstract修饰的方法必须被子类重写
• public与private不能共用 只表示一个访问权限，又公共又私有是不可能的。

1.2 面向对象中Eclipse的应用

1.2.1 常用快捷操作

Alt+shift+s+c 构造方法有参

Alt+shift+s+o 构造方法无参

Alt+shift+s+r get/set方法

Ctrl+T 查看所选中类的继承树(按第一下看类，再按第二下看接口)

Ctrl+滑鼠左键 或者 F3 查看所选中类的源代码,当选中一个方法查看源代码时,会出现以下显示,上边为方法声明的位置,下边为方法实现的位置。

Eclipse中的JRE System Library是默认的Eclipse依赖JRE中的类库。在该位置可以查找到平常使用的String类、Random类、Math类等。

1.2.2 文档注释导出帮助文档

在eclipse使用时，可以配合文档注释，导出对类的说明文档，从而供其他人阅读学习与使用。

使用文档注释，将类或者方法进行注释用@简单标注基本信息，如@author 作者；@see详情参见；@since 从第几个版本开始；@version 当前版本是什么等。

使用eclpise导出，导出javadoc文档即可。

1.2.3 项目的jar包导出

jar包是.class的压缩文件，一般一个jar包中包含许多.class文件。我们可以将一个jar包加入到项目的依赖中，从而该项目可以使用该jar下的所有类。

加入jar包的过程是将.class加入到classpath当中去，让项目识别，以下是加入步骤：

1：根文件夹下创建lib文件夹，用于同一管理所有的jar文件

2：右键点击jar文件，点击Build Path，选择Add to Build Path，此时查看根文件夹下的.classpath文件，发现新加入的jar包路径被配置到了该文件中。

注意：

Jar包加入后，必须Add to Build Path才能使用

Jar包加入后，加入的类也必须导包，如果加入的类其包名与现有类包名相同，则视作在同一个包下。(不常见)

本次讲解方式并不是唯一一种方式，还有其他加入jar包的方式。

第2章 自定义数据类型的使用

2.1 辨析成员变量与方法参数的设计定义

定义长方形类，包含求周长与求面积的方法

定义数学工具类，包含求两个数和的二倍与求两个数积的方法

思考：两个类的计算方法均需要两个数参与计算，请问两个数定义在成员位置还是形参位置更好，为什么？

如果变量是该类的一部分时，定义成成员变量。

如果变量不应该是类的一部分，而仅仅是功能当中需要参与计算的数，则定义为形参变量。

/*

* 定义长方形类

* 周长

* 面积

*/

public class CFX {

// 对于长方形来说 长宽就是它的属性 长宽是属于长方形的一部分

private double chang;

private double kuan;

//

// public double zhouChang(double chang,double kuan){

//

// return (chang+kuan)*2;

// }

public CFX() {

super();

}

public CFX(double chang, double kuan) {

super();

this.chang = chang;

this.kuan = kuan;

}

/*

* 周长

*/

public double zhouChang() {

return (chang + kuan) * 2;

}

/*

* 面积

*/

public double mianJi(){

return chang*kuan;

}

public double getChang() {

return chang;

}

public void setChang(double chang) {

this.chang = chang;

}

public double getKuan() {

return kuan;

}

public void setKuan(double kuan) {

this.kuan = kuan;

}

}

/*

* 自定义数学工具类

*

* 两个数和的2倍

* 两个数积的方法

*/

public class MyMath {

public double sum2Times(double number1,double number2){

return (number1+number2)*2;

}

public double chengJi(double number1,double number2){

return number1*number2;

}

}

public class Test {

public static void main(String[] args) {

CFX cfx = new CFX(12.0,10.0);

double zhouChang = cfx.zhouChang();

double mianJi = cfx.mianJi();

System.out.println(zhouChang);

System.out.println(mianJi);

System.out.println("-------------------");

MyMath mm = new MyMath();

double sum2Times = mm.sum2Times(12.0, 10.0);

double chengJi = mm.chengJi(12.0, 10.0);

// System.out.println(sum2Times);

System.out.println(chengJi);

}

}

2.2 不同位置使用自定义类型(接口与类)

自定义类型作为成员变量，如：

公司类

总资产属性

所有员工属性

经理属性

发工资方法：从总资产中减去所有员工支出。

员工：

姓名

工号

存款

工资

经理、厨师、服务员均为员工子类。经理在员工基础上添加奖金属性。

发完工资后，请查看所有员工的存款情况。

自定义类型作为方法参数，如：

公司类加入调整员工工资方法：

返回值为void

参数为：被调整工资的员工与调整金额(涨工资为正数、降工资为负数)。

方法体逻辑为，在员工工资的基础上调整相应的金额

自定义类型作为方法返回值，如：

在上边需求基础上，添加评选幸运员工(随机抽取一名员工并返回)。

自定义类型(接口)作为方法参数，如：

在上边需求基础上，添加组织年会活动方法，传入一个会组织年会的单位即可。任意具备组织年会的功能的单位均可。

自定义类型作为集合/数组元素类型，如：

上例中，所有员工便是集合中存储自定义类型。

在以上需求基础上，使用多态、匿名对象、匿名内部类。

一切需要对象时，均可以使用多态、匿名对象、匿名内部类。

分析以上需求并重构代码。

2.2.1 员工类

/*

* 定义一个员工类

*

* 姓名 String

* 工号 String

* 存款 double

* 工资 double

*/

public abstract class YuanGong {

//成员变量

/**

* 姓名

*/

private String name;

/**

* 工号

*/

private String id;

/**

* 存款

*/

private double cunKuan;

/**

* 工资

*/

private double gongZi;

/*

* 员工的无参构造

*/

public YuanGong() {

super();

}

/*

* 员工的带参构造

*/

public YuanGong(String name,String id,double cunKuan,double gongZi){

this.name = name;

this.id = id;

this.cunKuan = cunKuan;

this.gongZi = gongZi;

}

//普通方法 工作

public abstract void work();

//=============gs=============================

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

public String getId() {

return id;

}

public void setId(String id) {

this.id = id;

}

public double getCunKuan() {

return cunKuan;

}

public void setCunKuan(double cunKuan) {

this.cunKuan = cunKuan;

}

public double getGongZi() {

return gongZi;

}

public void setGongZi(double gongZi) {

this.gongZi = gongZi;

}

}

2.2.2 经理类

/*

* 经理类

* 属性 奖金 double

*

*/

public class JingLi extends YuanGong{

/**

* 奖金

*/

private double jiangJin;

/**

* 经理的无参构造

*/

public JingLi() {

super();

// TODO Auto-generated constructor stub

}

/**

* 经理的满参构造

* @param name 名字

* @param id 工号

* @param cunKuan 存款

* @param gongZi 工资

* @param jiangJin 奖金

*/

public JingLi(String name, String id, double cunKuan, double gongZi,double jiangJin) {

super(name, id, cunKuan, gongZi);

this.jiangJin = jiangJin;

}

/**

* 经理类重写员工类的工作方法

*/

@Override

public void work() {

System.out.println("经理没事闲的管管人");

}

//=============gs==========================

public double getJiangJin() {

return jiangJin;

}

public void setJiangJin(double jiangJin) {

this.jiangJin = jiangJin;

}

}

2.2.3 厨师类

/**

*

* 厨师类 继承类员工

*/

public class ChuShi extends YuanGong implements NianHui{

/**

* 厨师的无参构造

*/

public ChuShi() {

super();

// TODO Auto-generated constructor stub

}

/**

* 厨师的满参构造

*

* @param name

* 名字

* @param id

* 工号

* @param cunKuan

* 存款

* @param gongZi

* 工资

*/

public ChuShi(String name, String id, double cunKuan, double gongZi) {

super(name, id, cunKuan, gongZi);

}

/**

* 厨师类重写员工类的工作方法

*/

@Override

public void work() {

System.out.println("我来做饭炒菜");

}

/**

* 厨师重写晚宴方法

*/

@Override

public void wanYan() {

System.out.println("我来做饭，边做边吃!!");

}

}

2.2.4 服务员类

/**

*

* 服务员类 继承类员工类

*/

public class FuWuYuan extends YuanGong {

/**

* 服务员无参构造

*/

public FuWuYuan() {

super();

}

/**

* 服务员的满参构造

*

* @param name

* 名字

* @param id

* 工号

* @param cunKuan

* 存款

* @param gongZi

* 工资

*/

public FuWuYuan(String name, String id, double cunKuan, double gongZi) {

super(name, id, cunKuan, gongZi);

}

@Override

public void work() {

System.out.println("努力端盘子！！努力赚钱！！");

}

}

2.2.5 开年会接口

/**

* 组织年会的接口

*/

public interface NianHui {

/**

* 年会接口的晚宴方法 抽象方法 要求子类重写

*/

public abstract void wanYan();

}

2.2.6 公司类

import java.util.ArrayList;

import java.util.Random;

/**

*

* 公司类 总资产属性 double 所有员工属性 ArrayList<YuanGong> 经理属性 JingLi

*

* 发工资方法：从总资产中减去所有员工支出。

*

*/

public class GongSi {

/**

* 总资产属性

*/

private double zongZiChan;

/**

* 存储所有员工的集合

*/

private ArrayList<YuanGong> yuanGongList;

/**

* 经理属性

*/

private JingLi jl;

/**

* 公司类无参构造

*/

public GongSi() {

super();

// TODO Auto-generated constructor stub

}

/**

* 公司类的带参构造

* @param zongZiChan 总资产

* @param yuanGongList 所有员工的集合

* @param jl 经理属性

*/

public GongSi(double zongZiChan, ArrayList<YuanGong> yuanGongList, JingLi jl) {

super();

this.zongZiChan = zongZiChan;

this.yuanGongList = yuanGongList;

this.jl = jl;

}

/**

* 公司类发工资方法

*/

/*

* 分析

* 遍历员工集合，依次获取每个员工

* 总资产=总资产-每个员工的工资

* 每个员工的存款 = 以前的存款+当月的工资

*

* 如果当前员工是经理类型

* 向下转型转换为经理类型

* 总资产 = 总资产-经理的奖金

* 每个经理的存储 = 以前的存款+当月的奖金

*

*/

public void faGongZi(){

//遍历员工集合，依次获取每个员工

for (int i = 0; i < yuanGongList.size(); i++) {

//依次获取每个员工

YuanGong thisYuanGong = yuanGongList.get(i);

// //获取每个员工的工资

// double thisGongZi = thisYuanGong.getGongZi();

// //获取每个员工的存款

// double thisCunKuan = thisYuanGong.getCunKuan();

// //总资产=总资产-每个员工的工资

// zongZiChan -= thisGongZi;

// //每个员工的存款 = 以前的存款+当月的工资

// thisCunKuan += thisGongZi;

// //给员工的存款重新赋值

// thisYuanGong.setCunKuan(thisCunKuan);

//总资产=总资产-每个员工的工资

zongZiChan -= thisYuanGong.getGongZi();

//每个员工的存款 = 以前的存款+当月的工资

thisYuanGong.setCunKuan(thisYuanGong.getCunKuan()+thisYuanGong.getGongZi());

//如果当前员工是经理类型

if(thisYuanGong instanceof JingLi){

//向下转型转换为经理类型

JingLi thisJl =(JingLi)thisYuanGong;

//总资产 = 总资产-经理的奖金

zongZiChan -= thisJl.getJiangJin();

//每个经理的存款= 以前的存款+当月的奖金

thisJl.setCunKuan(thisJl.getCunKuan()+thisJl.getJiangJin());

}

}

}

/**

* 调整员工薪资的方法

* @param yg 要调整薪资的员工

* @param fuDu 薪资调整的幅度

*/

public void tiaoXin(YuanGong yg , double fuDu){

//重新设置员工的工资 以前的工资+调整幅度

yg.setGongZi(yg.getGongZi()+fuDu);

}

/**

* 幸运员工方法

* @return 返回一个幸运的员工

*/

/*

* 生成一个在集合长度范围内的随机整数

* 使用随机数到集合中找到相应的员工

*/

public YuanGong luckyYuanGong(){

// Random r = new Random();

// int index = r.nextInt(yuanGongList.size());

// YuanGong yuanGong = yuanGongList.get(index);

return yuanGongList.get(new Random().nextInt(yuanGongList.size()));

}

/**

* 开年会的方法

* @param nianHuier 具备晚宴方法的人

*/

public void kaiNianHui(NianHui nianHuier){

System.out.println("开年会了！！！");

nianHuier.wanYan();

}

//==============gs==========================

public double getZongZiChan() {

return zongZiChan;

}

public void setZongZiChan(double zongZiChan) {

this.zongZiChan = zongZiChan;

}

public ArrayList<YuanGong> getYuanGongList() {

return yuanGongList;

}

public void setYuanGongList(ArrayList<YuanGong> yuanGongList) {

this.yuanGongList = yuanGongList;

}

public JingLi getJl() {

return jl;

}

public void setJl(JingLi jl) {

this.jl = jl;

}

}

2.2.7 测试类

import java.util.ArrayList;

/*

* 测试公司类 发工资的方法

*/

public class Test {

public static void main(String[] args) {

//定义一个存储员工的集合

ArrayList<YuanGong> list = new ArrayList<YuanGong>();

JingLi jl = new JingLi("柳岩", "380", 25000, 250, 10000);

//添加一个经理对象

list.add(jl);

//通过匿名对象的方式添加一个厨师对象

list.add(new ChuShi("范伟", "250", 500000, 250));

//通过匿名对象的方式添加一个服务员对象

list.add(new FuWuYuan("金小莲", "438", 0, 1000));

//使用匿名内部类创建 一个YuanGong的子类对象 赋值给yuanGong类型 多态

YuanGong sy = new YuanGong() {

@Override

public void work() {

System.out.println("我是收银员，我各种贪钱！");

}

};

sy.setName("张三");

list.add(sy);

// list.add(new YuanGong() {

//

// @Override

// public void work() {

// System.out.println("我是收银员，我各种贪钱！");

// }

// });

//创建公司对象

GongSi gs = new GongSi(100000000.00, list, jl);

System.out.println("-------------发工资之前-------------------");

System.out.println("公司总资产："+gs.getZongZiChan());

//遍历员工集合 打印每个人的信息

for (int i = 0; i < list.size(); i++) {

YuanGong thisYuanGong = list.get(i);

System.out.println("姓名"+thisYuanGong.getName()

+" 工号："+thisYuanGong.getId()

+" 工资"+thisYuanGong.getGongZi()

+" 存款："+thisYuanGong.getCunKuan());

if(thisYuanGong instanceof JingLi){

//向下转型

JingLi thisJl = (JingLi)thisYuanGong;

System.out.println(" 奖金："+thisJl.getJiangJin());

}

}

//调用公司发工资的方法

gs.faGongZi();

System.out.println("---------发工资后-----------");

System.out.println("公司总资产："+gs.getZongZiChan());

//遍历员工集合 打印每个人的信息

for (int i = 0; i < list.size(); i++) {

YuanGong thisYuanGong = list.get(i);

System.out.println("姓名"+thisYuanGong.getName()

+" 工号："+thisYuanGong.getId()

+" 工资"+thisYuanGong.getGongZi()

+" 存款："+thisYuanGong.getCunKuan());

if(thisYuanGong instanceof JingLi){

//向下转型

JingLi thisJl = (JingLi)thisYuanGong;

System.out.println(" 奖金："+thisJl.getJiangJin());

}

}

System.out.println("---------------------------------------------------------");

//调用调薪方法

YuanGong yuanGong = list.get(1);

gs.tiaoXin(yuanGong, 5000);

System.out.println(yuanGong.getGongZi());

System.out.println("--------------------------------------------------");

//调用幸运员工的方法

YuanGong luckyYuanGong = gs.luckyYuanGong();

System.out.println(luckyYuanGong.getName());

System.out.println("----------------------------------------------");

//调用公司开年会的方法

YuanGong yuanGong2 = list.get(1);

ChuShi cs = (ChuShi)yuanGong2;

gs.kaiNianHui(cs);

// gs.kaiNianHui((ChuShi)list.get(1));

// gs.kaiNianHui(new ChuShi(name, id, cunKuan, gongZi));

}

}