201871010114-李岩松《面向对象程序设计（java）》第六、七周学习总结

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

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

类、超类、子类：
关键字extends表死后继承
Java用关键字extends代替了C++里的冒号（在Java中，所有的继承都是公有继承，没有C++里的私有继承和保护继承。
子类方法不能直接访问超类的私有域，如果一定要访问，则需要使用公用的接口（例如：超类中又一个私有的name，子类想要访问，就需要使用超类公有的getname()方法）
super不是一个对象的引用，不能将super赋给另一个对象变量，它只是一个只是编译器访问超类方法的特殊关键字
super调用构造器的语句一定是子类构造器的第一条语句，如果子类没有显式的调用超类的构造器，则将自动的调用超类默认（没有参数）的构造器。如果超类没有不带参数的构造器，并且在子类的构造器中有没有显式的调用超类的其他构造器，则Java编译器将报告错误。
回忆一下：this关键字有两个作用：1.引用隐式参数，2.调用该类其他的构造器。super关键字也有两个作用：1.调用超类的方法，2.调用超类的构造器
(重要概念)一个对象变量（例如，变量e）可以指示多种实际类型的现象叫做多态（例如Employee对象引用可以存Employee也可以存Manager）。在运行时能够自动的选择调用哪个方法的现象成为动态绑定。
在Java中，不需要将方法声明为虚拟方法，动态绑定是默认的处理方式。如果不希望让一个方法具有虚拟特征，可以将它标记为final
Java不支持多继承，可以使用接口实现多继承。
所有数组都要牢记创建它们的元素类型，并负责监督仅将类型兼容的引用存储到数组中。（如果new Manager[10]，这个时候试图存储一个Employee的对象的引用就回引发ArrayStoreException异常）
理解方法调用：
编译器查看对象的声明类型和方法名
接下来，编译器将查看调用方法时提供的参数类型（如果没有找到或者经过类型转换后有多个签名与之匹配，就回报错）
如果是private、static、final 或者构造器，那么编译器将可以准确的知道应该调用哪个方法，我们将这种调用称为静态绑定
当程序运行时，并且采用动态绑定调用方法时，虚拟机一定调用与x所引用对象的实际类型最合适的哪个类的方法
override（重写=覆盖）、overload（重载）、polymorphism（多态）。注意static方法不能被重写，可以被重载，也可以继承。重写的概念是，参数列表、返回值、异常等等都要一样，才能叫做重写，否则是重载
希望阻止人们利用某个类定义子类，不允许扩展的类被称为final类。类中的特定方法也可以被声明为final。如果这样做，子类就不能覆盖这个方法（final类的所有方法自动编程final方法，但不包括域，这说明域还是可以改变的） - 这样做的意义是确保它们不回在子类中改变语义。
如果一个方法没有被覆盖并且很短，比那一起就能够对它进行优化处理，这个过程叫做==内联==，方法是否是内联方法由虚拟机来决定（虚拟机真强啊）
强制类型转换 - 进行类型转换的唯一原因是：在暂时护士对象的实际类型后，可以使用对象的全部功能，（例如manager对象用Employee e引用来存，那么e就不能调用Manager对象里的特定setbonus方法，只有强制类型转换为Manager的对象引用才行）
总结：
子类转超类（随便转）
超类转子类；需要强制类型转换，如果原来声明的不是这个子类的对象类型，还会报错（ClassCastException）。建议强制转换前使用instanceof判断
抽象类：
含有抽象方法的类一定是抽象类
抽象类也可以包含具体的方法（getter/setter等）
抽象类的子类也可以是抽象类，但如果子类不设置为抽象类，则应实现超类里的所有抽象方法
抽象类不能被实例化
下面归纳一下Java中用于控制可见性的4个访问修饰符：
仅对本类可见（private）、
对所有类可见（public）
对本包和所有子类可见（protected）
对本包可见（如果子类和父类是在同一个包里，则子类能够访问，否则不行）（默认，不需要修饰符,default可以不写）
Object：所有类的超类
可以使用Object类型的变量引用任何类型的对象
在Java中，只有基本类型（int、double、long…）不是对象。所有的数组类型，不管是对象数组还是基本类型的数组都扩展类Object类，即数组是对象
equals：Object类中的equals方法用于检测一个对象是否等于另外一个对象。这个方法将判断两个对象是否具有相同的引用.(对于String对象来说，equals比较的是字符串的内容是否相等，而‘= =’判断的是字符串引用的是不是同一个对象)
完美的equals方法的建议：
显式参数命名为otherObject，稍后需要将它转换称另一个叫做other的变量
检测this与otherObject是否引用同一个对象
检测otherObject是否为null，如果为null，返回false
比较this与otherObject是否属于同一个类
对所有需要比较的域进行比较。使用==比较基本类型域，equals比较对象域
hashCode:
散列码是由对象导出的一个整型值，两个不同的对象，其散列码基本不会相同
其值为对象的存储地址（String对象的hashCode不是存储地址，而是重写过的计算散列码的方法，因为java中相同内容字符串放在字符串池里）
最好使用null安全的方法：Objects.hashCode()
equals和hashCode方法必需一致
数组类型的域，用Arrays.hasCode获得散列码
toString:
Object定义里toString，用来打印对象所属类和散列码
强烈建议为每一个自定义类重写一个toString方法，用于调试
泛型数组列表
ArrayList（数组列表） ----> 数组的替代品，需要导入额外的包
java SE5.0之前不提供泛型类
set()：设置指定位置元素值，传入下标和值
get()：获得指定位置元素值，传入下标
add()：插入元素
remove()：删除一个元素，传入下标
对象包装器与自动拆装箱
基本类型都对应一个包装类
装箱和拆箱是编译器认可的，而不是虚拟机。编译器在生成类的字节码时，插入必要的方法调用。虚拟机只是执行这些字节码。
inValue() - 返回Integer对象的int值
toString(int i) - 数字类型转字符串（10进制）
toString(int i, int radix) - 返回数字基于radix进制的表示(原来是10进制的，例如toString(6, 2)返回110)
parseint(String s) - 字符串转数字（10进制）
parseint(String s, int radix) - 返回radix进制的String，的10进制表示，例如parseInt(“110”, 2) 返回6
valueOf(String s) - 同parseInt, 不过返回Integer对象
valueOf(String s, int radix) - 同parseInt，不过返回Integer对象
总结：toString方法传入的数字原来是10进制的，可以转10进制和其他进制的字符串。parseInt方法传入的字符串原来是10进制或者其他进制的，转为10进制。valueOf与parseInt相同，只是返回的是Integer对象，而parseInt返回int数字
参数可变的方法
传参的时候使用…
Main方法可以写成：public static void main(String… args) 与传数组没有区别
枚举类：了解就行。（P188）
继承设计技巧
将公共操作和域放在超类
不要使用受保护的域（pritected）
使用继承实现“is-a”关系
除非所有的继承的方法都有意义，否则不要使用继承
在覆盖方法时，不要改变预期的行为
使用多态，而非类型信息
不要过多的使用反射

第二部分：实验部分

1、实验目的与要求

(1) 理解继承的定义；

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

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

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

2、实验内容和步骤

实验1： 导入第5章示例程序，测试并进行代码注释。

测试程序1：

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

Ÿ   掌握子类的定义及用法；

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

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

5-1

package week6;

/**
 * This program demonstrates inheritance.
 * @version 1.21 2004-02-21
 * @author Cay Horstmann
 */
public class ManagerTest
{
   public static void main(String[] args)
   {
      // 构造管理器对象
      var boss = new Manager("Carl Cracker", 80000, 1987, 12, 15);
      boss.setBonus(5000);//根据boss.setBonus设置经理的津贴，其中setBonus是Manager的特有方法

      var staff = new Employee[3];///定义一个包含三个雇员的数组；

      //用manager和employee对象填充staff数组

      staff[0] = boss;
      staff[1] = new Employee("Harry Hacker", 50000, 1989, 10, 1);
      staff[2] = new Employee("Tommy Tester", 40000, 1990, 3, 15);

      // 用for循环遍历的方法打印有关所有员工对象的信息
      for (Employee e : staff)
         System.out.println("name=" + e.getName() + ",salary=" + e.getSalary());
   }
}　

　5-2

package week6;

import java.time.*;

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

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

　　5-3

package week6;

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);//用super实现对超类构造器的调用
      bonus = 0;
   }

   public double getSalary()
   {
      double baseSalary = super.getSalary();
      return baseSalary + bonus;
   }

   public void setBonus(double b)//用super调用超类的方法
   {
      bonus = b;
   }
}

5-1，5-2，5-3运行结果：

测试程序2：

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

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

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

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

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

5-4

package week6;

/**
 * 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];//创建一个 数组，数组包含两个雇员

      // 用student和employee对象填充people数组
      people[0] = new Employee("Harry Hacker", 50000, 1989, 10, 1);
      people[1] = new Student("Maria Morris", "computer science");

      // 打印所有Person对象的名称和描述
      for (Person p : people)
         System.out.println(p.getName() + ", " + p.getDescription());
   }
}

　5-5

package week6;

public abstract class Person//创建一个抽象类
{
   public abstract String getDescription();
   private String name;

   public Person(String name)
   {
      this.name = name;
   }

   public String getName()
   {
      return name;
   }//person类中还保存着姓名和一个返回姓名的方法
}

5-6

package week6;

import java.time.*;

public class Employee extends Person//继承Person类来定义Employee类的格式，关键字extend表示继承
{
   private double salary;
   private LocalDate hireDay;

   public Employee(String name, double salary, int year, int month, int day)
   {
      super(name);//super关键字继承父类的方法
      this.salary = salary;
      hireDay = LocalDate.of(year, month, day);//hireDay使用localData方法
   }

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

public class Student extends Person//studen类继承person类
{
   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;
   }
}

运行结果

抽象类的特点：

A：抽象类和抽象方法必须用abstract关键字修饰

B：抽象类中不一定有抽象方法，但是有抽象方法的类必须定位为抽象类

C：抽象类不能实例化
因为他不是具体的，抽象类也有构造方法，但是不能实例化，那么构造方法的作用是什么呢？
用于子类访问父类数据的初始化。

D：抽象类的子类问题
a:如果不想重写抽象方法，该子类是一个抽象类
b:重写所有的抽象方法，这个时候子类是一个具体的类。

E：抽象类的实例化其实是靠具体的子类来实现的，是使用多态的方式

测试程序3：

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

Ÿ   掌握Object类的定义及用法；

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

5-8

package week6;

/**
 * This program demonstrates the equals method.
 * @version 1.12 2012-01-26
 * @author Cay Horstmann
 */
public class EqualsTest//实现Employee类和Manager类的equals，hashCode方法
{
   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());  //在这里实现Employee类和Manager类的hashCode方法
      System.out.println("carl.hashCode(): " + carl.hashCode());
   }
}

5-9

package week6;

import java.time.*;
import java.util.Objects;

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

   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)
   {
     //检测this与otherObject是否引用同一个对象；
      if (this == otherObject) return true;

    //检测otherObject是否为null，如果为null返回false;
      if (otherObject == null) return false;

      //getClass方法将返回一个对象所属的类；
      if (getClass() != otherObject.getClass()) return false;

      //知道otherObject是一个非空的Employee；
      var other = (Employee) otherObject;

      // 测试字段是否具有相同的值；
      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 week6;

public class Manager extends Employee//Employee类来定义Manager类的格式，关键字extend表示继承
{
   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;
      ////检查这个和其他是否属于同一个类；
      return bonus == other.bonus;
   }

   public int hashCode()
   {
      return java.util.Objects.hash(super.hashCode(), bonus);
   }

   public String toString()
   {
      return super.toString() + "[bonus=" + bonus + "]";
   }
}

运行结果:

实验2：编程练习

Ÿ   定义抽象类Shape：

属性：不可变常量double PI，值为3.14；

方法：public double getPerimeter()；public double getArea())。

Ÿ   让Rectangle与Circle继承自Shape类。

Ÿ   编写double sumAllArea方法输出形状数组中的面积和和double sumAllPerimeter方法输出形状数组中的周长和。

Ÿ   main方法中

1）输入整型值n，然后建立n个不同的形状。如果输入rect，则再输入长和宽。如果输入cir，则再输入半径。
2） 然后输出所有的形状的周长之和，面积之和。并将所有的形状信息以样例的格式输出。
3） 最后输出每个形状的类型与父类型，使用类似shape.getClass()(获得类型)，shape.getClass().getSuperclass()(获得父类型);

思考sumAllArea和sumAllPerimeter方法放在哪个类中更合适？

import java.util.Scanner;

public class Work
{

    public static void main(String[] args)
    {
        Scanner in = new Scanner(System.in);
        String rect = "rect";
        String cir = "cir";
        System.out.print("请输入所需图形的形状个数:");
        int n = in.nextInt();
        shape[] count = new shape[n];
        for(int i=0;i<n;i++)
        {
            System.out.println("请输入图形形状：");
            String input = in.next();
            if(input.equals(rect))
            {
                double length = in.nextDouble();
                double width = in.nextDouble();
                System.out.println("长方形："+"长:"+length+"  宽:"+width);
                count[i] = new Rect(length,width);
            }
            if(input.equals(cir))
            {
                double radius = in.nextDouble();
                System.out.println("圆："+"半径:"+radius);
                count[i] = new Cir(radius);
            }
        }
        Work c = new Work();
        System.out.println(c.sumAllPerimeter(count));
        System.out.println(c.sumAllArea(count));
        for(shape s:count)
        {

            System.out.println(s.getClass()+",  "+s.getClass().getSuperclass());
        }
    }
public double sumAllArea(shape count[])
    {
         double sum = 0;
         for(int i = 0;i<count.length;i++)
             sum+= count[i].getArea();
         return sum;
    }

    public double sumAllPerimeter(shape count[])
    {
         double sum = 0;
         for(int i = 0;i<count.length;i++)
             sum+= count[i].getPerimeter();
         return sum;
    }

}

1 public abstract class shape
2  {
3      double PI = 3.14;
4      public abstract double  getPerimeter();
5      public abstract double  getArea();
6  }

public class Rect extends shape
{
    private double width;
    private double length;
    public Rect(double w,double l)
    {
        this.width = w;
        this.length = l;
    }
    public double getPerimeter()
    {
        double Perimeter = 2*(length+width);
        return Perimeter;
    }
    public double getArea()
    {
        double Area = length*width;
        return Area;
    }
}
 1 public class Cir extends shape
 2 {
 3     private double radius;
 4
 5     public Cir(double radius2) {
 6         // TODO Auto-generated constructor stub
 7     }
 8     public double getPerimeter()
 9     {
10         double Perimeter=2*PI*radius;
11         return Perimeter;
12     }
13     public double getArea()
14     {
15         double Area=PI*radius*radius;
16         return Area;
17     }
18 }

输出结果：

实验总结：

在本周的学习中，我学会了面向对象的特征之一继承的相关知识。在后面的两个实验中，我了解了在父类下定义子类的方法程序以及其中的注意点，比如子类会继承父类的所有方法和域，我体会到继承的优点，它可以轻松定义子类，使得设计应用程序更加简单。前面的实验要求进行注解，通过这种方式，感觉读代码理解更深，以后应该加强学习。