Sun java

JAVA 程序设计

清华万博

课程内容：
 一 Java 简介
 二类，方法和构造函数
 三高级语言特性
 四数组， Collection
 五异常

一 Java 简介
 概述
 Java 的特点
 JDK ， JVM ， JRE 概念
 Java 的垃圾回收机制

概述－ Java 版本

Java 1.0
Java 1.1 Java 1

Java 1.2 Java 2
Java 1.3
Java 1.4
Java 1.5 (Java 5.0)

概述

J2SE 标注版
(Java 2 Standard Edition) •适用于开发用户端程序

J2EE 企业版
(Java 2 Enterprise Edition) •适用于开发 Server 端程序

J2ME 手持设备版
(Java 2 Micro Edition) •适用于开发手机，无线设备程序

IDE
NetBean/Jbuilder/Eclipse (IDE)

JDK (Java Development Kit)

JRE (Java Runtime
Environment)

Java
Java VM
Runtime
(JVM)
Classes

Java 的优点
 简单，上手快
 面向对象
 平台无关
 垃圾自动回收
 安全，不支持指针，避免内存泄漏

Java 的不足
 解释执行比编译解释执行慢
 部分功能不能实现

Java Runtime Enviornment(JRE)

*.java
编译器 javac *.java
平台无关字节码 *.class
平台相关解释器 JVM for 1. 执行字节码
2. 对底层硬件做适
当调整
Dos Unix Windows

Java 的垃圾回收机制
 提供自动垃圾收集来进行内存的管理
 java 不支持指针，一切对内存的访问都
必须通过对象
 在 JVM 空闲周期，垃圾收集线程
检查，释放内存
 时间不固定

二面向对象编程
 类 (Class) ，实例 / 对象 (Instance)
 super/this 方法
 instanceof ，类型转换
 参数传递－值传递
 多态
 重载
 重写
 封装
 命名规范
 Java 注释

类
 类是一个用来创建对象的模板
 每个 java 文件只能有一个 public 的类

 类包含方法和成员变量

 文件名必须与公有类类名一致

例如：文件名： Application.java
public Application{
public static void main(String[] args) {
System.out.println("Hello World!") ；
}

}

实例 / 对象（ Instance ）
 对象是一个类的具体实例，是对类中属
性的实化
 使用 new 关键字创建 Instance 的三个作
用
1. 为对象实例分配内存空间
2. 调用构造函数
3. 返回对象实例的引用

封装 (Information Hiding)
 类 / 对象封装了数据和方法
 尽量缩小成员的可访问性
 实现了模块化和信息隐藏

Not Hiding
public class MyDate {
public int day;
public int month;
public int year;
}

Hiding
public class MyDate {
private int day;
private int month;
private int year;

public void setDay(int day){
...
}

public int getDay(){
return day;
}
...
}

构造函数
 构造函数的访问权限不仅仅是 public
 总有一个 default 的构造函数
 每个类的构造函数体的第一条语句都是
缺省调用 super(), 故如果父类中无此形
式的构造函数则编译出错

构造函数
public class Thing {
private int x;

public Thing() {
x = 47;
}
public Thing(int new_x) {
x = new_x;
}

public int getX() {
return x;
}

}

Java Document API
public interface List extends Collection {

/**
* Returns the number of elements in this list. If this list contains
* more than <tt>Integer.MAX_VALUE</tt> elements, returns
* <tt>Integer.MAX_VALUE</tt>.
*
* @return the number of elements in this list.
*/
int size();

…

Java Document API
public int size()
Returns the number of elements in this list. If
this list contains more than
Integer.MAX_VALUE elements, returns
Integer.MAX_VALUE.
Returns:
the number of elements in this list.
…

继承
 单一继承
 构造函数不被继承
 private 修饰的成员不被继承
 构造子类对象时，缺省沿继承链调用父
类无参的构造方法 super()
 Java 中，所有的类都是通过直接或间接
的继承 java.lang.Object 得到的

多态
父类引用指向子类对象
 引用可以点取父类中的成员（编译时指

向父类成员，运行时动态绑定到子类中
的成员）
 不可以点取子类扩充的成员

多态
 Employee e = new Manager();

 1. 是 Manager 对象
 2. 编译器认为是 Employee 对象
 3. 方法覆盖时 , 指向 Manager 类中的方
法

Heterogeneous Collections
Employee[] staff = new Employee[1024];
staff[0] = new Manager();
staff[1] = new Employee();
staff[2] = new Engineer();
…

例子
class Parent{
void callme(){
System.out.println(“Invoke Parent’s callme()”);}
}
class Child extends Parent{
void callme(){
System.out.println(“invoke Child’s callme()”);}
}
public class Main{
public static void main(String args[]){
Parent p=new Child();
p.callme();}
}

上例说明
a 为 Parent 类型的变量，用 new 建立
Parent 类型的子类 Child 的一个实例，
并将其引用存储到 a 中。编译时
a.callme() 指向父类 Parent 的成员方法
，而运行时，则动态绑定到子类 Child 中
的成员方法。故程序将调用 Child 的
callme() 方法。

Class Cast
public void doSomething(Employee e) {
if (e instanceof Manager) {
Manager m = (Manager)e;
…
}
}

成员权限（数据成员，方法成
员）
本类同包非同包非同包
类子类非子类
public √ √ √ √

protected √ √ √

(default) √ √

private √

参数传递－值传递
 被调用方法不能改变参数
 当参数为对象时，传递的是对象引用
 当参数为基本类型时，传递的是值

问题：
public class Foo {
public static void main (String [] args) {
StringBuffer a = new StringBuffer ("A");
StringBuffer b = new StringBuffer ("B");
operate (a,b);
system.out.println(a + "," +b);
}

static void operate (StringBuffer x, StringBuffer y) {
x.append (y);
y = x;
}
}

方法重载（ overloading ）
 在同一个类中
 方法名相同

 参数的个数或类型不同

 重载是编译时问题

注：只有返回值类型不同，不叫方法重
载，编译时会报错

重载方法
 public void println(int i)
 public void println(float f)
 public void println()

重载构造函数
public class Employee {
private String name;
private double salary;
private Date birthDate;

public Employee(String name, double salary, Date DoB) {
this.name = name;
this.salary = salary;
this.birthDate = DoB;
}
public Employee(String name, double salary) {
this(name, salary, null);
}
public Employee(String name, Date DoB) {
this(name, BASE_SALARY, DoB);
}
public Employee(String name) {
this(name, BASE_SALARY);
}
}

this 关键字
 this 指代对象实例自身
 静态方法中不存在 this 的使用
 使用 this 简化构造函数的编写
 当不能事先知道实例名时使用 this 代替
 使用 this 区别成员变量和自动变量

方法重写（ overriding ）
 方法声明形式一致
 方法权限不允许缩小
 覆盖的方法不允许抛出比父类方法更多
的异常

方法重写例子
 class Parent
 {
 public void Parent()
 {System.out.println(“Parent”);}
 }
 class Child extends Parent
 {
 public void Child ()
 {System.out.println(“Child ”);}
 }

问题
 public void setVar (int a, int b, float c)
Which overload the setVar method? (Choose Two)

A. Private void setVar (int a, float c, int b) { }
B. Protected void setVar (int a, int b, float c) { }
C. Public int setVar (int a, float c, int b) (return a;)
D. Public int setVar (int a, int b, float c) (return a;)
E. Protected float setVar (int a, int b, float c) (return c;)

super 关键字
 super 用来引用父类的变量或方法
 通常用来扩展父类方法的功能
 super() 表示调用父类的构造函数（如果
父类存在缺省的构造函数）
 子类的构造函数会自动调用 super()

Object 类
 所有的类都是从 Object 类继承
 数组也是一种 Object ，例如： int[]
 public boolean equals(Object obj) 方法
 toString() 方法

equals 方法和“ ==”
 “==” 可用于基本数据类型及引用类型
 equals() 只能用于引用类型
 equals() 表示逻辑上的“相等”
 “==” 对于任何引用值 X ， Y ，当且仅当
X 和 Y 指向同一对象时，“ X==Y” 返回
true
 Object 类的 equals 方法相当于“ ==”
 “==” 用于引用类型时 ,“==” 两边的类型必
须一致 , 否则编译报错

equals 方法和“ ==”
String s1=new String (“abc”);
String s2=new String (“abc”);
System.out.println(s1==s2); // print ‘false’
System.out.println(s1.equals(s2)); //print ‘true’
若 : String s1=“abc”;
String s2=“abc”;
s1,s2 常量对象 , 系统只分配一个空间 , 所
以引用相同
s1==s2; true

toString 方法
 用来显示一个对象的信息，或把该对象转换成
String
 当 System.out.println(Object) 时，实际上自动
调用了 System.out.println(Object.toString());
class Date {
public String toString()
{ return year+”/”+month+”/”+day; }
}
System.out.println(d); 系统调用 d.toString

命名规范
 包名 : 全小写 , 一般为名词 , 如 :
package shipping.objects
 类名 (Class) ：首字母大写（如
System ， Date ）
 方法名 (Method) ：首字母小写，由大写字母
区分词 ( 如 sayHello())
 变量 (Variable) ：首字母小写，由大写字母区
分词 ( 如 currentCustomer)
 常量 (Constant): 全部大写，并下划线连接词
( 如 MAX_SIZE)

Java 注释
 // 单行注释
 /* 单、多行注释 */
 /** 文档注释 */ （放在变量、方法、
类的前面，通过 javadoc 命令自动被包
含在所产生的 HTML 文档中）

三数组，集合类 Collection
 数组
 List
 Map
 Set

数组
 下标从 0 开始
 声明

int a[ ] ；
int[ ] a ；
String[] s;
 创建数组

a = new int[5] ；
 数组一旦被创建 , 大小无法改变

数组初始化
int a[]={1 ， 2 ， 3 ， 4 ， 5} ；
String s[]={“abc” ，“ def”}
Circle[] c = {new Circle(),new Circle()};

数组初始化
 数组中的每个元素具有相同的数据类型，包括基本数
据类型和对象
 对于基本数据类型，系统会自动初始化
如上例： a 初始化成 a ＝ {0,0,0,0,0};
boolean 类型的元素会自动初始化为 false
 对于对象类型，系统不会自动初始化，还必须分别手
工创建
如： Circle[] c = new Circle[5];
//c = {null,null,null,null,null};
Circle c1 = new Circle();
C[0] = c1;

多维数组
 定义：
int[][] a;
int a[][];
 创建多维数组时 , 必须指明第一维的大小

int twoDim[][] = new int [4][];
int twoDim[0] = new int[5];
或： int twoDim[][] = new int[4][5];

数组拷贝
int a[]={1,2,3};
int b[]={4,5,6,7,8,9};
System.arraycopy(a,0,b,0,a.length);
// 结果： b[]={1,2,3,7,8,9};

问题：
Which of the following statements are true?
1) The elements in a Java array can only be of primitive
tray can only be of primitive types, not objects
2) Arrays are initialized to default values wherever they
are created
3) An array may be dynamically resized using the
setSize method
4) You can find out the size of an array using the size
method

Collection 框架
四个接口
 Collection 接口：元素可重复 , 无序

 Set 接口：元素不重复 , 无序

 List 接口：元素可重复 , 有序

 Map 接口： key/value 对

Collection 框架
Vector
List

ArrayList
Collection
HashSet

Set

TreeSet
HashMa
p
Map

Hashtable

问题
Which statement is true for the class
java.util.HashSet?
A. The elements in the collection are ordered.
B. The collection is guaranteed to be
immutable.
C. The elements in the collection are
guaranteed to be unique.
D. The elements in the collection are
accessed using a unique key.
E. The elements in the collections are
guaranteed to be synchronized.

问题
You need to store elements in a collection that
guarantees that no duplicates are stored and
all elements
can be accessed in natural order. Which
interface provides that capability?
A. java.util.Map.
B. java.util.Set.
C. java.util.List.
D. java.util.SortedSet.
E. java.util.SortedMap.
F. java.util.Collection.

四高级语言特性
 static 关键字
 final 关键字
 接口 (interface)
 内部类

static 关键字
 只能修饰成员 , 不能修饰方法变量
 static 方法不能被覆盖

使用场合：
 类变量

 类方法

 static 块

实例变量的访问
public class Circle
{ int x,y;
public int x(){return x;}
public void setX(int newX){x=newX;}

Circle myCircle=new Circle();
myCircle.setX(23);
System.out.println("myCircle.x="+myCircle.x());
}
}

类变量的访问
public class Circle{
static int x,y;
public int x(){return x;}
public void setX(int newX){x=newX;}

Circle myCircle=new Circle();
myCircle.setX(23);
System.out.println("myCircle.x="+myCircle.x());
}
}

static 方法
Public class GeneralFunction{
public static int addUp(int x,int y){
return x + y;
}
}

静态方法不能访问非静态变
量
class Circle
{
private int x;
public static int x()
{return x;}
} //Wrong!!!!!!

非静态方法可以访问静态变
量
class Circle
{
private static int x;
public int x()
{return x;}
} //right!!

static 块
Public class StaticInitDemo{
static int i = 5;
static{
System.out.println(“i=“ + i);
}
}

问题
 非静态方法能不能访问静态变量？

问题

1) static methods do not have access to the
implicit variable called this
2) A static method may be called without
creating an instance of its class
3) A static method may not be overriden to be
non-static
4) A static method may not be overloaded

final 关键字
使用场合：
 终极类 (final class)

 终极方法 (final method)

 常量 (const) ( 例： final int MAX_SIZE=

10)

final 类 / 方法
 final 类不被继承
 final 方法不被重写

 声明为 static 或 private 的方法自动地声

明为 final
例：
java 中的 String 类为 final 类，不能被继
承。

abstract 类和方法
 abstract 类必须被继承
 abstract 方法必须被重写
 abstract 类中可以包含 abstract 方法
 abstract 方法只需声明，不需实现。
 abstract 类中不一定要包含 abstract 方
法，但某个类中如包含了 abstract 方法
，则这个类必须声明为 abstract 类。

abstract 例子
abstract class AbstractParent{
abstract void callme();
}
class Child extends AbstractParent{
void callme(){ System.out.println("Invoke Child’s callme()");}
}
public class Test{
AbstractParent c=new Child();
c.callme();
}
}

interface
 interface 是抽象类地变体
 interface 中的所有方法都是抽象的
 inteface 只可定义 static final 的成员变量
 inteface 是多继承的

interface
接口（ interface ）定义：
public interface Transparency{
public static final int OPAQUE=1;
public static final int BITMASK=2;
public static final int TRANSLUCENT=3;
public int getTransparency();
}

interface
类实现接口（ interface ）：
public class MyApplet extends Applet
implements Runnable, MousListener{
…
}

问题

1) An interface can only contain method and not
variables
2) Interfaces cannot have constructors
3) A class must extend only one other class and
implement only one interface
4) Interfaces are the Java approach to addressing its
lack of multiple inheritance, but require implementing
classes to create the functionality of the Interfaces.

内部类
 内部类可以访问外部类的所有成员 , 包括
private 成员，内部类可以互相调用
 内部类可以定义在方法中 , 但只能使用方
法中的 final 常量
 可以被定义为 abstract 抽象类
 内部类不能声明任何 static 成员
 编译后 : A$B.class （ B 为内部类）

内部类
class TopClass
{
…
class InnerClass
{ }
}

本地类
public class TopClass{
public void methodA{
class LocalClass{
……
}
……
}
……
}

匿名类
 匿名类 (anonymouse class)— 内部类的一种
特殊形式
 匿名类没有自己的名字
 匿名类不能有构造函数
 匿名类不能定义静态的成员
 只可以创建一个匿名类实例

匿名类 (anonymous class)
public class MainUI extends JDialog{
JTextField txt = new JTextField("");
...
txt.addKeyListener(new KeyListener(){
public void keyTyped(KeyEvent e) {
}
public void keyPressed(KeyEvent e) {
}
public void keyReleased(KeyEvent e) {
}
});
}

Which statement is true?
A. An anonymous inner class may be declared as final.
B. An anonymous inner class can be declared as
private.
C. An anonymous inner class can implement multiple
interfaces.
D. An anonymous inner class can access final variables
in any enclosing scope.
E. Construction of an instance of a static inner class
requires an instance of the enclosing outer class.

五异常
 什么是异常
 异常处理结构
 finally 语句
 异常类的继承关系
 创建自定义异常
 常见异常的理解

什么是异常
在程序执行过程中，任何中断正常程序流程的
错误条件就是异常：
 想打开的文件不存在
 网络连接中断
 受控操作数超出范围
 正在装载的类文件丢失

调用栈机制

顶部
connect()

init() 异常
调
传递
用
栈 MyDialog()

main() 底部
异常向下通过调用堆栈直到它被一个方法处理，
如果到了 main 还没有方法处理，该异常会中断程
序

异常处理结构
try{
…
}catch( 异常类 e){
异常处理 ;
} finally{
终止处理 ;
}

catch 语句的顺序
捕获例外的顺序和不同 catch 语句的顺
序有关 , 当捕获到一个例外时 , 剩下的
catch 语句就不再进行匹配。因此，在安
排 catch 语句的顺序时，首先应该捕获
最特殊的例外，然后再逐渐一般化。也
就是一般先安排子类，再安排父类

finally 语句
 finally 语句总是执行，不考虑异常是否被
捕获
 finally 唯一不被执行的情况是
System.exit() 在保护码内执行

异常类的继承关系

Error

Throwable RuntimeException

Exception

。。。

常见的 Exception
 ArithmeticException
 NullPointerException
 NegativeArraySizeException
 ArrayIndexOutOfBoundsException
 SecurityException

方法声明异常
 方法可以声明抛出的 Exception
 比如：

public void callsTroublesome() throws
IOException

异常应该不从 RuntimeException 继承

创建异常类
继承 Exception 类，或 RuntimeException
类
class MyException extends Exception{
public MyException(){
super();
}
}

使用异常

方法声明时使用 throws 抛出异常
 方法体中需要产生异常的地方抛出异常对象 throw
class A{
public void a(int number)throws MyException{
if (number)
throw new MyException();
……
}
}

使用异常
//b （）中不处理 Exception ，继续向上抛
class B{
void b() throws MyException{
A a=new A();
a.a(-1);
}
}

Sun java

Recomendados

Recomendados

Más contenido relacionado

La actualidad más candente

La actualidad más candente (20)

Destacado

Destacado (8)

Similar a Sun java

Similar a Sun java (19)

Sun java