201771010102 常惠琢第6周学习指导及要求

最新推荐文章于 2024-08-18 21:36:31 发布

weixin_30390075

最新推荐文章于 2024-08-18 21:36:31 发布

阅读量157

点赞数

文章标签： java

原文链接：http://www.cnblogs.com/hongyanohongyan/p/9750456.html

版权

1、第五章

(1) 理解继承的定义；

继承：用已有类来构建新类的一种机制。当定义了一个新类继承了一个类时，这个新类就继承了这个类的方法和域，同时在新类中添加新的方法和域以适应新的情况。 

继承是Java程序设计中的一项核心技术,也是面向对象特征之一。

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

子类的构造器不能直接访问超类的私有域，必须调用超类构造器，而且必须是第一条语句。

子类不能直接访问超类的私有域，必须和其他方法一样——使用公有接口。

通过扩展超类定义子类时，仅需要指出子类与超类的不同之处。在子类中可以增加域、增加方法或覆盖（override）超类的方法，但绝对不能删除超类的任何域和方法。 

super是一个指示编译器调用超类方法的特有关键字，它不是一个对象的引用，不能将super赋给另一个对象变量。super关键字一般有两个用途：一是调用超类的方法（格式：super.方法名（）），二是调用超类的构造器(格式：super())。 

若子类构造器没有显式地调用超类的构造器，则将自动地调用超类默认构造器。如果超类只定义了带参数的构造器，若子类构造器没有显式地调用超类的构造器，则Java编译器将报告错误。

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

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

–超类中定义的域或方法，被子类继承之后，可以具有不同的数据类型或表现出不同的行为。

–这使得同一个域或方法在超类及其各个子类中具有不同的语义。

–超类中的方法在子类中可方法重写。

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

为了提高程序的清晰度，包含一个或多个抽象方法的类本身必须被声明为抽象类。除了抽象方法之外，抽象类还可以包含具体数据和具体方法。

抽象方法充当着占位的角色，它们的具体实现在子类中。扩展抽象类可以有两种选择：一种是在子类中实现部分抽象方法，这样就必须将子类也标记为抽象类；另一种是实现全部抽象方法，这样子类就可以不是抽象类。

此外，类即使不含抽象方法，也可以将类声明为抽象类。 •抽象类不能被实例化，即不能创建对象，只能产生子类。可以创建抽象类的对象变量，只是这个变量必须指向它的非抽象子类的对象。

(5) 掌握类中4个成员访问权限修饰符的用途；

使用访问修饰符的原因：实现受限信息隐藏。 

信息隐藏目的：

–对类中任何实现细节的更改不会影响使用该类的代码

–防止用户意外删除数据

–易于使用类

注：不写访问修饰符时默认为friendly

掌握枚举类定义方法及用途。

a.声明枚举类 publicenumGrade{A,B,C,D,E}; 

它包括一个关键字enum，一个新枚举类型的名字 Grade以及为Grade定义的一组值，这里的值既非整型，亦非字符型。

b.枚举类说明:

–枚举类是一个类，它的隐含超类是java.lang.Enum。

–枚举值并不是整数或其它类型，是被声明的枚举类的自身实例，例如A是Grade的一个实例。

–枚举类不能有public修饰的构造函数，构造函数都是隐含private，编译器自动处理。

–枚举值隐含都是由public、static、final修饰的，无须自己添加这些修饰符。

–在比较两个枚举类型的值时，永远不需要调用equals 方法，直接使用"=="进行相等比较。

类、超类和子类；

（1）已有类称为：超类（superclass）、基类（base class）或父类（parent class）

新类称作：子类（subclass）、派生类（derived class）或孩子类（child class）

（2）．super是一个指示编译器调用超类方法的特有关键字，它不是一个对象的引用，不能将super赋给另一个对象变量

注：Java不支持多继承。

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

（4）. 不允许继承的类称为final类，在类的定义中用final修饰符加以说明

（5）.抽象类：抽象方法充当着占位的角色，它们的具体实现在子类中。（抽象类不能被实例化，即不能创建对象，只能产生子类。）

Object：所有类的超类；

1. Object类是Java中所有类的始祖——每一个类都由它扩展而来。

2.可以使用类型为Object的变量指向任意类型的对象。但要对它们进行专门的操作都要进行类型转换。

3. Object类中的equals方法用于测试某个对象是否同另一个对象相等。

4. Object类中的hashCode方法导出某个对象的散列码。散列码是任意整数，表示对象的存储地址。

两个相等对象的散列码相等。

泛型数组列表；

1. Java中，利用ArrayList类，可允许程序在运行时确定数组的大小。.

2.ArryList是一个采用类型参数的泛型类。为指定数组列表保存元素的对象类型，需要用一对尖括号将数组元素对象类名括起来加在后面。

ArryList<Employee> staff=new ArrayList<Employee>();

对象包装器和自动打包；

1. 所有基本数据类型都有着与之对应的预定义类，它们被称为对象包装器。

2. 对象包装器类是不可变的，即一旦构造了包装器，就不允更改包装在其中的值。且对象包装器类还是final，因此不能定义它们的子类。

3. 在JavaSE5.0中，可以自动的将基本数据类型转换为包装器类的对象，将这种变换称为自动打包

参数数量可变的方法；

1 在Java SE 5.0以前的版本中，每个Java方法都有固定数量的参数。然而，现在的版本提供了可以用可变的参数数量调用的方法（称为“可变参 ”方法）。

2. 用户自己可以定义可变参数的方法，并将参数指定为任意类型，甚至是基本类型。

toString方法；

Object类的toString方法返回一个代表该对象域值的字符串。 

toString方法返回字符串的格式：类名，然后在方括号中列举域值。 

通过getClass().getName()获得类名的字符串。 toString的调用方式： 

一个字符串与对象名通过操作符“+”连接起来，就会自动调用toString方法。

String message = “The current employee is”+x; 

如果x是任意一个对象，调用System.out.println(x)，就会直接地调用x.toString()，并打印输出字符串。 

定义子类的toString方法时，可先调用超类的toString方法。 super.toString() toString方法是非常重要的调试工具。标准类库中，多数类定义了toString方法，以便用户获得对象状态的必要信息。

2、实验内容和步骤

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

测试程序1：

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

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

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

测试结果：

测试程序2：

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

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

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

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

测试结果：

测试程序3：

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

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

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

代码如下：

EqualsTest.java:

package equals;

/** *这个程序演示了等值方法 * @version 1.12 2018-10-7 * @author 常惠琢 */ //实现了Employee类和Manager类的equals、hashCode和toString方法 public class EqualsTest { public static void main(String[] args) { Employee alice1 = new Employee("Alice Adams", 75000, 1987, 12, 15); Employee alice2 = alice1; Employee alice3 = new Employee("Alice Adams", 75000, 1987, 12, 15); Employee 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);

Manager carl = new Manager("Carl Cracker", 80000, 1987, 12, 15); Manager 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()); } }

Employee.java:

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

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) { // 快速测试以查看对象是否相同 if (this == otherObject) return true;

// 如果explicit的参数为null，必须返回false if (otherObject == null) return false;

// 如果类不匹配，那么他们不能相等 if (getClass() != otherObject.getClass()) return false;

// 现在我们知道otherObject是一个非null的Employee类 Employee 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 + "]"; } }

Manager.java:

package equals;

public class Manager extends Employee { 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; Manager other = (Manager) otherObject; // Suff.Enter检查这个和其他属于同一个类。 return bonus == other.bonus; }

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

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

测试结果：

测试程序4：

Ÿ 在elipse IDE中调试运行程序5-11（教材182页），结合程序运行结果理解程序；

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

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

代码如下：

ArrayListTest.java:

package arrayList;

import java.util.*;

/** * 这个程序演示了ARAYLIST类 * @version 1.50 2018-10-7 * @author 常惠琢 */ public class ArrayListTest { public static void main(String[] args) { // 用三个雇员对象填充工作人员数组列表 ArrayList<Employee> staff = new ArrayList<>();

staff.add(new Employee("Carl Cracker", 75000, 1987, 12, 15)); staff.add(new Employee("Harry Hacker", 50000, 1989, 10, 1)); staff.add(new Employee("Tony Tester", 40000, 1990, 3, 15));

//把每个人的薪水提高5% for (Employee e : staff) e.raiseSalary(5);

// 打印所有员工对象的信息 for (Employee e : staff) System.out.println("name=" + e.getName() + ",salary=" + e.getSalary() + ",hireDay=" + e.getHireDay()); } }

Employee.java:

package arrayList;

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; } //访问器 public double getSalary() { return salary; } //访问器 public LocalDate getHireDay() { return hireDay; } //计算专职职工涨工资后的工资 public void raiseSalary(double byPercent) { double raise = salary * byPercent / 100; salary += raise; } }

测试结果：

测试程序5：

Ÿ 编辑、编译、调试运行程序5-12（教材189页），结合运行结果理解程序；

Ÿ 掌握枚举类的定义及用法；

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

代码如下：

package enums;

import java.util.*;

/** * 这个程序演示枚举类型。 * @version 2.30 2018-10-7 * @author 常惠琢 */ public class EnumTest { //所有枚举类型都是Enum的子类 public static void main(String[] args) { Scanner in = new Scanner(System.in); System.out.print("Enter a size: (SMALL, MEDIUM, LARGE, EXTRA_LARGE) "); String input = in.next().toUpperCase(); Size size = Enum.valueOf(Size.class, input); //将size设置成Size.input System.out.println("size=" + size); System.out.println("abbreviation=" + size.getAbbreviation()); if (size == Size.EXTRA_LARGE) //判断语句 System.out.println("Good job--you paid attention to the _."); } }

enum Size { SMALL("S"), MEDIUM("M"), LARGE("L"), EXTRA_LARGE("XL");

private Size(String abbreviation) { this.abbreviation = abbreviation; } public String getAbbreviation() { return abbreviation; }

private String abbreviation; }

测试结果：

实验2：编程练习1

Ÿ 定义抽象类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方法放在哪个类中更合适？

输入样例:

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

代码：

package Cin;

import Cin. Shape; class 圆形 extends Shape{

private double PI=3.14;

private int r;

public void 圆形(int r) {

this.r = r;

}

double getPerimeter(){

return 2 * PI * r;

}

double getArea(){

return r * r*PI;

}

package Cin;

import Cin. Shape;

class 长方形 extends Shape{

private int width;

private int length;

public 长方形(int width2, int length2) { // TODO Auto-generated constructor stub }

public void 长方形(int length, int width) {

this.width = width;

this.length = length;

}

double getPerimeter(){

return 2*(length+width);

} double getArea(){ return length*width; } }

package Cin;

import Cin.Shape;

abstract class Shape { //定义抽象父类Shape abstract double getPerimeter(); //定义求解周长的方法 abstract double getArea(); //定义求解面积的方法 }

class Rectangle extends Shape{ private int length; private int width; public Rectangle(int length, int width) { this.length = length; this.width = width; } //继承父类 double getPerimeter(){ //调用父类求周长的方法 return 2*(length+width); } double getArea(){ return length*width; //调用父类求面积的方法 } }

class Circle extends Shape{ private int radius; public Circle(int radius) { this.radius = radius; } double getPerimeter(){ return 2 * Math.PI * radius; } double getArea(){ return Math.PI * radius * radius; } }

package Cin; import Cin.Shape; import Cin.Test; import Cin.圆形; import Cin.长方形; import java.util.Scanner; public class Test { double PI=3.14;

public double AllArea(Shape score[])

{

double sum=0;

for(int i=0;i<score.length;i++)

sum+= score[i].getArea();

return sum;

}

public double AllPerimeter(Shape score[])

{

double sum=0;

for(int i=0;i<score.length;i++)

sum+= score[i].getPerimeter();

return sum;

}

public static void main(String[] args) {

Scanner in = new Scanner(System.in);

System.out.println("请输入创建图形的个数");

int a = in.nextInt();

System.out.println("请输入图形种类（选择输入cir或rect）");

String rect="rect";

String cir="cir";

Shape[] num=new Shape[a];

for(int i=0;i<a;i++){

String input=in.next();

if(input.equals(rect)) {

System.out.println("请输入长和宽");

int width = in.nextInt();

int length = in.nextInt();

num[i]=new 长方形(width,length);

System.out.println("长方形["+"长方形的长为:"+length+" 长方形的宽为:"+width+"]");

}

if(input.equals(cir)) {

System.out.println("输入所创建的圆的半径");

int r = in.nextInt();

num[i]=new 圆形();

System.out.println("圆["+"圆的半径为:"+r+"]");

}

Test c=new Test();

System.out.println("求所有图形的面积和：");

System.out.println(c.AllPerimeter(num));

System.out.println("求所有图形的周长和：");

System.out.println(c.AllArea(num));

for(Shape s:num) {

System.out.println(s.getClass()+","+s.getClass().getSuperclass()); } } }

测试结果：

实验3： 编程练习2

编制一个程序，将身份证号.txt 中的信息读入到内存中，输入一个身份证号或姓名，查询显示查询对象的姓名、身份证号、年龄、性别和出生地。

代码：

Student.java:

package Second;

public class Student {

private String name; private String number ; private String sex ; private String year; private String province; public String getName() { return name; } public void setName(String name) { this.name = name; } public String getnumber() { return number; } public void setnumber(String number) { this.number = number; } public String getsex() { return sex ; } public void setsex(String sex ) { this.sex =sex ; } public String getyaer() { return year; } public void setyear(String year ) { this.year=year ; } public String getprovince() { return province; } public void setprovince(String province) { this.province=province ; } }

IDnumber.java:

package Second; import java.io.BufferedReader; import java.io.File; import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.IOException; import java.io.InputStreamReader; import java.util.ArrayList; import java.util.Scanner; /** *这个程序为身份证信息查询 * @version 12：00 2018-10-7 * @author 常惠琢 */ public class IDnumber { private static ArrayList<Student> studentlist; public static void main(String[] args) { studentlist = new ArrayList<>(); Scanner scanner = new Scanner(System.in); File file = new File("F:\\\\java\\实验六\\身份证号.txt"); try { FileInputStream fis = new FileInputStream(file); BufferedReader in = new BufferedReader(new InputStreamReader(fis)); String temp = null; while ((temp = in.readLine()) != null) { Scanner linescanner = new Scanner(temp); linescanner.useDelimiter(" "); String name = linescanner.next(); String number = linescanner.next(); String sex = linescanner.next(); String year = linescanner.next(); String province =linescanner.nextLine(); Student student = new Student(); student.setName(name); student.setnumber(number); student.setsex(sex); student.setyear(year); student.setprovince(province); studentlist.add(student);

} } catch (FileNotFoundException e) { System.out.println("未找到学生信息文件"); e.printStackTrace(); } catch (IOException e) { System.out.println("读取学生信息文件错误"); e.printStackTrace(); } boolean isTrue = true; while (isTrue) {

System.out.println("1.用户姓名查询"); System.out.println("2.身份证号查询"); System.out.println("3.退出"); int nextInt = scanner.nextInt(); switch (nextInt) { case 1: System.out.println("请输入用户姓名"); String studentname = scanner.next(); int nameint = findStudentByname(studentname); if (nameint != -1) { System.out.println("查找信息为：身份证号:" + studentlist.get(nameint).getnumber() + " 姓名:" + studentlist.get(nameint).getName() +" 性别:" +studentlist.get(nameint).getsex() +" 年龄:" +studentlist.get(nameint).getyaer()+" 地址:" +studentlist.get(nameint).getprovince() ); } else { System.out.println("该学生不存在"); } break; case 2: System.out.println("请输入身份证号"); String studentid = scanner.next(); int idint = findStudentByid(studentid); if (idint != -1) { System.out.println("查找信息为：身份证号:" + studentlist.get(idint ).getnumber() + " 姓名:" + studentlist.get(idint ).getName() +" 性别:" +studentlist.get(idint ).getsex() +" 年龄:" +studentlist.get(idint ).getyaer()+" 地址:" +studentlist.get(idint ).getprovince() ); } else { System.out.println("该学生不存在"); } break; case 3: isTrue = false; System.out.println("程序已退出!"); break; default: System.out.println("输入有误"); } } }

public static int findStudentByname(String name) { int flag = -1; int a[]; for (int i = 0; i < studentlist.size(); i++) { if (studentlist.get(i).getName().equals(name)) { flag= i; } } return flag; }

public static int findStudentByid(String id) { int flag = -1;

for (int i = 0; i < studentlist.size(); i++) { if (studentlist.get(i).getnumber().equals(id)) { flag = i; } } return flag; } }

测试结果：

实验总结：

本次实验，理解了继承的定义，掌握了子类的定义要求、多态性的概念及用法和抽象类的定义及用途、Object类的用途及常用API、ArrayList类的定义方法及用法、以及toString方法、枚举类定义方法及用途。但有很多方面还不够理解，实验部分参考同学的代码以及网上查询完成。

转载于:https://www.cnblogs.com/hongyanohongyan/p/9750456.html

weixin_30390075

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
201771010102 常惠琢第6周学习指导及要求

1、第五章(1) 理解继承的定义；继承：用已有类来构建新类的一种机制。当定义了一个新类继承了一个类时，这个新类就继承了这个类的方法和域，同时在新类中添加新的方法和域以适应新的情况。 继承是Java程序设计中的一项核心技术,也是面向对象特征之一。(2) 掌握子类的定义要求子类的构造器不能直接访问超类的私有域，必须调用超类构造器，而且必须是第...
复制链接

扫一扫