第十四天 面向对象-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));

}

}

原文发布于微信公众号 - Java帮帮(javahelp)

原文发表时间:2018-05-28

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏斑斓

编程修炼 | Scala亮瞎Java的眼(二)

继续上一期的话题,介绍Scala有别于Java的特性。说些题外话,当我推荐Scala时,提出质疑最多的往往不是Java程序员,而是负责团队的管理者,尤其是略懂技...

40350
来自专栏做全栈攻城狮

电脑小白学习软件开发(八)-复杂数据类型介绍使用,枚举,数组

枚举表示的是:限定只能包括列出来的值。我们这里以星期来举例子。顾名思义,星期只能包括星期一到星期日。用代码来表示下。

10940
来自专栏iKcamp

翻译连载 | 附录 A:Transducing(上)-《JavaScript轻量级函数式编程》 |《你不知道的JS》姊妹篇

原文地址:Functional-Light-JS 原文作者:Kyle Simpson-《You-Dont-Know-JS》作者 JavaScript 轻量级函数...

22080
来自专栏JackieZheng

初探JavaScript(四)——作用域链和声明提前

前言:最近恰逢毕业季,千千万万的学生党开始步入社会,告别象牙塔似的学校生活。往往在人生的各个拐点的时候,情感丰富,感触颇深,各种对过去的美好的总结,对未来的展望...

21050
来自专栏青玉伏案

设计模式(四):从“兵工厂”中探索简单工厂、工厂方法和抽象工厂模式

前面陆陆续续的更新了三篇关于设计模式的博客,是关于“策略模式”、“观察者模式”、“装饰者模式”的,今天这篇博客就从“兵工厂”中来探索一下“工厂模式”(Facto...

257100
来自专栏HTML5学堂

JavaScript实现十进制转换成二进制

HTML5学堂:平时大家在写JavaScript效果的时候,可能会比较少接触二进制、八进制,经常使用的是十进制。计算机中的二进制则是一个非常微小的开关,用“开”...

34980
来自专栏Java爬坑系列

【JAVA零基础入门系列】Day3 Java基本数据类型

  前两篇已经将开发环境搭建完成,如果你已经按之前的教程按部就班的完成了部署,那么世界上最优秀的编程语言之一和世界上最优秀的IDE之一已经出现在你的电脑上(此处...

23980
来自专栏黑泽君的专栏

编码知识大杂烩

ASCII码 (American Standard Code for Information Interchange,美国标准信息交换代码),最原始最直观的表...

11040
来自专栏zaking's

js算法初窥04(算法模式01-递归)

14520
来自专栏chafezhou

Python 工匠:编写条件分支代码的技巧

16740

扫码关注云+社区

领取腾讯云代金券