对于苏浪浪201771010120《面向对象程序设计感兴趣的读者，本文将提供您所需要的所有信息，我们将详细讲解java》第9周学习总结，并且为您提供关于#201652062017-2018-2《Jav
对于苏浪浪 201771010120 《面向对象程序设计感兴趣的读者，本文将提供您所需要的所有信息，我们将详细讲解java》第 9 周学习总结，并且为您提供关于# 20165206 2017-2018-2 《Java 程序设计》第 4 周学习总结、20165101 刘天野 2017-2018-2 《Java 程序设计》第 4 周学习总结、20165101 刘天野 2017-2018-2 《Java 程序设计》第 5 周学习总结、20165101 刘天野 2017-2018-2 《Java 程序设计》第 8 周学习总结的宝贵知识。
本文目录一览：- 苏浪浪 201771010120 《面向对象程序设计（java）》第 9 周学习总结（java面向对象程序设计苏守宝答案）
- # 20165206 2017-2018-2 《Java 程序设计》第 4 周学习总结
- 20165101 刘天野 2017-2018-2 《Java 程序设计》第 4 周学习总结
- 20165101 刘天野 2017-2018-2 《Java 程序设计》第 5 周学习总结
- 20165101 刘天野 2017-2018-2 《Java 程序设计》第 8 周学习总结
苏浪浪 201771010120 《面向对象程序设计（java）》第 9 周学习总结（java面向对象程序设计苏守宝答案）
实验九异常、断言与日志
实验时间 2018-10-25
1、实验目的与要求
(1) 掌握 java 异常处理技术；
(2) 了解断言的用法；
(3) 了解日志的用途；
(4) 掌握程序基础调试技巧；
2、实验内容和步骤
实验 1：用命令行与 IDE 两种环境下编辑调试运行源程序 ExceptionDemo1、ExceptionDemo2，结合程序运行结果理解程序，掌握未检查异常和已检查异常的区别。
| // 异常示例 1 public class ExceptionDemo1 { public static void main(String args[]) { int a = 0; System.out.println(5 / a); } } |
| // 异常示例 2 (找不到文件名) import java.io.*;
public class ExceptionDemo2 { public static void main(String args[]) { FileInputStream fis=new FileInputStream("text.txt");//JVM 自动生成异常对象 int b; while((b=fis.read())!=-1) { System.out.print(b); } fis.close(); } } |
package aaa;
public class 异常{
public static void main(String args[]) {
int a = 0;
if(a==0)
System.out.println("除数为0");
else
System.out.println(5 / a);
}
}更改后的异常 2
文件名找不到故此出现异常
//异常示例2(找不到文件名)package aaa;
import java.io.*;
public class b {
public static void main (String args []) throws IOException // 添加抛出申明
{
FileInputStream fis=new FileInputStream ("text.txt");//JVM 自动生成异常对象
int b;
while((b=fis.read())!=-1)
{
System.out.print(b);
}
fis.close();
}
}
实验 2： 导入以下示例程序，测试程序并进行代码注释。
测试程序 1：
l 在 elipse IDE 中编辑、编译、调试运行教材 281 页 7-1，结合程序运行结果理解程序；
l 在程序中相关代码处添加新知识的注释；
l 掌握 Throwable 类的堆栈跟踪方法；
package stackTrace;
import java.util.*;
/**
* A program that displays a trace feature of a recursive method call.
* @version 1.01 2004-05-10
* @author Cay Horstmann
*/
public class StackTraceTest
{
/**
* Computes the factorial of a number
* @param n a non-negative integer
* @return n! = 1 * 2 * . . . * n
*/
public static int factorial(int n)
{
System.out.println("factorial(" + n + "):");
Throwable t = new Throwable();//构造一个Throwable 对象
StackTraceElement[] frames = t.getStackTrace();//获得构造这个对象时调用的对战的跟踪
for (StackTraceElement f : frames)
System.out.println(f);
int r;
if (n <= 1) r = 1;
else r = n * factorial(n - 1);
System.out.println("return " + r);
return r;
}
public static void main(String[] args)
{
Scanner in = new Scanner(System.in);
System.out.print("Enter n: ");
int n = in.nextInt();
factorial(n);
}
} 
测试程序 2：
l Java 语言的异常处理有积极处理方法和消极处理两种方式；
l 下列两个简答程序范例给出了两种异常处理的代码格式。在 elipse IDE 中编辑、调试运行源程序 ExceptionalTest.java，将程序中的 text 文件更换为身份证号.txt，要求将文件内容读入内容，并在控制台显示；
l 掌握两种异常处理技术的特点。
| // 积极处理方式 import java.io.*;
class ExceptionTest { public static void main (string args[]) { try{ FileInputStream fis=new FileInputStream("text.txt"); } catch（FileNotFoundExcption e） { …… } …… } } |
| // 消极处理方式
import java.io.*; class ExceptionTest { public static void main (string args[]) throws FileNotFoundExcption { FileInputStream fis=new FileInputStream("text.txt"); } } |
异常 1
package aaa;
//积极处理方式
import java.io.*;
import java.io.BufferedReader;
import java.io.FileReader;
public class ExceptionTest {
public static void main (String args[])
{
File fis=new File("身份证号.txt");
try{
FileReader fr = new FileReader(fis);
BufferedReader br = new BufferedReader(fr);
try {
String s, s2 = new String();
while ((s = br.readLine()) != null) {
s2 += s + "\n ";
}
br.close(); System.out.println(s2);
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}异常 2
package aaa;
//消极处理方式
import java.io.*;
public class ExceptionTest {
public static void main (String args[]) throws IOException
{
File fis=new File("身份证号.txt");
FileReader fr = new FileReader(fis);
BufferedReader br = new BufferedReader(fr);
String s, s2 = new String();
while ((s = br.readLine()) != null) {
s2 += s + "\n ";
}
br.close();
System.out.println(s2);
}
}
实验 3: 编程练习
练习 1：
l 编制一个程序，将身份证号.txt 中的信息读入到内存中；
l 按姓名字典序输出人员信息；
l 查询最大年龄的人员信息；
l 查询最小年龄人员信息；
l 输入你的年龄，查询身份证号.txt 中年龄与你最近人的姓名、身份证号、年龄、性别和出生地；
l 查询人员中是否有你的同乡；
l 在以上程序适当位置加入异常捕获代码。
package aaa;
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.Arrays;
import java.util.Collections;
import java.util.Scanner;
public class b{
private static ArrayList<Student> studentlist;
public static void main(String[] args) {
studentlist = new ArrayList<>();
Scanner scanner = new Scanner(System.in);
File file = new File("身份证号.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 age = linescanner.next();
String province =linescanner.nextLine();
Student student = new Student();
student.setName(name);
student.setnumber(number);
student.setsex(sex);
int a = Integer.parseInt(age);
student.setage(a);
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("选择你的操作， ");
System.out.println("1.字典排序 ");
System.out.println("2.输出年龄最大和年龄最小的人 ");
System.out.println("3.寻找老乡 ");
System.out.println("4.寻找年龄相近的人 ");
System.out.println("5.退出 ");
String m = scanner.next();
switch (m) {
case "1":
Collections.sort(studentlist);
System.out.println(studentlist.toString());
break;
case "2":
int max=0,min=100;
int j,k1 = 0,k2=0;
for(int i=1;i<studentlist.size();i++)
{
j=studentlist.get(i).getage();
if(j>max)
{
max=j;
k1=i;
}
if(j<min)
{
min=j;
k2=i;
}
}
System.out.println("年龄最大："+studentlist.get(k1));
System.out.println("年龄最小："+studentlist.get(k2));
break;
case "3":
System.out.println("地址?");
String find = scanner.next();
String place=find.substring(0,3);
for (int i = 0; i <studentlist.size(); i++)
{
if(studentlist.get(i).getprovince().substring(1,4).equals(place))
System.out.println("老乡"+studentlist.get(i));
}
break;
case "4":
System.out.println("年龄：");
int yourage = scanner.nextInt();
int near=agenear(yourage);
int value=yourage-studentlist.get(near).getage();
System.out.println(""+studentlist.get(near));
break;
case "5 ":
isTrue = false;
System.out.println("退出程序!");
break;
default:
System.out.println("输入有误");
}
}
}
public static int agenear(int age) {
int j=0,min=53,value=0,ok=0;
for (int i = 0; i < studentlist.size(); i++)
{
value=studentlist.get(i).getage()-age;
if(value<0) value=-value;
if (value<min)
{
min=value;
ok=i;
}
}
return ok;
}
}package aaa;
public class Student implements Comparable<Student> {
private String name;
private String number ;
private String sex ;
private int age;
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 int getage() {
return age;
}
public void setage(int age) {
// int a = Integer.parseInt(age);
this.age= age;
}
public String getprovince() {
return province;
}
public void setprovince(String province) {
this.province=province ;
}
public int compareTo(Student o) {
return this.name.compareTo(o.getName());
}
public String toString() {
return name+"\t"+sex+"\t"+age+"\t"+number+"\t"+province+"\n";
}
}
注：以下实验课后完成
练习 2：
l 编写一个计算器类，可以完成加、减、乘、除的操作；
l 利用计算机类，设计一个小学生 100 以内数的四则运算练习程序，由计算机随机产生 10 道加减乘除练习题，学生输入答案，由程序检查答案是否正确，每道题正确计 10 分，错误不计分，10 道题测试结束后给出测试总分；
l 将程序中测试练习题及学生答题结果输出到文件，文件名为 test.txt；
l 在以上程序适当位置加入异常捕获代码。
1 package aaa;
2 import java.io.FileNotFoundException;
3 import java.io.PrintWriter;
4 import java.util.Scanner;
5
6
7 public class b {
8 public static void main(String[] args) {
9
10 Scanner in = new Scanner(System.in);
11 Student student=new Student();
12 PrintWriter out = null;
13 try {
14 out = new PrintWriter("text.txt");
15 } catch (FileNotFoundException e) {
16 e.printStackTrace();
17 }
18 int sum = 0;
19
20
21
22 for (int i = 1; i <=10; i++) {
23 int a = (int) Math.round(Math.random() * 100);
24 int b = (int) Math.round(Math.random() * 100);
25 int c= (int) Math.round(Math.random() * 3);
26
27
28 switch(c)
29 {
30 case 0:
31 System.out.println(i+": "+a+"/"+b+"=");
32
33 while(b==0)
34 {
35 b = (int) Math.round(Math.random() * 100);
36 }
37
38 int C = in.nextInt();
39 out.println(a+"/"+b+"="+C);
40 if (C == student.division(a, b)) {
41 sum += 10;
42 System.out.println("恭喜答案正确");
43 }
44 else {
45 System.out.println("抱歉，答案错误");
46 }
47
48 break;
49
50 case 1:
51 System.out.println(i+": "+a+"*"+b+"=");
52 int D = in.nextInt();
53 out.println(a+"*"+b+"="+D);
54 if (D == student.multiplication(a, b)) {
55 sum += 10;
56 System.out.println("恭喜答案正确");
57 }
58 else {
59 System.out.println("抱歉，答案错误");
60 }
61 break;
62 case 2:
63 System.out.println(i+": "+a+"+"+b+"=");
64 int E = in.nextInt();
65 out.println(a+"+"+b+"="+E);
66 if (E == student.add(a, b)) {
67 sum += 10;
68 System.out.println("恭喜答案正确");
69 }
70 else {
71 System.out.println("抱歉，答案错误");
72 }
73
74 break ;
75 case 3:
76 System.out.println(i+": "+a+"-"+b+"=");
77 int F = in.nextInt();
78 out.println(a+"-"+b+"="+F);
79 if (F == student.reduce(a, b)) {
80 sum += 10;
81 System.out.println("恭喜答案正确");
82 }
83 else {
84 System.out.println("抱歉，答案错误");
85 }
86 break ;
88 }
89 }
90 System.out.println("成绩"+sum);
91 out.println("成绩:"+sum);
92 out.close()；
93 }
94 }package aaa;
public class Student {
private int a;
private int b;
public int add(int a,int b)
{
return a+b;
}
public int reduce(int a,int b)
{
return a-b;
}
public int multiplication(int a,int b)
{
return a*b;
}
public int division(int a,int b)
{
if(b!=0)
return a/b;
else return 0;
}
}
实验 4：断言、日志、程序调试技巧验证实验。
实验程序 1：
| // 断言程序示例 public class AssertDemo { public static void main(String[] args) { test1(-5); test2(-3); }
private static void test1(int a){ assert a > 0; System.out.println(a); } private static void test2(int a){ assert a > 0 : "something goes wrong here, a cannot be less than 0"; System.out.println(a); } } |
l 在 elipse 下调试程序 AssertDemo，结合程序运行结果理解程序；
l 注释语句 test1 (-5); 后重新运行程序，结合程序运行结果理解程序；
l 掌握断言的使用特点及用法。
修改后
package duanyan;
public class AssertDemo {
public static void main(String[] args) {
// test1(-5);
test2(-3);
}
private static void test1(int a){
assert a > 0;
System.out.println(a);
}
private static void test2(int a){
assert a > 0 : "something goes wrong here, a cannot be less than 0";
System.out.println(a);
}
}
实验程序 2：
l 用 JDK 命令调试运行教材 298 页 - 300 页程序 7-2，结合程序运行结果理解程序；
l 并掌握 Java 日志系统的用途及用法。
实验程序 3：
l 用 JDK 命令调试运行教材 298 页 - 300 页程序 7-2，结合程序运行结果理解程序；
l 按课件 66-77 内容练习并掌握 Elipse 的常用调试技术。
实验总结：
在本周的学习中，掌握了 java 异常处理的一些基础技术；通过调试测试书上的示例程序，以及老师和助教学长的讲解下使我初步的理解了这一章的知识。课后的自主实验在学长帮助的基础上将其做出来，通过这周的学习初步的对于本章知识有了些许的理解。
# 20165206 2017-2018-2 《Java 程序设计》第 4 周学习总结
20165206 2017-2018-2 《Java 程序设计》第 4 周学习总结
教材学习内容总结
- 继承：继承是一种由已有的类创建新类的机制。
- 子类和父类：由继承得到的类称为子类，被继承的类称为父类。子类只能有一个父类。
- 方法重写：子类通过重写可以隐藏已继承的方法。在子类中定义一个方法，这个方法与父类的方法类型相同，子类可以将其修改为自身的状态和行为。重写时，不容许降低权限，但可以提供权限。
- super：使用关键字 super 来访问和调用被子类隐藏的成员变量和方法。
- final 类：final 类不能被继承，故不能有子类。如果用 final 修饰父类的一个方法，则该方法不能被子类重写。如果成员变量或局部变量被修饰成 final，则其为常量。
- 接口：用关键字 interface 来定义一个接口。接口由类来实现以便使用接口中的方法，用关键字 implements 声明来实现一个或多个接口。
教材学习中的问题和解决过程
问题 1：继承和接口在功能和定义上有很多相似之处，二者具体的区别有哪些？ 问题 1 解决方案：
- 一个类只能继承一个类，但是可以实现多个接口。
- 接口传达的意思是：can-do，拥有某种功能，能干嘛，比如：Serializable 代表可序列化的。
- 继承传达的是意思是：is-a，比如：猫 是一个 动物，猫就是动物的子类。
代码调试中的问题和解决过程
问题 1：在编译时出现这样的提示 
问题 1 解决方案：查阅后得知，程序本身并没有错误，只是方法部分过时，不影响运行。
代码托管
感悟：
这周上课考试时，发现有很多东西之前看的时候感觉还可以，但实际操作的时候就不会了。包括一些已经敲过的代码，这说明很多东西还是要在看过之后，实践操作几次才行，这样才能真正的由一些理解。差的还很多，要更加努力，加大学习和实践的时间了。
20165101 刘天野 2017-2018-2 《Java 程序设计》第 4 周学习总结
#20165101 刘天野 2017-2018-2 《Java 程序设计》第 4 周学习总结
教材学习内容总结
### 第五章：子类与继承
面向对象程序设计语言有三大特性：封装、继承和多态性。继承是面向对象语言的重要特征之一，没有继承的语言只能被称作 “使用对象的语言”。继承是非常简单而强大的设计思想，它提供了我们代码重用和程序组织的有力工具。
我们把用来做基础派生其它类的那个类叫做父类、超类或者基类，而派生出来的新类叫做子类。Java 用关键字 extends 表示这种继承 / 派生关系：
class ThisClass extends SuperClass {
//…
}
继承表达了一种 is-a 关系，就是说，子类的对象可以被看作是父类的对象。
不同访问属性的父类成员在子类中的访问属性：
| 父类成员访问属性 | 在父类中的含义 | 在子类中的含义 |
|---|---|---|
| public | 对所有人开放 | 对所有人开放 |
| protected | 只有包内其它类、自己和子类可以访问 | 只有包内其它类、自己和子类可以访问 |
| 缺省 | 只有包内其它类可以访问 | 如果子类与父类在同一个包内：只有包内其它类可以访问 否则：相当于 private，不能访问 |
| private | 只有自己可以访问 | 不能访问 |
#### 一、父类引用指向子类对象时
-
若子类覆盖了某方法，则父类引用调用子类重新定义的新方法
-
若子类未覆盖某方法，则父类引用调用父类本身的旧方法
-
若子类覆盖了某属性，但父类引用仍调用父类本身的旧属性
-
若子类未覆盖某属性，则父类引用调用父类本身的旧属性
-
父类引用不能访问子类新定义的方法
#### 二、子类引用指向自身对象时
-
若子类覆盖了某方法，则子类引用调用子类重新定义的新方法
-
若子类未覆盖某方法，则子类引用调用父类本身的旧方法
-
若子类覆盖了某属性，则子类引用调用子类重新定义的新属性
-
若子类未覆盖某属性，则子类引用调用父类本身的旧属性
-
子类引用可以访问子类新定义的方法
### 第六章：接口与实现
#### 接口的定义
使用 interface 来定义一个接口。接口定义同类的定义类似，也是分为接口的声明和接口体，其中接口体由常量定义和方法定义两部分组成。定义接口的基本格式如下：
[修饰符] interface 接口名 [extends 父接口名列表]{
[public] [static] [final] 常量；[public] [abstract] 方法；}
修饰符：可选，用于指定接口的访问权限，可选值为 public。如果省略则使用默认的访问权限。
接口名：必选参数，用于指定接口的名称，接口名必须是合法的 Java 标识符。一般情况下，要求首字母大写。
extends 父接口名列表：可选参数，用于指定要定义的接口继承于哪个父接口。当使用 extends 关键字时，父接口名为必选参数。
方法：接口中的方法只有定义而没有被实现。
#### 接口的实现
接口在定义后，就可以在类中实现该接口。在类中实现接口可以使用关键字 implements，其基本格式如下：
[修饰符] class < 类名 > [extends 父类名] [implements 接口列表]{ }
修饰符：可选参数，用于指定类的访问权限，可选值为 public、abstract 和 final。
类名：必选参数，用于指定类的名称，类名必须是合法的 Java 标识符。一般情况下，要求首字母大写。
extends 父类名：可选参数，用于指定要定义的类继承于哪个父类。当使用 extends 关键字时，父类名为必选参数。
implements 接口列表：可选参数，用于指定该类实现的是哪些接口。当使用 implements 关键字时，接口列表为必选参数。当接口列表中存在多个接口名时，各个接口名之间使用逗号分隔。
在类中实现接口时，方法的名字、返回值类型、参数的个数及类型必须与接口中的完全一致，并且必须实现接口中的所有方法。
代码托管
20165101 刘天野 2017-2018-2 《Java 程序设计》第 5 周学习总结
#20165101 刘天野 2017-2018-2 《Java 程序设计》第 5 周学习总结
教材学习内容总结
### 第七章：内部类与异常类
内部类（nested classes），面向对象程序设计中，可以在一个类的内部定义另一个类。嵌套类分为两种，即静态嵌套类和非静态嵌套类。静态嵌套类使用很少，最重要的是非静态嵌套类，也即是被称作为内部类 (inner)。内部类是 JAVA 语言的主要附加部分。内部类几乎可以处于一个类内部任何位置，可以与实例变量处于同一级，或处于方法之内，甚至是一个表达式的一部分。
匿名类是一种特殊的内部类，它是在一个表达式内部包含一个完整的类定义。
异常类是系统内置的一个类，异常跟错误都是语法错误。但是错误不能够运行，而异常可以运行，但是有异常的时候程序也不能正常运行，这个时候我们要 try 一下 ，捕获这个异常，catch 输出是什么异常，助于程序查错
### 第十章：输入、输出流
1：Java 语言定义了许多类专门负责各种方式的输入或者输出，这些类都被放在 java.io 包中。其中，所有输入流类都是抽象类 InputStream (字节输入流)，或者抽象类 Reader (字符输入流) 的子类；而所有输出流都是抽象类 OutputStream (字节输出流) 或者 Writer (字符输出流) 的子类。
2：InputStream 类是字节输入流的抽象类，是所有字节输入流的父类，InputStream 类具有层次结构如下图所示：
3：java 中的字符是 Unicode 编码的，是双字节的。InputStream 是用来处理字节的，在处理字符文本时很不方便。Java 为字符文本的输入提供了专门的一套类 Reader。Reader 类是字符输入流的抽象类，所有字符输入流的实现都是它的子类。
4: 输出流 OutputStream 类是字节输入流的抽象类，此抽象类表示输出字节流的所有类的超类。
5:Writer 类是字符输出流的抽象类，所有字符输出类的实现都是它的子类。
6：File 类是 IO 包中唯一代表磁盘文件本身的对象。通过 File 来创建，删除，重命名文件。File 类对象的主要作用就是用来获取文本本身的一些信息。如文本的所在的目录，文件的长度，读写权限等等。
代码托管
20165101 刘天野 2017-2018-2 《Java 程序设计》第 8 周学习总结
#20165101 刘天野 2017-2018-2 《Java 程序设计》第 8 周学习总结
## 教材学习内容总结 ### 第十二章 Java 多线程机制 #### 一、进程与线程
#####1.1、任务调动
大部分操作系统 (如 Windows、Linux) 的任务调度是采用时间片轮转的抢占式调度方式，也就是说一个任务执行一小段时间后强制暂停去执行下一个任务，每个任务轮流执行。
多任务运行过程的示意图如下：
#####1.2 进程 计算机的核心是 CPU，它承担了所有的计算任务；而操作系统是计算机的管理者，它负责任务的调度、资源的分配和管理，统领整个计算机硬件；应用程序侧是具有某种功能的程序，程序是运行于操作系统之上的。
进程是一个具有一定独立功能的程序在一个数据集上的一次动态执行的过程，是操作系统进行资源分配和调度的一个独立单位，是应用程序运行的载体。进程是一种抽象的概念，从来没有统一的标准定义。进程一般由程序、数据集合和进程控制块三部分组成。程序用于描述进程要完成的功能，是控制进程执行的指令集；数据集合是程序在执行时所需要的数据和工作区；程序控制块 (Program Control Block，简称 PCB)，包含进程的描述信息和控制信息，是进程存在的唯一标志。
进程具有的特征：
动态性：进程是程序的一次执行过程，是临时的，有生命期的，是动态产生，动态消亡的；
并发性：任何进程都可以同其他进程一起并发执行；
独立性：进程是系统进行资源分配和调度的一个独立单位；
结构性：进程由程序、数据和进程控制块三部分组成。
#####1.3 线程 在早期的操作系统中并没有线程的概念，进程是能拥有资源和独立运行的最小单位，也是程序执行的最小单位。任务调度采用的是时间片轮转的抢占式调度方式，而进程是任务调度的最小单位，每个进程有各自独立的一块内存，使得各个进程之间内存地址相互隔离。
后来，随着计算机的发展，对 CPU 的要求越来越高，进程之间的切换开销较大，已经无法满足越来越复杂的程序的要求了。于是就发明了线程，线程是程序执行中一个单一的顺序控制流程，是程序执行流的最小单元，是处理器调度和分派的基本单位。一个进程可以有一个或多个线程，各个线程之间共享程序的内存空间 (也就是所在进程的内存空间)。一个标准的线程由线程 ID、当前指令指针 (PC)、寄存器和堆栈组成。而进程由内存空间 (代码、数据、进程空间、打开的文件) 和一个或多个线程组成。
#####1.4 进程与线程的区别
1. 线程是程序执行的最小单位，而进程是操作系统分配资源的最小单位；
2. 一个进程由一个或多个线程组成，线程是一个进程中代码的不同执行路线；
3. 进程之间相互独立，但同一进程下的各个线程之间共享程序的内存空间 (包括代码段、数据集、堆等) 及一些进程级的资源 (如打开文件和信号)，某进程内的线程在其它进程不可见；
4. 调度和切换：线程上下文切换比进程上下文切换要快得多。
线程与进程关系的示意图：
进程与线程的资源共享关系
单线程与多线程的关系
#### 二、Java 中的线程
#####2.1 线程的概述
线程是一个程序的多个执行路径，执行调度的单位，依托于进程存在。 线程不仅可以共享进程的内存，而且还拥有一个属于自己的内存空间，这段内存空间也叫做线程栈，是在建立线程时由系统分配的，主要用来保存线程内部所使用的数据，如线程执行函数中所定义的变量。
注意：Java 中的多线程是一种抢占机制而不是分时机制。抢占机制指的是有多个线程处于可运行状态，但是只允许一个线程在运行，他们通过竞争的方式抢占 CPU。
#####2.2 线程的定义
定义一个线程（Defining a Thread）有两种方法
- 继承 java.lang.Thread 类
- 实现 java.lang.Runnable 接口
#####2.3 线程的启动
何一个线程的执行的前提都是必须有 Thread class 的实例存在，并且通过调用 run () 方法启动线程。
#####2.4 线程的状态
新生状态： 当一个线程的实例被创建即使用 new 关键字和 Thread 类或其子类创建一个线程对象后，此时该线程处于新生 (new) 状态，处于新生状态的线程有自己的内存空间，但该线程并没有运行，此时线程还不是活着的（not alive）；
就绪状态： 通过调用线程实例的 start () 方法来启动线程使线程进入就绪状态；处于就绪状态的线程已经具备了运行条件，但还没有被分配到 CPU 即不一定会被立即执行，此时处于线程就绪队列，等待系统为其分配 CPCU，等待状态并不是执行状态； 此时线程是活着的； 运行状态： 一旦获取 CPU (被 JVM 选中)，线程就进入运行 (running) 状态，线程的 run () 方法才开始被执行；在运行状态的线程执行自己的 run () 方法中的操作，直到调用其他的方法而终止、或者等待某种资源而阻塞、或者完成任务而死亡；如果在给定的时间片内没有执行结束，就会被系统给换下来回到线程的等待状态；此时线程是活着的； 阻塞状态：通过调用 join ()、sleep ()、wait () 或者资源被暂用使线程处于阻塞状态；处于 Blocking 状态的线程仍然是活着的
死亡状态：当一个线程的 run () 方法运行完毕或被中断或被异常退出，该线程到达死亡状态。此时可能仍然存在一个该 Thread 的实例对象，当该 Thready 已经不可能在被作为一个可被独立执行的线程对待了，线程的独立的 call stack 已经被 dissolved。一旦某一线程进入 Dead 状态，他就再也不能进入一个独立线程的生命周期了。对于一个处于 Dead 状态的线程调用 start () 方法，会出现一个运行期的异常；处于 Dead 状态的线程不是活着的。
代码托管
我们今天的关于苏浪浪 201771010120 《面向对象程序设计和java》第 9 周学习总结的分享就到这里，谢谢您的阅读，如果想了解更多关于# 20165206 2017-2018-2 《Java 程序设计》第 4 周学习总结、20165101 刘天野 2017-2018-2 《Java 程序设计》第 4 周学习总结、20165101 刘天野 2017-2018-2 《Java 程序设计》第 5 周学习总结、20165101 刘天野 2017-2018-2 《Java 程序设计》第 8 周学习总结的相关信息，可以在本站进行搜索。
本文标签：
![[转帖]Ubuntu 安装 Wine方法（ubuntu如何安装wine）](https://www.gvkun.com/zb_users/cache/thumbs/4c83df0e2303284d68480d1b1378581d-180-120-1.jpg)
