项目
内容
《面向对象程序设计(java)》
https://home.cnblogs.com/u/nwnu-daizh/
这个作业的要求在哪里
https://www.cnblogs.com/nwnu-daizh/p/11605051.html
作业学习目标
随笔博文正文内容包括:
第一部分:总结第五章理论知识(30分)
一.继承:
用已有的类来构建新类的一种机制。当定义了一个新类继承了一个类时,这个类就继承了这个方法和域,同时在新类中添加新的方法和域以适应新情况。继承时Java程序设计中的一项核心技术,也是面向对象特征之一。
继承的优点:具有层次结构。子类继承父类的域和方法。 代码可重用性。父类的域和方法课用于子类。可以轻松定义子类。设计应用程序变得更加简单。
二.类、超类和子类:
1.定义子类:关键字extends表明正在构造的新类派生于一个已存在的类,已存在的类称为超类、基类或父类;新类称为子类、派生类或孩子类。子类比父类拥有的功能更加丰富。
在通过扩展超类定义子类的时候,仅需要指出子类与超类的不同之处。在设计类的时候,将通用的方法放在超类中,将具有特殊用途的方法放在子类中。
2.覆盖方法:在子类中可以增加域,增加方法或覆盖超类的方法,但绝对不能删除继承的任何域和方法。
3.子类构造器:如果子类的构造器没有显式地调用超类的构造器,则将自动地调用超类默认地构造器,如果超类没有不带参数地构造器,并且在子类的构造器中又没有显式地调用超类地其他构造器,则Java编译器将报告错误。
一个对象变量可以指示多种实际类型的现象被称为多态,在运行时能够自动地选择调用哪个方法地现象称为动态绑定。
this :1.引用隐式传参 2.调用类其他构造器
super:1.调用超类的方法 2.调用超类的构造器
使用super调用基类的方法
子类构造器会默认调用基类的无参构造来初始化基类的私有域,如果基类没有无参构造,则会报错
java中,不需要将方法声明为虚拟方法方法,基类指针指向不同对象时,虚拟指针知道指针指向的实际对象类型,所以能正确调用对应的方法,如果不希望让一个方法具有虚拟特征,可以标记为final
4.继承层次:继承并不仅限于一个层次,由一个公共超类派生出来的所有类的集合被称为继承层次,在继承层次中,从某个特定的类到其祖先的路径被称为该类的继承链。Java不支持多继承。
5.动态绑定、静态绑定和方法表:
编译器准确知道调用哪个方法的叫静态绑定(用private、static、final声明过的方法)
在运行时,调用方法依赖于实际类型并实现方法绑定(运行时可知)的叫动态绑定,虚拟机为基类和派生类生成一个方法表,虚拟机会在方法表中搜索最适合的方法进行调用。
动态绑定的优点就是:对程序进行拓展时,不需要重新对调用方法的代码进行重新编译,方法重写时,子类的方法的访问性不能低于基类方法。
6.阻止继承 final类 :
final修饰的类不能被继承,final修饰的方法不能被覆盖,final修饰的域在构造方法内初始化,并且不能被改动。
被final修饰的类,其方法自动为final方法,但而不包括域。
动态绑定对系统开销很大,所以即时编译器会自动为没有被覆盖的类标记为内联函数,减少对系统的开销。
7.强制转换:
只能在继承层次内进行转换,将基类转换为子类之后,需判断是否转换成功 使用instanceof运算符检验。如果转换失败java不会生成一个空对象,而是抛出一个异常。
static_cast:基本数据类型转换。
const_cast:常量转化为非常量,或者反过来。
reinterpret_cast:任意类型转换而无须考虑安全和常量问题,不要轻易使用。
dynamic_cast:运行时转换,运行时要进行类型检查,存在继承关系之间(类中要有虚函数才能进行此转换,需检查类型信息,而类型信息保存在虚函数表中)。
8.抽象类与抽象方法
抽象类包含抽象方法也可以包含具体数据、具体方法。
类即时不含有抽象方法,也可以声明为抽象类。
抽象类不能被实例化。
9.受保护访问:
private:本类可见(也是c++初始化列表的原因,因为子类不可方位基类的private字段,需要调用基类的构造函数)
public:对所有类可见
protected:本包和所有子类可见(c++只对子类可见)
默认(无修饰符):对本包可见
三.object:所有类的超类 :
在java中,只有基本类型不是对象,其他类型(包括数组,枚举)都是对象,都扩展于超类
Object类是Java中所有类的祖先——每一个类都由它扩 展而来。在不给出超类的情况下,Java会自动把Object 作为要定义类的超类。
可以使用类型为Object的变量指向任意类型的对象。但 要对它们进行专门的操作都要进行类型转换。
equals方法:定义子类的equals方法时,可调用超类的equals方法。 super.equals(otherObject)
hashCode方法:Object类中的hashCode方法导出某个对象的散列 码。散列码是任意整数,表示对象的存储地址。 两个相等对象的散列码相等。
四.泛型数组列表:
利用ArrayList类,课允许程序在运行时确定数组的大小。
ArrayList是一个采用类型参数的泛类型。
五.对象包装器与自动装箱:
每个基本类型都有之对应的类(对象包装类)
对象包装类不允许修改其中的值,同时也是final声明的
使用包装器声明变量时,其==表示其是否指向同一个对象,因此
两个对象包装器比较时调用equal方法
六.参数数量可变的方法
java 使用持有者类型(IntHolder、BooleanHold等)
可变参数 使用:public static double max(double… value);实际上将若干参数绑定在数组中传递该max函数:public static void main(String… args)。
七.枚举类:
实际上是一个类,包含若干个实例,因此两个枚举类型的值比较,直接使用 == ,永远不要调用equal。
所有的枚举类型都是Enum类的子类。所以他们继承了这个类的许多方法String toString() //返回枚举常量名
static Enum valueOf(Class enumClass,String name)//返回指定名字给定类的枚举常量
int ordinal() //返回在enum声明中枚举常量的索引 (从0 开始)
int compareTo(E other) //在枚举中的顺序比较
八.反射:
反射被大量用在javaBeans中。
反射的作用:
①在运行中分析类的能力
②在运行在查看类的对象
③实现通过的数组操作代码
④利用Method对象。
第二部分:实验部分
1、实验目的与要求
(1) 理解继承的定义;
(2) 掌握子类的定义要求
(3) 掌握多态性的概念及用法;
(4) 掌握抽象类的定义及用途。
2、实验内容和步骤
实验1:测试程序1(10分)
5-1程序代码如下:
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
package
inheritance;
/**
* 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定义了一个只能在该类中访问的字符串常量
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;
}``//访问器
public
double
getSalary()
{
return
salary;
}``//访问器
public
LocalDate getHireDay()
{
return
hireDay;
}``//访问器
public
void
raiseSalary(``double
byPercent)
{
double
raise = salary * byPercent /
100``;
salary += raise;
}
}
程序运行结果如下:
5-3程序代码如下:
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
package
inheritance;
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)
{
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;
}
}
程序运行结果如下:
删除程序中Manager类、ManagerTest类,背录删除类的程序代码,在代码录入中理解父类与子类的关系和使用特点。
删除Manager类程序代码如下:
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
package
inheritance;
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)
{
super``(name, salary, year, month, day);
//调用超类Employee中含有这些参数的构造器
bonus =
0``;
}
@Override
public
double
getSalary()
{
double
baseSalary =
super``.getSalary();
//用关键字super调用超类Employee中的getsalary方法
return
baseSalary + bonus;
}
public
void
setBonus(``double
b)
{
bonus = b;
}
}
删除ManagerTest类程序代码如下:
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
package
inheritance;
/**
* 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());
}
}
程序运行结果如下:
实验1:测试程序2(10分)
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
package
abstractClasses;
public
abstract
class
Person
// 使用abstract关键字
{
public
abstract
String getDescription();
// 定义抽象类型person
private
String name;
public
Person(String name)
{
this``.name = name;``//将局部变量的值赋给成员变量
}``//为子类person类的构造器提供代码的构造器
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
{
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);``//hireday使用LocalDate的方法
}
public
double
getSalary()
{
return
salary;
}
public
LocalDate getHireDay()
{
return
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;
}
}
程序运行结果如下:
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
//扩展了一个子类Student
{
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;
//返回学生信息
}
}
程序运行结果如下:
删除程序中Person类,PerTest类,背景录入删除类的程序代码,在代码录入中理解抽象类与子类的关系和使用特点。
删除Person类程序代码如下:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
package
abstractClasses;
public
abstract
class
Person
// 使用abstract关键字
{
public
abstract
String getDescription();
// 定义抽象类型person
private
String name;
public
Person(String name)
{
this``.name = name;``//将局部变量的值赋给成员变量
}``//为子类person类的构造器提供代码的构造器
public
String getName()
{
return
name;
//Person类中还保存着姓名和一个返回姓名的方法
}``//构造器
}
删除PersonTest类程序代码如下:
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());
// 输出对象的姓名和信息描述
}
}
程序运行结果如下:
实验1:测试程序3(11分)
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
{
public
static
void
main(String[] args)
{
var alice1 =
new
Employee(``"Alice Adams"``,
75000``,
1987``,
12``,
15``);
var alice2 = alice1;
var alice3 =
new
Employee(``"Alice Adams"``,
75000``,
1987``,
12``,
15``);
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());
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定义了一个只能在该类中访问的字符串变量
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;
}
public
double
getSalary()
{
return
salary;
}
public
LocalDate getHireDay()
{
return
hireDay;
}``//访问器
public
void
raiseSalary(``double
byPercent)
{
double
raise = salary * byPercent /
100``;
salary += raise;
}
public
boolean
equals(Object otherObject)
{
// a quick test to see if the objects are identical 快速测试这些对象是否相同
if
(``this
== otherObject)
return
true``;
// must return false if the explicit parameter is null 如果显示参数为空,必须返回false
if
(otherObject ==
null``)
return
false``;
// if the classes don't match, they can't be equal 如果第几个类不匹配,则他们不相同
if
(getClass() != otherObject.getClass())
return
false``;
// now we know otherObject is a non-null Employee //其他对象为非空Employee类
var other = (Employee) otherObject;
// 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
//扩展了一个子类Manager
{
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 用super.equals检查这个类和其他类是否属于同一个类
return
bonus == other.bonus;
}
public
int
hashCode()
{
return
java.util.Objects.hash(``super``.hashCode(), bonus);
}
public
String toString()``//吧其他类型的数据转换为字符串类型的数据
{
return
super``.toString() +
"[bonus="
+ bonus +
"]"``;
}
}
程序运行结果如下:
实验2:编程练习(20分)
程序代码如下:
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
112
import
java.util.Scanner;
abstract
class
Shape {
double
PI =
3.14``;
public
abstract
double
getPerimeter();
public
abstract
double
getArea();
}
class
Rectangle
extends
Shape {
int
wide, len;
Rectangle(``int
a,
int
b) {
wide = a;
len = b;
}
@Override
public
double
getPerimeter() {
// TODO Auto-generated method stub
return
2
* (wide + len);
}
@Override
public
double
getArea() {
// TODO Auto-generated method stub
return
wide * len;
}
public
String toString(){
return
"[width="
+ wide +
", length="
+ len +
"]"``;
}
}
class
Circle
extends
Shape {
int
radius;
Circle(``int
_radius) {
radius = _radius;
}
@Override
public
double
getPerimeter() {
// TODO Auto-generated method stub
return
radius *
2
* PI;
}
@Override
public
double
getArea() {
// TODO Auto-generated method stub
return
radius * radius * PI;
}
public
String toString(){
return
"[radius="
+ radius +
"]"``;
}
}
public
class
Main {
public
static
void
main(String[] args) {
Scanner in =
new
Scanner(System.in);
int
n = in.nextInt();
in.nextLine();
Shape A[] =
new
Shape[n];
int
k =
0``, j =
0``;
double
sumAllArea =
0``, sumAllPerimeter =
0``;
for
(``int
i =
0``; i < n; i++) {
String S = in.next();
if
(S.equals(``"rect"``)) {
int
wide = in.nextInt(), len = in.nextInt();
in.nextLine();
A[i] =
new
Rectangle(wide, len);
}
else
if
(S.equals(``"cir"``)) {
int
radius = in.nextInt();
in.nextLine();
A[i] =
new
Circle(radius);
}
sumAllArea += A[i].getArea();
sumAllPerimeter += A[i].getPerimeter();
}
System.out.println(sumAllPerimeter);
System.out.println(sumAllArea);
System.out.print(``"["``);
for
(``int
i =
0``; i < n; i++) {
if``(i !=
0``)
System.out.print(``", "``);
if
(A[i]
instanceof
Rectangle) {
System.out.print(``"Rectangle "``);
System.out.print(A[i].toString());
}
else
{
System.out.print(``"Circle "``);
System.out.print(A[i].toString());
}
}
System.out.println(``"]"``);
for``(``int
i =
0``;i < n;i++) {
if``(A[i]
instanceof
Rectangle) {
System.out.println(``"class Rectangle,class Shape"``);
}``else
{
System.out.println(``"class Circle,class Shape"``);
}
}
in.close();
}
}
程序运行结果如下:
3. 实验总结:(10分)
本次学习理解了Java程序设计中类与对象的关系,理解OO程序设计的特征:继承和多态,并学会采用继承定义类设计程序,掌握利用了父类定义子类的语法规则及对象使用要求。在完成实验过程中理解了继承的定义,掌握子类的定义要求,多态性的概念及用法,抽象类的定义及用途。通过自己动手敲代码让我更加深刻的理解了本章的知识。但本章知识比较多也比较重要,仍需要多多加强巩固,继续努力。
手机扫一扫
移动阅读更方便
你可能感兴趣的文章