201871020225-牟星源《面向对象程序设计（java）》第6-7周学习总结
201871020225-牟星源《面向对象程序设计（java）》第6-7周学习总结
博文正文：
项目
内容
这个作业属于哪个课程
https://www.cnblogs.com/nwnu-daizh/
这个作业的要求在哪里
https://www.cnblogs.com/nwnu-daizh/p/11605051.html
作业学习目标
随笔博文正文：
第一部分：总结第五章理论知识（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中继承的用法和作用，理解继承的定义，通过这次实验，我学习到了子类的定义要求，掌握多态性的概念及用法，掌握抽象类的定义方法及用途，知道了枚举类定义方法及用途。通过继承内容在编程中的应用，代码的逻辑结构更清晰，对我们的算法设计思维也有所帮助，同时，在自己自主学习过程中依然有碰到困难，在日后的学习中平时会加强自主学习，努力解决在学习中遇到的问题，提高编程能力。
手机扫一扫
移动阅读更方便
你可能感兴趣的文章