Chapter_4_JAVA作业

Posted 2020-09-16 徐亨彬

一.类的封装，继承与多态

1.课前预习

1.1 举列现实生活中的封装，以及简述在程序中什么是属性的封装？

　　1.1.1 将东西捆绑在一起，如集成芯片；高压电线等等

　　1.1.2 封装就是将属性私有化，提供公有的方法访问私有属性。做法就是：修改属性的可见性来限制对属性的访问，

　　　　　　 并为每个属性创建一对取值（getter）方法和赋值（setter）方法，用于对这些属性的访问。　

1.2 构造函数与普通函数相比较都有那些特点？

　　构造函数： 永远没有返回值，也绝对不能为它指定返回类型，甚至是VOID类型

　　　　　　    构造函数的名称永远要和类名相同

　　　　　　　 构造函数只能用New运算符来调用

　　普通函数： 不需要用new关键字调用

　　　　　　　 可以用return语句返回值

　　　　　　　 函数内部不建议使用this关键字

　　　　　　    函数命名以驼峰方式，首字母小写

1.3 简述什么是方法的重载？

　　方法名相同，参数不同或多个参数的形式。

1.4 简述继承父类必须满足什么条件，以及继承了父类后子类将会怎样？

　　  1.4.1 不能是Fina类型，父类的构造方法不能是私有的。

　　1.4.2 子类会继承父类的不受限制成员变量和方法

1.5 简述什么是方法的重写？

　　子类可继承父类中的方法，而不需要重新编写相同的方法。但有时子类并不想原封不动地继承父类的方法，而是想作一定的修改，这就需要采用方法的重写。方法重写又称方法覆盖。

1.6 子类构造函数与父类构造函数之间有什么关系？

　　1.6.1 父类中没有显式定义任何构造方法，此时父类中实际有一个默认的无参数构造方法。这时，在子类中显式定义任何构造方法时，可以不用使用super调用父类的默认方法。

　　1.6.2 父类中显式定义了默认的无参数构造方法，那么子类可以定义任意的构造方法，而不必使用super调用父类的构造方法

　　1.6.3 父类中显示定义了构造方法，却没有显示定义默认的无参数构造方法，那么子类定义任何构造方法中都需要通过super调用父类的构造方法

1.7 访问修饰符有几种，他们分别都起什么作用？

　　Public ： 所有包所有地方都可以访问
　  Protected ： 同包以及子类可以访问
　  Friendly(default) ： 同包可以访问
　  Private： 除了当前类任何地方都不可以访问（私有的【封装】）

　

1.8 要使用多态性需要那些条件？

　　需要有继承关系的存在

　　需要有方法的重写

　　需要有父类的引用指向子类对象

2.课后复习

2.1 属性封装的目的是什么？以及进行封装的步骤是什么？　　

　　2.1.1 将事物的特性和功能包装在一起。隐藏信息，实现细节，对外暴露调用的接口。

　　2.1.2 a: 如封装一个属性（成员变量）。

    　　    b: 将访问修饰符改为私有的（private）

　　　　  c: 定义一个设定值的方法（方法名SetXxx）用于设定成员变量的值。

     　　   d: 定义一个外部访问的方法（方法名 GetXxx）用于外部的访问与调用。

2.2 使用构造函数的目的是什么？以及怎么样的函数才是构造函数？　　

　　2.2.1 给对象数据进行初始化

　　2.2.2 无返回类型、方法名与类名相同

2.3 简述重载和重写的区别？

　　重载: 方法名相同，返回类型不同，参数不同，叫重载。

　　重写: 当子类中的一个方法与父类中的方法有相同的方法名并且有相同的参数和类型，那么这个子类中新定义的方法将替代父类中帮子类定义好的方法，这就是子类中的方法重写，方法重写也叫方法的覆盖。

2.4 简述各种方法修饰符的作用？

　　Public: 公共的，所有的包、类之间都可以访问。

　　Privte: 私有的，只能在相同的类中访问。

　　Protect: 保护的，可以被同一个包中的所有类访问，也可以被所有的子类访问，子类可以在不同的包。

 

　　Default: 违约的、拖欠的，同包可以访问。

　　static: 静态修饰符，可用类名直接调用

　　final: 常量，不可改变的。

　　无访问修饰符： 可以被同一个包中的所有类访问，子类必须在同一个包中。

2.5 子类继承父类，则子类是否能使用父类的私有方法？

　　不能直接访问。

　　可以对属性（成员变量进行封装）。

 

 　父类有一个年龄的属性（成员变量）

package com.xuheng.classroon.encapsulation;
/**父类（基类），动物基本属性*/
public class Animal {
    /**狗的名字*/
    public String name;
    /**狗的颜色*/
    public String clooa;
    
    private String age;    
    /**调用方法*/
    public String getCc() {
        return cc;
    }
    /**设定值*/
    public void setCc(String cc) {
        this.cc = cc;
    }
    /**展示*/
    public void show() {
        System.out.println("这是一条"+name+",我的颜色是"+clooa);
    }

}

　　子类

package com.xuheng.classroon.encapsulation;
/**狗的类，是一个子类*/
public class Dog extends Animal{    //extends继承的关键字  前者是子类，后者是父类。
    /**价格*/
    public int jiage;    
    
}

调用继承父类中子类的Age

package com.xuheng.classroon.encapsulation;
/**父类（基类），动物基本属性*/
public class Zoo {
    public static void main(String[] args) {
//        Dog dog = new Dog();
//        dog.name = "野狗";
//        dog.clooa = "死黄色";
//        dog.show();
//    
        Dog a = new Dog();
        a.setCc("das");
        System.out.println(a.getCc());
    }
    
}

 

2.6 编写程序定义一个父类并添加吃饭，挣钱，睡觉的方法，在定义一个儿子类继承父亲类，然后给子类添加一个自己独特的方法（例如唱歌跳舞），并在子类中重写父类挣钱的方法（例如老爸一月赚5000，儿子一月赚8000），最后添加一个测试类，创建子类对象，并调用子类对象的方法进行吃饭，唱歌，挣钱，睡觉等。

　　父类

package com.xuheng.computer;

/**父类*/
public class Ba {
    /**吃饭方法*/
    public void chifan() {
        System.out.println("我正在吃饭");
    }
    /**挣钱方法*/
    public void zhengqian() {
        System.out.println("我正在挣钱");
    }
    /**睡觉方法*/
    public void shuijiao() {
        System.out.println("我正在睡觉");
    }
}

　　子类

package com.xuheng.computer;

public class Erzi extends Ba {
    public void tiaowu() {
        System.out.println("我正在跳舞");
    }
    
    /**方法重写*/
    public void zhengqian() {
        System.out.println("我的老爸在挣钱,一月挣700000。");
    }
}

　　测试类

package com.xuheng.computer;
/**测试类*/
public class Test {
    public static void main(String[] args) {
        Erzi show = new Erzi();
        show.chifan();
        show.shuijiao();
        show.zhengqian();
        show.tiaowu();
        
        Ba test = new Erzi();
        test.zhengqian();
    }

}

 

2.7 编写程序实现多态性的步骤是什么？

　　1. LSP李氏代换原则

　　2. 重写

　　3. 重载

 

3. 作业部分 

3.1 解答题

3.1.1 用自己的语句描述面向对象的多态是什么？

　　面向对象多态的体现在重写和重载，同一个类的不同子类对象对同一个方法的调用产生不同的结果叫多态。

3.1.2 简述面向对象的封装是什么？

　　将事物的特性和功能包装在一起。隐藏信息，实现细节，对外暴露调用的接口。

　　封装就是将属性私有化，提供公有的方法访问私有属性。做法就是：修改属性的可见性来限制对属性的访问，

并为每个属性创建一对取值（getter）方法和赋值（setter）方法，用于对这些属性的访问。

3.1.3 简述面向对象的继承是什么？

　　继承是从已有的类中派生出新的类，新的类能吸收已有类的数据属性和行为，并能扩展新的能力。

　　继承的特性：　　

　　　　　　　　1. 单根性： 若类B继承类A，那么建立类B时只需要再描述与基类(类A)不同的少量特征(数据成员和成员方法)即可。这种做法能减小代码和数据的冗余度，大大增加程序的重用性。

　　　　　　　　2. 传递性： 若类C继承类B，类B继承类A（多继承），则类C既有从类B那里继承下来的属性与方法，也有从类A那里继承下来的属性与方法，还可以有自己新定义的属性和方法。继承来的属性和方法尽管是隐式的，但仍是类C的属性和方法。继承是在一些比较一般的类的基础上构造、建立和扩充新类的最有效的手段。

　　　　　　　　3. 复用性： 继承提供了软件复用功能。若类B继承类A，那么建立类B时只需要再描述与基类(类A)不同的少量特征(数据成员和成员方法)即可。这种做法能减小代码和数据的冗余度，大大增加程序的重用性。　　　　　　

　　继承的特点：

　　　　　　　　1. Java中只支持单继承，不支持多继承 ， 继承格式： public class 子类 extends 父类

　　　　　　　 2. 有些语言是支持多继承的（C++，C#）

　　　　　　　 3. Java支持多层继承（继承体系）

 

3.2 代码题

　　3.2.1 创建一个员工类（Employee），定义两个构造函数，定义两个重载方法（构造函数的参数类型不限，重载方法的方法名与参数不限）

　　　　员工类　　

package com.xuheng.computer;
/**员工类*/
public class Employee {
    /**无参*/
    public Employee() {
        System.out.println("无参的构造方法");
    }
    /**有参的构造方法*/
    public Employee(int i) {
        System.out.println("有参的构造方法，参数值是："+i);
    }
    /**员工类，自我介绍方法，*/
    public void Introduce() {
        System.out.println("大家好！我是Xxx");
    }
    /**重载方法1*/
    public void Introduce(String name) {
        System.out.println("大家好！我是"+name);
    }
    /**重载方法2*/
    public void Introduce(String name , int age) {
        System.out.println("大家好！我是"+name+"，我今年"+age+"岁。");
    }
}

　　测试类

package com.xuheng.computer;

public class Text_Employee {
    public static void main(String[] args) {
        //无参的
        Employee ss = new Employee();
        ss.Introduce();
        ss.Introduce("张山");
        ss.Introduce("李四", 18);
        //有参的
        Employee s1 =new Employee(12);
        s1.Introduce();
    }
}

　　结果

　　3.2.2 创建一个部门经理类（Manager），定义二个构造方法，定义重写一个方法，方法体可以用一行注释来表示方法体。

　　员工类（父类）　

package com.xuheng.computer;
/**员工类*/
public class Employee {
    /**无参*/
    public Employee() {
        System.out.println("无参的构造方法");
    }
    /**Show 显示*/
    public void Show() {
        System.out.println("这里是员工类");
    }

}

 

 

 

　　部门经理类（子类）

 

package com.xuheng.computer;
/**部门经理类，继承员工类*/
public class Manager extends Employee {
    /**部门经理类，日常事务*/
    public void Processs() {
        System.out.println("我们是部门经理类，我们的日常事务是Xxx");
    }
    
    public Manager() {
        System.out.println("无惨构造方法");
    }
    /**有参的构造方法*/
    public Manager(int s) {
        System.out.println("有参构造方法，参数"+s);
    }
    /**重写了员工类的方法*/
    public void Show() {
        System.out.println("重写了员工类的现实方法");
    }

}

　　

　测试类

package com.xuheng.computer;

public class Text_Employee {
    public static void main(String[] args) {
        Manager s1 = new Manager();
        s1.Show();
    }
}

　　结果