zoukankan      html  css  js  c++  java
  • 201871020225牟星源《面向对象程序设计(java)》第四周学习总结

    201871020225-牟星源《面向对象程序设计(java)》第四周学习总结

    项目

    内容

    这个作业属于哪个课程

    https://www.cnblogs.com/nwnu-daizh/

    这个作业的要求在哪里

    https://www.cnblogs.com/nwnu-daizh/p/11552848.html

    作业学习目标

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

    2. 掌握对象与对象变量的关系;

    3. 掌握预定义类Date、LocalDate类的常用API;

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

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

    6. 理解重载概念及用法;

    掌握包的概念及用法

    随笔博文正文内容包括:

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

    一、面向对象程序设计概述:

      1.面向对象程序设计(OOP)是一种新的程序设计思维。

        (1)对象是面向对象编程的核心。

        (2)实现方式为:自顶向下,模块分解(按功能分),分模块细化。

      2、类(class)

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

       2)每个类由一组结构化的数据(称作实例域)和一组操作构成。

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

    3、对象的三个主要特征:

       (1)行为:对对象施加哪些操作或者可以使用哪些方法;

       (2)状态:加操作或者方法,对象如何应对;

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

    4、识别类

    1)oop的思路,从设计类开始,然后在每个类里面添加方法。

    2)简单规则是在分析问题的过程中寻找名词,而方法对应名词。

        5、类之间的关系:

      (1)依赖(“uses-a”):一个类中的方法操作了另一个类的对象,这个类就依赖于另一个类。

      (2)聚合(“has-a”):类A的对象包含类B的对象。

      (3)继承(“is-a”):表示一个特定类和一个 一般类之间的关系。如果类A继承了类B,那么类A 有类B的方法与状态,也有属于自己的状态与方法。

    二、使用预定义类

        1.对象与对象变量:要使用对象,必须先构造对象,并指定初始状态。利用构造器(constructor)构造新实例。new 构造器名(参数)。

          2.更改器方法和访问器方法:

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

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

    三、用户自定义类:

      1.包括两部分:声明和类体

      2.类体由两部分构成:实体域(或成员变量),方法定义

      3.域的定义:

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

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

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

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

         (5)私有实例域的更改器和访问器:有时需要获得或设置私有实例域的值

         (6)final实例域:可将实例域定义为final,此类域构建对象时时必须进行初始化;在后面的操作中,不能再对它的值进行修改

       4.私有方法 :可以设置一些辅助方法为private的,并且由于不会被其他类调用,所以可以随时删去。

    四、方法定义:

      1.包括方法声明和方法体;

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

      (2)方法体由局部变量和Java语句构成;一个类中可以有多个方法具有相同的名字,不同的类型,不同的参数,这种情况叫重载;

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

      1.构造器的名字必须要与它所在类名字相同;

      2.每个包可以由一个以上的构造器;

      3.构造器可以由一个,一个以上的参数;

      4.构造器没有返回值;

      5.构造器总是被new运算符调用;

    六、静态域与静态方法

      1.静态域:也称为类域。      

        如将域定义为static,每个类中只有一个这样的域。而每个对象对于所有的实例域却都有自己的一份拷贝。

      2.静态常量:静态变量用的少,但是静态常量用的多。Math.PI

      3.静态方法:不能向对象实施操作,可认为没有this参数的方法。

        (1)静态方法不能操作对象,不能在静态方法中访问实例域。但静态方法可以访问自身类中的静态域。

          (2)一个类的静态方法不可以访问非静态成员变量。          

            (3)使用时间:不需要访问对象状态,参数都由显示参数提供

        (4)只需访问类的静态域

        (5)main不对任何对象进行操作

    七、对象构造

      1.重载:多个方法有相同名字,不同参数

      2.默认域初始化:自动赋值为默认值0, flase, null

      3调用另一构造器:this引用方法的隐式参数

    八、类的导入

      1.静态导入:import语句不仅可以导入类,还增加了静态导入方法和静态域的功能;

      2.将类放如包中:用package语句指明报的名字,且该句应为程序的第一条语句,然后才定.类的语句;

      3.如源文件不使用package语句指明包名,源文件的类将属于默认包。

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

      5.当程序中所使用的类位于不同包时,起源问价和类文件必须如下组织;

           包作用域:

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

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

      (3)如果没有为类、方法或实例域指定访问控制修饰符public或private,这部分可以被同一包中的所有方法访问;

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

    九、类路径:

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

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

    第二部分:实验部分

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

    1. 实验目的:

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

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

    (3) 掌握对象的声明;

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

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

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

    2. 实验步骤与内容:

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

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

    输入样例

    34080019810819327X

    输出样例:

    1981-08-19

    程序代码如下:

     import java.util.Scanner;
     
    public class Main {
     
        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)

    程序代码如下:

     

    import java.io.BufferedReader;
    import java.io.FileReader;
    import java.io.IOException;
    import java.util.ArrayList;
    import java.util.Scanner;
    public class Main1 {
     // 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  测试程序2 编辑、编译、调试运行程序4-3(教材116);

    1)结合程序运行结果,理解程序代码,掌握静态域(netxtId)与静态方法(getNextId)的用法,在相关代码后添加注释;

    2)理解Java单元(类)测试的技巧。

    程序代码如下:

     

    import java.time.*;
    /**
     * This program tests the Employee class.
     * @version 1.13 2018-04-10
     * @author Cay Horstmann
     */
    public class EmployeeTest
    {
       public static void main(String[] args)
       {
          Employee[] staff = new Employee[3];   // 三个Employee对象来填充staff数组
          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);//第三个
          for (Employee e : staff) //把每个人的工资提高5%
             e.raiseSalary(5);
          for (Employee e : staff)  //调用getName,getSalary,getHireDay来打印雇工信息
             System.out.println("name=" + e.getName() + ",salary=" + e.getSalary() + ",hireDay="
                + e.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()//实例域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;
       }
    }

    运行结果如下:

     

    实验2  测试程序3  编辑、编译、调试运行程序4-4(教材121);

    结合程序运行结果,理解程序代码,掌握Java方法参数的用法,在相关代码后添加注释;

    程序代码如下:

     

    public class ParamTest
    {
       public static void main(String[] args)
       {
          /*
           * Test 1: 该方法不能修改数值参数
           */
          System.out.println("Testing tripleValue:");
          double percent = 10;
          System.out.println("Before: percent=" + percent);
          tripleValue(percent);
          System.out.println("After: percent=" + percent);
          /*
           * Test 2: 该方法可以改变对象参数的状态
           */
          System.out.println("\nTesting tripleSalary:");
          var harry = new Employee("Harry", 50000);/  /定义名为Harry的类型为var初始化
          System.out.println("Before: salary=" + harry.getSalary());
          tripleSalary(harry);
          System.out.println("After: salary=" + harry.getSalary());
          /*
           * Test 3:该方法可以将新对象附加到对象参数
           */
          System.out.println("\nTesting swap:");
          var a = new Employee("Alice", 70000);    //定义名为a的类型为var初始化
          var b = new Employee("Bob", 60000);
          System.out.println("Before: a=" + a.getName());
          System.out.println("Before: b=" + b.getName());
          swap(a, b);    //交换
          System.out.println("After: a=" + a.getName());
          System.out.println("After: b=" + b.getName());
       }
       public static void tripleValue(double x) // doesn't work
       {
          x = 3 * x;
          System.out.println("End of method: x=" + x);
       }
       public static void tripleSalary(Employee x) // works
       {
          x.raiseSalary(200);   //调用x
          System.out.println("End of method: salary=" + x.getSalary());
       }
       public static void swap(Employee x, Employee y)
       {
          Employee temp = x;
          x = y;
          y = temp;
          System.out.println("End of method: x=" + x.getName());
          System.out.println("End of method: y=" + y.getName());
       }
    }
    class Employee // simplified Employee class
    {
       private String name;   //实例域定义
       private double salary;
       public Employee(String n, double s)
       {
          name = n;
          salary = s;
       }
       public String getName()
       {
          return name;
       }
       public double getSalary()
       {
          return salary;
       }
       public void raiseSalary(double byPercent)
       {
          double raise = salary * byPercent / 100;
          salary += raise;
       }
    }

    运行结果如下:

     

    实验2  测试程序4 编辑、编译、调试运行程序4-5(教材129);

    结合程序运行结果,理解程序代码,掌握Java用户自定义类的用法,掌握对象构造方法及对象使用方法,在相关代码后添加注释。

    程序代码如下:

     

    import java.util.*;
    public class ConstructorTest
    {
       public static void main(String[] args)
       {
          // fill the staff array with three Employee objects 三个Employee对象来填充staff数组
          var staff = new Employee[3];
          staff[0] = new Employee("Harry", 40000);//填充内容
          staff[1] = new Employee(60000);
          staff[2] = new Employee();
          // print out information about all Employee objects
          for (Employee e : staff)   //foreach循环
             System.out.println("name=" + e.getName() + ",id=" + e.getId() + ",salary="
                + e.getSalary());//调用getName 方法,getId方法和getSalary方法打印
       }
    }
    class Employee//静态域nextId
    {
       private static int nextId;//静态域nextId
       private int id;
       private String name = ""; // instance field initialization  实例字段intialization
       private double salary;
     
       // static initialization block 静态intialization块
       static
       {
          var generator = new Random();//定义generator为var类型
          // set nextId to a random number between 0 and 9999  nextId为0到999之间的随机值
          nextId = generator.nextInt(10000);
       }
       // object initialization block
       {
          id = nextId;
          nextId++;
       }
       // three overloaded constructors 三个重载的构造
       public Employee(String n, double s)
       {
          name = n;
          salary = s;
       }
       public Employee(double s)
       {
          // calls the Employee(String, double) constructor
          this("Employee #" + nextId, s);   //this引用当前对象
       }
       // the default constructor
       public Employee()
       {
          // name initialized to ""--see above
          // salary not explicitly set--initialized to 0
          // id initialized in initialization block
       }
       public String getName()
       {
          return name;
       }
       public double getSalary()
       {
          return salary;
       }
       public int getId()
       {
          return id;
       }
    }

    运行结果如下:

     

    实验2  测试程序5 编辑、编译、调试运行程序4-6、4-7(教材135);

    结合程序运行结果,理解程序代码,掌握Java包的定义及用法,在相关代码后添加注释;

    程序4-6

    程序代码如下:

    import com.horstmann.corejava.*;
    // the Employee class is defined in that package Employees类在该包中定义
    import static java.lang.System.*;  //静态导入System类
    public class PackageTest
    {
       public static void main(String[] args)
       {
          // because of the import statement, we don't have to use
          // com.horstmann.corejava.Employee here
          Employee harry = new Employee("Harry Hacker", 50000, 1989, 10, 1);
          harry.raiseSalary(5);
          // because of the static import statement, we don't have to use System.out here
          out.println("name=" + harry.getName() + ",salary=" + harry.getSalary());
       }
    }

    运行结果如下:

     

    程序4-7

    程序代码如下:

      package com.horstmann.corejava;    //将类放入包中

    3 // the classes in this file are part of this package   (这个文件中的类就是这个包中的一部分)

    5 import java.time.*;   //java.time包的引入

    7 // import statements come after the package statement   (import语句位于package语句之后)

    9 /**
    10 * @version 1.11 2015-05-08
    11 * @author Cay Horstmann
    12  */
    13 public class Employee
    14 {
    15    private String name;     //实例域定义
    16    private double salary;
    17    private LocalDate hireDay;
    18 
    19    public Employee(String name, double salary, int year, int month, int day)  //构造器定义
    20    {
    21       this.name = name;   //this用来引用当前对象
    22       this.salary = salary;
    23       hireDay = LocalDate.of(year, month, day);   
    24    }
    25 
    26    public String getName()    //实例域name的访问器方法
    27    {
    28       return name;
    29    }
    30 
    31    public double getSalary()   //实例域Salary的访问器方法
    32    {
    33       return salary;
    34    }
    35 
    36    public LocalDate getHireDay()   //实例域HireDay的访问器方法
    37    {
    38       return hireDay;
    39    }
    40 
    41    public void raiseSalary(double byPercent)
    42    {
    43       double raise = salary * byPercent / 100;
    44       salary += raise;
    45    }
    46 }

    运行代码如下:

     

    3. 实验总结:

    通过这一周的学习,对于对象和类有了更深刻的了解,也发现了自己在编程方面的不足,希望在下一周的学习中可以多多编程提高编程能力。

  • 相关阅读:
    看完动画你还会不懂 快速排序么
    看动画轻松理解时间复杂度(一)
    LeetCode Animation 题目图解汇总(持续更新中...)
    分而治之,归并排序的动画演示
    在Object-C中学习数据结构与算法之排序算法
    iOS面试准备之思维导图
    .net core跨域设置
    .NET Core WebAPI Swagger使用
    vue-resource emulateJSON的作用
    百度地图API简单初始化
  • 原文地址:https://www.cnblogs.com/muxingyuan/p/11575080.html
Copyright © 2011-2022 走看看