张兴盼-201871010131 《面向对象程序设计（java）》第六、七周学习总结

张兴盼-201871010131 《面向对象程序设计（java）》第六、七周学习总结

项目	内容
这个作业属于哪个课程	https://www.cnblogs.com/nwnu-daizh/
这个作业要求在哪里	https://www.cnblogs.com/nwnu-daizh/p/11605051.html
作业的学习目标	深入理解程序设计中算法与程序的关系； 深入理解java程序设计中类与对象的关系； 理解OO程序设计的第2个特征：继承、多态； 学会采用继承定义类设计程序（重点、难点）； 能够分析与设计至少包含3个自定义类的程序； 掌握利用父类定义子类的语法规则及对象使用要求。

第一部分：理论知识部分

1.继承

1.1 继承：用已有的类来构建新类的一种机制。当定义了一个新类继承了一个类时，这个类就继承了这个方法和域，同时在新类中添加新的方法和域以适应新情况。继承时Java程序设计中的一项核心技术，也是面向对象特征之一。

1.2继承的优点：具有层次结构。子类继承父类的域和方法。 代码可重用性。父类的域和方法课用于子类。可以轻松定义子类。设计应用程序变得更加简单。

2.类、超类和子类：

2.1.定义子类：关键字extends表明正在构造的新类派生于一个已存在的类，已存在的类称为超类、基类或父类；新类称为子类、派生类或孩子类。子类比父类拥有的功能更加丰富。在通过扩展超类定义子类的时候，仅需要指出子类与超类的不同之处。在设计类的时候，将通用的方法放在超类中，将具有特殊用途的方法放在子类中。

2.2 覆盖方法：在子类中可以增加域，增加方法或覆盖超类的方法，但绝对不能删除继承的任何域和方法。

2.3 子类构造器：如果子类的构造器没有显式地调用超类的构造器，则将自动地调用超类默认地构造器，如果超类没有不带参数地构造器，并且在子类的构造器中又没有显式地调用超类地其他构造器，则Java编译器将报告错误。

一个对象变量可以指示多种实际类型的现象被称为多态，在运行时能够自动地选择调用哪个方法地现象称为动态绑定。

　　this :1.引用隐式传参 2.调用类其他构造器

super:1.调用超类的方法 2.调用超类的构造器

　　 使用super调用基类的方法：子类构造器会默认调用基类的无参构造来初始化基类的私有域，如果基类没有无参构造，则会报错

　　java中，不需要将方法声明为虚拟方法方法，基类指针指向不同对象时，虚拟指针知道指针指向的实际对象类型，所以能正确调用对应的方法，如果不希望让一个方法具有虚拟特征，可以标记为final

2.4.继承层次：继承并不仅限于一个层次，由一个公共超类派生出来的所有类的集合被称为继承层次，在继承层次中，从某个特定的类到其祖先的路径被称为该类的继承链。Java不支持多继承。

2.5.动态绑定、静态绑定和方法表：

　　编译器准确知道调用哪个方法的叫静态绑定(用private、static、final声明过的方法）

　　在运行时，调用方法依赖于实际类型并实现方法绑定(运行时可知)的叫动态绑定，虚拟机为基类和派生类生成一个方法表，虚拟机会在方法表中搜索最适合的方法进行调用。

　　动态绑定的优点就是：对程序进行拓展时，不需要重新对调用方法的代码进行重新编译，方法重写时，子类的方法的访问性不能低于基类方法。

2.6.阻止继承 final类  ：　

　　 final修饰的类不能被继承，final修饰的方法不能被覆盖，final修饰的域在构造方法内初始化，并且不能被改动。　　

　　被final修饰的类，其方法自动为final方法，但而不包括域。

　　动态绑定对系统开销很大，所以即时编译器会自动为没有被覆盖的类标记为内联函数，减少对系统的开销。

2.7.强制转换：

　　只能在继承层次内进行转换，将基类转换为子类之后，需判断是否转换成功 使用instanceof运算符检验。如果转换失败java不会生成一个空对象，而是抛出一个异常。

　　static_cast:基本数据类型转换。

　　const_cast:常量转化为非常量，或者反过来。

　　reinterpret_cast:任意类型转换而无须考虑安全和常量问题，不要轻易使用。

　　dynamic_cast:运行时转换，运行时要进行类型检查，存在继承关系之间（类中要有虚函数才能进行此转换,需检查类型信息，而类型信息保存在虚函数表中）。

2.8.抽象类与抽象方法
　　抽象类包含抽象方法也可以包含具体数据、具体方法。
　　类即时不含有抽象方法，也可以声明为抽象类。
　　抽象类不能被实例化。
2.9.受保护访问：
　　private:本类可见（也是c++初始化列表的原因，因为子类不可方位基类的private字段，需要调用基类的构造函数）
　　public:对所有类可见
　　protected:本包和所有子类可见（c++只对子类可见）
　　默认(无修饰符)：对本包可见

3.object：所有类的超类

　　 在java中,只有基本类型不是对象，其他类型（包括数组，枚举）都是对象，都扩展于超类
　    Object类是Java中所有类的祖先——每一个类都由它扩 展而来。在不给出超类的情况下，Java会自动把Object 作为要定义类的超类。 
       可以使用类型为Object的变量指向任意类型的对象。但 要对它们进行专门的操作都要进行类型转换。
　　equals方法：定义子类的equals方法时，可调用超类的equals方法。 super.equals（otherObject）
　　hashCode方法：Object类中的hashCode方法导出某个对象的散列 码。散列码是任意整数，表示对象的存储地址。 l两个相等对象的散列码相等。

4.泛型数组列表：

　　利用ArrayList类，课允许程序在运行时确定数组的大小。

ArrayList是一个采用类型参数的泛类型。
5.对象包装器与自动装箱：
　　每个基本类型都有之对应的类(对象包装类)
　　对象包装类不允许修改其中的值，同时也是final声明的
　　使用包装器声明变量时，其==表示其是否指向同一个对象，因此
　　两个对象包装器比较时调用equal方法

6.参数数量可变的方法
　　java 使用持有者类型(IntHolder、BooleanHold等)
　　可变参数 使用：public static double max(double... value)；实际上将若干参数绑定在数组中传递该max函数：public static void main(String... args)。
7.枚举类：
　　实际上是一个类，包含若干个实例，因此两个枚举类型的值比较，直接使用 == ，永远不要调用equal。 
　　所有的枚举类型都是Enum类的子类。所以他们继承了这个类的许多方法String toString() //返回枚举常量名
　　static Enum valueOf（Class enumClass,String name）//返回指定名字给定类的枚举常量
　　int ordinal() //返回在enum声明中枚举常量的索引 （从0 开始）
　　int compareTo(E other) //在枚举中的顺序比较
8.反射：
　　反射被大量用在javaBeans中。
　　反射的作用：
　　①在运行中分析类的能力
　　②在运行在查看类的对象
　　③实现通过的数组操作代码
　　④利用Method对象。

第二部分：实验部分

实验内容和步骤

实验1：测试程序1（10分）

5-1代码如下：

1	package inheritance;

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27

<br data-filtered="filtered">/** * This program demonstrates inheritance. * @version 1.21 2004-02-21 * @author Cay Horstmann */ public class ManagerTest { public static void main(String[] args) { // construct a Manager object        构造一个manager对象 var boss = new Manager("Carl Cracker", 80000, 1987, 12, 15); boss.setBonus(5000);                   //由boss.setBonus单独设置津贴，其中setBonus是Manager的特有方法； var staff = new Employee[3];            //定义一个包含三个雇员的数组； // fill the staff array with Manager and Employee objects staff[0] = boss;                 // 父类可以引用子类； staff[1] = new Employee("Harry Hacker", 50000, 1989, 10, 1);        //将经理和雇员都放到数组中去； staff[2] = new Employee("Tommy Tester", 40000, 1990, 3, 15); // print out information about all Employee objects for (Employee e : staff)                                       //for循环打印出各个雇员对象的信息； System.out.println("name=" + e.getName() + ",salary=" + e.getSalary()); } }

运行结果如下：

5-2代码如下：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38

package inheritance; import java.time.*; public class Employee { private String name; private double salary; private LocalDate hireDay;   //类的实例域定义来存放的需要操作的数据； public Employee(String name, double salary, int year, int month, int day) { this.name = name; this.salary = salary; hireDay = LocalDate.of(year, month, day);   //根据参数设置日期，参数分别为年月日； } public String getName() { return name;       //取得name属性的值； } public double getSalary() { return salary;            //取得salary属性的值； } public LocalDate getHireDay() { return hireDay;               //取得hireDay属性的值； } public void raiseSalary(double byPercent) { double raise = salary * byPercent / 100; salary += raise;                 //调用方法的对象salary实例域设置为新值； } }

运行结果如下：

5-3代码如下：

1	package inheritance;

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28

<br data-filtered="filtered">public class Manager extends Employee   //由继承Employee类来定义Manager类的格式，关键字extend表示继承； { private double bonus; /** * @param name the employee's name * @param salary the salary * @param year the hire year * @param month the hire month * @param day the hire day */ public Manager(String name, double salary, int year, int month, int day)//创建Employee类的实例 { super(name, salary, year, month, day);      //调用超类Employee中含有这些参数的构造器； bonus = 0; } public double getSalary() { double baseSalary = super.getSalary();           //用关键字super调用超类Employee中的getsalary方法 return baseSalary + bonus; } public void setBonus(double b) { bonus = b; } }

运行结果如下：

测试程序2：

1. 编辑、编译、调试运行教材PersonTest程序（教材163页-165页)；

2.掌握超类的定义及其使用要求；

3. 掌握利用超类扩展子类的要求；

4.在程序中相关代码处添加新知识的注释；

5. 删除程序中Person类、PersonTest类，背录删除类的程序代码，在代码录入中理解抽象类与子类的关系和使用特点。

5-4代码如下：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22

package abstractClasses; /** * This program demonstrates abstract classes. * @version 1.01 2004-02-21 * @author Cay Horstmann */ public class PersonTest { public static void main(String[] args) { var people = new Person[2];                 //定义一个包含2个雇员的数组； // fill the people array with Student and Employee objects people[0] = new Employee("Harry Hacker", 50000, 1989, 10, 1); people[1] = new Student("Maria Morris", "computer science");  //将雇员和学生的对象填充到Person引用数组； // print out names and descriptions of all Person objects for (Person p : people) System.out.println(p.getName() + ", " + p.getDescription());  // 输出对象的姓名和信息描述； } }

5-5代码如下：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

package abstractClasses; public abstract class Person      // 使用abstract关键字； { public abstract String getDescription(); // 包含一个或多个抽象方法的类本身必须被声明为抽象的； private String name; public Person(String name) { this.name = name; } public String getName() { return name;               //Person类中还保存着姓名和一个返回姓名的方法； } }

　　

5-6代码如下：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37

package abstractClasses; import java.time.*; public class Employee extends Person  //由继承Person类来定义Employee类的格式，关键字extend表示继承； { private double salary; private LocalDate hireDay;  //类的实例域定义来存放的需要操作的数据； public Employee(String name, double salary, int year, int month, int day) { super(name); this.salary = salary; hireDay = LocalDate.of(year, month, day);         //根据参数设置日期，参数分别为年月日； } public double getSalary() { return salary;          //返回salary属性的值； } public LocalDate getHireDay() { return hireDay;       //返回hireDay的值； } public String getDescription() { return String.format("an employee with a salary of $%.2f", salary); } public void raiseSalary(double byPercent) { double raise = salary * byPercent / 100; salary += raise;                      //调用方法的对象salary实例域设置为新值； } }

　　

5-7代码如下：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22

package abstractClasses; public class Student extends Person { private String major; /** * @param name the student's name * @param major the student's major */ public Student(String name, String major) { // pass name to superclass constructor super(name); this.major = major;     //将名称传递给超类构造函数； } public String getDescription() { return "a student majoring in " + major;   // 返回学生信息； } }

　　

运行结果如下：

抽象类与子类的关系及使用特点:

A.abstract方法只能声明，不能实现

B.包含一个或多个抽象方法的类本身必须被声明为抽象类

C.抽象方法充当着占位的角色，它们的具体实现在子类中

D.抽象类不能被实例化，即不能创建对象，只能产生子类。

测试程序3：

1.编辑、编译、调试运行教材程序5-8、5-9、5-10，结合程序运行结果理解程序（教材174页-177页）；

2.掌握Object类的定义及用法；

3.在程序中相关代码处添加新知识的注释。

5-8示例程序：

5-8代码如下：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37

package equals; /** * This program demonstrates the equals method. * @version 1.12 2012-01-26 * @author Cay Horstmann */ public class EqualsTest                  // 实现Employee类和Manager类的equals，hashCode方法 { public static void main(String[] args) { var alice1 = new Employee("Alice Adams", 75000, 1987, 12, 15); //初始化alice1 var alice2 = alice1;                                           //将Alice1的值赋给alice2 var alice3 = new Employee("Alice Adams", 75000, 1987, 12, 15); //初始化alice3 var bob = new Employee("Bob Brandson", 50000, 1989, 10, 1); System.out.println("alice1 == alice2: " + (alice1 == alice2)); System.out.println("alice1 == alice3: " + (alice1 == alice3)); System.out.println("alice1.equals(alice3): " + alice1.equals(alice3)); System.out.println("alice1.equals(bob): " + alice1.equals(bob)); System.out.println("bob.toString(): " + bob); var carl = new Manager("Carl Cracker", 80000, 1987, 12, 15); var boss = new Manager("Carl Cracker", 80000, 1987, 12, 15); boss.setBonus(5000); System.out.println("boss.toString(): " + boss); System.out.println("carl.equals(boss): " + carl.equals(boss)); System.out.println("alice1.hashCode(): " + alice1.hashCode()); System.out.println("alice3.hashCode(): " + alice3.hashCode()); System.out.println("bob.hashCode(): " + bob.hashCode());  //在这里实现Employee类和Manager类的hashCode方法 System.out.println("carl.hashCode(): " + carl.hashCode()); } }

　　

5-9代码如下：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69

package equals; import java.time.*; import java.util.Objects; public class Employee { private String name; private double salary; private LocalDate hireDay;        //类的实例域定义来存放的需要操作的数据； public Employee(String name, double salary, int year, int month, int day) { this.name = name; this.salary = salary; hireDay = LocalDate.of(year, month, day); } public String getName() { return name;    // 返回name属性的值； } public double getSalary() { return salary;            //返回salary属性的值； } public LocalDate getHireDay() { return hireDay;    // 返回hireDay属性的值； } public void raiseSalary(double byPercent) { double raise = salary * byPercent / 100; salary += raise;           //调用方法的对象salary实例域设置为新值； } public boolean equals(Object otherObject) { // a quick test to see if the objects are identical if (this == otherObject) return true;  //检测this与otherObject是否引用同一个对象； // must return false if the explicit parameter is null if (otherObject == null) return false;   //检测otherObject是否为null，如果为null返回false; // if the classes don't match, they can't be equal if (getClass() != otherObject.getClass()) return false; //getClass方法将返回一个对象所属的类； // now we know otherObject is a non-null Employee var other = (Employee) otherObject;    //知道otherObject是一个非空的Employee； // test whether the fields have identical values   测试字段是否具有相同的值； return Objects.equals(name, other.name) && salary == other.salary && Objects.equals(hireDay, other.hireDay); } public int hashCode() { return Objects.hash(name, salary, hireDay); } public String toString() { return getClass().getName() + "[name=" + name + ",salary=" + salary + ",hireDay=" + hireDay + "]"; } }

　　

5-10代码如下：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41

package equals; public class Manager extends Employee   //由继承Employee类来定义Manager类的格式，关键字extend表示继承 { private double bonus; public Manager(String name, double salary, int year, int month, int day) { super(name, salary, year, month, day); bonus = 0;     //自动生成构造函数存根； } public double getSalary() { double baseSalary = super.getSalary(); return baseSalary + bonus; } public void setBonus(double bonus) { this.bonus = bonus; } public boolean equals(Object otherObject) { if (!super.equals(otherObject)) return false; var other = (Manager) otherObject; // super.equals checked that this and other belong to the same class return bonus == other.bonus; //检查这个和其他是否属于同一个类； } public int hashCode() { return java.util.Objects.hash(super.hashCode(), bonus); } public String toString() { return super.toString() + "[bonus=" + bonus + "]"; } }

　　

运行结果如下：

实验2：编程练习

1.定义抽象类Shape：

2.属性：不可变常量double PI，值为3.14；

3.方法：public double getPerimeter()；public double getArea())。

　　让Rectangle与Circle继承自Shape类。

　　 编写double sumAllArea方法输出形状数组中的面积和和double sumAllPerimeter方法输出形状数组中的周长和。

　　 main方法中

1）输入整型值n，然后建立n个不同的形状。如果输入rect，则再输入长和宽。如果输入cir，则再输入半径。
2） 然后输出所有的形状的周长之和，面积之和。并将所有的形状信息以样例的格式输出。
3） 最后输出每个形状的类型与父类型，使用类似shape.getClass()(获得类型)，shape.getClass().getSuperclass()(获得父类型);

思考sumAllArea和sumAllPerimeter方法放在哪个类中更合适？

输入样例:

3

rect

1 1

rect

2 2

cir

1

输出样例:

18.28

8.14

[Rectangle [width=1, length=1], Rectangle [width=2, length=2], Circle [radius=1]]

class Rectangle,class Shape

class Rectangle,class Shape

class Circle,class Shape

代码如下：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111

import java.util.Scanner; public class Shape1 {     public static double sumAllArea(double areaall)     {         return areaall;     }     public static double sumAllPerimeter(double perimeterall)     {         return perimeterall;     }        public static void main(String[] args) {         Scanner sc = new Scanner(System.in);         int n = sc.nextInt();         sc.nextLine();         Shape []xz = new Shape[n];         double sumAllArea = 0, sumAllPerimeter = 0;         for(int i = 0;i < n;i++)         {             String ss = sc.nextLine();             if(ss.equals("rect"))             {                 int a = sc.nextInt(),b = sc.nextInt();                 sc.nextLine();                 xz[i] = new Rectangle(a,b);             }             if(ss.equals("cir"))             {                 int r = sc.nextInt();                 sc.nextLine();                 xz[i] = new Circle(r);             }             sumAllArea += xz[i].getArea();             sumAllPerimeter += xz[i].getPerimeter();         }         System.out.println(sumAllPerimeter(sumAllPerimeter));         System.out.println(sumAllArea(sumAllArea));         System.out.print("[");         for(int i = 0;i < n;i++)         {             if(i != 0)                 System.out.print(", ");             System.out.print(xz[i].toString());         }         System.out.println("]");         for(int i = 0;i < n;i++)         {             System.out.println(xz[i].getClass()+","+xz[i].getClass().getSuperclass());         }         sc.close();     }    }    abstract class Shape {     final double PI = 3.14;     public abstract double getPerimeter();     public abstract double getArea(); }    class Rectangle extends Shape {     public int width;     public int length;           public Rectangle(int width, int length) {         super();         this.width = width;         this.length = length;     }              @Override     public String toString() {         return "Rectangle [width=" + width + ", length=" + length + "]";     }           public double getPerimeter() {         return 2*(width+length);     }        public double getArea() {         return width*length;     }    }    class Circle extends Shape {     public int radius;           public Circle(int radius) {         super();         this.radius = radius;     }              @Override     public String toString() {         return "Circle [radius=" + radius + "]";     }           public double getPerimeter() {         return 2*PI*radius;     }        public double getArea() {         return PI*radius*radius;     }    }

运行结果如下：

3.实验总结

在本周的学习中，我学习到了什么是继承（新类继承了旧类的方法和域，并添加了新的方法和域）以及它的特点和优点，通过老师的讲解和课后的学习，大致了解了什么是类、子类、超类，父类与子类的部分用法，学会了如何定义抽象类，使用supper关键字等。在实验过程中也遇到了诸多困难，包括无法改正错误的程序，不能理解题目，最后一题程序编写困难等问题。在后期，我又通过请教同学，查阅资料等途径解决了这些问题。在Java这本课程的逐渐学习深入的过程中，我对这门课程的认识也越来越深。