张兴盼-201871010131 《面向对象程序设计（java）》第六、七周学习总结
|
项目 |
内容 |
|
这个作业属于哪个课程 |
https://www.cnblogs.com/nwnu-daizh/ |
|
这个作业要求在哪里 |
https://www.cnblogs.com/nwnu-daizh/p/11605051.html |
|
作业的学习目标 |
|
第一部分：理论知识部分
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这本课程的逐渐学习深入的过程中，我对这门课程的认识也越来越深。