第十四天 面向对象-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，大数据
长按指纹，识别二维码，一键关注Python
长按指纹，识别二维码，一键关注产品经理
