201871010115 马北 《面向对象程序设计(java)》 第6-7周学习总结
阅读原文时间:2023年07月16日阅读:1

项目

内容

《面向对象程序设计(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程序设计的特征:继承和多态,并学会采用继承定义类设计程序,掌握利用了父类定义子类的语法规则及对象使用要求。在完成实验过程中理解了继承的定义,掌握子类的定义要求,多态性的概念及用法,抽象类的定义及用途。通过自己动手敲代码让我更加深刻的理解了本章的知识。但本章知识比较多也比较重要,仍需要多多加强巩固,继续努力。

手机扫一扫

移动阅读更方便

阿里云服务器
腾讯云服务器
七牛云服务器