201771010135杨蓉庆《面向对象程序设计（java）》第四周学习总结

学习目标

1、掌握类与对象的基础概念，理解类与对象的关系；

2、掌握对象与对象变量的关系；

3、掌握预定义类的基本使用方法，熟悉Math类、String类、math类、Scanner类、LocalDate类的常用API；

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

5、掌握对象的构造方法、定义方法及使用要求；（重点）

6、理解重载概念及用法；

7、掌握包的概念及用法；

8、了解文档注释技术；

一、 理论学习部分目的与要求

1、类与对象的基础概念

类：对具有相同属性和方法的一类事物的抽象。

对象：具体的某一事物，代表自身的一些属性和方法。

类（对象）之间的关系：类是一种抽象的概念集合，是最基础的组织单位，作为对象的模板、合约或蓝图。类是对象的类型，使用一个通用类可以定义同一类型的对象，类中定义对象的数据域是什么以及方法是做什么的。

关联（组合、聚合），继承，依赖、实现。

2、使用预定义类

（1）在java程序设计语言中，使用构造器构造新事例。构造器是一种特殊的方法，用来构造并初始化对象。

（2）更改器前缀为set;访问器前缀为get；

（3）构造器和类有相同的名字

3、用户自定义类

（1）Employee类

（2）隐式参数与显式参数

4、静态域与静态方法

（1）静态域： 如果将静态域定义为static ，那么每个类中只有一个这样的域，而每一个对象对于所有的实例域都有自己的一份拷贝本。

（2静态常量 ：静态变量使用的比较少，但是静态常量却使用的比较多 。

（3）静态方法 ： 静态方法是一种不能由对象操作的方法, 例如Math类中的求取一个数的次方的pow()方法就是一个静态方法。表达式是： Math.pow(x, a),在运算时，不使用任何Math对象，换句话说，没有隐式的参数。可以认为静态方法是没有this参数的方法（在一个非静态的方法中，this参数表示这个方法的隐式参数）

（4）main方法:我们学习java的时候，程序中大多会有一个main 方法，我们都称作程序的入口，main方法不对任何对象进行操作，事实上，在启动程序的时候，还没有任何一个对象，静态的main方法将执行并创建程序所需的对象。

5、方法参数

6、对象构造

7、包

Java允许把一个或多个类收集在一起成为一组，称作包，以便于组织任务，标准Java库分为许多包.java.langjava.utiljava，net等，包是分层次的所有的java包都在java和javax包层次内。

8、类路径

9、文档注释

10、类设计技巧

二、实验学习部分目的与要求

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

(2) 掌握对象的声明；

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

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

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

实验内容和步骤

实验1 测试以下程序，掌握文件输入输出程序设计技术（文件输入输出，教材61-62）。

import java.io.*;
import java.util.*;
public class FileWriteReadTest {
    public static void main(String[] args) throws IOException{
        //写入文件演示
        PrintWriter out = new PrintWriter("myfile.txt");
        out.println("姓名 高数 Java 数据结构 平均成绩 总成绩");
        out.println("张三 20 30 40 0 0");
        out.println("李四 50 60 70 0 0");
        out.close();//输出完毕，需要close
        //读入文件演示
        Scanner in = new Scanner(new File("myfile.txt"));//为myfile.txt这个File创建一个扫描器in
        int number = 1;//行号
        System.out.println(in.nextLine());
        while(in.hasNextLine()){//判断扫描器是否还有下一行未读取，该循环把文件的每一行都读出
            String line = in.nextLine();//读出myfile.txt的下一行
            System.out.print("第"+(++number)+"行的内容: ");
            Scanner linescanner = new Scanner(line);//行内容建立扫描器
            linescanner.useDelimiter(" ");//使用空格作为分隔符
            String name = linescanner.next();
            String math = linescanner.next();
            String java = linescanner.next();
            String ds = linescanner.next();
            String avg = linescanner.next();
            String total = linescanner.next();
            System.out.println("name="+name+"  math="+math+"  java="+java+"  ds="+ds+"  avg"+avg+"  total="+total);
        }
        in.close();//读入完毕，最后需要对其进行close。
    }
}

结果如下：

测试程序1：

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

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

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

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

姓名      性别 java成绩

代码如下：

import java.util.Scanner;
    public class StudentTest
    {
       @SuppressWarnings("resource")
    public static void main(String[] args)
       {
          Student[] staff = new Student[3];
          System.out.println("请输入学生的信息");

          Scanner in = new Scanner(System.in);
          for(int i=0;i<staff.length;i++) {
              staff[i]=new Student(in.next(),in.next(),in.nextInt());
          }
          System.out.println("name"+" "+"sex"+" "+"javascore");

          for (Student e : staff)
             System.out.println(e.getName() +"    "+e.getSex()+"          "+e.getJavaScore());
       }
    }

    class Student
    {
       private String name;
       private String sex;
       private int javascore;

       public Student(String n, String s, int j)
       {
          name = n;
          sex = s;
          javascore =j;
       }

       public String getName()
       {
          return name;
       }

       public String getSex()
       {
          return sex;
       }

       public int getJavaScore()
       {
          return javascore;
       }

    }

结果如下：

测试程序2：

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

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

3、理解Java单元（类）测试的技巧

/**
 * This program demonstrates static methods.
 * @version 1.01 2004-02-19
 * @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];

      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());
      }

      int n = Employee.getNextId(); // calls static method
      System.out.println("Next available id=" + n);
   }
}

class 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());
   }
}

结果如下：

测试程序3：

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

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

代码如下：

/**
 * This program demonstrates parameter passing in Java.
 * @version 1.00 2000-01-27
 * @author Cay Horstmann
 */
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);
      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);
      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);
      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;
   }
}

结果如下：

测试程序4：

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

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

import java.util.*;

/**
 * This program demonstrates object construction.
 * @version 1.01 2004-02-19
 * @author Cay Horstmann
 */
public class ConstructorTest
{
   public static void main(String[] args)
   {
      // fill the staff array with three Employee objects
      Employee[] 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)
         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 = 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);
   }

   // 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;
   }
}

结果如下：

测试程序5：

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

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

import com.horstmann.corejava.*;
// the Employee class is defined in that package

import static java.lang.System.*;

/**
 * This program demonstrates the use of packages.
 * @version 1.11 2004-02-19
 * @author Cay Horstmann
 */
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());
   }
}

结果如下：

实验3：编写长方形类Rectangle与圆形类Circle，其中Rectangle类设置私有属性：width,length；Circle类设置私有属性radius。编写Rectangle类的带参构造函数Rectangle(int width,int length), Circle类的带参构造函数Circle(int radius)，编写两个类的toString方法(Eclipse可自动生成)。上述2个类均定义以下方法：

求面积的方法public int getArea()

在main方法中完成以下任务：

（1） 输入1行长与宽，创建一个Rectangle对象；

（2） 输入1行半径，创建一个Circle对象；

将两个对象的周长加总输出，将两个对象的面积加总输出

import java.util.Scanner;
public class Rectangle {// 创建一个Rectangle类
    double width, length;
    static double A;
    double B;
    Rectangle(double x) { // 把两个变量初始化为相同传入值
        width = x;
        length = x;
        }
    Rectangle(double w, double len) { // 分别对两个变量初始化不同的值
    width = w;
    length= len;
        }
    public  double BRectangle() {
    B= (width + length) * 2;
    return B;}
    public  double ARectangle() {
        A= width * length;
    return A;}
public static void main(String[] args)
{ // 声明对象和创建对象double
    @SuppressWarnings("resource")
    Scanner sc = new Scanner(System.in);
    System.out.println("请输入矩形的w, len：");
    int w = sc.nextInt();
    int len = sc.nextInt();
double c,s;Rectangle
Rectangle1 = new Rectangle(5, 6);Rectangle
Rectangle2 = new Rectangle(8);
c= Rectangle1.BRectangle();
s= Rectangle2.ARectangle();
System.out.println("周长是："+ c);
System.out.println("面积是："+ s);
System.out.println("矩形与圆的周长和为："+c);

    }

    }
class  Perimeter{
         public static double getPerimeter(double width, double height) {
                return 2*(width + height);
         }

            public static double getPerimeter(int r) {
                return 2*3.14*r;
        }

 }

实验总结：本周我们学习了一部分对象和类的知识，这次实验大多以解读代码和在已有代码上仿照编写程序为主，锻炼了我们的解读代码能力，感觉在理论知识的基础上，还得动手多练习，才有可能真正掌握书里说的内容，总得来说，还是得私底下多学java，多实践，多学习。

原文地址：https://www.cnblogs.com/YRQY/p/9698918.html

时间： 2024-10-09 00:29:17

201771010135杨蓉庆《面向对象程序设计（java）》第四周学习总结的相关文章

《数据结构与面向对象程序设计》第四周学习总结

20182304 2019-2020-1 <数据结构与面向对象程序设计>第四周学习总结 教材学习内容总结 1.本章我们学习了使用并编写我们自己的类:类中有与类同名的构造方法,也可以有set,get,toSring与自己定义的方法.实例化一个对象,可通过该对象使用类里的所有方法.实例数据是每次创造一个实例后自动生成新的内存空间的变量 2.uml类图 :每个类可能包含三部分内容:类名.属性.操作(方法).UML类图有属于自己的语法,变量的类型名在变量名的后面,它们之间用冒号作为分隔符,方法的+和-

201771010135 杨蓉庆《面对对象程序设计（java）》第十八周学习总结

1.实验目的与要求 (1) 综合掌握java基本程序结构: (2) 综合掌握java面向对象程序设计特点: (3) 综合掌握java GUI 程序设计结构: (4) 综合掌握java多线程编程模型: (5) 综合编程练习. 2.实验内容和步骤 任务1:填写课程课后调查问卷,网址:https://www.wjx.cn/jq/33108969.aspx. 任务2:综合编程练习 练习1:设计一个用户信息采集程序,要求如下: (1) 用户信息输入界面如下图所示: 1)用户点击提交按钮时,用户输入信息显示

201771010135杨蓉庆《面向对象程序设计（java）》第二周学习总结

第一部分:理论知识学习部分 3.1 标识符:由字母.下划线.美元符号和数字组成, 且第一个符号不能为数字,可用作:类名.变量名.方法名.数组名.文件名等.有Hello.$1234.程序名.www_123等. (2)关键词:是java语言中已经被赋予特定意义的一些特定单词. 3.2 注释: Java有三种注释的方式: (1)  // 注释内容由//一直到此行结束. (2). /*和*/ 定义一个注释块. (3) /**开始,*/结束 这种注释方法可用来自动产生文档. 3.3 数据类型: Java是

201771010135杨蓉庆《面向对象程序设计（java）》第六周学习总结

实验六 继承定义与使用 1.实验目的与要求 (1) 理解继承的定义: (2) 掌握子类的定义要求 (3) 掌握多态性的概念及用法: (4) 掌握抽象类的定义及用途: (5) 掌握类中4个成员访问权限修饰符的用途: (6) 掌握抽象类的定义方法及用途: (7)掌握Object类的用途及常用API: (8) 掌握ArrayList类的定义方法及用法: (9) 掌握枚举类定义方法及用途. 一. 理论学习部分目的与要求 5.1 类.超类和子类 1.父类/子类是相对的: 2.继承:用已有类来构建新类的一种

201771010135杨蓉庆 《面对对象程序设计（java）》第九周学习总结

第7章 异常.日志.断言和调试 1.实验目的与要求 (1) 掌握java异常处理技术: (2) 了解断言的用法: (3) 了解日志的用途: (4) 掌握程序基础调试技巧: 一.理论知识 1.异常:在程序的执行过程中所发生的异常事件,它 中断指令的正常执行. 2.Java的异常处理机制可以控制程序从错误产生的 位置转移到能够进行错误处理的位置. 3.异常分类:Java把程序运行时可能遇到的错误分为两类: –非致命异常:通过某种修正后程序还能继续执行. 这类错误叫作异常.如:文件不存在.无效的数组

201771010135 杨蓉庆《面对对象程序设计（java）》第十周学习总结

1.实验目的与要求 (1) 理解泛型概念: (2) 掌握泛型类的定义与使用: (3) 掌握泛型方法的声明与使用: (4) 掌握泛型接口的定义与实现: (5)了解泛型程序设计,理解其用途. 一.理论知识 泛型类的定义: (1)泛型:也称参数化类型(parameterized type),就是在定义类.接口和方法时,通过类型参数指示将要处理的对象型. (2)一个泛型类(generic class)就是具有一个或多个类型变量的类,即创建用类型作为参数的类.如一个泛型类定义格式如下:class Gene

201771010135杨蓉庆 《面对对象程序设计（java）》第八周学习总结

1.实验目的与要求 (1) 掌握接口定义方法: (2) 掌握实现接口类的定义要求: (3) 掌握实现了接口类的使用要求: (4) 掌握程序回调设计模式: (5) 掌握Comparator接口用法: (6) 掌握对象浅层拷贝与深层拷贝方法: (7) 掌握Lambda表达式语法: (8) 了解内部类的用途及语法要求. 一.理论学习 6.1 接口:用interface声明,是抽象方法和常量值定义的集 合.从本质上讲,接口是一种特殊的抽象类. (1)在Java程序设计语言中,接口不是类,而是对类 的一组

201771010135 杨蓉庆《面对对象程序设计（java）》第十六周学习总结

1.实验目的与要求 (1) 掌握线程概念: (2) 掌握线程创建的两种技术: (3) 理解和掌握线程的优先级属性及调度方法: (4) 掌握线程同步的概念及实现技术: 一.理论知识 ? 线程的概念 (1)多线程是进程执行过程中产生的多条执行线索. ‐线程是比进程执行更小的单位. ‐线程不能独立存在,必须存在于进程中,同一进 程的各线程间共享进程空间的数据. ‐每个线程有它自身的产生.存在和消亡的过程, 是一个动态的概念. ‐多线程意味着一个程序的多行语句可以看上去几 乎在同一时间内同时运行. (2

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

教材学习内容总结 1.编写类与方法(构造方法的结构和用途) 2.实际参数与形式参数.public与private.return与void的区别与含义. 3.UML类图的含义与形式 4.静态类(Math类)静态变量.静态方法 5.类间关系(依赖关系.聚合关系.继承关系) 6.接口的使用,能够在某个类中实现接口的方法(Comparable.Iterator) 7.软件活动开发.方法设计.方法重载.测试(黑盒测试.白盒测试) 教材学习中的问题和解决过程 问题1:toString与return返回的值的