Java程序设计笔记

 chapter1 1.1 Java历史和发展

Java:1990 SUN“Green”--开发家用电器软件 94年Oka语言（橡树语言）95年名Java语言SUN并发布第一版编译器JDK1.0(SUN:Stanford University Network),其发明者James Gosling ，官网：Java.sun.com，后被oracle公司收购

Java三大平台：

Java SE标准版(J2SE,Java 2 Platform Standard Edition)桌面应用

Java EE企业版(J2EE,Java 2 Platform Enterprise Edition)网络/web应用

Java ME微型版(J2ME,Java 2 Platform Micro Edition)手机应用

开发工具包JDK(Java Development Kit)

主要改进：

 What is Java:编程语言：面向对象编程（OOP）语法结构与c/c++相似，语法简单

特点：简单，面向对象，平台无关性，安全稳定，支持多线程，提供大量的库（语言包package,实用程序包，I/O包，网络包，图形用户界面包etc）

What  can Java do:面向对象的应用开发，网络应用程序开发，计算过程的可视化，动态画面/交互操作，Internet系统管理，数据库操作etc

Java是C++--:

无直接指针操作，自动内存管理，数据类型长度固定，不用头文件，不包含结构和联合，不支持宏，不用多重继承，无类外全局变量，无goto

Java三大核心机制：

Java虚拟机（Java Virtual Machine）

代码安全性检测（Code Security）

垃圾收集机制（Garbage collection）

Java程序的编译与运行 javac编译java运行

 

 Java虚拟机(JVM）读取并处理经编译的字节码class文件

定义了：指令集，寄存器集，类文件结构，堆栈，垃圾收集堆，内存区域

运行环境(JRE) JRE=JVM+API(Lib)

JRE运行的主要功能：加载，校验，执行   java的安全性和跨平台性

加载代码：class loader完成；校验代码：Bytecode verifier完成；执行代码：runtime interpreter完成

Java自动垃圾回收技术

c/c++中程序员负责回收无用内存，但Java系统级线程跟踪存储空间分配，在JVM空闲时可检查并释放可被释放的存储器空间，程序员无需也无法精确和干预该回收过程。

Java开发工具包 JDK=JRE+Tools JDK下载可以只下载JavaSE或与NetBeans绑定的版本，只运行Java下载JRE

JDK提供的工具：java编译器javac.exe/java执行器java.exe/文档生成器javadoc.exe/java打包器jar.exe/java调试器jdb.exe

Java技术：Java SE/Java SE Support/Java SE Advanced&Suite/Java Embedded/Java EE/Java ME/JavaFX/Java Card/Java TV/Java DB/development Tools

1.2面向对象的设计思路

对象（object）客观世界中的一个实体--一个可标识的存储区域

类（Class）:具有共同属性和行为的对象集合  属性：变量（字段 field）行为：函数（方法 Method）

类&对象  类时对象的抽象（模板）对象是类的实例 有时类也称为对象，对象为对象实例

 面向对象的特征：封装性 继承性 多态性

封装

 模块化：将属性和行为封装在类中，程序定义很多类

信息隐蔽：将类的细节部分隐藏起来 用户只通过受保护的接口访问某个类

 继承（inheritance）

继承性：父类和子类共享数据和方法 

好处：更好地抽象与分类，增强代码的重用率，提高可维护性

 多态性（polymorphism）

多态：不同对象收到同一消息（调用方法）可产生不同效果，实现的细节由接受对象自行决定

 设计思路要点：对象类，属性方法，类的关系（继承&关联）对象间发送消息（调用方法）

 

Chpater2 2.1Java基本类型和构成

JavaSE类型：Application Applet

Application为独立程序，需要执行器（调用虚拟机）运行；Applet嵌入HTML中非独立的程序，由专门的appletVIewer或Web游览器(调用JVM)运行

Application程序：HelloWorld.java

要点：class定义类，public类型与文件名同名，public是公用的，static静态 void没有返回值 主体是一个main方法，带参数 string时字符串，[]是数组，即字符串数组；system.out系统输出，print打印ln换行，printf格式化，format格式化的显示（）System.out.print/println/printf

Applet程序：

HelloWorldApplet.java

 import--导入 extends JApplet/Applet --继承 paint()--绘制  HelloWorldApplet.html

 Java基本构成：HelloDate.java 

package 语句（0/1句） import 语句（多个）导入其他类的类库  类定义-class（多个）一个文件只能有一个public类（与文件同名）

类=头+类体  类成员=字段field<  method

 

 

 2.3程序的输入输出

文本界面：Scanner   in&out

//Scanner类 使用java.util.Scanner类  nextInt() nextDouble() next()  注：Since JDK1.5

import java.util.Scanner;

class ScannerTest{
  public static void main(String[] args){
     Scanner scanner =new Scanner(System.in);
     System.out.print("1")
     int a =scanner.nextInt();
     System.out.printf("%d的平方是%d\n",a,a*a);        
   }  
}
//in&out  java.io包  System.in.read() System.out.print()/println()/printf() AppCharInOut.java try-catch
char c ='';
 System.out.print("Please input a char ");
 try {
  c=(char)System.in.read();
 }catch(IOException e) {}
 System.out.println("You hava entered:"+c;)
//AppLineInOut.java 输入输出行 更复杂一些
try{
  BufferedReader in=new BufferedReader(
     new InputStreamReader(System.in));
  s=in.readLine();
}catch(IOException e){} 
//AppNumberInOut.java 输入输出数字 用Integer.parseInt(s);用Double.parseDouble(s)
BufferedReader in=new BufferedReader(
   new InputStreamReader(System.in));
System.out.print("Please input an int:");
s=in.readLine();
n=Inter.parseInt(s);

 图形界面输入输出

文本框对象TextField获取用户输入数据；标签对象Label或文本框对象输出数据；命令按钮Button执行命令

Java Application图形界面输入输出

AppGraphInOut.java  用Frame创建用户界面，构建AppFrame时设定该Frame大小并用setVisible(true)方法显示出来

 AppGraphInout.java  add(xx)加入对象；btn.addActionListener.处理事件  actionPerformed(函数).具体处理事件

Java8  e->{...}

 Applet输入输出

init()  add(xx) btn.addActionLIstener.处理事件 acrionPerformed().具体处理事件

 

2.4Java开发工具

开发环境：

JDK Javac  java  appleViewer

文本工具+调用JDK sublime/Notepad++/UltraEdit/EditPlus+JCreator/Freejava

集成开发环境IDE(integrated development environment)  Eclipse,NetBeans Jdeveloper(Oracle)  VisualAge for Java(IBM) BlueJ（教学）InTELLI JDEA

EditPlus

Eclipse:可下载多插件 

编程：新建项目-添加类-main() - 运行/Run as   打包File-Export-Java-Runable jar  生成java.doc：Project-Generate Javadoc

NetBeans:运行F6

代码模板

Eclipse：main+alt/--main函数   sysout+alt/--System.out.println("")  更多：Window-Preferences-Java-Editor-Templates

NetBeans:psvm+tab--main函数  sout+tab--System.out.println("")  更多工具-选项-编辑器-代码模板

WindowBuilder--**

 

W3:数据运算、流控制、数组

Java数据类型

数据类型决定数据的存储方式和运算方式 

Java数据类型：基本数据类型:数值型（整数<byte short int long>  浮点（float double)）字符型（char）布尔型(boolean)

                          引用数据类型:类(class) 接(interface) 数组

    基本类型变量在栈引用变量在堆

 转义符：\ddd  \uxxx \' \" \\ \r \n \f \t \b

整形类型常量   表示形式：0b/0B  0     0x/0X    默认：int型  long型后加l/L   java中没有无符号数若表示可用long处理

浮点数：有固定的表数范围和字段长度    float(4字节) double(8字节)

表示形式：十进制必含小数点 java7123_456.145_236（千分位分隔符用_表示） 科学记数法3.14e/E2

 默认类型为double

标识符identifier：名字就是标识符任何变量常量方法对象类都需要有名字

       由字母数字_$组成，不以数字开头，类名首字母大写pascal其余（名 方法名 变量名）首字母小写camel 少用小花仙常量使用随定义

 

3.2运算符与表达式

15/4=3（整数） 15.0/4=3.5（实数除法）

短路short-circuit逻辑运算符 && ||  eg:if((d!=null)&&(d.day>31))

位运算：~取反 &按位与 |或 ^异或

移位运算符<<  >>  >>>

赋值运算符 = （casting）byte=12 （T   byte=4096 (x)   扩展赋值运算+=/-=/*=//=/%=/&=/|=/^=/<<=/>>=/>>>=

 字符串连接运算符+：只要有一个是字符串string类型，系统会自动将另一个转为字符串后连接

 

表达式：符合一定语法规则的运算符和操作符的序列，对表达式中操作数进行运算得到的结果为表达式的值，表达式的值的数据类型为表达式的类型，表达式的运算顺序由优先级高到低进行。

表达式的类型转换：不同类型混合运算int->long->float->double   所有byte short char参与算术运算等转为int

eg:int a=2  b=a++ + ++a//6

3.3流程控制语句

顺序 分支 循环

注释：//   /*..*/  /**...*/-doc注释  @ @see/@version/@author/@param/@return/@exception

if-else switch-case(deafult中break可不用)

 IDE窗体设计

循环语句：满足循环条件下反复执行特定代码

五个要素：初始化部分init_statement 循环条件部分test_exp 循环体部分body_statement 迭代部分alter_statement 结束后处理

 

 for循环：for(init_statement;test_exp;;alter_statement){body_statement}

 while循环：{init_statement} while(test_exp){body_statement;[]alter_statement;]}

do-while循环[init_statement] do{body_statement;[alter-statement;]}while(test_exp)；

 

 Goto语句：break continue 标号

public class Prime100Continue{
    public static void main(String args[]) {
        System.out.println("**100到200的质数**");
        int n=0;
        outer:for(int i=101;i<200;i+=2) {//外层循环
            for(int j=2;j<i;j++) {       //内层循环
                if(i%j==0)               //不是质数，则继续外层循环
                    continue outer;
            }
            System.out.print(""+1);      //显示指数
            n++;                         //计算个数
            if(n<0)                      //未满10个数则不换行
                continue;
            System.out.println();
            n=0;
        }
        System.out.println();
    }
    
}

100-200的质数

 

3.4数组

数组：多个相同类型数据的组合 []位置可以写变量前后    Java语言规范

数组定义与为数组元素分配空间分开进行

一维数组声明：Java中声明数组时不能指定长度eg:int[5];//非法    数组是引用类型eg:int []a=new int[5]  a.length

静态初始化：定义数组的同时为数组元素分配空间并赋值 eg：int []a={3,9,8}或int []a=new int[]{3,9,8};

隐式初始化 初值0

数组元素引用方式：index为下表可为整型常量或整型表达式eg:a[3]    b[i*6]   数组元素下表从0开始长度为n的数组合法下表取值范围：0~n~1

增强for语句：enhanced for方便处理数组、集合各元素  eg:

int [] ages=new int[10];
for(int age:age)
{
 System.out.println(age);
}                 //只读式遍历

复制数组：Array.copyOf()或System.arraycopy()     复制效率：for循环<Arrays.copy<Object.done()<System.arraycopy()

int[] source={1,2.3.4;5;6};   //源数组

int []dest={10,9,8,7,6,};      //目的数组

System.arraycopy(source,0,dest,0,source.Length)       //复制源数组从下标0开始的source.length个元素到目的数组，从下标0的位置开始存储

多维数组  eg:int [][]a={{1.2}.{3,4,6}}; 声明和初始化从高维到低维的顺序进行eg：int t1[][]=new int [][4]--非法//与c++不同，4放前面

 

 

chapter4类 包 接口

4.1类 字段 方法

类class  将变量,函数封装在类中 字段field为类的属性由变量表示（又域 域变量 属性 成员变量）方法method是类的功能和操作-函数表示

构造方法constructor 初始化new该类的新对象   构造方法和类名同名且不写返回数据类型 类有0-n个构造方法  默认构造方法default constructor不带参数方法体为空

适用对象：访问对象的字段或方法需要用算符“.”   使用方法的好处：封装性 安全性

方法重载overload：实现多态polymorphism

this用法：

1在方法和构造中使用this访问字段和方法

2用this解决局部变量与域同名问题eg Person(int age ,String name){this.age=age;this.name.name;}--this.age表示域变量age表示参数变量

3构造方法中用this调用另一种构造方法 eg:Person(){this(0,"");...} 调用语句放在第一句

 4.2类的继承

 继承inheritance：子类subclass 父类/超类superclass java中支持单继承一个类只有一个直接父类 

 继承好处：子类继承父类状态和行为（修改 添加）提高程序抽象程度 实现代码重用提高开发效率和可维护性   is a

 派生子类extends  egclass Student extends Person{...} 若无extends子句该类默认为java.lang.Object的子类（所有的类都是通过直接或间接继承java.lang.Object得到）

字段的继承：隐藏/添加   

方法的继承 覆盖（Override）修改（JDK1.5 @Override注记 不用也可以 void sayHello(){System.out.println("Hello!My name is"+name+"My school is"+school)} 添加 重载（Overload）’重载是新加方法eg:void sayHello(Student another){System.out.println("Hi!");  if(school.equals(another.school)  System.out.println("Schoolmates"));}

super的使用

1有时明确指名父类的域和方法，用super但不能访问子类中添加的域和方法  eg:void testThisSuper(){int a; a=age; a=this.age; a=super.age;}

   有时使用super区别同名的域和方法，使用super访问被子类隐藏的同名变量如党覆盖父类的同名方法时调用父类方法必须使用super  eg:void sayHello(){super.sayHello ();System.out.println("My school is"+school)}

2构造方法不能继承但子类可用super调用父类的构造方法 Student(String name,int age,String school){super(name,age);this.school=school;} super放第一句

父类与子类对象的转换

父类对象包含多个子类对象，若一个方法的形式参数定位是父类调用可用子类对象作为实际参数，若父类对象引用指向实际为一个子类对象父类对象的引用可以用强制类型转换casting成子类对象的引用

4.3包

package pkg1...

 

包和子包实际上为了解决名字空间、名字冲突，与类继承无关系，子类父类可以在不同包中

包：名字控件、存储路径（文件夹）；可访问性（同一个包中各类默认可访问）

包层次的根目录由环境变量Classpath决定，无pakagez语句为无名包unnamed package ，java中称default package ,java的JDK提供很多包java.applet/io/lang/net/util  java.awt.image/peer javax.swing等

import语句

  import package1.. eg:import java.awt.*  /*星号智能表示本层次所有类不含子层次中的类 java自动导入java.lang.*（算术等） IDE能方便生成import语句

编译和运行包中的类：运行程序需指名main的类名 java pk.TestPkg     -d 指名包的根目录  “.”-当前目录 eg:d:tang\ch04   .pk\*java

Classpath包层次根目录确定操作：java/javac命令行中用-classpath/-cp指明  或设定classpath环境变量用命令行设定环境变量 eg:java -classpath d:tang\ch04   set path=d:\tang\ch04

 

4.4访问控制符

修饰符modifiers：访问修饰符access modifiers如public/private 或其他修饰符如abstract等，可以修饰类或修饰类成员（字段方法）

setter与getter：java中就是set和get （设置和修改）

 

4.5其他修饰符

非访问控制符：static final abstract

 

static字段：表示全局变量 In/out static方法：不能访问实例变量，this/super故不能用eg：Math.random() Integer.parseInt()为类方法，直接用类名进行访问

      import static java.lang.System.* ;   out.println();表示System.out.println();

final：表明类不能被继承，所修饰的方法也不能被子类所覆盖的方法   static.final 表示常量eg:Math.PI

abstract类 抽象类 不能被实例化 abstract(;)--格式：abstract returnType abstractMethod([paramlist]);

 

4.6接口interface

接口，某种特征的约定

定义接口interface 所有方法都自动是public abstract       实现接口Implements 可以实现多继承，与类的继承关系无关

面向接口编程： eg：Flyable f=new Bird();   Java中有大量的接口    接口也是一种引用类型

作用:通过接口实现不相关类的相同行为，而不需要考虑这些类之间的层次关系从而在一定意义上实现了多重继承  ；通过接口指名多个类需要实现的方法； 了解对象的交互界面而不需了解对象所对应的类。

接口的定义：包括口声明和接口体两部分  interfaceDeclaration {interface Body}

    1.接口声明：最简单  interface interfaceName  {... } 通常接口以able/ible结尾，表明接口能完成一定的行为 ，接口声明中还包括对接口的访问权限以及它的父接口列表

                    完整的接口声明  [public] interface interfaceName [extends listOfSuperInterface]  {...}

              public指明任意类均可以使用这个接口，缺省情况下只有与该接口定义在同一包中的类才可以访问这个接口，一个接口可以有多个父接口用逗号隔开，一个类只有一个父类 

 接口类型：一种引用类型

接口中的常量： type NAME=value  type为任意类型NAME-常量名，通常大写 value-常量值 接口定义的常量具有public,static final属性，接口中定义的常量可以被实现该接口的多个类共享，与c中用#define以及c++中用const定义的常量是相同的   JDK1.5 可以使用枚举,JDK1.8接口还可以是static方法

 

 

 

 

 

 chapter5 深入理解java语言 

5.1变量及传递

基本类型变量&引用型变量

       基本类型primitive type:其值存于变量中 “在这里”   引用型reference type变量占据一定空间引用对象实体（new创建）也占据空间 “在那里”

字段变量&局部变量

       字段变量field在类中，在堆中，可以自动赋初值     局部变量Local variable是方法中定义的变量/参变量 在栈中，必须显式赋值      --生命周期不同

      区别：字段变量属于类可用public private static final修饰；局部变量不能被访问控制符和static修饰，两者都能被final修饰

变量的传递与返回

5.2多态及虚方法调用

 多态polymorhism一个程序中相同的名字表示不同的含义的情况

     编译时多态：：重载Overload

    运行时多态：覆盖override（子类对父类进行覆盖）动态绑定dynamic binding --虚方法调用virtual method invoking

 上溯造型upcasting ：把派生类型当作基本类型处理

     用虚方法调用，运行时系统根据调用该方法的实力类型来决定调用，所用非final都会自动进行动态绑定

动态类型确定    instanceof 类型，结果为boolean值

 

什么情况不是虚方法调用：java中普通方法为虚方法但static,private final不是虚方法调用，static private与虚方法编译后用的指令是不同的

 

5.3对象构造与初始化

构造方法default    this调用本类 super调用直接父类 this/super放第一语句

创建对象初始化 p==new Person(){{age=18;name="李明"；}}；

 

5.4对象清除与垃圾回收

对象清除：new创建对象    

如何销毁对象？Java自动清除不需要使用delete-垃圾回收:由Java虚拟机的垃圾回收线程完成（任何对象都有一个引用计数器当其值为0 时说明该对象可以回收）

System.gc()方法：System类的static方法，可以要求系统进行垃圾回收

finalize()方法

try-with-resources   try(Scanner scanner=new Scanner(..)){......}  会自动调用close()  相当于finally{Scanner close();}

 

5.5内部类与匿名类

内部类：将类的定义class xxx{...}置于一个类的内部即可，编译器生成xxx$xxx这样的class文件，内部类不与外部类同名，在封装它的类中使用与普通类相同，其他地方则用.外部对象名.new.内部类名（参数） 内部类可直接访问外部类的字段和方法private也可以，有与外部类同名的字段或方法可用外部类名.this.字段或方法

  内部类的修饰符：同类中字段方法一样 访问控制符：public protected 默认 及private（外部类只能够使用public修饰或默认） final abstract

 static修饰符：与外部类实力无关，有人认为static为嵌套类nested class非Inner class，

局部类local class：方法中的内部类   不能用public private protected static修饰但可被final abstract修饰 ，可用访问其他外部类成员但不能够访问该方法的局部变量除非是final局部变量

匿名类anonymous class：没有雷鸣，定义类同时生成一个实例 一次性使用的类

 

5.6Lambda表达式（*）

（参数）->结果

函数式接口：@FunctionnalInterface

 

5.7装箱 枚举 注解 JDK1.5

基本类型的包装类：将基本类型primitive type包装为Object引用类型 共8类;Boolean ByteShort Character Integer Long Float  Double

装箱Boxing  Integer I=10   拆箱Unboxing int i=I     实际：Integer I=Integer.valueOf（10）   int i=1.intValue()

 枚举enum：特殊class类型 

 

注解annotation 又称注记 标记 标注 注释，在各种语法要素上加上附加信息，以供编译器或其他程序使用，所有的注解都是java.lang.annotation.Annotation的子类

    @Override-覆盖父类  @Deprecated-过时 @SuppressWarnings -让编译器不产生警告

 

 5.8没有指针的java

引用与指针： 引用reference实际上为指针pointer但它受控 安全eg:会检查空指引 没有指针运算*（p+5）不能访问没有引用到的内存 自动回收垃圾

传地址->对象   指针运算->数组    函数指针->接口  指向结点的指针->对象的引用   使用JNI

==   基本类型是值相等引用类型是引用相等  eg:Double.NAN=Double.NAN结果为false 

 -127

 

 Chapter6 异常处理

6.1异常处理

异常excetion又称为例外、差错、违例  对应着Java运行错误处理机制

    基本写法：try {语句组} catch（Exception ex）{异常处理语句组；}

 传统语句如何处理：

 

 

 

 6.2自定义异常

重抛异常 异常链接

6.3断言及程序的测试

断言assertion   assert格式：assert 表达式 |assert 表达式 ：信息

 程序的测试及JUnit

   测试驱动   JUnit框架

测试函数 @Test   fail/assertEqauls(参数1，参数2)  assertNull（参数）

 

程序中的错误：语法错误syntax error (编辑 编译器发现)  运行错误runtime error（异常处理机制）逻辑错误logic error(调试debug 单元测试unit test)

程序调试debug：手段：断点breakpoint 跟踪trace 监视watch

 

 Chapter7工具类及常用算法

7.1java语言基础类

JDK API

阅读JDK API文档  

阅读JDK源码  src.zip

Object类:equels( )   

getClass( ) final方法

toString（ )

finalize( )

object其他方法：notify( ) notifyAll( )  wait( ) 与线程相关

JDK1.5     包装boxing与拆包unboxing  Integer I=5 即I = integer.valueOf(5);    int i=I 即I=LintValue( )；

Math类

System类：

 

7.2字符串及日期

字符串;String  StringBuffer\StringBuilder

 

7.3集合类

Collection API 提供集合 收集功能 ，包含一系列的接口和类  

    三大类：

Collection接口：2个接口List Set

       List :Collection子接口，记录元素的保存顺序，且允许有重复元素

       Set ：Collection子接口，不记录元素的保存顺序，且不允许又重复元素

Map接口，即映射：键-值对key-value pair的集合

 

List接口：线性表linear list  ，主要实现类是ArrayList.Linkedlist，以及早期的Vector

                     

Iterator迭代器（所有Collection都能产生）

       Iterator iterator=iterable.iterator()               while (iterator.hasNext())  doSomething （iterator.next()）

JDK1.5 增强的for语句enhanced for或叫for-each 

          

 Stack栈 遵循后进先出LIFO原则(Last In First Out)原则 ，重要线性数据结构

        包含三个方法：

             public Object push(Object item):将指定对象压入栈中

            Public Object pop()：将栈最上面的元素从栈中取出并返回这个对象

            Public boolean empty()：判断栈中没有对象元素

队列Queue：先进先出FIFO原则  重要的线性数据结构  入队-出队  重要的实现是LinkedList类

          

几个早期的类或接口

           

Set集  HashSet TreeSet(底层用TreeMap来实现)

      Set中对象不重复，即hashCode()不等，若hashCode()相等再看equals或==是否为false

 Hashtable的实现

         

Map：键-值对的集合 其中可取到entrySet() keySet() values()  Map.Entry是一个嵌套接口   实现：HashMap类 TreeMap类（用红黑树的算法）

     Map层次结构：简化

 

                  

7.4排序与查找

自编程序排序与查找如冒泡排序 选择排序 快速排序   ；系统已有的排序与查找如Arrays类及Collections类

Arrays类：用于对数组进行排序和搜索的类 eg:Arrays.asList(10,7,6,5,9)方法可以直接得到一个List对象

          Arrays类提供了sort()和binarySearch()

            

 

7.5泛型（*）

     泛型Generic是JDK1.5增加的，可用针对不同的类有相同的处理方法

            好处：类型更安全，适用更广泛，针对不同的类有相同的处理方法，但这些类之间不一定有继承关系

 

 自定义泛型

         

         

 

 7.6常用算法

       通用算法：遍试 迭代 递归 回溯

遍试：穷举 exhaust algorithm  有限范围内对所有的值进行试验和判断从而找到满足条件的值       基本模式：for(;;){ if();}

迭代 iterative algorithm 是多次利用同一公式进行计算每次将计算的结果带入公式进行计算从而逐步逼近精确解   基本模式：while(){ x=f(x);}

递归recursive：一个过程调用过程本身,一个过程执行的某一步比上一步（或上几步）的结果   基本模式：f(n){ f(n-1);}

 回溯back-track 又试探回溯法 选择将某一可能的线索进行一一试探若不符合条件就返回纠正，反复进行这种试探再返回纠正，直到得出全部符合条件的答案或是问题无解为止  基本模式：x++;if(...)x--;

 

chapter8 多线程

8.1多线程的创建

进程&线程      一个程序的执行为进程，程序中单个顺序的流控制称为线程，一个进程含多个线程  java从语言级别支持多线程

 线程体  run()方法实现 

           

 

8.2线程的控制

            线程的状态与生命周期

 

 

 8.3线程的同步（*）

Java引入对象互斥锁Lock.mutex保证共享数据操作的完整性，关键字synchronized用来与对象的互斥锁联系

          

 

 8.4并发API

8.5流式操作及并行流（*）

 

 

 

 

 

Chapter9 流 文件及基于文本的应用

9.1输入输出流

流：不同类型的输入输出stream

字符流Reader Writer与字节流InputStream OutputStream

InputStream类

 

转载于:https://www.cnblogs.com/Pucua/p/9539510.html