201871020225-牟星源《面向对象程序设计（java）》第6-7周学习总结

201871020225-牟星源《面向对象程序设计（java）》第6-7周学习总结

博文正文：

项目	内容
这个作业属于哪个课程	https://www.cnblogs.com/nwnu-daizh/
这个作业的要求在哪里	https://www.cnblogs.com/nwnu-daizh/p/11605051.html
作业学习目标	深入理解程序设计中算法与程序的关系； 深入理解java程序设计中类与对象的关系； 理解OO程序设计的第2个特征：继承、多态； 学会采用继承定义类设计程序（重点、难点）； 能够分析与设计至少包含3个自定义类的程序； 掌握利用父类定义子类的语法规则及对象使用要求。

随笔博文正文：

第一部分：总结第五章理论知识（30分）

1.  继承：用已有类来构建新类。子类不仅继承了父类的方法和域，还在子类中添加新的方法和域。

特点：具有层次结构；子类继承了父类的方法和域。

类继承格式：class 子类名  extends 父类名

父类（来自系统类库；用户自定义类）

需要注意的是：（1）在子类中可以增加域、方法或覆盖父类的方法，但不能删除父类的任何域和方法。

（2）一个子类可以有一个父类，但一个父类可以有多个子类，即Java不支持多继承。

2.多态性：泛指在程序中同一个符号在不同的情况下具有不同解释的现象。

（1）Java中，对象变量是多态的。

（2）继承层次结构中，每个子类对象也可看成父类对象，因此可以将子类对象赋给超类变量。

（3）不能把对超类的对象引用赋给子类对象变量。

3.抽象类：（abstract class Person）包含一个或多个抽象方法的类本身必须被声明为抽象类。

（1）除了抽象方法之外，抽象类还可以包含具体数据和具体方法。

（2）抽象方法具体实现在子类中。

（3）abstract方法不能被实例化，即只能声明，不能实现。

应当注意的是（1）扩展抽象类:一种是在子类中实现部分抽象方法，而子类也被标记为抽象类;

（2）另一种是实现全部抽象方法，这样子类就可以不是抽象类。此外，类即使不含抽象方法，也可以将类声明为抽象类。

4.阻止继承：final类和方法

（1）final类：不允许继承的类，在类的定义中用final修饰符加以说明。

（2）如果一个类声明为final,属于它的方法会被自动设为final. 但不包括域(如果域定义为final,在对象构造以后，final城就不能再修改了)

5.强制类型转换

（1）如果要把一个超类对象赋给一个子类对象变量，就必须进行强制类型转换，格式如下：子类  对象 = (子类) (父类对象)

Eg:Manager boss=（Manager）staff【0】；

（2）类型转换必须在继承层次内进行，且在父类转换为子类之前。应先使用instanceof操作符进行继承链检查（应该尽量少用类型转换和instanceof运算符）继承用extends关键字来实现.除构造方法之外。父奖的所有方法和属性都被子奖继承.，继承建立了类与类间的关系。同时也是多态特征的前提。

6.受保护访问：如果希望父类的某些方法或域允许被子类直接访问,就需要在父类定义时,将这些方法或域声明为producted。

7.object：所有类的超类 ：

　　（1）在java中,只有基本类型不是对象，其他类型（包括数组，枚举）都是对象，都扩展于超类
　 （2）Object类是Java中所有类的开始——每一个类都由它扩 展而来。在不给出超类的情况下，Java会自动把Object 作为要定义类的超类。 
   （3）可以使用类型为Object的变量指向任意类型的对象。但 要对它们进行专门的操作都要进行类型转换。
　（4）equals方法：定义子类的equals方法时，可调用超类的equals方法。 super.equals（otherObject）
　　（5）hashCode方法：Object类中的hashCode方法导出某个对象的散列 码。散列码是任意整数，表示对象的存储地址。 注：两个相等对象的散列码相等。

8.泛型数组列表：

　　（1）利用ArrayList类，课允许程序在运行时确定数组的大小。

注：ArrayList是一个采用类型参数的泛类型。

9.对象包装器与自动装箱：
　　（1）每个基本类型都有之对应的类(对象包装类)
　　（2）对象包装类不允许修改其中的值，同时也是final声明的
　　（3）使用包装器声明变量时，其==表示其是否指向同一个对象，因此
　　（4）两个对象包装器比较时调用equal方法
10.参数数量可变的方法
　　（1）java 使用持有者类型(IntHolder、BooleanHold等)
　　（2）可变参数 使用：public static double max(double... value)；实际上将若干参数绑定在数组中传递该max函数：public static void main(String... args)。
11.枚举类：
　　（1）实际上是一个类，包含若干个实例，因此两个枚举类型的值比较，直接使用 == ，永远不要调用equal。 
　　（2）所有的枚举类型都是Enum类的子类。所以他们继承了这个类的许多方法String toString() //返回枚举常量名
　　（3）static Enum valueOf（Class enumClass,String name）//返回指定名字给定类的枚举常量
　　（4）int ordinal() //返回在enum声明中枚举常量的索引 （从0 开始）
　　（5）int compareTo(E other) //在枚举中的顺序比较
12.反射：
　　（1）反射被大量用在javaBeans中。
　　（2）反射的作用：
　　   ①在运行中分析类的能力
　　   ②在运行在查看类的对象
　　   ③实现通过的数组操作代码
　　   ④利用Method对象。

第二部分：实验部分

1、实验目的与要求

(1) 理解继承的定义；

(2) 掌握子类的定义要求

(3) 掌握多态性的概念及用法；

(4) 掌握抽象类的定义及用途。

2、实验内容和步骤

实验1：测试程序1

在elipse IDE中编辑、调试、运行程序5-1 —5-3（教材152页-153页） ；

掌握子类的定义及用法；

结合程序运行结果，理解并总结OO风格程序构造特点，理解Employee和Manager类的关系子类的用途，并在代码中添加注释；

删除程序中Manager类、ManagerTest类，背录删除类的程序代码，在代码录入中理解父类与子类的关系和使用特点。

5.1代码

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代码

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代码

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

结果

实验1：测试程序2

编辑、编译、调试运行教材PersonTest程序（教材163页-165页)；

掌握超类的定义及其使用要求；

掌握利用超类扩展子类的要求；

在程序中相关代码处添加新知识的注释；

删除程序中Person类、PersonTest类，背录删除类的程序代码，在代码录入中理解抽象类与子类的关系和使用特点。

5.4代码

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代码

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代码

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代码

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;  //返回学生信息
   }
}

结果

实验1：测试程序3

编辑、编译、调试运行教材程序5-8、5-9、5-10，结合程序运行结果理解程序（教材174页-177页）；

掌握Object类的定义及用法；

在程序中相关代码处添加新知识的注释。

5.8代码

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代码

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代码

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：编程练习

代码

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

结果

2.  实验总结：

通过这两周的学习，基本掌握了Java中继承的用法和作用，理解继承的定义，通过这次实验，我学习到了子类的定义要求，掌握多态性的概念及用法，掌握抽象类的定义方法及用途，知道了枚举类定义方法及用途。通过继承内容在编程中的应用，代码的逻辑结构更清晰，对我们的算法设计思维也有所帮助，同时，在自己自主学习过程中依然有碰到困难，在日后的学习中平时会加强自主学习，努力解决在学习中遇到的问题，提高编程能力。