201871010115 马北 《面向对象程序设计（java)》 第6-7周学习总结

 

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

随笔博文正文内容包括：

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

一.继承：

　　用已有的类来构建新类的一种机制。当定义了一个新类继承了一个类时，这个类就继承了这个方法和域，同时在新类中添加新的方法和域以适应新情况。继承时Java程序设计中的一项核心技术，也是面向对象特征之一。

 　  继承的优点：具有层次结构。子类继承父类的域和方法。 代码可重用性。父类的域和方法课用于子类。可以轻松定义子类。设计应用程序变得更加简单。

二.类、超类和子类：

　　1.定义子类：关键字extends表明正在构造的新类派生于一个已存在的类，已存在的类称为超类、基类或父类；新类称为子类、派生类或孩子类。子类比父类拥有的功能更加丰富。

　　在通过扩展超类定义子类的时候，仅需要指出子类与超类的不同之处。在设计类的时候，将通用的方法放在超类中，将具有特殊用途的方法放在子类中。

　　2.覆盖方法：在子类中可以增加域，增加方法或覆盖超类的方法，但绝对不能删除继承的任何域和方法。

　　3.子类构造器：如果子类的构造器没有显式地调用超类的构造器，则将自动地调用超类默认地构造器，如果超类没有不带参数地构造器，并且在子类的构造器中又没有显式地调用超类地其他构造器，则Java编译器将报告错误。

 　　一个对象变量可以指示多种实际类型的现象被称为多态，在运行时能够自动地选择调用哪个方法地现象称为动态绑定。

 　　this :1.引用隐式传参 2.调用类其他构造器

        super:1.调用超类的方法 2.调用超类的构造器

　　使用super调用基类的方法

　　子类构造器会默认调用基类的无参构造来初始化基类的私有域，如果基类没有无参构造，则会报错

　　java中，不需要将方法声明为虚拟方法方法，基类指针指向不同对象时，虚拟指针知道指针指向的实际对象类型，所以能正确调用对应的方法，如果不希望让一个方法具有虚拟特征，可以标记为final

　　4.继承层次：继承并不仅限于一个层次，由一个公共超类派生出来的所有类的集合被称为继承层次，在继承层次中，从某个特定的类到其祖先的路径被称为该类的继承链。Java不支持多继承。

　　5.动态绑定、静态绑定和方法表：

　　编译器准确知道调用哪个方法的叫静态绑定(用private、static、final声明过的方法）

　　在运行时，调用方法依赖于实际类型并实现方法绑定(运行时可知)的叫动态绑定，虚拟机为基类和派生类生成一个方法表，虚拟机会在方法表中搜索最适合的方法进行调用。

　　动态绑定的优点就是：对程序进行拓展时，不需要重新对调用方法的代码进行重新编译，方法重写时，子类的方法的访问性不能低于基类方法。

　　6.阻止继承 final类  ：　

　　 final修饰的类不能被继承，final修饰的方法不能被覆盖，final修饰的域在构造方法内初始化，并且不能被改动。　　

　　被final修饰的类，其方法自动为final方法，但而不包括域。

　　动态绑定对系统开销很大，所以即时编译器会自动为没有被覆盖的类标记为内联函数，减少对系统的开销。

　　7.强制转换：

　　只能在继承层次内进行转换，将基类转换为子类之后，需判断是否转换成功 使用instanceof运算符检验。如果转换失败java不会生成一个空对象，而是抛出一个异常。

　　static_cast:基本数据类型转换。

　　const_cast:常量转化为非常量，或者反过来。

　　reinterpret_cast:任意类型转换而无须考虑安全和常量问题，不要轻易使用。

　　dynamic_cast:运行时转换，运行时要进行类型检查，存在继承关系之间（类中要有虚函数才能进行此转换,需检查类型信息，而类型信息保存在虚函数表中）。

　　8.抽象类与抽象方法
　　抽象类包含抽象方法也可以包含具体数据、具体方法。
　　类即时不含有抽象方法，也可以声明为抽象类。
　　抽象类不能被实例化。
　　9.受保护访问：
　　private:本类可见（也是c++初始化列表的原因，因为子类不可方位基类的private字段，需要调用基类的构造函数）
　　public:对所有类可见
　　protected:本包和所有子类可见（c++只对子类可见）
　　默认(无修饰符)：对本包可见

三.object：所有类的超类 ：

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

四.泛型数组列表：

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

        ArrayList是一个采用类型参数的泛类型。
五.对象包装器与自动装箱：
　　每个基本类型都有之对应的类(对象包装类)
　　对象包装类不允许修改其中的值，同时也是final声明的
　　使用包装器声明变量时，其==表示其是否指向同一个对象，因此
　　两个对象包装器比较时调用equal方法

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

第二部分：实验部分

1、实验目的与要求

(1) 理解继承的定义；

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

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

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

2、实验内容和步骤

实验1：测试程序1（10分）

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

 

　　程序运行结果如下：

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

 删除Manager类程序代码如下：

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 ;
   }
   @Override
   public  double  getSalary()
   {
      double  baseSalary =  super .getSalary();     //用关键字super调用超类Employee中的getsalary方法
      return  baseSalary + bonus;
   }

   public  void  setBonus( double  b)
   {
      bonus = b;
   }
}

　　删除ManagerTest类程序代码如下：

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

　　程序运行结果如下:

 

实验1：测试程序2（10分）

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

　　程序运行结果如下：

 

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

删除Person类程序代码如下：

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类中还保存着姓名和一个返回姓名的方法
   } //构造器
}

　删除PersonTest类程序代码如下：　

 

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());    // 输出对象的姓名和信息描述
   }
}

　　程序运行结果如下：

实验1：测试程序3（11分）

 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：编程练习（20分）

 程序代码如下：

 

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

 

　　程序运行结果如下：

 

3. 实验总结：（10分）

本次学习理解了Java程序设计中类与对象的关系，理解OO程序设计的特征：继承和多态，并学会采用继承定义类设计程序，掌握利用了父类定义子类的语法规则及对象使用要求。在完成实验过程中理解了继承的定义，掌握子类的定义要求，多态性的概念及用法，抽象类的定义及用途。通过自己动手敲代码让我更加深刻的理解了本章的知识。但本章知识比较多也比较重要，仍需要多多加强巩固，继续努力。