如果您想了解狄慧201771010104《面向对象程序设计的相关知识，那么本文是一篇不可错过的文章，我们将对java》第六周学习总结进行全面详尽的解释，并且为您提供关于#20175204张湲祯2018
如果您想了解狄慧201771010104《面向对象程序设计的相关知识，那么本文是一篇不可错过的文章，我们将对java》第六周学习总结进行全面详尽的解释，并且为您提供关于#20175204 张湲祯 2018-2019-2《Java程序设计》第六周学习总结、20165115 2017-2018-2 《Java程序设计》第六周学习总结、20165205 2017-2018-2 《Java程序设计》第六周学习总结、20165210 Java 第六周学习总结的有价值的信息。
本文目录一览：- 狄慧201771010104《面向对象程序设计（java）》第六周学习总结（面向对象程序设计java答案）
- #20175204 张湲祯 2018-2019-2《Java程序设计》第六周学习总结
- 20165115 2017-2018-2 《Java程序设计》第六周学习总结
- 20165205 2017-2018-2 《Java程序设计》第六周学习总结
- 20165210 Java 第六周学习总结
狄慧201771010104《面向对象程序设计（java）》第六周学习总结（面向对象程序设计java答案）
实验六继承定义与使用
实验时间 2018-9-28
1、知识点总结
1）继承：已有类来构建新类的一种机制。档定义了一个新类继承另一个类时，这个新类就继承了这个类的方法和域，同时在新类中添加新的方法和域以适应新的情况。
继承的特点：具有层次结构；子类继承了超类的方法和域。
2）类继承的格式：class 新类名 extends 已有类名
已有类称为：超类（superclass）、基类（base class） 或父类（parent class）
新类称作：子类（subclass）、派生类（derived class）或孩子类（child class）
1>继承类中，子类的构造器不能直接访问超类的私有域，必须调用超类构造器，且必须是第一条语句。
2>子类不能直接访问超类的私有域，必须和其他方法一样使用公有接口。
3>子类中可以增加域、增加方法或覆盖（override）超类的方法，但是绝不能删除超类的任何域和方法。
注：java不支持多继承。
3)多态性：泛指在程序中同一个符号在不同情况下具有不同解释。
超类方法在子类中可以重写。
java中，对象变量是多态的。
继承层次结构中，每个子类对象也可视作超类对象，因此，也可以将子类对象赋给超类变量。如：boss.setBouns(5000)；
4)final类：不允许继承的类，在类的定义中用final修饰符加以说明。
5)强制转换类型：如果要把一个超类对象赋给一个子类对象变量，就必须进行强制类型转换，格式如下：Manager boss=（Manager）staff【0】；
6)抽象类：abstract class Person
1>abstract方法不能被实例化，即只能声明，不能实现！
2>包含一个或多个抽象方法的类本身必须被声明为抽象类。
7)Object类：所有类的超类。
8)equals方法：用于测试某个对象是否和另一个对象相等。如果两个对象有相同的引用，则他们一定相等。
9)hasCode方法：导出某个对象的散列码（任意整数）。
两个相等对象的散列码相等。
10)toString方法：返回一个代表该对象域值的字符串。
格式：类名【域值】
11)枚举类：它包括一个关键字enum，一个新枚举类型的名字 Grade以及为Grade定义的一组值，这里的值既非整型，亦非字符型。
1>枚举类是一个类，它的隐含超类是java.lang.Enum。
2>枚举值并不是整数或其它类型，是被声明的枚举类的自身实例
2.实验目的与要求
(1) 理解继承的定义；
(2) 掌握子类的定义要求
(3) 掌握多态性的概念及用法；
(4) 掌握抽象类的定义及用途；
(5) 掌握类中4个成员访问权限修饰符的用途；
(6) 掌握抽象类的定义方法及用途；
(7)掌握Object类的用途及常用API；
(8) 掌握ArrayList类的定义方法及用法；
(9) 掌握枚举类定义方法及用途。
3.实验内容和步骤
实验1： 导入第5章示例程序，测试并进行代码注释。
测试程序1：
在elipse IDE中编辑、调试、运行程序5-1 （教材152页-153页） ；
掌握子类的定义及用法；
结合程序运行结果，理解并总结OO风格程序构造特点，理解Employee和Manager类的关系子类的用途，并在代码中添加注释。
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;//返回姓名
}
public double getSalary()//创建一个浮点型类得到薪水
{
return salary;//返回薪水
}
public LocalDate getHireDay()//创建一个当地时间类得到入职时间
{
return hireDay;//返回入职时间
}
public void raiseSalary(double byPercent)//创建一个空类加薪（浮点型加薪百分比）
{
double raise = salary * byPercent / 100;//加薪=薪水*加薪百分比/100
salary += raise;//薪水赋值为加薪+薪水
}
}package inheritance;
public class Manager extends Employee
{
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);//指代父类对象雇员（姓名、薪水、年月日）
bonus = 0;//补贴为0
}
public double getSalary()//创建类浮点型得到薪水
{
double baseSalary = super.getSalary();//浮点型基本薪水赋值为父类对象雇员得到的薪水
return baseSalary + bonus;//返回基本薪水+补贴
}
public void setBonus(double b)//创建一个空类补贴（浮点型b）
{
bonus = b;//补贴赋值为b
}
}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 boss = new Manager("Carl Cracker", 80000, 1987, 12, 15);//创建一个经理CC，工资、入职时间
boss.setBonus(5000);//老板的补贴5000
Employee[] staff = new Employee[3];//创建职员为3的数组
// fill the staff array with Manager and Employee objects（填写经理和雇员对象的职员数组）
staff[0] = boss;//将BOSS赋值给职员数组0
staff[1] = new Employee("Harry Hacker", 50000, 1989, 10, 1);//将HH雇员赋值给职员数组1
staff[2] = new Employee("Tommy Tester", 40000, 1990, 3, 15);//将TT雇员赋值给职员数组2
// print out information about all Employee objects//输出所有雇员对象的信息
for (Employee e : staff)//循环职员数组e
System.out.println("name=" + e.getName() + ",salary=" + e.getSalary());//输出姓名、薪水
}
}
测试程序2：
编辑、编译、调试运行教材PersonTest程序（教材163页-165页)；
掌握超类的定义及其使用要求；
掌握利用超类扩展子类的要求；
在程序中相关代码处添加新知识的注释。
package abstractClasses;
import java.time.*;
public class Employee extends 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);//工龄
}
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;
}
}package abstractClasses;
public abstract class Person
{
public abstract String getDescription();//
private String name;//创建私有类字符串姓名
public Person(String name)//创建人们类（字符串姓名）
{
this.name = name;//当前对象赋值
}
public String getName()//创建类得到姓名
{
return name;//返回姓名
}
}package abstractClasses;
public class Student extends Person
{
private String major;//主修、专业
/**
* @param nama the student''s name
* @param major the student''s major
*/
public Student(String name, String major)//类学生（姓名、专业）
{
// pass n to superclass constructor 途径是超类函数构造器
super(name);//父类对象人
this.major = major;//赋值专业
}
public String getDescription()
{
return "a student majoring in " + major;//返回，，，+专业
}
}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)//构造一个对象
{
Person[] 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");
// print out names and descriptions of all Person objects//输出所有人对象的姓名和描述
for (Person p : people)//循环此数组p
System.out.println(p.getName() + ", " + p.getDescription());//输出姓名，描述
}
}
测试程序3：
编辑、编译、调试运行教材程序5-8、5-9、5-10，结合程序运行结果理解程序（教材174页-177页）；
掌握Object类的定义及用法；
在程序中相关代码处添加新知识的注释。
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)//相同类（对象 其他对象）
{
// a quick test to see if the objects are identical（一个快速检测对象是否一样）
if (this == otherObject) return true;//如果此对象是其他对象，返回true
// must return false if the explicit parameter is null（如果明确的参数是空的，必须返回false）
if (otherObject == null) return false;//如果其他对象是空的，返回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 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
+ "]";
}
}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;//奖金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;//相等
// 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 + "]";
}
}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)//自变量为数组
{
Employee alice1 = new Employee("Alice Adams", 75000, 1987, 12, 15);//将雇员AA的值赋给雇员a1
Employee alice2 = alice1;//将a1赋值给雇员a2
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);//将经理CC赋值给经理car1
Manager boss = new Manager("Carl Cracker", 80000, 1987, 12, 15);
boss.setBonus(5000);//老板奖金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());
}
}
测试程序4：
在elipse IDE中调试运行程序5-11（教材182页），结合程序运行结果理解程序；
掌握ArrayList类的定义及用法；
在程序中相关代码处添加新知识的注释。
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;
}
}package arrayList;
import java.util.*;
/**
* This program demonstrates the ArrayList class.
* @version 1.11 2012-01-26
* @author Cay Horstmann
*/
public class ArrayListTest
{
public static void main(String[] args)
{
// fill the staff array list with three Employee objects（填全体员工的数组表用三个雇员对象）
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));
// raise everyone''s salary by 5%（增加每个人的薪水5%）
for (Employee e : staff)
e.raiseSalary(5);
// print out information about all Employee objects（输出关于所有雇员对象的信息）
for (Employee e : staff)
System.out.println("name=" + e.getName() + ",salary=" + e.getSalary() + ",hireDay="
+ e.getHireDay());
}
}
测试程序5：
编辑、编译、调试运行程序5-12（教材189页），结合运行结果理解程序；
掌握枚举类的定义及用法；
在程序中相关代码处添加新知识的注释。
package enums;
import java.util.*;
/**
* This program demonstrates enumerated types.
* @version 1.0 2004-05-24
* @author Cay Horstmann
*/
public class EnumTest
{
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);//号码 枚举
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方法放在哪个类中更合适？
输入样例:
3
rect
1 1
rect
2 2
cir
1
输出样例:
18.28
8.14
[Rectangle [width=1, length=1], Rectangle [width=2, length=2], Circle [radius=1]]
class Rectangle,class Shape
class Rectangle,class Shape
class Circle,class Shape
import java.util.Scanner;
public class Shap
{
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);
}
}
Shap c = new Shap();
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;
}
}public abstract class shape
{
double PI = 3.14;
public abstract double getPerimeter();
public abstract double getArea();
}public class Cir extends shape
{
private double radius;
public Cir(double radius2) {
// TODO Auto-generated constructor stub
}
public double getPerimeter()
{
double Perimeter=2*PI*radius;
return Perimeter;
}
public double getArea()
{
double Area=PI*radius*radius;
return Area;
}
}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;
}
}
实验3：编程练习2
编制一个程序，将身份证号.txt 中的信息读入到内存中，输入一个身份证号或姓名，查询显示查询对象的姓名、身份证号、年龄、性别和出生地。
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;
public class Test{
private static ArrayList<Person> personlist;
public static void main(String[] args) {
personlist = new ArrayList<>();
Scanner scanner = new Scanner(System.in);
File file = new File("E:/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 id = linescanner.next();
String sex = linescanner.next();
String age = linescanner.next();
String address =linescanner.nextLine();
Person person = new Person();
person.setName(name);
person.setId(id);
person.setSex(sex);
person.setAge(age);
person.setAddress(address);
personlist.add(person);
}
} 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 personname = scanner.next();
int nameint = findPersonByname(personname);
if (nameint != -1) {
System.out.println("查找信息为：身份证号:"
+ personlist.get(nameint).getId() + " 姓名:"
+ personlist.get(nameint).getName() +" 性别:"
+ personlist.get(nameint).getSex() +" 年龄:"
+ personlist.get(nameint).getAge()+" 地址:"
+ personlist.get(nameint).getAddress()
);
} else {
System.out.println("不存在该公民");
}
break;
case 2:
System.out.println("请输入身份证号");
String personid = scanner.next();
int idint = findPersonByid(personid);
if (idint != -1) {
System.out.println("查找信息为：身份证号:"
+ personlist.get(idint ).getId() + " 姓名:"
+ personlist.get(idint ).getName() +" 性别:"
+ personlist.get(idint ).getSex() +" 年龄:"
+ personlist.get(idint ).getAge()+" 地址:"
+ personlist.get(idint ).getAddress()
);
} else {
System.out.println("不存在该公民");
}
break;
case 3:
isTrue = false;
System.out.println("程序已退出!");
break;
default:
System.out.println("输入有误");
}
}
}
public static int findPersonByname(String name) {
int flag = -1;
int a[];
for (int i = 0; i < personlist.size(); i++) {
if (personlist.get(i).getName().equals(name)) {
flag= i;
}
}
return flag;
}
public static int findPersonByid(String id) {
int flag = -1;
for (int i = 0; i < personlist.size(); i++) {
if (personlist.get(i).getId().equals(id)) {
flag = i;
}
}
return flag;
}
}public class Person {
private String name;
private String id ;
private String sex ;
private String age;
private String address;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public String getSex() {
return sex ;
}
public void setSex(String sex ) {
this.sex =sex ;
}
public String getAge() {
return age;
}
public void setAge(String age ) {
this.age=age ;
}
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address=address ;
}
} 
四.实验总结
通过本周的学习，我初步掌握了有关继承类的知识，理解了父类和子类的定义，知道了继承指的是子类继承父类的方法和域，这能在编写时简化程序，在这个过程中常会用到关键字super。在完成最后两个实验时，我通过查书查资料，并仿照老师的源程序，写出了大概的程序，尤其是第二个程序，和之前的实验有相似之处。通过完成这次实验，我深深认识到，很多知识一定要看书，并多敲代码练习。而对于很多自己还不理解的知识，我也一定会加强学习，希望之后的实验中，遇到的问题能够越来越少。
#20175204 张湲祯 2018-2019-2《Java程序设计》第六周学习总结
#20175204 张湲祯 2018-2019-2《Java程序设计》第六周学习总结
##教材学习内容总结 ###-第七章内部类与异常类要点： 一.内部类： Java支持在一个类中定义另一个类，这样的类称作内部类，而包含内部类的类称为内部类的外嵌类。 二.内部类和外嵌类之间的重要关系如下： 1、内部类的外嵌类的成员变量在内部类中仍然有效，内部类中的方法也可以调用外嵌类中的方法。 2、内部类的类体中不可以声明类变量和类方法。外嵌类的类体中可以用内部类声明对象，作为外嵌类的成员。 3、内部类仅供它的外嵌类使用，其他类不可以用某个类的内部类声明对象。 三.匿名类： 创建子类对象时，除了允许使用父类的构造方法之外还有类体，此类体被认为是一个子类去掉类声明对后的类体，称作匿名类。匿名类就是一个子类，由于无名可用，所以不可能用匿名类声明对象，但却可以直接用匿名类创建一个对象。 四.匿名类有一下特点： 1、匿名类可以继承父类的方法也可以重写父类的方法。 2、使用匿名类时，必然是在某个类中直接使用匿名类创建对象，因此匿名类一定是内部类。 3、匿名类可以访问外嵌类中的成员变量和方法，匿名类的类体中不可以声明static成员变量和static方法。 4、由于匿名类是一个子类，但没有类名，所以在用匿名类创建对象时，要直接使用父类的构造方法。 五.异常类： java的异常可以出现在方法调试中，即在方法调用过程中抛出异常对象，导致程序运行出现异常，并且等待处理。java 使用Try-catch语句来处理异常，将可能出现的异常操作放在try部分，当try的某个方法发生一场之后，try部分将立即结束执行，转向相应的catch语句部分。
###第十章 输入/输出要点： 一.串流设计的概念： 1.Java将输入/输出抽象化为串流，数据有来源及目的地，衔接两者的是串流对象。 2.从应用程序角度来看，如果要将数据从来源取出，可以使用输入串流，如果要将数据写入目的地，可以使用输出串流。在Java中，输入串流代表对象为java.io.Inputstream实例，输出串流代表对象为java.io.OutputStream实例。 3.在不使用InputStream与utputStream时，必须使用close()方法关闭串流。由于InputStream与OutputStrem操作了java.io.Closeable接口，其父接口为java.lang.AutoCloseable接口。 二.串流继承架构： 标准输入/输出 1.System.in与System.out查看API文件的话，会发现它们分别是InputStream与PrintStream的实例，分别代表标准输入与标准输出。 2.可以使用System的setIn()方法指定InputStream实例，重新指定标准输入来源。标准输出可以重新导向至文档，只要执行程序时使用>将输出结果导向至指定文档。可以使用System的setOut()方法指定printStream实例，将结果输出至指定的目的地。 三.串流处理装饰器： InputStream、OutStream提供串流基本操作，如果想要为输入/输出的数据做加工处理，则可以使用打包器类。常用的打包器具备缓冲区作用的BufferedOutputStream、BufferedInputStream,具备数据转换处理的DataInputStream、DataOutputStream,具备对象串行化能力的ObjectInputStream、ObjectOutputStream等。 (1)BufferedInputStream与BufferedOutputStream BufferedInputStream与BufferedOutputStream主要在内部提供缓冲区功能，操作上与InputStream、OutputStream并没有太大区别。 (2)DataInputStream与DataOutputStream DataInputStream、DataOutputStream用来装饰InputStream、OutputStream,DataInputStream、DataOutputStream,提供读取、写入Java基本数据类型的方法，像是读写int、double、boolean等的方法。
##教材学习中的问题和解决过程： 1.问题: 在抛出异常中，throw和throws的区别。 解决方案：在网上通过搜索得知： 1.throws是用来声明一个方法可能抛出的所有异常信息 2.throw则是指抛出的一个具体的异常类型。 3.通常在一个方法（类）的声明处通过throws声明方法（类）可能抛出的异常信息，而在方法（类）内部通过throw声明一个具体的异常信息。 4.throws通常不用显示的捕获异常，可由系统自动将所有捕获的异常信息抛给上级方法。 5.throw则需要用户自己捕获相关的异常，而后在对其进行相关包装，最后在将包装后的异常信息抛出。
##-代码托管 （https://gitee.com/zyzgl/zyz）
##其他 学习了第七章第十章后，对于抛出异常，处理异常代码编写不能灵活运用，可能由于假期本周对Java学习时间没有上周多，对于一些基本概念没有理解，导致出现知识盲区，对于第十章输入输出流，只是对相关概念有了整体把握但也较难理解，还需要在下周用更多时间学习Java，对以前的知识漏洞和基础回看，熟悉。
20165115 2017-2018-2 《Java程序设计》第六周学习总结
20165115 2017-2018-2 《Java程序设计》第六周学习总结
教材学习内容总结
- 正则表达式的有关内容
- Scanner 类的方法调用
- 数字格式化与日期
- Class类、Console类、Pattern类
代码托管
上周考试错题总结
待补
其他（感悟、思考等，可选）
本周由于假期不在学校的原因，学习进度受到了一定的影响，本该完成的习题也没投完成。遗漏的内容将在以后补上。
学习进度条
| 代码行数（新增/累积） | 博客量（新增/累积） | 学习时间（新增/累积） | 重要成长 | |
|---|---|---|---|---|
| 目标 | 5000行 | 30篇 | 400小时 | |
| 第一周 | 200/200 | 2/2 | 20/20 | |
| 第二周 | 300/500 | 2/4 | 18/38 | |
| 第三周 | 500/1000 | 3/7 | 22/60 | |
| 第四周 | 300/1300 | 2/9 | 30/90 | |
| 第五周 | 300/1300 | 2/9 | 30/90 | |
| 第六周 | 1175/1300 | 1/9 | 20/90 |
参考：软件工程软件的估计为什么这么难，软件工程 估计方法
参考资料
-
Java学习笔记(第8版)
-
《Java学习笔记(第8版)》学习指导
-
...
20165205 2017-2018-2 《Java程序设计》第六周学习总结
20165205 2017-2018-2 《Java程序设计》第六周学习总结
教材学习内容总结
- String类
- String对象（常量，对象）
- 字符串并置（结果仍是常量）
- 常用方法
- length，equals，startsWith，compareTo，contains，contains，substring
- 字符串与基本数据类型相互转化
- 对象的字符串表示
- 正则表达式与字符串
- StringTokenizer类
- Scanner类
- StringBuffer类
- StringBuffer对象
- 常用方法
- append，charAt，serCharAt，insert，reverse，delete，replace
- Date类和Calendar类
- 日期格式化
- Math类，BigInteger类，Random类
- 数字格式化：format方法，格式化整数，格式化浮点数
- Class类与Console类
- Pattern类和Matcher类
- 泛型，链表，堆栈
- 映射（散列，树）
- 树集
教材学习中的问题和解决过程
- 问题1：在看到第一章的时候看到常量池和动态区，看课本的时候我还分的清这两个，但是单独看代码的时候还是会被迷惑，然后我就简单查了一下常量池和动态区的区分方法，但是查到了更深的东西，我就简单把我理解的东西总结了一下
- 问题1解决方法：1）常量池分为两种，静态常量池和运行时的常量池。静态常量池也就是Class文件中的常量池，运行时的常量池：运行时常量池是方法区的一部分。2）常量池的好处：节约内存空间，节省运行时间。
- 问题2：在学习键入数据时我们学到了两种方法，一种是使用Scanner in的方法，还有一种是Integer的方法，但是这两种方法我有时候会混淆，然后我也是自己做了一个总结，当然也查了资料。
- 问题2解决方案：
1.Java命令行参数：
1) 即main方法的参数String[] args；
2) 这里就只声明三点：
1) 命令行参数是从程序名称之后开始算的：java JavaApplication arg1 arg2 arg3 ...
2) args[0]是第一个参数arg1，而并非程序名JavaApplication；
3) 命令行参数是用空格作为分隔符的，如果参数本身是包含空格的，则该参数应该用双引号""引起来，避免其中的空格被当做参数分隔符！！
2.Scanner：
- 是一种基于正则表达式的文本扫描器，可以扫描文本中的字符串（模式）、数字等；
2) 它是一种高级处理流，可以包装文件、键盘输入流、字符串等，对这些节点中的文本流数据进行解析；
代码托管
##总结 本周的学习内容基本是学习了java库中的函数，知道了java库中有许多现成的，可以直接拿来用的函数，这些东西都非常有用，还学习了和c语言有些类似的链表，当然也学习了和c语言不同的映射，本周的错题还没有到截止时间，所以我还无法总结错题，下一篇博客中将会总结两周错题。
20165210 Java 第六周学习总结
20165210 Java 第六周学习总结
教材学习内容
-
第八章学习总结
- String 类：
- 构造 String 对象：
1. 常量对象
2. String对象
3. 引用String常量
- 字符串的并置：
String对象可以用“+”进行并置运算，即首尾相接得到一个新的String对象。例如，对于:
String you = "你"；
String you = "好"；
String testOne;
you和hi进行并置运算you+hi得到一个新的String对象，可以将这个新的String对象的引用赋值给一个String声明的对象，例如：
testOne=you+shi;
- String 类的常用方法：
1. public int length():
String china = "1945年抗战胜利"；
int n1,n2;
n1 = china.length();
n2 = "小鸟 fly".length();
2. public boolean equals(String s):
String tom = new String("天道酬勤")；
String boy = new String("知心朋友")；
String jerry = new String("天道酬勤")；
- StringTokenizer 类
StringTokenizer fenxi = new ("you are welcome");
StringTokenizer fenxi = new StringTokenizer("you#*are*##welcome", "#*");
- Scannner 类
1. Scanner对象：
Scanner对象可以解析字符序列中的单词，例如，对于String对象NBA：
String NBA = "I Love This Game";
为了解析出NBA的字符序列中的的单词，可以如下构造一个Scanner对象：
Scanner scanner = new Scanner（NBA）；
Scanner对象可以调用方法
- StringBuffer 类
- StringBuffer 对象
- StringBuffer 类的常用方法
- Date 类与 Calendar 类
- Date 类
1. 使用无参数构造方法
2. 使用带参数的构造方法
- Calendar 类
-
第十五章学习总结
- 泛型
- 泛型类声明
- 使用泛型类声明对象
- 链表
- LinkedList<E> 泛型类
- 常用方法
- 遍历链表
- 排序与查找
- 洗牌与旋转
- 堆栈 使用 java.util 包中的 Stack<E> 泛型类创建一个堆栈对象，堆栈对象可以使用：
public E push(E item);
实现压栈操作。使用
public E pop();
实践弹栈操作。使用
public boolean empty();
判断堆栈是否还有数据，有数据返回 false，否则返回 true。使用
public E peek();
获取堆栈顶端的数据，但不删除该数据。使用
public int search(Object data);
- 散列映射
- HashMap<K,V> 泛类型
- 常用方法
- 遍历散列映射
- 基于散列映射的查询
- 树集
- TreeSet<E> 泛型类
- 结点的大小关系
- TreeSet 类的常用方法
代码托管
感悟
由于在清明期间，所以这周的代码量比较多，主要是对 String 类和泛型的学习，感觉还是有所收获的。
今天的关于狄慧201771010104《面向对象程序设计和java》第六周学习总结的分享已经结束，谢谢您的关注，如果想了解更多关于#20175204 张湲祯 2018-2019-2《Java程序设计》第六周学习总结、20165115 2017-2018-2 《Java程序设计》第六周学习总结、20165205 2017-2018-2 《Java程序设计》第六周学习总结、20165210 Java 第六周学习总结的相关知识，请在本站进行查询。
本文标签：
![[转帖]Ubuntu 安装 Wine方法（ubuntu如何安装wine）](https://www.gvkun.com/zb_users/cache/thumbs/4c83df0e2303284d68480d1b1378581d-180-120-1.jpg)
