张兴盼-201871010131 《面向对象程序设计（java）》第六、七周学习总结

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

第一部分：理论知识部分

1.继承

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

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

2.类、超类和子类：

2.1.定义子类：关键字extends表明正在构造的新类派生于一个已存在的类，已存在的类称为超类、基类或父类；新类称为子类、派生类或孩子类。子类比父类拥有的功能更加丰富。在通过扩展超类定义子类的时候，仅需要指出子类与超类的不同之处。在设计类的时候，将通用的方法放在超类中，将具有特殊用途的方法放在子类中。

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

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

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

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

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

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

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

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

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

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

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

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

2.6.阻止继承 final类：　

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

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

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

2.7.强制转换：

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

　　static_cast:基本数据类型转换。

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

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

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

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

3.object：所有类的超类

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

4.泛型数组列表：

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

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

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

第二部分：实验部分

实验内容和步骤

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

5-1代码如下：

1	package inheritance;

<br data-filtered="filtered">/**

* 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 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; //调用方法的对象salary实例域设置为新值；

}

运行结果如下：

5-3代码如下：

1	package inheritance;

<br data-filtered="filtered">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)//创建Employee类的实例

{

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;

}

运行结果如下：

测试程序2：

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

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

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

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

5. 删除程序中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(); // 包含一个或多个抽象方法的类本身必须被声明为抽象的；

private String name;

public Person(String name)

{

this.name = name;

}

public String getName()

{

return name; //Person类中还保存着姓名和一个返回姓名的方法；

}

5-6代码如下：

package abstractClasses;

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

this.salary = salary;

hireDay = LocalDate.of(year, month, day); //根据参数设置日期，参数分别为年月日；

}

public double getSalary()

{

return salary; //返回salary属性的值；

}

public LocalDate getHireDay()

{

return hireDay; //返回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; //调用方法的对象salary实例域设置为新值；

}

5-7代码如下：

package abstractClasses;

public class Student extends 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.抽象类不能被实例化，即不能创建对象，只能产生子类。

测试程序3：

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

2.掌握Object类的定义及用法；

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

5-8示例程序：

5-8代码如下：

package equals;

/**

* 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); //初始化alice1

var alice2 = alice1; //将Alice1的值赋给alice2

var alice3 = new Employee("Alice Adams", 75000, 1987, 12, 15); //初始化alice3

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

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

}

public boolean equals(Object otherObject)

{

// a quick test to see if the objects are identical

if (this == otherObject) return true; //检测this与otherObject是否引用同一个对象；

// must return false if the explicit parameter is null

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

// if the classes don't match, they can't be equal

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

// now we know otherObject is a non-null Employee

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

// 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 //由继承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;

// super.equals checked that this and other belong to the same class

return bonus == other.bonus; //检查这个和其他是否属于同一个类；

}

public int hashCode()

{

return java.util.Objects.hash(super.hashCode(), bonus);

}

public String toString()

{

return super.toString() + "[bonus=" + bonus + "]";

}

运行结果如下：

实验2：编程练习

1.定义抽象类Shape：

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

3.方法：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方法放在哪个类中更合适？

输入样例:

rect

1 1

rect

2 2

cir

输出样例:

18.28

8.14

[Rectangle [width=1, length=1], Rectangle [width=2, length=2], Circle [radius=1]]

class Rectangle,class Shape

class Circle,class Shape

代码如下：

100

101

102

103

104

105

106

107

108

109

110

111

import java.util.Scanner;
public class Shape1 {
    public static double sumAllArea(double areaall)
    {
        return areaall;
    }
    public static double sumAllPerimeter(double perimeterall)
    {
        return perimeterall;
    }
  
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        sc.nextLine();
        Shape []xz = new Shape[n];
        double sumAllArea = 0, sumAllPerimeter = 0;
        for(int i = 0;i < n;i++)
        {
            String ss = sc.nextLine();
            if(ss.equals("rect"))
            {
                int a = sc.nextInt(),b = sc.nextInt();
                sc.nextLine();
                xz[i] = new Rectangle(a,b);
            }
            if(ss.equals("cir"))
            {
                int r = sc.nextInt();
                sc.nextLine();
                xz[i] = new Circle(r);
            }
            sumAllArea += xz[i].getArea();
            sumAllPerimeter += xz[i].getPerimeter();
        }
        System.out.println(sumAllPerimeter(sumAllPerimeter));
        System.out.println(sumAllArea(sumAllArea));
        System.out.print("[");
        for(int i = 0;i < n;i++)
        {
            if(i != 0)
                System.out.print(", ");
            System.out.print(xz[i].toString());
        }
        System.out.println("]");
        for(int i = 0;i < n;i++)
        {
            System.out.println(xz[i].getClass()+","+xz[i].getClass().getSuperclass());
        }
        sc.close();
    }
  
}
  
abstract class Shape {
    final double PI = 3.14;
    public abstract double getPerimeter();
    public abstract double getArea();
}
  
class Rectangle extends Shape {
    public int width;
    public int length;
     
    public Rectangle(int width, int length) {
        super();
        this.width = width;
        this.length = length;
    }
     
  
    @Override
    public String toString() {
        return "Rectangle [width=" + width + ", length=" + length + "]";
    }
  
  
    public double getPerimeter() {
        return 2*(width+length);
    }
  
    public double getArea() {
        return width*length;
    }
  
}
  
class Circle extends Shape {
    public int radius;
     
    public Circle(int radius) {
        super();
        this.radius = radius;
    }
     
  
    @Override
    public String toString() {
        return "Circle [radius=" + radius + "]";
    }
  
  
    public double getPerimeter() {
        return 2*PI*radius;
    }
  
    public double getArea() {
        return PI*radius*radius;
    }
  
}

运行结果如下：

3.实验总结

在本周的学习中，我学习到了什么是继承（新类继承了旧类的方法和域，并添加了新的方法和域）以及它的特点和优点，通过老师的讲解和课后的学习，大致了解了什么是类、子类、超类，父类与子类的部分用法，学会了如何定义抽象类，使用supper关键字等。在实验过程中也遇到了诸多困难，包括无法改正错误的程序，不能理解题目，最后一题程序编写困难等问题。在后期，我又通过请教同学，查阅资料等途径解决了这些问题。在Java这本课程的逐渐学习深入的过程中，我对这门课程的认识也越来越深。

posted @ 2019-10-07 21:39 201871010131-张兴盼阅读(241) 评论(1) 编辑收藏举报

名字忘了ia

张兴盼-201871010131 《面向对象程序设计（java）》第六、七周学习总结

公告