201777010217-金云馨《面向对象程序设计Java》第四周总结学习

2019面向对象程序设计（Java）第4周学习指导及要求

项目 内容
这个作业属于哪个课程 <任课教师博客主页链接>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. 理解重载概念及用法；
  7. 掌握包的概念及用法；

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

一、类与对象的基础概念

1、类的基本概念

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

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

3）每个类由一组结构化的数据（称作实例域）和在其上的一组操作（称为方法）构成。

2、对象的基本概念

1）对象是具体实体，具有明确定义的状态和行为。

2）对象的三个主要特征：

行为：可以对对象施加什么操作

状态：当施加哪些方法时，对象如何如何响应

标识：如何辨别具体相同行为与状态的不同对象

二、类与对象的关系

1、类是对象，事物的描述和抽象，是具有相同属性和行为的对象集合。对象则是该类事物的实例。　　　　

2、类是一个静态的概念，类本身不携带任何数据。当没有为类创建任何对象时，类本身不存在于内存空间中。对象是一个动态的概念。每一个对象都存在着有别于其它对象的属于自己的独特的属性和行为。对象的属性可以随着它自己的行为而发生改变。

3、类之间的关系

1）依赖(use-a):如果一个类中的方法操作了另一个类的对象，那么这个类就依赖于另一个类。

2）聚合（has-a）：类A的对象包含类B的对象

3）继承（is-a）：表示一个特定类和一个一般类之间的关系。一般来说，如果类A继承了类B，那么类A不仅继承了类B的方法和状态，而且还有属于自己的方法和状态。

4、预定义类的使用

1）已学过的预定义类：Math类、math类、String类、Scanner类等，掌握练习预定义类API的技术方法。

2）要使用预定义类的方法，只需知道方法名和参数即可，无需了解它的内部实现过程。

3）使用预定义类g需要在程序开始处使用import命令导入该类所在的包路径。

5、对象与对象变量

1）在OOP中，要想使用对象，需先构造对象，并初始化对象状态，然后通过对象调用类中的办法。

2）java中，用构造器（constructor）构造并初始化对象。

3）构造器是类中一个特殊方法，该方法名与类名相同。

4）构造并初始化对象的格式：

5）new 构造器名（参数）

6、对象变量

1）如果要多次使用初始化的对象，可将初始化的对象放在一个对象变量中。

　 格式： Date birthday = new Date();

2）对象变量保存了对象后，可用对象变量引用对象。

三、用户自定义类

1、类的定义包括两部分内容：声明和类体

2、类体由两部分构成：

　  一为实体域（或成员变量）定义；二为方法定义。

3、域的定义

1）实例域（成员变量）：类定义时实例域部分所定义的变量。实例域在整个类内都有效。

2）局部变量：方法体中定义的变量和方法的参数。只在定义它的方法内有效。

4、实例域的隐藏性

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

四、掌握用户自定义类的语法规则

1、实例域：可将实例域定义为final,构建对象时必须初始化这样的域。

2、静态域：绝大多数面向对象程序设计语言中，静态域被称为类域。如果将域定义为static，每个类中只有一个这样的域。而每个对象对于所有的实例域却都有自己的一份拷贝。

3、静态方法：静态方法是一种不能向对象实时操作的方法。可以使用对象或类名调用静态方法。

4、构造器方法:构造器与类同名。构造器总是伴随着new操作符的执行被调用，而不能对一个已经存在的对象调用构造器来达到重新设置实例域的目的。

5、更改器方法：一个类中对实例域进行修改的方法，通常更改器方法名前缀为set。调用更改器方法后对象的状态会改变。

6、访问器方法：只访问对象而不修改对象的方法。

7、main方法：main方法不对任何对象进行操作。静态的main方法将执行并创建程序所需要的对象。

五、重载

　　多个方法有相同的名字、不同的类型、不同的参数、便产生了重载。Java允许重载任何方法，而不只是构造器方法。

六、包

1、Java允许使用包将类组织起来。借助包可以方便地组织自己的代码，并将自己的代码与别人提供的代码库分开管理。而且使用包可以确保类名的唯一性。

2、包作用域

1）类中标记为public的部分可以被任意类使用；

2）类中标记为private的部分只能在类中使用；

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

七、文档注释技术

类注释；方法注释；域注释；通用注释；包与概述注释

第二部分：实验部分

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

1.  实验目的：

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

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

(3) 掌握对象的声明；

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

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

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

3. 实验步骤与内容：

实验1  任务1（10分）

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

输入样例:  34080019810819327X

输出样例: 1981-08-19

程序代码及运行结果：

实验1  任务2（25分）

程序代码：

import java.io.BufferedReader;

import java.io.FileReader;

import java.io.IOException;

import java.util.ArrayList;

import java.util.Scanner;

public class students {

    private static ArrayList<Student> list;

    public static void main(String[] args) {

        // TODO Auto-generated method stub

        list = new ArrayList<>();

        Scanner in = new Scanner(System.in);

        try {

            readFile("studentfile.txt");  //读如文件  studentfile.txt的信息

            System.out.println("请选择操作，1按姓名，2按学号，3退出");  //首先在控制台输出  ：请选择操作，1按姓名，2按学号，3退出

            int i;

            while ((i = in.nextInt()) != 3)  //读出并转换下一个表示整型的字符序列

            {

                switch (i)  //switch语句控制菜单

                {

                case 1:  //按学生的姓名查找

                    System.out.println("请输入姓名");   //在控制台上输出：请输入姓名

                    String name = in.next();   //定义一个String类对象name，表示下一行字符串

                    Student student = findStudentByName(name);   //通过姓名查找学生的信息

                    if (student == null) {     

                        System.out.println("没找到");    //if语句判断，如果学生的信息为空，则在控制台输出： 没找到

                    } else {

                        System.out.println(student.toString());  //否则，调用toString方法输出学生的信息

                    }

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

                    break;   //退出当前的循环

                case 2:

                    System.out.println("请输入学号");   //按学生的学号查找

                    String id = in.next();      //定义一个String类对象id，表示下一行字符串

                    Student student1 = findStudentById(id);  //通过学号查找学生的信息

                    if (student1 == null) {    ////if语句判断，如果学生的信息为空，则在控制台输出： 没找到

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

                    } else {

                        System.out.println(student1.toString());    //否则，调用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();   //最后关闭0

        }

    }

    public static void readFile(String path) throws IOException {

        FileReader reader = new FileReader(path);   //

        BufferedReader br = new BufferedReader(reader);

        String result;   //定义一个String类对象 result

        while ((result = br.readLine()) != null) {   //while循环

            Student student = new Student();

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

            student.setID(result.substring(0,12));  //从第十三位开始，调用result对象的substring方法得到一个新的字符串

            list.add(student);  

        }

        br.close();

    }

    public static Student findStudentByName(String name) {  //通过姓名找学生的信息

        for (Student student : list) {

            if (student.getName().equals(name)) {  //用equals方法检测两个字符串是否相等

                return student;

            }  

        }

        return null;

    }

    public static Student findStudentById(String Id) {   //通过学号查找学生的信息

        for (Student student : list) {

            if (student.getID().equals(Id)) {    //用equals方法检测两个字符串是否相等

                return student;

            }

        }

        return null;

    }

}

class Student {

    private String name;   //String类对象name的私有的实例域

    private String ID;     //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  测试程序1（10分）导入第4章示例程序并测试。

l 编辑、编译、调试运行程序4-2（教材104页）；

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

l 尝试在项目中编辑两个类文件（Employee.java、 EmployeeTest.java ），编译并运行程序。

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

姓名    性别 java成绩

import java.time.*;

public class EmployeeTest
{
   public static void main(String[] args)
   {
      // fill the staff array with three Employee objects
      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%
      for (Employee e : staff)
         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());
   }
}

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()
   {
      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）程序代码：

public class EmployeeTest
{
   public static void main(String[] args)
   {
      // fill the staff array with three Employee objects
      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%
      for (Employee e : staff)
         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());
   }
}

运行结果：

实验2  测试程序2（5分）

l 编辑、编译、调试运行程序4-3（教材116）；

l 结合程序运行结果，理解程序代码，掌握静态域（netxtId）与静态方法（getNextId）的用法，在相关代码后添加注释；

l 理解Java单元（类）测试的技巧。

程序代码：

public class Statictest
{
   public static void main(String[] args)
   {
      // fill the staff array with three Employee objects  //用三个employee对象填充staff数组
       Employee[] staff = new Employee[3];

      staff[0] = new Employee("Tom", 40000);
      staff[1] = new Employee("Dick", 60000);////构造Employee数组，并有三个雇员对象；
      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());
      }

      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;          //构造Employee类的对象，并声明局部变量name,salary,hireday;
   }

   public String getName()
   {
      return name;     //实例域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分）

l 编辑、编译、调试运行程序4-4（教材121）；

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

程序代码：

public class ParamTest
{
   public static void main(String[] args)
   {
      /*
       * Test 1: Methods can‘t modify numeric parameters
       */                                    //测试方法不能修改数值参数
      System.out.println("Testing tripleValue:");
      double percent = 10;
      System.out.println("Before: percent=" + percent);
      tripleValue(percent);    //调用 tripleValue
      System.out.println("After: percent=" + percent);

      /*
       * Test 2: Methods can change the state of object parameters
       */                      //测试方法可以更改对象参数的状态
      System.out.println("\nTesting tripleSalary:");
      Employee harry = new Employee("Harry", 50000);
      System.out.println("Before: salary=" + harry.getSalary());
      tripleSalary(harry);      //调用tripleSalary
      System.out.println("After: salary=" + harry.getSalary());

      /*
       * Test 3: Methods can‘t attach new objects to object parameters
       */                        //方法可以将新对象附加到对象参数
      System.out.println("\nTesting swap:");
      Employee a = new Employee("Alice", 70000);
      Employee b = new Employee("Bob", 60000);
      System.out.println("Before: a=" + a.getName());
      System.out.println("Before: b=" + b.getName());
      swap(a, b);                //用交换函数交换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);
      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（5分）

l 编辑、编译、调试运行程序4-5（教材129）；

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

程序代码：

public class ConstructorTest
{
   public static void main(String[] args)
   {
      // fill the staff array with three Employee objects         用三个employee对象填充staff数组
       Employee[] staff = new Employee[3];

      staff[0] = new Employee("Harry", 40000);
      staff[1] = new Employee(60000);             //构造Employee数组，并有三个雇员对象；
      staff[2] = new Employee();

      // print out information about all Employee objects
      for (Employee e : staff)                    //打印每个雇员的信息
         System.out.println("name=" + e.getName() + ",id=" + e.getId() + ",salary="
            + e.getSalary());
   }
}

class Employee
{
   private static int nextId;

   private int id;
   private String name = ""; // instance field initialization    实例字段初始化
   private double salary;

   // static initialization block
   static
   {
       Random generator = new Random();
      // set nextId to a random number between 0 and 9999     将nextId设置为0到999之间的随机值
      nextId = generator.nextInt(10000);
   }

   // object initialization block      对象 initialization块
   {
      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);
   }

   // the default constructor     错误的构造器
   public Employee()
   {
      // name initialized to ""--see above      名称初始化为同上
      // salary not explicitly set--initialized to 0   工资未显示设置，初始化为0
      // id initialized in initialization block   id初始化
   }

   public String getName()
   {
      return name;      //实例域name的访问器方法
   }

   public double getSalary()
   {
      return salary;    //实例域salary的访问器方法
   }

   public int getId()
   {
      return id;      //实例域id的访问器方法
   }
}

运行结果：

实验2  测试程序5（5分）

l 编辑、编译、调试运行程序4-6、4-7（教材135）；

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

程序代码：

package com.horstmann.corejava;

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

import java.time.*;

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

/**

 * @version 1.11 2015-05-08

 * @author Cay Horstmann

 */

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);//根据参数设置日期，参数分别为年月日；

   }                              //构造Employee类的对象，并声明局部变量name,salary,hireday;

   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实例域设置为新值；

   }

运行结果：

4. 实验总结：（10分）

老师反复强调这一章的学习内容很重要，我们需要熟练掌握。不过对于我来说还是比较吃力，按照实验步骤进行程序的运行过程中，我遇到了一些的困难，经过同学的帮助，我解决了遇到的困难，但我同时也认识到，我的基础很差，应该多加练习，为后续的学习做好准备。

原文地址：https://www.cnblogs.com/1377x/p/11575163.html

时间： 2024-10-14 00:47:20

201777010217-金云馨《面向对象程序设计Java》第四周总结学习的相关文章

201777010217-金云馨《面向对象程序设计(Java)》第二周学习总结

项目 内容 这个作业属于哪个课程 https://www.cnblogs.com/nwnu-daizh/ 这个作业的要求在哪里 https://www.cnblogs.com/nwnu-daizh/p/11475377.html 作业学习目标 学习并掌握Java Application程序结构: 学习并掌握Java语言的数据类型与变量: 学会使用Java运算符构造各类表达式: 掌握Java Application输入输出技术: 掌握Java流程控制技术(分支.循环): 掌握Math类.Strin

201771010123汪慧和《面向对象程序设计Java》第二周学习总结

一.理论知识部分 1.标识符由字母.下划线.美元符号和数字组成, 且第一个符号不能为数字.标识符可用作: 类名.变量名.方法名.数组名.文件名等.第二部分:理论知识学习部分 2.关键字就是Java语言中已经被赋予特定意义 的一些单词. ?常见有:class.public.try.catch.if. float.import.void等. 关键字不做变量名. 3.Java有三种注释的方式:   // 注释内容由//一直到此行结束. /*和*/ 定义一个注释块.  /**开始,*/结束 这种注释方法

Java面向对象程序设计--Java反射机制

能够分析类的功能的程序称为反射程序,反射机制的功能相当强大,几个基本的应用是: 在运行时分析各种类的功能; 在运行时对对象进行分析... 实现繁星数组操作的代码 使用Method方法就像使用C++中的函数指针一样;  1. Class 类: 当程序运行时,Java运行时系统维持一份包含每个对象运行时类型标记的信息.这个信息标记了每个对象所属的类型.运行时类型 信息为虚拟机找到正确的函数提供了依据.但这个信息可以通过类的getClass方法得到! 1 public class TestReflec

201771010134杨其菊《面向对象程序设计java》第十周学习总结

第8章泛型程序设计学习总结 第一部分:理论知识 主要内容:   什么是泛型程序设计                   泛型类的声明及实例化的方法               泛型方法的定义                     泛型接口的定义                    泛型类型的继承规则                    通配符类型及使用方法 1:泛型类的定义 (1) 一个泛型类(generic class)就是具有一个或多个类型变量的类,即创建用类型作为参数的类.如一个泛型

20182329 2019-2020-1 《数据结构与面向对象程序设计》第1周学习总结

20182329 2019-2020-1 <数据结构与面向对象程序设计>第1周学习总结 教材学习内容总结 git代码托管代码 Java的基本编程 jdb代码调试 教材学习中的问题和解决过程 问题1:在课本自学过程中,有一题是Java中有什么是不可能被识别的,我做错了一道(12345)可以被识别. 问题1解决方案:后来询问学长数字不与命令相匹配时不是有效的标识符,且标识符不能以数字为开头. 问题2:在自己对于课本代码编译时,发现自己main处显示错误 问题2解决方案:一开始我以为是我main的方

20182323 2019-2020-1 《数据结构与面向对象程序设计》第4周学习总结

目录 学号20182323 2019-2020-1 <数据结构与面向对象程序设计>第4周学习总结 教材学习内容总结 教材学习中的问题和解决过程 代码调试中的问题和解决过程 代码托管 上周考试错题总结 结对及互评 点评模板: 点评过的同学博客和代码 学习进度条 参考资料 目录 学号20182323 2019-2020-1 <数据结构与面向对象程序设计>第4周学习总结 教材学习内容总结 1.对象和类的关系:(类是对象的蓝图) 2.理解对象的状态(属性)和行为(操作): 3.理解类的分配

20182301 2019-2020-1 《数据结构与面向对象程序设计》第4周学习总结

20182301 2019-2020-1 <数据结构与面向对象程序设计>第4周学习总结 教材学习内容总结 面向对象程序设计的核心是类的定义,它代表定义了状态和行为的对象 toString方法在将对象传递给print和println方法,以及将一个对象与一个字符串连接时,会自动调用对象的toString方法 public String toString() { String result = Integer.toString(faceValue); return result; } 变量的作用域

2019-2020-26 《数据结构与面向对象程序设计》第5周学习总结

目录 2019-2020-26 <数据结构与面向对象程序设计>第5周学习总结 教材学习内容总结 教材学习中的问题和解决过程 代码调试中的问题和解决过程 [代码托管] 上周考试错题总结 点评过的同学博客和代码 其他(感悟) 学习进度条 参考资料 2019-2020-26 <数据结构与面向对象程序设计>第5周学习总结 教材学习内容总结 保护可见性提供了继承之间最恰当的封装机制 可以使用super引用来调用父类的构造方法 子类可以重写(重定义)继承自父类的方法 教材学习中的问题和解决过程

学号 2019-2020-20182318 《数据结构与面向对象程序设计》第7周学习总结

学号 2019-2020-20182318 <数据结构与面向对象程序设计>第7周学习总结 教材学习内容总结 十二章在讲编程中的时间复杂度的概念,时间复杂度越低,程序运行效率越高.时间复杂度的计算可通过寻找运行次数最多的程序,计算他的运行次数,取n的最高次方的极数,即为程序的时间复杂度. 栈可以理解为一类数据的集合,栈中的元素可以写入,也可以读出.元素存在先后次序.先入栈的先被读出.栈可用数组,链表两种形式实现.应注意使用数组的实现链表时要注意数组大小,在push过程中可添加扩大数组大小的程序.

20182333 2019-2020-1 《数据结构与面向对象程序设计》第八周学习总结

20182333 2019-2020-1 <数据结构与面向对象程序设计>第八周学习总结 教材学习内容总结 查找 1.查找:是一个过程,即在某个项目组中寻找某一项指定目标元素,或者确定该指定目标并不存在. 2.静态方法:也称为类方法,可以通过类名来调用,无需实例化该类的对象. 在方法声明中,通过使用static修饰符就可以把他声明为静态的. 3.泛型方法:要创建一个泛型方法,只需要在方法头的返回类型前插入一个泛型声明即可,其格式是:修饰符 返回类型 方法名(形参列表) { 方法体 }.例如: p