201871010124-王生涛《面向对象程序设计(java)》第四周学习总结

2019年11月18日 阅读数:173
这篇文章主要向大家介绍201871010124-王生涛《面向对象程序设计(java)》第四周学习总结,主要内容包括基础应用、实用技巧、原理机制等方面,希望对大家有所帮助。

项目java

内容数据库

这个做业属于哪一个课程编程

<任课教师博客主页连接>https://www.cnblogs.com/nwnu-daizh/数组

这个做业的要求在哪里dom

<做业连接地址>https://www.cnblogs.com/ws-t/ide

做业学习目标函数

掌握类与对象的基础概念,理解类与对象的关系;oop

掌握对象与对象变量的关系;学习

掌握预约义类Date、LocalDate类的经常使用API;测试

掌握用户自定义类的语法规则,包括实例域、静态域、构造器方法、更改器方法、访问器方法、静态方法、main方法、方法参数的定义要求;

掌握对象的构造方法、定义方法及使用要求;(重点);

理解重载概念及用法;

掌握包的概念及用法;

 

第一部分:总结第四章理论知识

一、面向对象程序设计概述:面向对象程序设计(OOP)是一种新的程序设计思惟,这种方法更接近人类处理现实世界问题的天然表示方法。

  (1)对象是面向对象编程的核心,是具体实体,具备明肯定义的状态和行为。

  (2)对象的三个主要特征:

    1)行为:能够对对象施加哪些操做或者可使用哪些方法;

    2)状态:当施加那些操做或者方法时,对象应该如何应对;

    3)标识:如何辨别具备相同行为和状态的不一样对象。

  二、类(class)

   (1)类是具备相同属性和行为的一组对象的集合;

  (2)类是描述对象的模板,它定义一类对象所拥有的数据和能完成的操做,在面向对象的程序设计中,类是构造程序的基本单位;

  (3)每一个类由一组结构化的数据(称做实例域)和在其上的一组操做构成。

    三、如何识别类:

        (1)过程化程序设计,必须从顶部的main函数开始编写程序;

     (2)oop的思路,首先从设计类开始,而后在每一个类里面添加方法;

  (3)识别类简单规则是在问题分析过程当中寻找名词,而类的方法则对应动词。

  四、类和对象的关系:

  (1)类是对象的原型,对象是类的实例,类是同类对象的抽象;

       (2)全部属于同一个类的对象都具备相同的特征和操做。

    五、类之间的关系:

  (1) 依赖:若是一个类中的方法操做了另外一个类的对象,那么这个类就依赖于另外一个类;

  (2)聚合:类A的对象包含类B的对象;

  (3)继承:表示一个特定类和一个 通常类之间的关系。

                             通常来讲, 若是类A继承了类B,那么类A 不只有类B的方法与状态,还有属于本身的 状态与方法。

  六、表达类关系的UML符号:

     七、预约义类的使用:

  (1)已学过的预约义类:Math类、math类、String类、Scanner类;

  (2)要使用预约义类的方法,只需知道方法名和参数便可,无需了解它的内在实现过程;

  (3)使用预约义类须要在程序开始处用import命令导入该类所在的包路经。

    八、对象与对象变量:

  (1)在oop中,要想使用对象,就必须首先构造对象,并初始化对象的状态,而后经过对象调用类中的方法;

  (2)Java中,用构造器构造并初始化对象;

  (3)构造器是类中一个特殊的方法,该方法与类名相同。不须要提供返回值;

  (4)构造并初始化对象的格式:

    new 构造器名(参数)

    九、对象的初始化实例:

  (1)Date类,定义在Java标准类库的Java.util包中;

  (2)初始化Date类对象的实例:

    new   Date();

    System.out.println(new   Date());

  (3)能够在类中一个方法用于新建立的对象:String   s = new  Date().toString();

    十、对象变量:

  (1)若是要屡次使用初始化的变量,可将初始化后的变量放在一个对象变量中;

    格式:  Date birthday = new Date();

  (2)对象变量保存对象后,可用对象变量引用对象;

    System.out.println(birthday.toString());

  (3)可将一个对象变量设置为NULL,表示该对象变量未引用任何对象。

  十一、更改器方法和访问器方法:

  (1)一个类中对实例域进行修改的方法,更改器前面加set;

  (2)一个类中对实例域进行访问的方法,前缀get。

 十二、用户自定义类:

  (1)类的定义包括两部份内容:声明和类体

  (2)类体由两部分构成:

            一为实体域(或成员变量)定义;二为方法定义。

  (3)域的定义:

 1)实例域:类定义时实例域部分所定义的变量;

 2)局部变量:方法体中定义的变量和方法的参数;

 3)实例域的隐藏性:局部变量与实例域名字相同时,则实例域被隐藏,即在这个方法内暂时失效。

 4)实例域的有效性:在整个类内部有效,而局部变量只在定义它的方法内有效。

 5)私有实例域的更改器和访问器:有时须要得到或设置私有实例域的值,此时需提供下面三项内容:

           a)一个私有的数据库;

           b)一个共有的域访问器方法;

           c)一个共有的域访问器方法;

6)final实例域:

     能够将实例域定义为final,此类域构建对象时时必须进行初始化;即必须确保在构造器执行以前,这个域的值被设置,而且在后面的操做中,不能再对它的值进行修改,即该域无修改器。

final修饰符多用于基本数据类型域,或不可变类的域;

7)方法定义:

  a)包括方法声明和方法体;

  b)方法的声明:名字,类型和参数等属性的说明:方法的类型描述的数返回值类型;

  c)方法体由局部变量和Java语句构成;一个类中能够有多个方法具备相同的名字,不一样的类型,不一样的参数,这种状况叫重载;

 1三、构造器:用来构造并初始化对象。

  (1)构造器的名字必需要与它所在类名字相同;

  (2)每一个包能够由一个以上的构造器;

  (3)构造器能够由一个,一个以上的参数;

  (4)构造器没有返回值;

  (5)构造器老是被new运算符调用;

1四、(1)静态域:绝大多数面向对象程序设计语言中,静态域被称为类域。      

    若是将域定义为static,每一个类中只有一个这样的域。而每一个对象对于全部的实例域却都有本身的一份拷贝。

       (2)main方法:main方法不对任何对象进行操做。静态的main方法将执行并建立程序所须要的对象。

  (3)静态常量:静态变量用的少,可是静态常量用的多。   

         (4).静态方法:用修饰的方法叫静态方法或类方法,静态方法可经过类名或对象来调用,而其余方法只能经过对象来调用。静态方法不能操做对象,不能在静态方法中访问实例域。但静态方法能够访问自身类中的静态域。能够认为静态方法是没有this参数的方法,而在一个非静态方法中,this参数是表示这个对象/对象构造器的隐式参数。

1五、对象的定义:使用一个类建立一个对象时,即建立了一个类的实例域。只有经过对象才能够访问该域的公共实例域,调用类中共有的方法;

1六、类的导入:一个类能够直接使用它所在的包中的全部类,也可使用来自其余包中的全部public类。

  (1)静态导入:import语句不只能够导入类,还增长了静态导入方法和静态域的功能;

  (2)将类放如包中:首先用package语句指明报的名字,且该语句应为程序的第一条语句,而后才是定义类的语句;

  (3)若是源文件不使用package语句指明包名,源文件的类将属于默认包。

  (4)当一个源文件中使用了package语句时,那么这个包中全部的类文件的都必须放在与包名相匹配的目录中;

  (5)当程序中所使用的类位于不一样包时,起源问价和类文件必须以下组织;

1七、包做用域:

  (1)类中标记为public的部分能够被任意类使用;

  (2)类中标记为private的部分只能在类中使用;

  (3)若是没有为类、方法或实例域指定访问控制修饰符public或private,这部分能够被同一包中的全部方法访问;

  (4)若是实例域不标记为private,将默认为包可见,这样作会破坏类的封装性。

1八、类路径:

  (1)类存储在文件系统的子目录中,类得路径必须与包名匹配;

  (2)在命令行方式下,设置类路径,使用-classpath选项指定类路径。

第二部分:实验部分

实验名称:实验三 类与对象的定义及使用

1.  实验目的:

(1) 熟悉PTA平台线上测试环境;

(2) 理解用户自定义类的定义;

(3) 掌握对象的声明;

(4) 学会使用构造函数初始化对象;

(5) 使用类属性与方法的使用掌握使用;

(6) 掌握package和import语句的用途。

3. 实验步骤与内容:

实验1 

采用我的帐号登陆https://pintia.cn/,使用绑定码620781加入PTA平台NWNU-2019CST1教学班(西北师范大学 计算机科学与工程学院 2018级计算机科学与技术),完成《2019秋季西北师范大学面向对象程序设计程序设计能力测试1》,测试时间50分钟。

实验1.1

公民身份证号码按照GB11643—1999《公民身份证号码》国家标准编制,由18位数字组成:前6位为行政区划分代码,第7位至14位为出生日期码,第15位至17位为顺序码,第18位为校验码。从键盘输入1个身份证号,将身份证号的年月日抽取出来,按年-月-日格式输出。注意:输入使用Scanner类的nextLine()方法,以避免出错。

输入样例:

34080019810819327X

输出样例:

1981-08-19

程序代码:

 

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

import java.util.Scanner;

public class test1 {

  

    public static void main(String[] args) {

        // TODO Auto-generated method stub

        Scanner in = new Scanner(System.in);

        System.out.println("please input your ID:");

        String s1 = in.nextLine();

        String s2,s3,s4;

        s2 = s1.substring(6, 10);

        s3 =s1.substring(10, 12);

        s4 = s1.substring(12, 14);

        System.out.println(s2+"-"+s3+"-"+s4);

    }

}

 

运行结果如图:

实验1.2

studentfile.txt文件内容是某班同窗的学号与姓名,利用此文件编制一个程序,将studentfile.txt文件的信息读入到内存,并提供两类查询功能:(1)输入姓名查询学号;(2)输入学号查询姓名。要求程序具备友好人机交互界面。

编程建议:

(1)从文件中读入学生信息,能够编写以下函数:

public static void StudentsFromFile(String fileName))

(2)输入姓名查找学生学号,能够编写以下函数:

public static String findStudent(String name)

(3)输入学号查找学生姓名,能够编写以下函数:

public static String findStudent(String ID)

程序代码:

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

113

114

115

116

117

118

119

120

import java.io.BufferedReader;

import java.io.FileReader;

import java.io.IOException;

import java.util.ArrayList;

import java.util.Scanner;

 

public class Main {

    // private static Student students[];

 

    private static ArrayList<Student> list;

 

    public static void main(String[] args) {

        list = new ArrayList<>();

        Scanner in = new Scanner(System.in);

        try {

            readFile("studentfile.txt");

            System.out.println("请选择操做,1按姓名,2按学号,3退出");

            int i;

            while ((i = in.nextInt()) != 3) {

                switch (i) {

                case 1:

                    System.out.println("请输入姓名");

                    String name = in.next();

                    Student student = findStudentByName(name);

                    if (student == null) {

                        System.out.println("没找到");

                    } else {

                        System.out.println(student.toString());

                    }

                    System.out.println("请选择操做,1按姓名,2按学号,3退出");

                    break;

                case 2:

                    System.out.println("请输入学号");

                    String id = in.next();

                    Student student1 = findStudentById(id);

                    if (student1 == null) {

                        System.out.println("没找到");

                    } else {

                        System.out.println(student1.toString());

 

                    }

                    System.out.println("请选择操做,1按姓名,2按学号,3退出");

                    break;

 

                default:

                    System.out.println("输入有误");

                    System.out.println("请选择操做,1按姓名,2按学号,3退出");

                    break;

                }

 

            }

        } catch (IOException e) {

            // TODO 自动生成的 catch 块

            e.printStackTrace();

        }finally {

            in.close();

        }

 

    }

 

    public static void readFile(String path) throws IOException {

        FileReader reader = new FileReader(path);

        BufferedReader br = new BufferedReader(reader);

        String result;

        while ((result = br.readLine()) != null) {

            Student student = new Student();

            student.setName(result.substring(13));

            student.setID(result.substring(0,12));

            list.add(student);

        }

        br.close();

    }

 

    public static Student findStudentByName(String name) {

        for (Student student : list) {

            if (student.getName().equals(name)) {

                return student;

            }

        }

        return null;

 

    }

 

    public static Student findStudentById(String Id) {

        for (Student student : list) {

            if (student.getID().equals(Id)) {

                return student;

            }

        }

        return null;

 

    }

}

 

class Student {

    private String name;

    private String ID;

 

    public String getName() {

        return name;

    }

 

    public void setName(String name) {

        this.name = name;

    }

 

    public String getID() {

        return ID;

    }

 

    public void setID(String iD) {

        ID = iD;

    }

 

    @Override

    public String toString() {

        // TODO 自动生成的方法存根

        return "姓名是:" + name + "学号是:" + ID;

    }

}

运行结果以下:

 

 

 

实验2 导入第4章示例程序并测试。

测试程序1:

编辑、编译、调试运行程序4-2(教材104页);

结合程序运行结果,掌握类的定义与类对象的用法,并在程序代码中添加类与对象知识应用的注释;

尝试在项目中编辑两个类文件(Employee.java、 EmployeeTest.java ),编译并运行程序。

参考教材104页EmployeeTest.java,设计StudentTest.java,定义Student类,包含name(姓名)、sex(性别)、javascore(java成绩)三个字段,编写程序,从键盘输入学生人数,输入学生信息,并按如下表头输出学生信息表:

姓名    性别   java成绩

 

 实验2  测试程序1(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
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
import  java.time.*;
 
/**
  * This program tests the Employee class.
  * @version 1.13 2018-04-10
  * @author Cay Horstmann
  */
public  class  EmployeeTest    //带有public修饰的EmployeeTest类,其包含了main方法
{
    public  static  void  main(String[] args)
    {
       // fill the staff array with three Employee objects
       Employee[] staff =  new  Employee[ 3 ];    //构造了一个Employee数组,并填入了三个雇员对象
 
       staff[ 0 ] =  new  Employee( "Carl Cracker" 75000 1987 12 15 );
       staff[ 1 ] =  new  Employee( "Harry Hacker" 50000 1989 10 1 );
       staff[ 2 ] =  new  Employee( "Tony Tester" 40000 1990 3 15 );
 
       // raise everyone's salary by 5%
       for  (Employee e : staff)    //利用Employee类的raiseSalary方法将每一个雇员的薪水提升5%
          e.raiseSalary( 5 );
 
       // print out information about all Employee objects
       for  (Employee e : staff)
          System.out.println( "name="  + e.getName() +  ",salary="  + e.getSalary() +  ",hireDay="
             + e.getHireDay());    //调用getName方法、getSalary方法以及getHireDay方法将每一个雇员的信息打印出来
    }
}
 
class  Employee    //Employee类
{
    private  String name;    //三个雇员对象的私有实例域
    private  double  salary;
    private  LocalDate hireDay;
 
    public  Employee(String n,  double  s,  int  year,  int  month,  int  day)
    {
       name = n;
       salary = s;
       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;
    }
}

  运行结果以下:

(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
39
import  java.time.LocalDate;
 
 
public  class  Employee {
     
 
 
    private  String name;    //实例域定义
    private  double  salary;   //实例域定义
    private  LocalDate hireDay;   //实例域定义
 
    public  Employee(String n,  double  s,  int  year,  int  month,  int  day)      //构造器的定义
    {
       name = n;
       salary = s;
       hireDay = LocalDate.of(year, month, day);
    }
 
    public  String getName()     //实例域name的访问器方法
    {
       return  name;
    }
 
    public  double  getSalary()   //实例域Salary的访问器方法
    {
       return  salary;
    }
 
    public  LocalDate getHireDay()   ////实例域HireDay的访问器方法
    {
       return  hireDay;
    }
 
    public  void  raiseSalary( double  byPercent)  
    {
       double  raise = salary * byPercent /  100 ;
       salary += raise;
    }
}

  运行结果以下:

(3)代码以下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
public  class  EmployeeTest
{
    public  static  void  main(String[] args)
    {
       // 用三个employee对象填充staff数组
       Employee[] staff =  new  Employee[ 3 ];    
 
       staff[ 0 ] =  new  Employee( "Carl Cracker" 75000 1987 12 15 );
       staff[ 1 ] =  new  Employee( "Harry Hacker" 50000 1989 10 1 );
       staff[ 2 ] =  new  Employee( "Tony Tester" 40000 1990 3 15 );
 
       // raise everyone's salary by 5%    给每人涨5%的工资
       for  (Employee e : staff)      //进行foreach循环
          e.raiseSalary( 5 );
 
       // print out information about all Employee objects
       for  (Employee e : staff)
          System.out.println( "name="  + e.getName() +  ",salary="  + e.getSalary() +  ",hireDay="
             + e.getHireDay());
    }
}

  运行结果以下:

l  参考教材104页EmployeeTest.java,设计StudentTest.java,定义Student类,包含name(姓名)、sex(性别)、javascore(java成绩)三个字段,编写程序,从键盘输入学生人数,输入学生信息,并按如下表头输出学生信息表:

  姓名    性别        java成绩

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
public  class  StudentTest {
 
     public  static  void  main(String[] args) {
         // TODO Auto-generated method stub
         Student[] staff =  new  Student[ 3 ];    //构造了一个Employee数组,并填入了三个雇员对象
 
           staff[ 0 ] =  new  Student( "lulanxi" "female" 99 );
           staff[ 1 ] =  new  Student( "luhaonan" "male" 98 );
           staff[ 2 ] =  new  Student( "luyuxuan" "male" 97 );
           for  (Student e : staff)
               System.out.println( "name="  + e.getName() +  ",sex="  + e.getSex() +  ",javascore="
                  + e.getJavascore());    //调用getName方法、getSex方法以及getJavascore法将每一个雇员的信息打印出来
     }
}
class  Student    //Employee类
{
    private  String name;    //三个雇员对象的私有实例域
    private  String sex;
    private  int  javascore;
 
    public  Student(String n, String s,  int  score)
    {
       name = n;
       sex = s;
       javascore = score;
    }
    
    public  String getName()
    {
       return  name;
    }
 
    public  String getSex()
    {
       return  sex;
    }
 
    public  int  getJavascore()
    {
       return  javascore;
    }
}  

  运行结果以下:

实验2  测试程序2(5分)

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
/**
  * This program demonstrates static methods.
  * @version 1.02 2008-04-10
  * @author Cay Horstmann
  */
public  class  StaticTest
{
    public  static  void  main(String[] args)
    {
       // fill the staff array with three Employee objects
       Employee[] staff =  new  Employee[ 3 ];    //构造了一个Employee数组,并填入了三个雇员对象
 
       staff[ 0 ] =  new  Employee( "Tom" 40000 );
       staff[ 1 ] =  new  Employee( "Dick" 60000 );
       staff[ 2 ] =  new  Employee( "Harry" 65000 );
 
       // print out information about all Employee objects
       for  (Employee e : staff)
       {
          e.setId();
          System.out.println( "name="  + e.getName() +  ",id="  + e.getId() +  ",salary="
             + e.getSalary());     ////调用getName方法、getId方法以及getSalary方法将每一个雇员的信息打印出来
       }
 
       int  n = Employee.getNextId();  // calls static method    经过类名调用这个方法,只须要访问类的静态域
       System.out.println( "Next available id="  + n);   //将其输出在控制台上
    }
}
 
class  Employee      //Employee类
{
    private  static  int  nextId =  1 ;      //静态方法访问自身的静态域
 
    private  String name;                //私有域
    private  double  salary;
    private  int  id;
 
    public  Employee(String n,  double  s)
    {
       name = n;
       salary = s;
       id =  0 ;
    }
 
    public  String getName()
    {
       return  name;
    }
 
    public  double  getSalary()
    {
       return  salary;
    }
 
    public  int  getId()
    {
       return  id;
    }
 
    public  void  setId()
    {
       id = nextId;  // set id to next available id
       nextId++;
    }
 
    public  static  int  getNextId()
    {
       return  nextId;  // returns static field
    }
 
    public  static  void  main(String[] args)  // unit test
    {
       Employee e =  new  Employee( "Harry" 50000 );    
       System.out.println(e.getName() +  " "  + e.getSalary());    //输出在控制台上
    }
}

  运行结果以下:

实验2  测试程序3(5分)

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