题目描述

某公司的雇员分为以下若干类：
Employee：这是所有员工总的父类，
属性：员工的姓名，员工的生日月份。
方法：getSalary(intmonth)
根据参数月份来确定工资，如果该月员工过生日，则公司会额外奖励100 元。
SalariedEmployee：Employee 的子类，拿固定工资的员工。
属性：月薪
HourlyEmployee： Employee 的子类， 按小时拿工资的员工，每月工作超出160 小时的部分按照1.5 倍工资发放。
属性：每小时的工资、每月工作的小时数
SalesEmployee：Employee 的子类，销售人员，工资由月销售额和提成率决定。
属性：月销售额、提成率
BasePlusSalesEmployee：SalesEmployee 的子类，有固定底薪的销售人员，工资 由底薪加上销售提成部分。
属性：底薪。
根据要求创建 SalariedEmployee 、 HourlyEmployees 、SaleEmployee 和 BasePlusSalesEmployee四个类的对象各一个，并计算某个月这四个对象的工资。
注意：要求把每个类都做成完全封装，不允许非私有化属性。

Java 代码实现

public class Homework1801 {
    public static void main(String[] args) {
        //创建员工对象
        SalariedEmployee a = new SalariedEmployee("赵四",8,4000);
        HourlyEmployee b =new HourlyEmployee("王五",9,20,270);
        SalesEmployee c = new SalesEmployee("孙六",5,40000,0.1);
        BasePlusSalesEmploy d = new BasePlusSalesEmploy("张三",7,40000,0.1,1000);

        System.out.println(a.getName()+"的工资是:"+a.getSalary(8));
        System.out.println(b.getName()+"的工资是:"+b.getSalary(8));
        System.out.println(c.getName()+"的工资是:"+c.getSalary(8));
        System.out.println(d.getName()+"的工资是:"+d.getSalary(8));

    }
}
//员工的父类
class Employee{
    //姓名
    private String name;
    //生日
    private int birth;
    //构造方法
    public Employee(){}
    public Employee(String name, int birth) {
        this.name = name;
        this.birth = birth;
    }
    //getter setter方法
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
    public int getBirth() {
        return birth;
    }

    public void setBirth(int birth) {
        this.birth = birth;
    }
    //工资方法
    public double getSalary(int month){
        return (this.birth == month)?100:0;
    }
}
//SalariedEmployee:拿固定工资的员工
class SalariedEmployee extends Employee{
    //月薪
    private double monthMoney;
    //无参数构造方法

    public SalariedEmployee() {
    }
    //有参数构造方法
    public SalariedEmployee(String name, int birth, double monthMoney) {
        super(name, birth);
        this.monthMoney = monthMoney;
    }

    public double getMonthMoney() {
        return monthMoney;
    }

    public void setMonthMoney(double monthMoney) {
        this.monthMoney = monthMoney;
    }

    //工资方法
    public double getSalary(int month) {
        return monthMoney + super.getSalary(month);
    }
}
//HourlyEmployee:按小时拿工资的员工
class HourlyEmployee extends Employee{
    //每小时的工资
    private double hourMoney;
    //每月工作的小时数
    private int hourWork;
    //无参数构造方法
    public HourlyEmployee() {
    }
    //有参数构造方法
    public HourlyEmployee(String name, int birth, double hourMoney, int hourWork) {
        super(name, birth);
        this.hourMoney = hourMoney;
        this.hourWork = hourWork;
    }

    public double getHourMoney() {
        return hourMoney;
    }

    public void setHourMoney(double hourMoney) {
        this.hourMoney = hourMoney;
    }

    public int getHourWork() {
        return hourWork;
    }

    public void setHourWork(int hourWork) {
        this.hourWork = hourWork;
    }

    //工资方法
    public double getSalary(int month) {
        if (hourWork > 160){
            return 160 * hourMoney + (hourWork - 160) * 1.5 * hourMoney + super.getSalary(month);
        }else {
            return hourMoney * hourWork + super.getSalary(month);
        }
    }
}
//SalesEmployee：按月销售额和提成率拿工资的员工
class SalesEmployee extends Employee{
    //月销售额
    private double saleMoney;
    //提成率
    private double commissionRate;
    //无参构造
    public SalesEmployee() {
    }
    //有参构造
    public SalesEmployee(String name, int birth, double saleMoney, double commissionRate) {
        super(name, birth);
        this.saleMoney = saleMoney;
        this.commissionRate = commissionRate;
    }
    //getter setter方法
    public double getSaleMoney() {
        return saleMoney;
    }

    public void setSaleMoney(double saleMoney) {
        this.saleMoney = saleMoney;
    }

    public double getCommissionRate() {
        return commissionRate;
    }

    public void setCommissionRate(double commissionRate) {
        this.commissionRate = commissionRate;
    }
    //工资方法
    public double getSalary(int month) {
        return saleMoney * commissionRate + super.getSalary(month);
    }
}
//BasePlusSalesEmploy：有固定底薪和提成的员工
class BasePlusSalesEmploy extends SalesEmployee{
    //底薪
    private double baseMoney;
    //无参构造
    public BasePlusSalesEmploy() {
    }
    //有参构造
    public BasePlusSalesEmploy(String name, int birth, double saleMoney, double commissionRate, double baseMoney) {
        super(name, birth, saleMoney, commissionRate);
        this.baseMoney = baseMoney;
    }
    //getter setter方法
    public double getBaseMoney() {
        return baseMoney;
    }

    public void setBaseMoney(double baseMoney) {
        this.baseMoney = baseMoney;
    }
    //工资方法
    public double getSalary(int month) {
        return super.getSalary(month) + baseMoney;
    }
}

实现效果

赵四的工资是:4100.0
王五的工资是:6500.0
孙六的工资是:4000.0
张三的工资是:5000.0

java封装继承多态

1. 面向对象

面向对象的三个特征：
封装(Encapsulation);
继承(Inheritance);
多态(Polymorphism)。

我的总结：
面向过程：强调的是具体的功能实现；（执行者）
面向对象：强调的是具备功能的对象。（管理者）

2、类
类(class)是Java 语言的最小编程单位，也是设计和实现Java 程序的基础，本部分将深入介绍类的相关知识。
类的概念
类是一组事物共有特征和功能的描述。类是对于一组事物的总体描述，是按照面向对象技术进行设计时最小的单位，也是组成项目的最基本的模块。类的概念是抽象的，类似于建筑设计中的图纸，是对于现实需要代表的具体内容的抽象。类只包含框架结构，而不包含具体的数据。所以类代表的是总体，而不代表某个特定的个体。

我的总结：类是抽象的，对象是具体的，实实在在的！

类的定义：
[修饰符] class 类名{
1~n个构造方法；
0~n个字段；
0~n个方法
}
定义类，其实就是定义类里面的对象

对象包含：
状态；（属性）
功能、行为；（方法）
通过类来描述对象；
状态——–成员变量；
功能、行为——方法；

class Person{
//属性
private String name;
private int age;
private int sal;
//方法
public void show(){
System.out.println(“个人情况：”+name+age+sal);
}
}
3、构造方法
构造方法：用来构造类的实例（每一个类都默认有一个无参的构造方法，得使用new调用）
字段：类或对象所包含的数据，对类状态的一种描述；
方法：类或对象的特征或行为

作用：
给类中的字段进行初始化，可以用来创建对象。

特点：
方法名与类名相同
不用定义返回值类型
不需要写return语句

我的总结：
注意：
默认构造方法的特点。
多个构造方法是以重载的形式存在的。

构造方法的重载:（需要哪个就去适配哪个，调用哪个）
this([实参]);调用当前类的构造方法
注意: this([实参]);必须放在构造器的第一行;

对象的产生格式：
类名称 对象名 = new 类名称();
因为有(),所以是方法,实际上它就是构造方法，并且是非私有的构造方法。
如：CellPhone cp = new CellPhone();

class Person{
    private String name;
    private int age;
    private int sal;

    public void show(){
        System.out.println("个人情况："+name+age+sal);
    }

    public Person(String name) {
        super();
        this.name = name;
    }

    public Person(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }


    public Person(String name, int age, int sal) {
        super();
        this.name = name;
        this.age = age;
        this.sal = sal;
    }
}

4、static关键字
特点：
随着类的加载而加载
优先于对象存在
被所有对象所共享
可以直接被类名调用
使用注意：
静态方法只能访问静态成员
但是非静态成员可以访问静态成员;
静态方法中不可以使用this，super关键字
主方法（main）是静态的（可以利用类名去调用静态的main方法，很正常！但是会陷入死循环，导致内存溢出，jvm自动停止！）
public static void main(String[] agrs){}

可修饰字段,方法。
用static 修饰的成员表示它属于这个类共有，而不是属于该类的单个实例。
static 修饰的字段 == 类字段
static 修饰的方法 == 类方法

没使用static修饰的字段和方法，成员属于类的单个实例，
不属于类。
没有static 修饰的字段 == 实例字段
没有static 修饰的方法 == 实例方法

类和实例访问字段和方法的语法：
访问类成员： 类.字段 类.方法
访问实例成员： 实例.字段 实例.方法

我的总结：
static 修饰的字段和方法，既可以通过类调用，也可以使用实例调用；
没static 修饰的字段和方法，只能使用实例来调用（建议使用:类名来调用; 其实在底层,对象调用类成员,也会转换类名调用）
static关键字不能与this，super同时连用！

5、匿名对象
一个没有名字的对象, 创建了一个对象出来,没有赋给一个变量;
特点：
对方法或字段只进行一次调用时；
可作为实际参数进行传递；
只在堆里面开辟存储区域,
只能使用一次, 使用完就被销毁了;
何时使用？只拿来用一次！！
new Person();表示匿名对象,没有名字的对象
new Person().age = 17;//使用一次之后就被销毁了

6、this关键字
特点：this表示当前对象。
当前对象 ←→ 当前正在调用实例成员的对象
换言之：谁调用了方法，谁就是当前对象。

什么时候使用this关键字呢？
方法间的相互调用;
this.字段;
构造器中相互调用，但是此时this([参数])必须写在构造方法第一行。
this不能用在static修饰的方法里和static修饰的代码块里;

Eg：构造方法中的this.name = name;

7、面向对象之封装
封装的两个含义：
1.把对象的状态和行为看成一个统一的整体，将二者存放在一个独立的模块中(类)；
2.”信息隐藏”, 把不需要让外界知道的信息隐藏起来,尽可能隐藏对象功能实现细节,字段;

封装机制在程序中的体现是：把描述对象的状态用字段表示，描述对象的行为用方法表示，把字段和方法定义在一个类中，并保证外界不能任意更改其内部的字段值，也不允许任意调动其内部的功能方法。

程序中的一种体现：通常将类中的成员变量私有化(private)，通过对外提供方法（setXxx,getXxx）,可对该变量(xxx)进行访问。
boolean 类型的变量没有getXX,只有 isXX;

class Person1{
    private String name;
    private int age;
    private int sal;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

8、访问修饰符
private 类访问权限:本类内部可以访问,不能继承到子类;
default 什么都不写,包访问权限:本类内部可以访问，同包其他类也可以访问,同包可继承;
protected 子类访问权限:本类内部可以访问，不同包的子类也可以访问，同包其他类也可以访问,能继承到子类;
public 公共访问权限:任何地方都可以访问,能继承到子类;

9、类的设计分析
分析思路：
根据要求写出类所包含的字段；
所有的字段都必须私有化；
封装之后的字段可通过setter和getter设值和取得；
按需求可添加若干构造方法；
根据需求可添加相应的方法；
类中的所有方法都不要直接处理(输出打印)，而是交给调用者去处理。

10、面向对象之继承
首先有反映一般事物特性的类,然后在此基础上反映出特殊事物的类；
也就是说：继承是一种从一般到特殊的关系；

特点：
1、提高了代码的复用性。
2、让类与类之间产生关系，有了这个继承关系才有了多态的特性。
3、Java语言中只支持单继承（有别于C语言）。
因为多继承容易带来安全隐患（父类多了， 功能相同的话，就会出现调用不确定性吗，覆写一个方法，到底覆写的谁的？）。
ps：接口可以实现多继承
4、Java支持多层继承，object是每个类的超类，实现树形结构。

我的总结：
继承是多态的前提。
对类而言，只支持单继承。

格式：
[修饰符] class SubClass extends SuperClass

按照这种关系，我们把SuperClass类称为父类或基类，把SubClass称为子类或派生类或拓展类；

我的总结：
java.lang.Object是所有类的父类，
Object要么是直接父类要么是间接父类。

Eg：
学生属于人的一种特殊情况,此时我把人的共性写在Person类里面,为了让学生拥有这些共性（别的比如老师也可以有这些共性）,然后我就让学生来拓展Person类。

我的总结：
子类与父类的关系:
子类拓展父类（子类是父类的一种特殊情况）
主要是以父类为基础，然后添加属于自己的字段和方法。

父类的私有成员子类不能继承到;父类的构造方法不能被继承；
Java只支持单继承,不支持多继承;//不然的话，比如show方法，继承了多个，不知道到底调用那一个。
一个类有且只有一个直接父类;
一个类没显示的继承其他的一个类的时候,默认的直接父类就是Object类;
Student 的直接父类是Person,Object类也是Student类的父类,但是是间接父类;
一旦一个类显示的继承了其他的一个类的时候,此时默认的直接父类Object就会被取消;
Java里一个类只能有一个直接父类;java.lang.Object是所有类的父类，Object要么是直接父类要么是间接父类。

子类对象实例化过程
在继承操作中，对于子类对象的实例化：
子类对象在实例化之前必须首先调用父类中的构造方法之后再调用自身的构造方法。

11、子类访问父类和方法覆写
子类不能直接访问父类的私有成员；
但是子类可以调用父类中的非私有方法来间接访问父类的私有成员。
Person类中有私有字段name,Student继承Person
new Sudent().name; ×
new Student().getName(); √

子类拓展父类（子类是父类的一种特殊情况）
主要是以父类为基础，然后添加属于自己的字段和方法。

方法覆写产生原因：
当父类中某个方法不适合于子类时,子类出现父类一模一样的方法.
判断必杀技:子类方法前加上@Override能编译通过,表明是方法的覆写。
调用被覆盖的父类方法：使用super.方法名(实参);
方法覆写时应遵循的原则(一同两小一大)：
(一同):方法签名必须相同;
(两小):
子类方法的返回值类型比父类方法的返回值类型更小或相等
子类方法声明抛出的异常应比父类方法申明抛出的异常更小或相等;
(一大):子类方法的访问权限应比父类方法更大或相等;

子类需要覆写父类方法。
当父类的某个方法不适合于子类本身的特征行为时就当覆写父类中应当改变的方法。

12、super关键字和调用父类构造方法
表示父类对象的默认引用
如果子类要调用父类被覆盖的实例方法，可用super作为调用者调用父类被覆盖的实例方法。
使用super调用父类方法
使用super调用父类的构造方法

调用构造方法
本类中调用另一个重载构造方法用this(参数列表)
子类构造方法调用父类构造方法用super(参数列表)
子类调用父类的构造方法时：
super必须放在第一句
Java在执行子类的构造方法前会先调用父类无参的构造方法，其目的是为了对继承自父类的成员做初始化操作。
子类在创建对象的时候，默认调用父类的无参构造方法，要是子类构造方法中显示指定调用父类其他构造方法，就调用指定的父类构造方法，取消调用父类无参构造方法。

package reviewDemo;

class A{
    String name;
    A(){
        System.out.println("父类默认隐式的构造方法！");
    }

    A(String name){
        System.out.println("父类显式的构造方法！");
    }
}
class B extends A{

    B(){
        super(null);
        System.out.println("子类默认隐式的构造方法！");
    }
}
public class Demo10 {
    public static void main(String[] args) {
        new B();
    }
}

13、面向对象之多态
多态:指同一个实体同时具有多种形式
好比,你去面馆吃面,说我要吃面,那么;老板给我牛肉面,鸡蛋面等都可以,
这就是说”面”有多种形态,也就是说实体有多种形态;
编译时的类型由声明该变量时使用的类型决定,运行时的类型由实际赋给变量的对象决定。
如果编译时类型和运行时类型不同，就出现多态。

Eg：
前提:Student extends Person:

Person p = new Person(); 
Student s = new Student(); 
Person p = new Student();//多态

引用关系:父类变量指向子类实例对象

实现多态的机制:
父类的引用变量可以指向子类的实例对象,而程序调用的方法在运行期才动态绑定，就是引用变量所指向的真正实例对象的方法,也就是内存里正在运行的那个对象的方法，而不是引用变量的类型中定义的方法。

多态的作用：
把不同的子类对象都当作父类来看，可以屏蔽不同子类对象之间的差异，写出通用的代码，做出通用的编程，以适应需求的不断变化。
只修改方法的实现，不必修改方法的声明
继承是多态产生的前提条件;

分类:
编译时多态：方法重载
运行时多态：方法覆写

package test;

class Dog{
    void eat(){
        System.out.println("一般的狗吃一般的狗粮！");
    }
}
class HashDog extends Dog{
    void eat(){
        System.out.println("哈士奇吃哈士奇的狗粮！");
    }
}
class ZangAoDog extends Dog{
    void eat(){
        System.out.println("藏獒吃藏獒的狗粮！");
    }
}

//定义一个动物园喂的方法

class Zoo{

    void feed(Dog d){
        d.eat();
    }

}
public class Demo11 {
    public static void main(String[] args) {

        Dog hd = new HashDog();

        Dog zd = new ZangAoDog();

        Zoo z = new Zoo();
        z.feed(hd);
        z.feed(zd);
    }
}

输出：
哈士奇吃哈士奇的狗粮！
藏獒吃藏獒的狗粮！

14、引用变量类型转换
向上转型（子类→父类）：(自动完成)
父类名称 父类对象 = 子类实例 ;

向下转型（父类→子类）：(强制完成)
子类名称 子类对象 = （子类名称）父类实例 ;

对象名 instanceof 类

判断指定的变量名此时引用的真正类型是不是当前给出的类或子类；
我的总结：对象的类型和类必须有继承关系

class A extends B{}

B = new A();
If(b instanceof A){ ...
}