9512.net
甜梦文库
当前位置:首页 >> 计算机软件及应用 >>

Java知识总结 完整版


第 1 章 Java 概述 Java 语言的特特点 一种面向对象的语言;一种平台无关的语言;一种健壮的语言,吸收了 C/C++的 优点,但去掉了其影响程序健壮性的部分(如:指针、内存的申请与释放等) Java 的两种核心机制 Java 虚拟机(Java Virtual Machine) 垃圾回收机制(Garbage Collection) 源程序(*.java 文件)→Java 编译器→字节码(*.class 文件)→类装载器→ 字节码校验器→解释器→操作系统平台 一次编译,随处运行 Java 是一种解释型语言 JDK(Java Development Kit)软件开发工具包 JRE(Java Runtime Environment)运行时环境 开发需要 JDK;用户只需 JRE PATH:WINDOWS 系统执行命令时要搜寻的路径(如 javac.exe,java.exe) CLASSPATH:Java 在编译和运行时要找的 class 所在路径( “.”代表当前路径) java:运行 java 程序 javac:编译 java 程序 java –version 一个源文件最多只能有一个 public 类, 其他类数量不限, 源文件名必须与 public 类名一致 Java 应用程序的执行入口时 main()方法:public static void main(String[] args){…} Java 语言中严格区分大小写 编译后,每一个类都对应一个 class 文件 第 2 章 基础语法 标示符由字母、下划线”_” 、美元符”$”或数字组成 标示符应以字母、下划线、美元符开头 Java 标示符对大小写敏感,长度无限制,注意“见名知意”且不能与 Java 语言 关键字重名 abstract default if private this boolean do implements protected throw break double import public throws

byte else instanceof return case extends int short catch final interface static char finally long strctfp class float native super const for new switch continue goto package synchronized goto 和 const 虽然未使用,但也被作为 Java 的关键字保留 程序执行过程:
程序 代码 内存 操作系统 代码

transient try void volatile while null

程序

heap 堆 new 出来的东西 stack 栈 局部变量

硬盘

data segment 静态变量 字符串常量 code segment 存放代码

1.load 到内存区 内存管理 Java 数据类型的划分

2.找到 main 方法开始执行

3.执行过程中的
整数类型(byte、 short、int、long

数值型 基本数据类型 字符型(char) 布尔型(boolean) 类(class) 引用数据类型 接口(interface) 数组 浮点类型(float、 double)

数据类型

boolean 类型数据只允许取值 true 或 false, 不可以使用 0 或非 0 的整数值取代 true 和 false,这点和 c 语言不同 Java 字符采用 Unicode 编码,每个字符占两个字节,因而可以用十六进制编码

形式表示,例: char c = ‘\u0061’; Java 语言的整型常量默认为 int 类型,声明 long 型常量可以后加 l 或 L 类型 byte short int long 占用存储空间 1 字节 2 字节 4 字节 8 字节 数值范围 -27~27-1 -215~215-1 -231~231-1 -263~263-1

Java 浮点型常量默认为 double 型,声明 float 型需在数字后面加 f 或 F 类型 占用存储空间 数值范围 float 4 字节 -3.403E38~3.403E38 double 8 字节 -1.798E308~1.798E308 基本数据类型转换 boolean 类型不可以转换为其他的数据类型 整型,字符型,浮点型的数据在混合运算中相互转换,转换时遵循以下原则: 容量小的类型自动转换为容量大的类型: byte,short,char->int->long->float->double byte,short,char 之间不需要相互转换,他们三者在计算时首先会转换为 int 类 型 可以将整型常量直接赋值给 byte,short,char 等类型变量, 而不需要进行强制类 型转换,只要不超过其表数范围 “+”除用于算术加法外,还可用于对字符串进行连接操作, “+”运算符两侧的 操作数中只要有一个是字符串(String)类型,系统会自动将另一个操作数转换 为字符串然后再进行连接,当进行打印时,无论任何类型,都自动转换为字符串 进行打印 break&continue break 语句用于终止某个语句块的执行。用在循环语句中,可以强行退出循环 continue 语句用在循环语句体中,用于终止某次循环过程,跳过循环体中 continue 语句下面未执行的循环,开始下一次循环过程 switch 小心 case 穿透,推荐使用 break 语句 多个 case 可以合并到一起 default 可以省略,但不推荐 java 中 switch 语句只能探测 int 类型值 方法 形参、实参、返回值、返回值类型

Java 中进行函数调用中传递参数时,遵循值传递的原则: 基本类型传递的是该数据值本身,引用类型传递的是对象的引用,而非对象本身 递归调用 递归调用指在方法执行过程中出现该方法本身的调用 第 3 章 面向对象编程 类是用来创建同一类型的对象的“模板” ,在一个类中定义了该类对象所应具有 的成员变量和方法,对象可以看成是静态属性(成员变量)和动态属性(方法) 的封装体,是该类的一个具体实例,在 Java 中“一切皆为对象” 继承、组合、实现、多态 类 = 成员变量 + 方法 成员变量系统可以对其自动初始化,局部变量不初始化会报错 引用 Java 语言中除基本类型之外的变量类型都称之为引用类型(基本类型占一块内 存,引用类型占两块内存) Java 中的对象时通过引用对其操作的 类时静态的概念,代码区 对象是 new 出来的,位于堆内存(动态分配内存用的) ,类的每个成员变量在不 同的对象中都有不同的值(除了静态变量) ,而方法只有一份,执行的时候才占 内存 对象 必须使用 new 关键字创建对象 同一类的每个对象有不同的成员变量存储空间(除了静态变量) 同一类的每个对象共享该类的方法 非静态方法时针对每个对象进行调用的(必须创建对象) 构造方法 使用 new+构造方法创建一个新的对象 构造方法是定义在 Java 类中的一个用来初始化对象的函数 构造方法与类同名且没有返回值 当没有指定构造方法时,编译器为类自动添加形如类名(){ }的构造方法 命名规则 类名的首字母大写 变量名和方法名的首字母小写 运用驼峰标识

方法重载(overload) 方法的重载是指一个类中可以定义有相同的名字,但参数不同的多个方法。调用 时根据不同的参数列表选择对应的方法 this 在类的方法定义中使用 this 关键字代表使用该类的对象的引用 有时使用 this 可以处理方法中成员变量和方法参数重名的问题 This 可以看做是一个变量,它的值时当前对象的引用 public class Leaf{ int I = 0; Leaf(int i) { this.i = i}; Leaf increament() { i++; return this; } void print() {System.out.println(“i = ” + i);} public static void main(String[] args) { Leaf leaf = new Leaf(100); leaf.increament().increament().print(); } } static 在类中,用 static 声明的成员变量为静态成员变量,它为该类的公用变量,在 第一次使用时被初始化,对于该类的所有对象来说,static 成员变量只有一份 用 static 声明的方法为静态方法,在调用该方法时,不会将对象的引用传递给 它,所以在 static 方法中不可访问非 static 的成员 静态方法不再是针对某个对象调用,所以不能访问非静态成员 可以通过对象引用或类名(不需要实例化)访问静态成员或方法 package&import 为了解决类的命名冲突问题,Java 引入的包(package)机制,提供类的多重类 命名空间 package 语句作为 Java 源文件的第一条语句,指明该文件中定义的类所在的包 (若缺省该语句,则指定为无名包,裸体类) Java 编译器把包对应于文件系统的目录管理,package 语句中,用“.”来指明 包(目录)的层次,例:package com.yao;则该文件中的类位于.\com\yao 目录 下 如果将一个类打包,则使用该类时,必须使用该类的全名(例如: com.yao.MyClass),Java 编译器才会找到该类 也可以使用 import 在文件的开头引入要使用的类, 例: import com.yao.MyClass 可以不需要用 import 语句直接使用 java.lang 包中的类

访问位于同一个包中的类不需要引入 class 文件的最上层包的父目录必须位于 classpath 下 JDK 中主要的包介绍 java.lang-包含一些 Java 语言的核心类,如 String、Math、Integer、System 和 Thread,提供常用功能,使用时不需要引入(lang-language) java.awt-包含了构成抽象窗口工具集(abstract window toolkits)的多个类, 这些类被用来构建和管理应用程序的图形用户界面(GUI) java.applet-包含了 applet 运行所需的一些类 java.net-包含了与网络相关的操作的类 java.io-包含能提供多种输入/输出功能的类 java.util-包含一些实用工具类,如定义系统特性、使用与日期日历相关的函数 java 运行时所需的类位于 jdk\jre\lib\rt.jar 打 jar 包,定位到需要打包的最上层的父路径 jar –cvf xxx.jar *.* (*.*指目录中所有文件夹打包) jar 包也可设为 classpath 变量 继承 extends 通过继承,子类自动拥有了基类(superclass)的所有成员(成员变量和方法) (包括 private 成员,拥有私有变量的所有权,但无使用权) Java 只支持单继承,不允许多继承,一个子类只能有一个基类,一个基类可以 派生多个子类 访问控制 权限修饰符 public、protected、private、default(包访问权限) 修饰符 类内部 同一个包 子类 任何地方 private √ X X X default √ √ X X protected √ √ √ X public √ √ √ √ 对于 class 的权限修饰符只可以用 public 和 default public 类可以在任意地方被访问 default 类只可以被同一个包内的类访问 方法重写 overwrite/override 在子类中可以根据需要对从基类中继承来的方法进行重写 重写方法必须和被重写方法具有相同方法名称、参数列表和返回类型 重写方法不能使用比被重写方法更严格的访问权限 super 在 Java 类中使用 super 来引用基类的成分 继承中的构造方法

子类的构造过程中必须调用其基类的构造方法 子类可以再自己的构造方法中使用 super(argument_list)调用基类的构造方 法 使用 this(argument_list)调用本类的另外的构造方法 如果调用 super,必须写在子类构造方法的第一行 如果子类的构造方法中没有显式地调用基类构造方法, 则系统默认调用调用基类 无参数的构造方法 如果子类构造方法中既没有显式调用基类构造方法, 而基类中又没有无参的构造 方法,则编译出错 Object 类 Object 类是所有 Java 类的根基类 如果在类的声明中未使用 extends 关键字指明其基类,则默认基类为 Object 类 public class Person { … } 等价于: public class Person extends Object { … } toString() Object 类中定义有 public String toString () 方法, 其返回值时 String 类型, 描述当前对象的有关信息,返回一个字符串,该字符串由类名(对象是该类的一 个实例) + “ @ ” + 此对象哈希码的无符号十六进制表示组成,即 getClass ().getName() + ‘@’ + Integer.toHexString(hashCode() ) 在进行 String 与其他类型数据的连接操作时 (如: System.out.println( “info” + person)),将自动调用该对象类的 toString()方法 可以根据需要在用户自定义类型中重写 toString()方法,建议所有子类都重 新此方法 equals() public boolean equals(Object obj) x.equals(y)对于任何非空引用值,当且仅当 x 和 y 引用同一个对象时,此方法 返回 true(x==y 具有值 true) JDK 提供了一些类,如 String,Date 等,重写了 Object 的 equals()方法,调 用这些类的 equals()方法,x.equals(y) ,当 x 和 y 所引用的对象时同一类 对象且属性内容相等时(并不一定时同一对象) ,返回 true,否则返回 false 建议重写 例子: String s1 = new String(“Hello”); String s2 = new String(“Hello”); System.out.println(s1 == s2); //false System.out.println(s1.equals(s2)); //true

对象转型(casting) 一个基类的引用类型变量可以“指向”其子类的对象 一个基类的引用不可以访问其子类对象新增加的成员(属性和方法) 可以使用 引用变量 + instanceof + 类名,来判断该引用变量所“指向”的对 象是否属于该类或该类的子类 子类的对象可以当作基类的对象来使用称作向上转型(upcasting) ,反之称为乡 下转型(downcasting) ,需强制转换 动态绑定和多态 动态绑定是指在执行期间(而非编译期间)判断所引用对象的实际类型,根据其 实际类型调用其相应的方法 1.要有继承 2.要有重写 3.父类引用指向子类对象 抽象类 用 abstract 关键字来修饰一个类时,这个类叫做抽象类;用 abstract 来修饰一 个方法时,该方法叫做抽象方法 含有抽象方法的类必须被声明为抽象类,抽象类必须被继承,抽象方法必须被重 写 抽象类不能被实例化 抽象方法只需声明,而不需实现 final final 的变量的值不能被改变 final 的方法不能被重写 final 的类不能被继承 接口 interface 实现 implements 接口是抽象方法和常量值得定义的集合 从本质上讲, 接口是一种特殊的抽象类,这种抽象类中只包含了常量和方法的定 义,而没有变量和方法的实现 多个无关的类可以实现同一个接口 一个类可以实现多个无关的接口 与继承关系类似,接口与实现类之间存在多态性 接口中声明属性默认为 public static final 的,也只能是 public static final 的 接口中只能定义抽象方法,而且这些方法默认为 public 的,也只能是 public 的 接口可以继承其他的接口,并添加新的属性和抽象方法

第 4 章 异常处理 异常指运行期出现的错误 所谓错误是指在程序运行的过程中发生的一些异常事件(如:除 0 溢出、数组下 标越界、所要读取的文件不存在) Java 程序的执行过程中如出现异常事件,可以生成一个异常类对象,该异常对 象封装了异常事件的信息并将被提交给 Java 运行时系统,这个过程称为抛出 (throw)异常 当 Java 运行时系统接收到异常对象时,会寻找处理这一异常的代码并把当前异 常对象交给其处理,这一过程称为捕获(catch)异常 声明该方法可能抛 异常的概念 出的异常
public void someMethod() throws someException { if(someCondition()) { throw new someException(“错误原因”); } ……… } 构 造 并抛 出 异常对象

调用该方法时试图捕获异 try { 常 someMethod(); 定义处理异常的代码 } catch (SomeException e) { //异常处理代码; }

Throwable

Error

Exception RuntimeException

Error:称为错误,由 Java 虚拟机生成并抛出,包括动态链接失败、虚拟机错误 等,程序对其不做处理 Exception:所有异常类的父类,其子类对应了各种各样可能出现的异常事件, 一般需要用户显式的声明或捕获 RuntimeException: 特殊的异常, 如被 0 除、 数组下标越界等, 其产生比较频繁, 处理麻烦, 如果显式的声明或捕获将会对程序可读性和运行效率影响很大,因此 由系统自动检测并将它们交给缺省的异常处理程序(用户可不必对其处理) ·Exception(in java.lang) ·ClassNotFoundException ·IOException ·InterruptedException ·RuntimeException · ArithmeticException (当出现异常的运算条件时, 抛出此异常。 例如, 一个整数“除以零”时,抛出此类的一个实例) ·NullPointerException ·IndexOutOfBoundsException(指示某排序索引(例如对数组、字符串 或向量的排序)超出范围时抛出。 ) · ArrayIndexOutOfBoundsException (用非法索引访问数组时抛出 的异常。如果索引为负或大于等于数组大小,则该索引为非法索引。 ) · StringIndexOutOfBoundsException (此异常由 String 方法抛出, 指示索引或者为负,或者超出字符串的大小。对诸如 charAt 的一些方法,当索 引等于字符串的大小时,也会抛出该异常。 ) finally

try { //可能抛出异常的语句 } catch(SomeException1 e) { …… } catch(SomeException2 e) { …… } finally { …… } 捕获 SomeException2 时 try { 语句 1; 语句 2; } catch (SomeException1 e) {… …} catch (SomeException2 e) {… …} finally {… …} 后面的语句;

try 代码段后跟有一个或多个 catch 代码段 每个 catch 代码段声明其能处理的一种特定类 型的异常并提供处理的方法 当异常发生时,程序会终止当前的流程,根据 获取异常的类型去执行相应的 catch 代码段 如果没有异常产生,所有的 catch 代码段都被 略过不执行 finally 段的代码无论是否发生异常都会执行 通常在 finally 语句中可以进行资源的清除工 作,如: 关闭打开的文件,删除临时文件等 没有捕获到异常时 try { 语句 1; 语句 2; } catch (SomeException1 e) { … …} catch (SomeException2 e) { … …} finally {… …} 后面的语句;

getMessage()方法,用来得到有关异常事件的信息 printStackTrace()方法,用来跟踪异常事件发生时执行堆栈的内容
readFile() throws IOException{… …} 在一个 try 语句块中,基类异常的捕获语句 method1() throws IOException { readFile() } method2() throws IOException { method2() } public static main(String s) { try {method2() } catch(IOException e) {…} }

抛 出

在一个 try 语句块中,基类异常 的捕获语句不可以写在子类异常 捕获语句的上面,否则会有编译 错误,子类异常不会被捕获 先逮小的,再逮大的

抛 出

抛 出

使用自定义的异常 1.通过继承 java.lang.Exception 类声明自己的异常类 2.在方法适当的位置生成自定义异常的实例,并用 throw 语句抛出 3.在方法的声明部分用 throws 语句声明该方法可能抛出的异常 class MyException extends Exception { private int id; public MyException(String message,int id) { super(message); this.id = id; } public it getId() { return id; } } 注意:重写方法需要抛出与原方法所抛出异常类型一致的异常货不抛出异常 第 5 章 数组 数组变量属引用类型, 数组也可以看成是对象,数组中的每个元素相当于该对象 的成员变,因此数组分配空间后,每个元素也被按照成员变量的规则被隐式初 始化 type var[];或 type[] var; Java 语言中声明数组时不能指定其长度(数组中元素的个数)例:int a[5]; //非法 Java 中使用关键字 new 创建数组对象,格式为: 数组名 = new 数组元素的类型 [数组元素的个数] 注意:元素为引用数据类型的数组中的每一个元素都需要实例化 动态初始化:数组定义与为数组元素分配空间和赋值的操作分开进行 静态初始化:在定义数组的同时就为数组元素分配空间并赋值 每一个数组都有一个属性 length 指明它的长度,例: a.length 的值为数组 a 的长度(元素个数) Java 中多维数组的声明和初始化应按从高维到低维的顺序进行 例如: int a[][] = new int[3][]; a[0] = new int[2]; a[1] = new int[4]; a[2] = new int[3]; //int error[][] = new int[][4];是错误的 数组的拷贝

使用 java.lang.System 类的静态方法 public static void arraycopy(Object src,int srcPos,Object dest,int destPos,int length) 可以用于数组 src 从第 srcPos 项元素开始的 length 个元素拷贝到目标数组 dest 从 destPos 项开始的 length 个位置 如果源数据数目超出目标数组边界会抛出 IndexOutOfBoundsException 异常 第 6 章 常用类 String Java.lang.String 类代表不可变的字符序列字符串是常量;它们的值在创建之 后不能更改。 字符串缓冲区支持可变的字符串。 因为 String 对象是不可变的, 所以可以共享。例如: String str = "abc"; 等效于 char data[] = {'a', 'b', 'c'}; String str = new String(data); Java 语言提供对字符串串联符号("+")以及将其他对象转换为字符串的特殊支 持。字符串串联是通过 StringBuilder(或 StringBuffer)类及其 append 方 法实现的。字符串转换是通过 toString 方法实现的,该方法由 Object 类定 义,并可被 Java 中的所有类继承。 “xxxx”为该类的一个对象 String 类的常见构造方法: String(String original) :创建一个 String 对象为 original 的拷贝 String(char[] value):用一个字符数组创建一个 String 对象 String(char[] value,int offset,int count):用一个字符数组从 offset 项 开始的 count 个字符序列创建一个 String 对象 public class Test { public static void main(String[] args) { String s1 = “hello”; String s2 = “hello”; System.out.println(s1 == s2);//true s1 = new String(“hello”); s2 = new String(“hello”); System.out.println(s1 == s2);//false System.out.println(s1.equals(s2));//true char[] c = {‘s’, ’u’, ’n’, ’ ‘, ‘j’, ‘a’, ‘v’, ‘a’}; String s4 = new String(c); String s5 = new String(c,4,4); System.out.println(s4);//sun java System.out.println(s5);//java } }

String 类常用方法(1) public char charAt(int index):返回字符创中的第 index 个字符 public int length():返回字符串的长度 public int indexOf(String str):返回字符串中出现 str 的第一个位置 public int indexOf(String str,int fromIndex):返回字符串中从 fromIndex 开始出现 str 的第一个位置 public boolean equalsIgnoreCase(String another): 比较字符串与 another 是否一样(忽略大小写) public String replace(char oldChar,char newChar):在字符串中用 newChar 字符替换 oldChar 字符 public class Test { public static void main(String[] args) { String s1 = “sun java”; s2 = “Sun Java”; System.out.println(s1.charAt(1));//u System.out.println(s2.length());//8 System.out.println(s1.indexOf(“java”));//4 System.out.println(s1.indexOf(“Java”));//-1 System.out.println(s1.equals(s2));//false System.out.println(s1.equalsIngoreCase(s2));//true String s = “我是程序员,我在学 java”; String sr = s.replace(‘我’,’你’); System.out.println(sr);//你是程序员,你在学 java } } String 类常用方法(2) public boolean startsWith(String prefix):判断字符串是否以 prefix 字符串 开头 public boolean endsWith(String suffix):判断字符串是否以 suffix 字符串结 尾 public String toUpperCase():返回一个字符串为该字符串的大写形式 public String toLowerCase():返回一个字符串为该字符串的小写形式 public String substring(int beginIndex):返回该字符串从 beginIndex 开始 到结尾的子字符串 public String substring(int beginIndex,int endIndex): 返回该字符串从 beginIndex 开始到 endIndex 结尾的子字符串 public String trim():返回将该字符串去掉开头和结尾空格后的字符串 public class Test { public static void main(String[] args) { String s = “ Welcome to Java World!”; String s1 = “ sun java ”; System.out.println(s.startWith(“Welcome”));//true

System.out.println(s.endWith(“World”));//false String sL = s.toLowerCase(); String sU = s.toUpperCase(); System.out.println(sL);//welcome to java world System.out.println(sU);//WELCOME TO JAVA WORLD String subS = s.substring(11); System.out.println(subS);//Java World String sp = s1.trim(); System.out.println(sp);//sun java } } String 类常用方法(3) 静态重载方法 public static String valueOf(…)可以将基本类型数据转换为 字符串,例: public static String valueOf(double d) public static String valueOf(int i) … … public String[] split(String regex) 可以将一个字符串按照指定的分隔符 (regex)分隔,返回分隔后的字符串数组 public class Test { public static void main(String[] args) { int j = 1234567; String sNum = String.valueOf(j); System.out.println(“j 是” + sNum.length() + “位数”);//j 是 7 位数 String s = “Mary,F,1988”; String[] sPlit = s.split(“,”); for(int i=0;i<sPlit.length;i++) System.out.println(sPlit[i]);//Mary/nF/n/1976 } } StringBuffer 类 java.lang.StringBuffer 代表可变的字符序列 StringBuffer 和 String 类似,但 StringBuffer 可以对其字符串进行改变 String s1 = “hello”; String s2 = “world”; s1 = s1 +s2;
hello world

helloworld s1 s2

StringBuffer 类常见的构造方法 StringBuffer() :创建一个不包含字符序列的“空”的 StringBuffer 对象 StringBuffer(String str) :创建一个 StringBuffer 对象,包含与 String 对 象相同的字符序列 StringBuffer 常用方法 重载方法 public StringBuffer append(…):可以为该 StringBuffer 对象添加 字符序列,返回添加后的该 StringBuffer 对象引用,例如: public StringBuffer append(String str) public StringBuffer append(StringBuffer sbuf) public StringBuffer append(char[] str) public StringBuffer append(char[] str,int offset,int len) public StringBuffer append(double d) public StringBuffer append(Object obj) 重载方法 public StringBuffer insert(…)可以为该 StringBuffer 对象在指定 位置插入字符序列,返回修改后的该 StringBuffer 对象引用,例: public StringBuffer insert(int offset,String str) public StringBuffer insert(int offset,double d) … 方法 public StringBuffer delete(int start,int end)可以删除从 start 开始 到 end-1 为止的一段字符序列,返回修改后的该 StringBuffer 对象引用 和 String 类含义类似的方法; public int indexOf(String str) public int indexOf(String str,int fromIndex) public String substring(int start) public String substring(int start,int end) public int length() public StringBuffer reverse() 用 于 将 字 符 序 列 逆 序 , 返 回 修 改 后 的 该 StringBuffer 对象的引用 public class Test { public static void main(String[] args) { String s = “Mircosoft”; char[] a = {‘a’,’b’,’c’}; StringBuffer sb1 = new StringBuffer(s); sb1.append(‘/’).append(“IBM”).append(‘/’).append(“Sun”); System.out.println(sb1);//Mircosoft/IBM/Sun StringBuffer sb2 = new StringBuffer(“数字”); for(int i=0;i<=9;i++) sb2.append(i); System.out.priintln(sb2);//数字 0123456789

sb2.delete(8,sb2.length()).insert(0,a); System.out.println(sb2);//abc 数字 012345 System.out.println(sb2.reverse());//54321 字数 cba } } 基本数据类型包装类 包装类(如:Integer,Double 等)这些类封装了一个相应的基本数据类型值, 并为其提供了一系列操作 以 java.lang.Integer 类为例,构造方法: Integer(int value) Integer(String s) 常见方法 public static final int MAX_VALUE 最大的 int 型数(231-1) public static final int MIN_VALUE 最小的 int 型数(-231) public long longValue():返回封装数据的 long 型值 public double doubleValue():返回封装数据的 double 型值 public in tint Value():返回封装数据的 int 型值 public static int parseInt(String s) throws NumberFormatException:将字 符串解析成 int 型数据,返回该数据 public static Integer valueOf(String s) throws NumberFormatException: 返回 Integer 对象,其中封装的整型数据为字符串 s 所表示 Math 类 java.lang.Math 提供了一系列静态方法用于科学计算,其方法的参数和返回值 类型一般为 double 型 abs:绝对值 acos,asin,atan,cos,sin,tan sqrt:平方根 pow(double a,double b):a 的 b 次幂 log:自然对数 exp:e 为底指数 max(double a,double b) min(double a,double b) random():返回 0.0 到 1.0(不包含)的随机数 long round(double a) :double 型的数据 a 转换为 long 型(四舍五入) toDegrees(double angrad):弧度->角度 toRadians(double angdeg) :角度->弧度 File 类 java.io.File 类代表系统文件名(路径和文件名) 常见构造方法: public File(String pathname): 以 pathname 为路径创建 File 对象,如果

pathname 是相对路径,则默认的当前路径在系统属性 user.dir 中存储 public File(String parent,String child):以 parent 为父路径,child 为子 路径创建 File 对象 File 的静态属性 String separator 存储了当前系统的路径分隔符 常用方法 通过 File 对象可以访问文件的属性 public boolean canRead() public boolean canWrite() public boolean exists() public boolean isDirectory() public boolean isFile() public boolean isHidden() public long lastModified():返回此抽象路径名表示的文件最后一次被修改的 时间 public long length():返回此抽象路径名表示的文件的长度。如果此路径表示 一个目录,则返回值不确定 public String getName():返回由此抽象路径名表示的文件或目录的名称 public String getPath():将此抽象路径名转换为一个路径名字符串 通过 File 对象创建空文件或目录 (在该对象所指的文件或目录不存在的情况下) public boolean createNewFile() throws IOException public boolean delete() public boolean mkdir():创建此抽象路径名指定的目录 public boolean mkdirs():创建此抽象路径名指定的目录,包括所有必需但不 存在的父目录 import java.io.*; public class TestFile { public static void main(String[] args) { String separator = File.separator; String filename = "myfile.txt"; String directory = "mydir1" + separator + "mydir2"; //String directory = "mydir1/mydir2"; //String directory = "mydir1\\mydir2"; File f = new File(directory, filename); if (f.exists()) { System.out.println("文件名:" + f.getAbsolutePath()); System.out.println("文件大小:" + f.length()); } else { f.getParentFile().mkdirs(); try { f.createNewFile();

} catch (IOException e) { e.printStackTrace(); } } } } 第 7 章 容器 JDK 所提供的容器 API 位于 java.util Collection 接口-定义可存取一组对象的方法,其子接口 Set 和 List 分别定义 了存储方式 Set 中的数据对象没有顺序且不可以重复 List 中的数据对象有顺序且可以重复 Map 接口定义了存储“键(key)—值(value)映射对”的方法

<interface> Collection

<interface> Map <interface> List HashMap

<interface> Set

HashSet

LinkedList

ArrayList

Collection 接口中所定义的方法: int size() boolean isEmpty() void clear() boolean contains(Object element) boolean add(Object element):只能添加对象,不能添加基础类型,添加基础 类型包装类对象(基础类型一般存放在栈上,站上的内容随时有可能被清空,不 能保存) boolean remove(Object element):调用对象的 equals()方法 Iterator iterator() boolean containAll(Collection c) boolean addAll(Collection c); boolean removeAll(Collection c) boolean retainAll(Collection c):交集

Object[] toArray() 容器类对象在调用 remove、contains 等方法时需要比较对象是否相等,这时会 涉及到对象类型的 equals()方法和 hashCode()方法;对于自定义的类型, 需要重写 equals() 和 hashCode() 方法以实现自定义的对象相等规则,重写 equals()方法的同时,必须重写 hashCode()方法 注意:相等的对象应该具有相等的 hash codes Iterator 接口 所有实现了 Collection 接口的容器类都有一个 iterator()方法用以返回一个实 现了 Iterator 接口的对象 Iterator 对象称作迭代器,用以方便的实现对容器内元素的遍历操作 Iterator 接口定义了以下方法: boolean hasNext():判断游标右边是否有元素 Object next():返回游标右边的元素并将游标移动到下一个位置(next()的返回 值为 Object 类型,需要转换为相应类型) void remove():删除游标左面的元素,在执行完 next 之后该操作只能执行一次

游标

元素

next() Iterator 对象的 remove()方法时在迭代过程中删除元素的唯一的安全方法 foreach 语句 foreach 对于遍历 array 或 Collection 相当方便 for( :) …; 缺陷: 数组:不能方便的访问下标值 集合:与使用 Iterator 相比,不能方便的删除集合中的内容 总结:除了简单遍历并阅读出其中的内容外,不建议使用 foreach Set 接口 Set 接口是 Collection 的子接口,Set 接口没有提供额外的方法,但实现 Set 接口的容器类中的元素师没有顺序的,而且不可以重复(即相同的元素不会被加 入) ,有 HashSet,TreeSet 等 List 接口 List 接口是 Collection 的子接口,实现 List 接口的容器类中的元素师有顺序 的,而且可以重复 List 容器中的元素都对应一个整数型的序号记载其在容器中的位置,可以根据 序号存取容器中的元素,有 ArraryList,LinkedList 等 List 接口常用方法

Object get(int index) Object set(int index,Object element):替换 void add(int index,Object element):插入 boolean remove(int index) int indexOf(Object o): 返回此列表中第一次出现的指定元素的索引;如果此 列表不包含该元素,则返回 -1 int lastIndexOf(Object o) Lists 常用算法 类 java.util.Collections 提供了一些静态方法实现了基于 List 容器的一些常 用算法 void sort(List):对 List 容器内的元素排序 void shuffle(List):对 List 容器内的对象进行随机排序 void reverse(List):对 List 容器内的对象进行逆序排序 void fill(List,Object):用一个特定的对象重写整个 List 容器 void copy(List dest,List src):将 src List 容器内容拷贝到 dest List 容器 内 int binarySearch(List,Object):对于顺序的 List 容器,采用折半查找法查找 特定对象 所有可以“排序”的类都实现了 java.lang.Comparable 接口,Comparable 接口 中只有一个方法:public int compareTo(Object obj),该方法:返回 0 表示 this ==obj;返回正数表示 this>obj;返回负数表示 this<obj 实现 Comparable 接口的类通过实现 comparaTo 方法从而确定该类对象的排序方 式 如何选择数据结构 衡量标准:读的效率和改的效率 Array 读快改慢 Linked 读慢改快 Hash 介于上两者之间 Map 接口 实现 Map 接口的类用来存储键-值对 Map 接口的实现类有 HashMap 和 TreeMap Map 类中存储的键-值对通过键来标识,所以键值不能重复 Map 类常用方法: Object put(Object key,Object vakue) Object get(Object key) Object remove(Object key) boolean containKey(Object key) boolean containValue(Object value)

int size() boolean isEmpty() void putAll(Map t):从指定映射中将所有映射关系复制到此映射中 void clear() import java.util.*; public class Test { private static final Integer ONE = new Integer(1); //private static final int ONE = 1; public static void main(String[] args) { Map m = new HashMap(); for(int i=0;i<args.length;i++) { Integer freq = (Integer)m.get(args[i]); //int freq = (Integer)m.get(args[i]) ==null?0: (Integer)m.get(args[i]); m.put(args[i],(freq==null?ONE:new Integer(freq.intValue()+1))); //m.put(args[i],freq==0?ONE:freq +1); } System.out.println(m.size() + “distinct words detected:”); System.out.println(m); } } Auto_boxing/unboxing 在合适的时机自动打包、解包 自动将基础类型装换成对象 自动将对象装换为基础类型 泛型 起因: import java.util.*; JDK1.4 以前类型不明确: public class BasicGeneric { 装入集合的类型都被当做 public static void main(String[] args) { Object 对待,从而失去自己 List<String> c = new ArrayList<String>(); c.add("aaa");c.add("bbb");c.add("ccc"); 的实际类型 从集合中取出时往往需要转 for(int i=0; i<c.size(); i++) { 型,效率低,容易产生错误 String s = c.get(i); 解决办法: System.out.println(s); 在定义集合的时候同时定义 } 集合中对象的类型 Collection<String> c2 = new HashSet<String>(); 可以在定义 Conllection 的时 c2.add("aaa"); c2.add("bbb"); c2.add("ccc"); for(Iterator<String> it = c2.iterator(); 候指定 it.hasNext(); ) { 也可以在循环时用 Iterator String s = it.next(); 指定 System.out.println(s);
好处: 增强程序的可读性和稳定性

} } } 第8章 流 java.io 按数据流的方向的不同可以分为:输入流和输出流(站在程序的角度上) 按处理数据单位不同可以分为字节流和字符流 按功能不同可以分为节点流和处理流 字节流 字符流 输入流 InputStream Reader 输出流 OutputStream Writer 节点流为可以从一个特定的数据源(节点)读写数据(如:文件,内存) 节点流
数据源 程序

处理流是“连接”在已存在的流(节点流或处理流)之上,通过对数据的处理为 程序提供更为强大的读写功能
数据源 程序

程序

数据源

InputStream 继承自 InputStream 的流都是用于向程序中输入数据,且数据的单位为字节 (8bit) ;下图中深色的为节点流,浅色的为处理流

FileInputStream LineNumberInputStream PipedInputStream DataInputStream FilterInputStream BufferdInputStream InputStream ByteArrayInputStream PushbackInputStream SequenceInputStream StringBufferInputStream ObjectInputStream
InputStream

InputStream 的基本方法 int read() throws IOException //读一个字节并以整数的形式返回(0~255) ,如果返回-1 表示已到输入流的末

尾 int read(byte[] buffer) throws IOException //读取一系列字节并存储到一个数组 buffer,返回实际读取的字节数,如果读 取前已到输入//流的末尾返回-1 int read(byte[] buffer,int offset,int length) throws IOException //读取 length 个字节,并存储到一个字节数组 buffer,从 offset 位置开始, 返回实际读取的//字节数,如果读取前已到输入流的末尾返回-1 void close() throws IOException //关闭流释放内存资源 long slip(long n) throws IOException //跳过 n 个字节不读,返回实际跳过的字节数 OutputStream 继承自 OutputStream 的流时用于程序中的输入数据,且数据的单位为字节 (8bit) ;下图中深色的为节点流,浅色的为处理流
FileOutputStream PipedOutputStream OutputStream FilterOutputStream ByteArrayOutputStream ObjectOutputStream DataOutputStream BufferdOutputStream PrintStream

OutputStream 的基本方法 void write(int b) throws IOException //向输出流中写入一个字节的数据,该字节数据位为参数 b 的低 8 位 void write(byte[] b) throws IOException //将一个字节类型的数组中的数据写入输出流 void write(byte[] b,int off,int len) throws IOException //将一个字节类型的数组中的从指定位置(off)开始的 len 个字节写入到输出 流 void close() throws IOException //关闭流释放内存资源 void flush() throws IOException //将输出流中缓冲的数据全部写出到目的地 Reader 继承自 Reader 的流都是用于向程序中输入数据, 且数据的单位为字符 (16bit) ; 下图中深色为节点流,浅色为处理流
BufferedReader CharArrayReader InputStreamReader Reader FilterReader PipedReader PushBackReader FileReader LineNumberReader

Reader 的基本方法 int read() throws IOException //读取一个字符并以整数的形式返回(0~255) ,如果返回-1 已到输入流的末尾 int read(char[] cbuf) throws IOException //读取一系列字符并存储到一个数组 buffer,返回实际读取的字符数,如果读 取前已到输入流的末尾返回-1 int read(char[] cbuf,int offset,int length) throws IOException //读取 length 个字符,并存储到一个数组 buffer,从 offset 位置开始,返回 实际读取的字符数,如果读取前已到输入流的末尾返回-1 void close() throws IOException //关闭流释放内存资源 long slip(long n) throws IOException //跳过 n 个字符不读,返回实际跳过的字符数 Write 继承自 Write 的流都是用于程序中输出数据,且数据的单位为字符(16bit) ;下 图中深色的为节点流,浅色的为处理流

BufferedWriter CharArrayWriter OutputStreamWriter Write FilterWriter PipedWriter StringWriter FilterWriter FileWriter

Write 的基本方法 void write(int c) throws IOException //向输出流中写入一个字符数据,该字符数据为参数 c 的低 16 位 void wrie(char[] cbuf) throws IOException //将一个字符类型的数组中的数据写入输出流 void write(char[] cbuf,int offset,int length) throws IOException //将一个字符类型的数组中的从指定位置(offset)开始的 length 个字符写入 到输出流 void write(String string) throws IOException //将一个字符串中的字符写入到输出流 void write(String string,int offset,iint length) throws IOException //将一个字符串从 offset 开始的 length 个字符写入到输出流 void close() throws IOException //关闭流释放内存资源 void flush() throws IOException //将输出流中缓冲的数据全部写出到目的地 节点流类型 类型 File(文件) Memory Array Memory String Pipe(管道)

字符流 FileReader FileWriter CharArrayReader CharArrayWriter StringReader StringWriter PipedReader PipedWriter

字节流 FileInputStream FileOutputStream ByteArrayInputStream ByteArrayOutputStream PipedInputStream PipedOutputStream

访问文件 FileInputStream 和 FileOutputStream 分 别 继 承 自 InputStream 和 OutputStream,用于向文件中输入和输出字节 FileInputStream 和 FileOutputStream 的常用构造方法: FileInputStream(String name) throws FileNotFoundException FileInputStream(File file) throws FileNotFoundException FileOutputStream(String name) throws FileNotFoundException FileOutputStream(File file) throws FileNotFoundException FileOutputStream(File file,boolean append) throws FileNotFoundException: 创建一个向具有指定 name 的文件中写入数据的输出文件流。 如果第二个参数为 true,则将字节写入文件末尾处,而不是写入文件开始处 import java.io.*; public class TestFileInputStream { public static void main(String[] args) { int b = 0;

FileInputStream in = null; try { in = FileInputStream("d:\\java\\io\\TestFileInputStream.java"); } catch (FileNotFoundException e) { System.out.println("找不到指定文件"); System.exit(-1); } try { long num = 0; while((b=in.read())!=-1){ System.out.print((char)b); num++; } in.close(); System.out.println(); System.out.println("共读取了 "+num+" 个字节"); } catch (IOException e1) { System.out.println("文件读取错误"); System.exit(-1); } } } import java.io.*; public class TestFileOutputStream { public static void main(String[] args) { int b = 0; FileInputStream in = null; FileOutputStream out = null; try { in = new FileInputStream("d:/java/HelloWorld.java"); out = new FileOutputStream("d:/java/io/HW.java"); while((b=in.read())!=-1){ out.write(b); } in.close(); out.close(); } catch (FileNotFoundException e2) { System.out.println("找不到指定文件"); System.exit(-1); } catch (IOException e1) { System.out.println("文件复制错误"); System.exit(-1); } System.out.println("文件已复制"); }

new

} FileReader 和 FileWriter 与 FileInputStream 和 FileOutputStream 类似,只 是读取写出字节和字符的差别 处理流类型 处理类型 Buffering Filtering Converting between bytes and character Object Serialization Data conversion Counting Peeking ahead Printing

字符流 BufferedReader BufferedWriter FilterReader FilterWriter InputStreamReader OutputStreamWriter LineNumberReader PushbackReader PrintWriter

字节流 BufferedInputStream BufferedOutputStream FilterInputStream FilterOutputStream

ObjectInputStream ObjectOutputStream DataInputStream DataOutputStream LineNumberInputStream PushbackInputStream PrintStream

缓冲流 缓冲流要“套接”在相应的节点流之上,对读写的数据提供了缓冲的功能,提高 了读写的效率,同时增加了一些新的方法 JDK 提供了四种缓存流,常见的构造方法为: BufferedReader(Reader in) BufferedReader(Reader in,int size) //size 为自定义缓存区的大小 BufferedWriter(Writer out) BufferedWriter(Writer out,int size) BufferedInputStream(InputStream in) BuffferedInputStream(InputStream in,int size) BufferedOutputStream(OutputStream out) BufferedOutputStream(OutputStream out,int size) 缓冲输入流支持其父类的 mark 和 reset 方法 BufferedReader 提供了 readLine 方法。 用于读取一行字符串 (以\r 或\n 分隔) BufferedWriter 提供了 newLine 方法,用于写入一个换行符 对于输出的缓冲流, 写出的数据会先在内存中缓存,使用 flush 方法将会使内存 中的数据立刻写出 import java.io.*; public class TestBufferStream1 { public static void main(String[] args) { try {

FileInputStream fis = new FileInputStream("d:\\java\\HelloWorld.java"); BufferedInputStream bis = new BufferedInputStream(fis); int c = 0; System.out.println(bis.read()); System.out.println(bis.read()); bis.mark(100);//在此输入流中标记当前的位置,标记到第 100 个字节 for(int i=0;i<=10 && (c=bis.read())!=-1;i++){ System.out.print((char)c+" "); } System.out.println(); bis.reset();// 将此流重新定位到最后一次对此输入流调用 mark 方法 时的位置,回到//mark(100)处 for(int i=0;i<=10 && (c=bis.read())!=-1;i++){ System.out.print((char)c+" "); } bis.close(); } catch (IOException e) {e.printStackTrace();} } } import java.io.*; public class TestBufferStream2 { public static void main(String[] args) { try { BufferedWriter bw = new BufferedWriter(new FileWriter("d:\\\java\\dat2.txt")); BufferedReader br = new BufferedReader( new FileReader("d:\\java\\dat2.txt")); String s = null; for(int i=1;i<=100;i++){ s = String.valueOf(Math.random()); bw.write(s); bw.newLine(); } bw.flush(); while((s=br.readLine())!=null){ System.out.println(s); } bw.close(); br.close(); } catch (IOException e) { e.printStackTrace();} }

} 转换流 InputStreamReader 和 OutputStreamWriter 语言字节数据到字符数据之间的转 换 InputStreamReader 需要和 InputStream“套接” OutputStreamWriter 需要和 OutputStream“套接” 转换流在构造时可以指定其编码集合,例如: InputStream isr = new InputStreamReader(System.in,”ISO8859_1”) import java.io.*; public class TestTransForm1 { public static void main(String[] args) { try { OutputStreamWriter osw = new OutputStreamWriter( new FileOutputStream("d:\\bak\\char.txt")); osw.write("mircosoftibmsunapplehp"); System.out.println(osw.getEncoding()); osw.close(); osw = new OutputStreamWriter(new FileOutputStream("d:\\bak\\char.t xt", true),"ISO8859_1"); //public OutputStreamWriter(OutputStream out, CharsetEncoder enc)创建 使用给定字符集编码 器的 OutputStreamWriter。 osw.write("mircosoftibmsunapplehp"); System.out.println(osw.getEncoding()); osw.close(); } catch (IOException e) { e.printStackTrace(); } } } import java.io.*; public class TestTransForm2 { public static void main(String args[]) { InputStreamReader isr = new InputStreamReader(System.in);//in 本身就是 InputStream BufferedReader br = new BufferedReader(isr); String s = null; try { s = br.readLine(); while(s!=null){

if(s.equalsIgnoreCase("exit")) break; System.out.println(s.toUpperCase()); s = br.readLine(); } br.close(); } catch (IOException e) { e.printStackTrace(); } } } //阻塞 数据流 DataInputStream 和 DataOutputStream 分 别 继 承 自 InputStream 和 OutputStream, 它属于处理流, 需要分别 “套接” 在 InputStream 和 OutputStream 类型的节点流上 DataInputStream 和 DataOutputStream 提供了可以存取与机器无关的 Java 原始 类型数据(如:int,double 等)的方法 DataInputStream 和 DataOutputStream 的构造方法为: DataInputStream(InputStream in) DataOutputStream(OutputStream out) import java.io.*; public class TestDataStream { public static void main(String[] args) { ByteArrayOutputStream baos = new ByteArrayOutputStream(); DataOutputStream dos = new DataOutputStream(baos); try { dos.writeDouble(Math.random()); dos.writeBoolean(true); ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());//创建一个新分 配的 byte 数组。 其大小是此输出流的当前大小,并且缓冲区的有效内容已复制 到该数组中。 System.out.println(bais.available());//返回可从此输入流读取(或 跳过)的剩余字节数 DataInputStream dis = new DataInputStream(bais); System.out.println(dis.readDouble()); System.out.println(dis.readBoolean()); dos.close(); dis.close(); } catch (IOException e) { e.printStackTrace(); } } }

Print 流 PrintWriter 和 PrintStream 都属于输出流,分别针对字符和字节 PrintWriter 和 PrintStream 提供了重载的 print print 流用于多种数据类型的输出 PrintWriter 和 PrintStream 的输出操作不会抛出异常,用户通过检测错误状态 获取错误信息 PrintWriter 和 PrintStream 有自动 flush 功能 PrintWriter(Writer out) PrintWriter(Writer out,boolean autoFlush) PrintWrite(OutputStream out) PrintWriter(OutputStream out,boolean autoFlush) PrintStream(OutputStream out) PrintStream(OutputStream out,boolean autoFlush) import java.io.*; public class TestPrintStream1 { public static void main(String[] args) { PrintStream ps = null; try { FileOutputStream fos = new FileOutputStream("d:\\bak\\log.dat"); ps = new PrintStream(fos); } catch (IOException e) { e.printStackTrace(); } if(ps != null){ System.setOut(ps); } int ln = 0; for(char c = 0; c <= 60000; c++){ System.out.print(c+ " "); if(ln++ >=100){ System.out.println(); ln = 0;} } } } import java.io.*; public class TestPrintStream2 { public static void main(String[] args) { String filename = args[0]; if(filename!=null){list(filename,System.out);} } public static void list(String f,PrintStream fs){

try { BufferedReader br = new BufferedReader(new FileReader(f)); String s = null; while((s=br.readLine())!=null){ fs.println(s); } br.close(); } catch (IOException e) { fs.println("无法读取文件"); } } } import java.util.*; import java.io.*; public class TestPrintStream3 { public static void main(String[] args) { String s = null; BufferedReader br = new BufferedReader( new InputStreamReader(System.in)); try { FileWriter fw = new FileWriter ("d:\\bak\\logfile.log", true); //Log4J PrintWriter log = new PrintWriter(fw); while ((s = br.readLine())!=null) { if(s.equalsIgnoreCase("exit")) break; System.out.println(s.toUpperCase()); log.println("-----"); log.println(s.toUpperCase()); log.flush(); } log.println("==="+new Date()+"==="); log.flush(); log.close(); } catch (IOException e) { e.printStackTrace(); } } } Objectl 流 直接将 Object 写入或读出 transient 关键字 //透明的 serializable 接口

externalizable 接口 import java.io.*; public class TestObjectIO { public static void main(String args[]) throws Exception { T t = new T(); t.k = 8; FileOutputStream fos = FileOutputStream("d:/java/io/testobjectio.dat"); ObjectOutputStream oos = new ObjectOutputStream(fos); oos.writeObject(t); oos.flush(); oos.close();

new

FileInputStream fis = new FileInputStream("d:/java/io/testobjectio.dat"); ObjectInputStream ois = new ObjectInputStream(fis); T tReaded = (T)ois.readObject(); System.out.println(tReaded.i + " " + tReaded.j + " " + tReaded.d + " " + tReaded.k); } } class T implements Serializable //标记对象序列化 { int i = 10; int j = 9; double d = 2.3; transient int k = 15; } 第 9 章 多线程机制 线程是一个程序内部的顺序控制流(线程是一个程序里面不同的执行路径)main 方法:主线程 线程和进程的区别 每个进程都有独立的代码和数据空间(进程上下文) ,进程间的切换会有较大的 开销 线程可以看成轻量级的进程, 同一类线程共享代码和数据空间,每个线程有独立 的运行栈和程序计数器(PC) ,线程切换的开销小 多进程:在操作系统中能同时运行多个任务(程序) (进程是一个静态的概念) 多线程:在同一个应用程序中有多个顺序流同时执行(在一个时间点上,CPU 只 能执行一个线程,只是 CPU 的运算速度很快,开始同时执行多个线程,多核 CPU 另说)

Java 的线程时通过 java.lang.Thread 类来实现的 VM 启动时会有一个由主方法 main 所定义的线程 可以通过创建 Thread 的实例来创建新的线程 每个线程都是通过某个特定 Thread 对象所对应的方法 run()来完成操作的,方 法 run()称为线程体 通过调用 Thread 类的 start()方法来启动一个线程 (直接执行 run 时方法调用) 线程的创建和启动 a. 定义线程类实现 Runnable 接口 Thread myThread = new Thread(target) //target 为 Runnable 接口类型 Runnable 中只有一个方法:public void run() :用以定义线程的运行体 使用 Runnable 接口可以为多个线程提供共享的数据 在实现 Runnable 接口的类的 run 方法定义中可以使用 Thread 的静态方法: public static Thread currentThread()获取当前线程的引用 b. 可以定义一个 Thread 的子类并重写 run 方法: class MyThread extends Thread { public void run() {} } 然后生成该类的对象: MyThread myThread = new MyThread(…) public class TestThread1 { public static void main(String args[]) { Runner1 r = new Runner1(); //r.start();//继承 Thread,可直接启动线程,不需创建 Thread 对象 //r.run(); Thread t = new Thread(r); t.start(); //并行运行 for(int i=0; i<100; i++) { System.out.println("Main Thread:------" + i); } } } class Runner1 implements Runnable { //class Runner1 extends Thread { public void run() { for(int i=0; i<100; i++) { System.out.println("Runner1 :" + i); } } }

线程状态转换
阻塞状态 创 建 终 止

阻塞解除

导致阻塞的事件

start()
就绪状态 运行状态

xi

调度

线程控制的基本方法 isAlive() :判断线程是否还“活”着,即线程时候还未终止 getPriority() :获得线程的优先级数值 setPriority() :设置线程的优先级数值 Thread.sleep() :将当前线程睡眠指定毫秒数 join() :调用某线程的该方法,将当前线程与该线程“合并” ,即等待该线程结 束,再恢复当前线程的运行 yield() :让出 CPU,当前线程进入就绪队列等待调度 wait() :当前线程进入对象的 wait pool notify/notifyAll() :唤醒对象的 wait pool 中的一个/所有等待线程 sleep 可以调用 Thread 的静态方法: public static void sleep(long mills) throws InterruptedException 使得 当前线程休眠(暂停执行时间 mills 毫秒) ,由于是静态方法,sleep 可以由类 名直接调用:Thread.sleep(…) import java.util.*; public class TestInterrupt { public static void main(String[] args) { MyThread thread = new MyThread(); thread.start(); try {Thread.sleep(10000);} catch (InterruptedException e) {} thread.interrupt();//中断线程 //thread.flag = false; } } class MyThread extends Thread { boolean flag = true;

public void run(){ while(flag){ System.out.println("==="+new Date()+"==="); try { sleep(1000); } catch (InterruptedException e) { return; } } } } join 合并某个线程(类似于调用方法,方法调用结束后,继续执行主函数) public class TestJoin { public static void main(String[] args) { MyThread2 t1 = new MyThread2("abcde"); t1.start(); try {t1.join();} catch (InterruptedException e) {} for(int i=1;i<=10;i++){ System.out.println("i am main thread"); } } } class MyThread2 extends Thread { MyThread2(String s){super(s);} public void run(){ for(int i =1;i<=10;i++){ System.out.println("i am "+getName()); try {sleep(1000);} catch (InterruptedException e) {return;} } } } yield 让出 CPU,给其他线程执行的机会 public class TestYield { public static void main(String[] args) { MyThread3 t1 = new MyThread3("t1"); MyThread3 t2 = new MyThread3("t2");

t1.start(); t2.start(); } } class MyThread3 extends Thread { MyThread3(String s){super(s);} public void run(){ for(int i =1;i<=100;i++){ System.out.println(getName()+": "+i); if(i%10==0){yield();} } } } 线程的优先级别 Java 提供一个线程调度器来监控程序中启动后进入就绪状态的所有线程,线程 调度器按照线程的优先级决定应调度哪个线程来执行 线程的优先级用数字表示,范围从 1 到 10,缺省为 5 Thread.MIN_PRIORITY = 1 Thread.MAX_PRIORITY = 10 Thread.NORM_PRIORITY = 5 使用下述方法获得或设置线程对象的优先级 int getPriority() void setPriority(int newPriority) public class TestPriority { public static void main(String[] args) { Thread t1 = new Thread(new T1()); Thread t2 = new Thread(new T2()); t1.setPriority(Thread.NORM_PRIORITY + 3); t1.start(); t2.start(); } } class T1 implements Runnable { public void run() { for(int i=0; i<1000; i++) { System.out.println("T1: " + i); } } } class T2 implements Runnable { public void run() { for(int i=0; i<1000; i++) { System.out.println("------T2: " + i);

} } } 线程同步 public class TestSync implements Runnable { Timer timer = new Timer(); public static void main(String[] args) { TestSync test = new TestSync(); Thread t1 = new Thread(test); Thread t2 = new Thread(test); t1.setName("t1"); t2.setName("t2"); t1.start(); t2.start(); } public void run(){ timer.add(Thread.currentThread().getName()); } } class Timer{ private static int num = 0; public /*synchronized*/void add(String name){ //synchronized (this) { num ++; try {Thread.sleep(1);} catch (InterruptedException e) {} System.out.println(name+", 你是第"+num+"个使用 timer 的线程"); //} } } 在 java 语言中,引入了对象互斥锁的概念,保证共享数据操作的完整性。每个 对象都对应于一个可称为“互斥锁”的标记,这个标记保证在任意时刻,只能有 一个线程访问该对象 关键字 synchronized 来与对象的互斥锁联系。 当某个对象 synchronized 修饰时, 表明该对象在任意时刻只能由一个线程访问(锁定的只是该方法内的代码) 生产者消费者问题 public class P2C { public static void main(String[] args) { LanZi lz = new LanZi(); Producer p =new Producer(lz); Consumer c =new Consumer(lz); //new Thread(p).start(); //new Thread(p).start(); new Thread(p).start();

new Thread(c).start(); } } class ManTou { int id; ManTou(int id) {this.id = id;} Object 类中 public String toString() {return "ManTou" + id;} public final void wait() throws } InterruptedException class LanZi { 在其他线程调用此对象的 notify() 方 int index = 0; 法或 notifyAll() 方法前,导致当前线 ManTou[] arrMT = new ManTou[6]; 程等待。 public synchronized void push(ManTou mt) { synchronized (obj) { while(index == arrMT.length) { while (<condition does not hold>) try{this.wait();} obj.wait(); catch (InterruptedException e){ ... // Perform action appropriate to e.printStackTrace();} condition } } this.notifyAll(); arrMT[index] = mt; public final void notify() index ++; 唤醒在此对象监视器上等待的单个线 } 程。 如果所有线程都在此对象上等待, public synchronized ManTou pop() { 则会选择唤醒其中一个线程。选择是 while(index == 0) { 任意性的,并在对实现做出决定时发 try {this.wait();} 生。线程通过调用其中一个 wait 方 catch (InterruptedException e){ 法,在对象的监视器上等待。 e.printStackTrace();} 直到当前线程放弃此对象上的锁定, } 才能继续执行被唤醒的线程。 this.notifyAll(); index --; return arrMT[index]; } } class Producer implements Runnable { LanZi lz = null; Producer(LanZi lz) {this.lz = lz;} public void run() { for(int i=0;i<20;i++) { ManTou mt = new ManTou(i); lz.push(mt); System.out.println("生产了:" + mt); try{Thread.sleep((int)(Math.random() * 200));} catch (InterruptedException e){ e.printStackTrace();} }

} } class Consumer implements Runnable { LanZi lz = null; Consumer(LanZi lz) {this.lz = lz;} public void run() { for(int i=0;i<20;i++) { ManTou mt = lz.pop(); System.out.println("消费了:" + mt); try{Thread.sleep((int)(Math.random() * 1000));} catch (InterruptedException e){ e.printStackTrace();} } } } wait 与 sleep wait 时别的线程可以访问锁定对象(调用 wait 方法的时候必须锁定该对象) sleep 时别的线程也不可以访问锁定对象 第 10 章 网络编程 参考模型 OSI 参考模型 应用层 表示层 会话层 传输层 网络层 数据链路层 物理层 IP(Internet Protocol) TCP(transmission control protocol) UDP(user data protocol) Socket(插座的意思) 两个 Java 应用程序可通过一个双向的网络通信连接实现数据交换,这个双向链 路的一端称为一个 Socket Soclet 通常用来实现 client-server 连接 java.net 包中定义的两个类 Socket 和 ServerSoclet, 分别用来实现双向连接的 client 和 server 端 建立连接时所需要的寻址信息为远程基选集的 IP 地址和端口号(Port number) TCP 端口 UDP 端口是分开的,每一个有 65536 个端口(建议使用 1024 以后的) TCP/IP 参考模型 应用层 传输层 网络层 物理+数据链路 层

TCP Socket 通信模型
Server --------------------------------------ServerSocket ss(port #) ss.accept() //等待连接 Socket 对象 --------------------------------------OutputStream InputStream --------------------------------------socket.close() Clicent --------------------------------------Socket s(host,port #) (Attempt to connect) --------------------------------------OutputStream InputStream --------------------------------------socket.close()

import java.net.*; import java.io.*; public class TCPServer { public static void main(String[] args) throws Exception { ServerSocket ss = new ServerSocket(6666); while(true) { Socket s = ss.accept(); DataInputStream dis = DataInputStream(s.getInputStream()); System.out.println(dis.readUTF());//阻塞的 dis.close(); s.close(); //System.out.println("A client connect"); } } } import java.net.*; import java.io.*; public class TCPClient{ public static void main(String[] args) throws Exception { Socket s = new Socket("127.0.0.1",6666); OutputStream os = s.getOutputStream(); DataOutputStream dos = new DataOutputStream(os); dos.writeUTF("hello server");

new

dos.flush(); dos.close(); s.close(); } } import java.io.*; import java.net.*; import java.applet.Applet; public class talkserver { public static void main(String args[]) { try { ServerSocket server = null; try { server = new ServerSocket(4700); }catch(Exception e) { System.out.println("can not listen to:" + e); } Socket socket = null; try { socket = server.accept(); }catch(Exception e) { System.out.println("Error:" + e); } String line; BufferedReader is = new BufferedReader(new InputStreamReader( socket.getInputStream())); PrintWriter os = new PrintWriter(socket.getOutputStream()); BufferedReader sin = new BufferedReader(new InputStreamReader(System.in)); System.out.println("Client:" + is.readLine()); line = sin.readLine(); while (!line.equals("bye")) { os.println(line); os.flush(); System.out.println("Server:" + line); System.out.println("Client:" + is.readLine());

line = sin.readLine(); } is.close(); os.close(); socket.close(); server.close(); }catch(Exception e) { System.out.println("Error" + e); } } } import java.io.*; import java.net.*; public class talkclient { public static void main(String args[]) { try { Socket socket = new Socket("127.0.0.1",4700); BufferedReader sin = new BufferedReader(new InputStreamReader(System.in)); PrintWriter os = new PrintWriter(socket.getOutputStream()); BufferedReader is = new BufferedReader(new InputStreamReader( socket.getInputStream())); String readline; readline = sin.readLine(); while (!readline.equals("bye")) { os.println(readline); os.flush(); System.out.println("Client:" + readline); System.out.println("Server:" + is.readLine()); readline = sin.readLine(); } os.close(); is.close(); socket.close(); }catch(Exception e) { System.out.println("Error" + e); }

} } UDP import java.net.*; import java.io.*; public class TestUDPServer { public static void main(String args[]) throws Exception { byte buf[] = new byte[1024]; DatagramPacket dp = new DatagramPacket(buf, buf.length); DatagramSocket ds = new DatagramSocket(5678); while(true) { ds.receive(dp); ByteArrayInputStream bais = new ByteArrayInputStream(buf); DataInputStream dis = new DataInputStream(bais); System.out.println(dis.readLong()); } } } import java.net.*; import java.io.*; public class TestUDPClient { public static void main(String args[]) throws Exception { long n = 10000L; ByteArrayOutputStream baos = new ByteArrayOutputStream(); DataOutputStream dos = new DataOutputStream(baos); dos.writeLong(n); byte[] buf = baos.toByteArray(); System.out.println(buf.length); DatagramPacket dp = new DatagramPacket(buf, buf.length, new InetSocketAddress("127.0.0.1", 5678)); DatagramSocket ds = new DatagramSocket(9999); ds.send(dp); ds.close(); } } 第 11 章 GUI 编程 AWT

AWT(Abstract Window Toolkit)包括了很多类和接口,用于 Java Application 的 GUI(Graphics User Interface 图形用户界面)编程 GUI 的各个元素(如:窗口,按钮,文本框等)由 Java 类来实现 使用 AWT 所涉及的类一般在 java.awt 包及其子包中 Container 和 Component 是 AWT 中的两个核心类

Component

Button TextArea Label TextField List …

Container

Window

Panel

Frame

Dialog

Applet

Component&Container Java 的图形用户界面的最基本组成部分是 Component,Component 类及其子类的 对象用来描述以图形化的方式显示在屏幕上并能与用户进行交互的 GUI 元素, 例 如,一个按钮,一个标签等 一般的 Component 对象不能独立的显示出来,必须将“放在”某一的 Container 对象中才可以显示出来 Container 是 Component 的子类, Container 子类对象可以 “容纳” 别的 Component 对象 Container 对象可使用方法 add(…)向其中添加其他 Component 对象 Container 是 Component 的子类,因此 Container 对象也可以被当做 Component 对象添加到其他 Container 对象中 有两种常用的 Container: Window:其对象表示自由停泊的顶级窗口 Panel:其对象可作为容纳其他 Component 对象,但不能独立存在,必须被添加 到其他 Container 中(如 Window 或 Applet) Frame Frame 是 Window 的子类,由 Frame 或其子类创建的对象为一个窗体 Frame 的常用构造方法: Frame() Frame(String s)创建标题栏为字符串 s 的窗口 setBounds(int x,int y,int width,int height): 设置窗体位置和大小, x , y 是左上角坐标 setLocation(int x,int y):设置窗体的位置,x,y 时左上角坐标

setSize(int width,int height):设置窗体的大小,width 和 heigtht 分别是宽 度和高度 setBackground(Color c):设置背景颜色,参数为 Color 对象 setVisible(boolean b):设置是否可见 setTitle(String name) String getTitle() setResizable(boolean b):设置是否可以调整大小 Panel Panel 对象可以看成可以容纳 Component 的空间 Panel 对象可以拥有自己的布局管理器 Panel 类拥有从其父类继承来的 setBounds(int x,int y,int width,int height) setSize(int width,int height) setLocation(int x,int y) setBackground(Color c) setLayout(LayoutManager mgr)等方法 Panel 的构造方法: Panel() :使用默认的 FlowLayout 类布局管理器初始化 Panel(LayoutManager layout)使用指定的布局管理器初始化 布局管理器 在 Java 语言中,提供了布局管理器类的对象可以管理 管理 Component 在 Container 中的布局, 不必直接设置 Component 的位置和大小 每个 Container 都有一个布局管理器对象, 当容器需要对某个组件进行定位或判 断其大小尺寸时,就会调用其对应的布局管理器,调用 Container 的 setLayout 方法改变其布局管理器对象 AWT 提供了 5 种布局管理器类: FlowLayout BorderLayout GridLayout CardLayout GridBagLayout FlowLayout FlowLayout 是 Panel 类的默认布局管理器 FlowLayout 布局管理器对组件逐行定位,行内从左到右,一行排满后换行 不改变组件的大小,按组件原始尺寸显示组件,可设置不同的组件间距,行距以 及对齐方式 FlowLayout 布局管理器默认的对齐方式时居中 FlowLayout 的构造方法 FlowLayout (FlowLayout.RIGHT,20,40) :右对齐, 组件之间水平间距 20 个像素,

垂直间距 40 个像素 FlowLayout(FlowLayout.LEFT):左对齐,水平和垂直间距为缺省值(5) FlowLayout() :使用缺省的居中对齐方式,水平和垂直间距为缺省值(5) BorderLayout BorderLayout 是 Frame 类的默认布局管理器 BorderLayout 将整个容器的布局划分成 东(EAST) ,西(WEST) ,南(SOUTH) ,北(NORTH) ,中(CENTER)五个区域,组 件只能被添加到指定的区域 如果不指定组件的加入部位,则默认加入到 CENTER 区 每个区域只能添加一个组件,如加入多个,则先前加入的会被覆盖 BorderLayout 型布局管理器尺寸缩放原则: 南、北两个区域在水平方向缩放 东、西两个区域在垂直方向缩放 中部可在两个方向上缩放 //f.add(bn, BorderLayout.NORTH); GridLayout 布局管理器 GridLayout 型布局管理器将空间划分为规则的矩形网络,每个单元格区域大小 相等。组件被添加到每个单元格中,先从左到右填满一行后换行,在从上到下 在 GridLayout 构造方法中指定分割的行数和列数,如:GridLayout(3,4) import java.awt.*; public class Test { public static void main(String[] args) { Frame f = new Frame("JavaFrame"); f.setLayout(new GridLayout(2,1)); Panel up =new Panel(new BorderLayout()); Panel down = new Panel(new BorderLayout()); f.add(up); f.add(down); up.add(new Button("SZ"),BorderLayout.WEST); up.add(new Button("SY"),BorderLayout.EAST); Panel upc = new Panel(new GridLayout(2,1)); up.add(upc,BorderLayout.CENTER); upc.add(new Button("SZS")); upc.add(new Button("SZX")); down.add(new Button("XZ"),BorderLayout.WEST); down.add(new Button("XY"),BorderLayout.EAST);

Panel downc = new Panel(new GridLayout(2,2)); down.add(downc,BorderLayout.CENTER); downc.add(new Button("1")); downc.add(new Button("2")); downc.add(new Button("3")); downc.add(new Button("4")); f.setSize(400,300); f.setVisible(true); } } 布局管理器总结 Frame 是一个顶级窗口,Frame 的缺省布局管理器为 BorderLayout Panel 无法单独显示,必须添加到某个容器中, Panel 的缺省布局管理器为 FlowLayout 当把 Panel 作为一个组件添加到某个容器中后, 该 Panel 仍然可以有自己的布局 管理器 使用布局管理器时, 布局管理器负责各个组件的大小和位置,因此用户无法在这 种 情 况 下 设 置 组 件 的 大 小 和 位 置 属 性 , 如 果 试 图 使 用 Java 语 言 提 供 的 setLocation(),setSize(),setBounds()等方法,则都会被布局管理器覆盖 如果用户确实需要亲自设置组件大小或位置,则应取消该容器的布局管理器,方 法为:setLayout(null) 事件监听 注册
事件源对象 实现了某种监听器接口 的类的对象

当某种事情发生 行某种处理 import java.awt.*; import java.awt.event.*; public class TestActionEvent { public static void main(String args[]) { Frame f = new Frame("Test"); Button b = new Button("Press Me!"); Monitor bh = new Monitor(); b.addActionListener(bh); f.add(b,BorderLayout.CENTER); f.pack();//调整此窗口的大小,以适合其子组件的首选大小和布局 f.setVisible(true); }

向监听器传送某种事件对象 (封装了某种事件的信息) 接到事件对象后进

} class Monitor implements ActionListener { public void actionPerformed(ActionEvent e) { System.out.println("a button has been pressed"); } } TextField 类 java.awt.TextField 类用来创建文本框对象 TextField 有如下常用方法: TextField() TextField(int columns) TextField(String text) TextField(String text,int columns) public void setText(String t) public String getText() public void setEchoChar(char c):设置回显字符 public void setEditable(boolean b) public boolean isEditable() public void setBackground(Color c) public void select(int selectionStart,int selectionEnd) public void selectAll() public void addActionListener(ActionListener):添加动作监听器 TextField 事件监听 TextField 对象可能发生 Action(光标在文本框内敲回车)事件。与该事件对应 的事件类是 java.awt.event.ActionEvent 用来处理 ActionEvent 事件是实现 java.awt.event.ActionListener 接口的类的 对象,ActionListener 接口定义有方法: public void actionPerformed(ActionEvent e) 实现该接口的类要在该方法中添加处理该事件(Action)的语句 使用 addActionListener(ActionListener l)方法为 TextField 对象注册一个 ActionListener 对象,当 TextField 对象发生 Action 事件时,会生成一个 ActionEvent 对 象 , 该 对 象 作 为 参 数 传 递 给 ActionListerner 对 象 的 actionPerformer 方法在方法中可以获取该对象的信息,并做相应的处理 import java.awt.*; import java.awt.event.*; public class TFActionEvent { public static void main(String[] args) { new TFFrame(); } } class TFFrame extends Frame

{ TFFrame() { TextField tf = new TextField(); add(tf); tf.addActionListener(new TFActionListener()); //tf.setEchoChar(‘*’);//密码 pack(); setVisible(true); } } class TFActionListener implements ActionListener { public void actionPerformed(ActionEvent e) { TextField tf = (TextField)e.getSource(); System.out.println(tf.getText()); tf.setText(""); } } 持有对方引用 import java.awt.*; import java.awt.event.*; public class TFMath { public static void main(String[] args) { new TFFrame().launchFrame(); } } class TFFrame extends Frame { TextField num1,num2,num3; public void launchFrame() { num1 = new TextField(10); num2 = new TextField(10); num3 = new TextField(15); Label lblPlus = new Label("+"); Button btnEqual = new Button("="); btnEqual.addActionListener(new MyMonitor(this)); setLayout(new FlowLayout()); add(num1);add(lblPlus);add(num2);add(btnEqual);add(num3); pack(); setVisible(true); } }

class MyMonitor implements ActionListener { /* TextField num1,num2,num3; public MyMonitor(TextField num1,TextField num2,TextField num3) { this.num1 = num1; this.num2 = num2; this.num3 = num3; } */ TFFrame tf = null; public MyMonitor(TFFrame tf) { this.tf = tf; } public void actionPerformed(ActionEvent e) { int n1 = Integer.parseInt(tf.num1.getText()); int n2 = Integer.parseInt(tf.num2.getText()); tf.num3.setText("" + (n1 + n2)); } } 内部类 OutClass$InClass.class 好处: 可以方便的访问包装类的成员 可以更清楚的组织逻辑,防止不应该被其他类访问的类进行访问 何时使用: 该类不允许或不需要其他类进行访问时 import java.awt.*; import java.awt.event.*; public class TFMath { public static void main(String[] args) { new TFFrame().launchFrame(); } } class TFFrame extends Frame { TextField num1,num2,num3; public void launchFrame() { num1 = new TextField(10); num2 = new TextField(10); num3 = new TextField(15); Label lblPlus = new Label("+"); Button btnEqual = new Button("="); btnEqual.addActionListener(new MyMonitor()); setLayout(new FlowLayout());

add(num1);add(lblPlus);add(num2);add(btnEqual);add(num3); pack(); setVisible(true); } private class MyMonitor implements ActionListener { public void actionPerformed(ActionEvent e) { int n1 = Integer.parseInt(num1.getText()); int n2 = Integer.parseInt(num2.getText()); num3.setText("" + (n1 + n2)); } } } Graphics 类 每个 Component 都有一个 paint(Graphics g)用于实现绘图目的,每次重画该 Component 时都自动调用 paint 方法 Graphics 类中提供了许多绘图方法,如: drawRect(int x,int y,int width,int height) fillRoundRect(int x,int y,int width,int height,int arcWidth,int arcHeight)等 Adapter&repaint import java.awt.*; import java.awt.event.*; import java.util.*; public class MyMouseAdapter{ public static void main(String args[]) { new MyFrame("drawing..."); } } class MyFrame extends Frame { ArrayList points = null; MyFrame(String s) { super(s); points = new ArrayList(); setLayout(null); setBounds(300,300,400,300); this.setBackground(new Color(204,204,255)); setVisible(true); this.addMouseListener(new Monitor()); } public void paint(Graphics g) { Iterator i = points.iterator(); while(i.hasNext()){

Point p = (Point)i.next(); g.setColor(Color.BLUE); g.fillOval(p.x,p.y,10,10); } } public void addPoint(Point p){ points.add(p); } } class Monitor extends MouseAdapter { public void mousePressed(MouseEvent e) { MyFrame f = (MyFrame)e.getSource(); f.addPoint(new Point(e.getX(),e.getY())); f.repaint(); } } 鼠标事件适配器 抽象类 java.awt.event.MouseAdapter 实现了 MouseListener 接口, 可以使用其 子类作为 MouseEvent 的监听器,只要重写其相应的方法即可 对于其他的监听器,也有对应的适配器 使用适配器可以避免监听器类定义没有必要的空方法 repaint-update()-paint()


赞助商链接

更多相关文章:
java知识点详细总结(毕向东笔记整理)
毕向东| java| java各知识点详细总结(毕向东笔记整理)_计算机硬件及网络_IT/计算机_专业资料。Java 基础知识总结 写代码: 1,明确需求。我要做什么? 2,分析思路。...
Java基础知识总结(超级经典)
Java基础知识总结(超级经典)_计算机软件及应用_IT/计算机_专业资料。Java 基础知识总结写代码: 1,明确需求。我要做什么? 2,分析思路。我要怎么做?1,2,3。 3...
java基础总结大全(笔记)
java基础总结大全(笔记)_IT认证_资格考试/认证_教育专区。一、基础知识: 1、JVM、JRE 和 JDK 的区别: JVM(Java Virtual Machine):java 虚拟机,用于保证 java ...
Java基础学习知识点总结
Java基础学习知识点总结_计算机软件及应用_IT/计算机_专业资料。黑马程序员_毕向东_Java 基础视频教程 Java 基础学习知识点总结 2016 年 01 月 06 日一、基础知识...
Java知识总结(五)--封装
Java知识总结(五)--封装_计算机软件及应用_IT/计算机_专业资料。java知识汇总 http://www.mybdqn.com/ Java 知识总结(五)--封装封 装(面向对象特征之一) :...
毕向东java基础总结(完整版)
毕向东java基础总结(完整版) - Java 基础知识总结(超级经典) 写代码: 1,明确需求。我要做什么? 2,分析思路。我要怎么做?1,2,3。 3,确定步骤。每一个思路...
尚学堂Java知识总结
尚学堂Java知识总结_互联网_IT/计算机_专业资料。Java 基础知识总结 目录 JAVA ...缓存的是完整的 sql 命令 AddBatch(sql) //添加到缓存中 sql 只能为 增加 ...
黑马程序员入学Java知识(精华总结)_图文
黑马程序员入学Java知识(精华总结)_计算机软件及应用_IT/计算机_专业资料。黑马程序员入学 Java 知识——精华总结 J2SE 部分,Java 高新技术部分,7K 面试题部分等...
java基础知识个人总结_图文
java基础知识个人总结_计算机软件及应用_IT/计算机_专业资料。第三章 对象和类 ...所以在标准版的 Java 中则提倡使用 Swing, 也就是通过牺牲速度来实现应用程 ...
Java基础知识总结(上)
Java基础知识总结(上)_计算机软件及应用_IT/计算机_专业资料。这是我从事IT行业3年对java基础知识的总结,能够帮助java学习借更快的了解java的基础,对刚毕业的同学...
更多相关标签:

All rights reserved Powered by 甜梦文库 9512.net

copyright ©right 2010-2021。
甜梦文库内容来自网络,如有侵犯请联系客服。zhit325@126.com|网站地图