chapter5(My--Java教案).doc

5.1 超类与继承类的关系
向上转换（upcasting）：把继承类作为父类使用

5.2 通过classpath访问另一个目录中的类
一个类能够访问另一个类：
1、这两个类在同一个文件中
2、若不在同一个文件中，他们在同一个目录里
若这两个类不满足上面的条件，还希望能够访问，就必须设置classpath，用来指出类所在的路径。
譬如：Him1.java在d:\javaplus目录中
public class Him1
{
public int k = 100;
}
要访问Him1.java的类Me1.java在d:\scjp\c4目录中
public class Me1
{
public static void main(String[] args)
{
Him1 him=new Him1();
System.out.println("Him.i= "+him.i);
}
}
为了是Me1能够找到Him1，我们设置classpath= d:\scjp\c4 ;d:\javaplus

5.3 通过软件包访问另一个目录中的类
1、建立软件包
package 软件包名称；
例如把Him2.class放到mypack . lib1软件包里：
package mypack.lib1;
public class Him2
{
public int i=100;
}
当编译完Him2.java后，把Him2.class放到目录mypack\lib1中，此时的classpath 恰好设置在mypack目录的父目录上。实际目录是d:\javaplus\mypack\lib1，classpath=d:\javaplus
2、使用软件包
import 软件包；
例如类Me2.java要访问Him2类：
import mypack.lib1.Him2;
public class Me2
{
….
}
注意：Me2.class在d:\scjp\c4 下，而Him2.class在d:\javaplus\mypack\lib1下，因为要运行Me2类，而且Me2类在运行时要能够找到Him2类，所以设置classpath 为：
classpath= d:\scjp\c4 ; d:\javaplus
3、在程序中正确使用package 和import语句的顺序
package ***.***
import ***.***
class ***
{
…
}
程序中只可能有一个package语句，但可以有多条import语句。
举例：
path已经被设置为：path=C:\jdk\bin
1）文件Him2.java
package mypack . lib1;
public class Him2
{
public int i=100;
}
2）文件test.java
package mypack . lib2;
import mypack . lib1 .*;
public class test
{
public static void main(String[] args)
{
Him2 h = new Him2();
System.out.print(h.i);
}
}
3）设置classpath = d:\project
编译Him2.java
将Him2.class移动到d:\project\mypack\lib1
编译test.java
将test.class移动到d:\project\mypack\lib2
4）运行test
无论当前目录在哪里，想要运行test.class，如下所示：
java mypack.lib2.test

5.4 存取（访问）控制
1、存取控制符：用来限定类可被外界访问的程度。
1） public ：可以修饰类、数据和方法，表示所修饰的事物是‘公共财产’，可以被任何程序访问。
一个类前面没有public和其他修饰符，他也可以被其他类访问，但是要满足：
Ø 两个类在同一个文件中
Ø 两个类在同一个文件夹中
Ø 两个类在同一个软件包中
2） private ：他修饰的数据只能在数据所在的类中才能使用，他修饰的方法只能在方法所在的类中使用，即使同一个文件的其他类也不能访问。
3） protected ：针对继承，表示他所修饰的数据或者方法对继承类公开，即继承类可以访问超类中的protected数据和方法，但外界不能访问。他不能修饰类。
例子：
在软件包mypack . lib1中的一个类Parent：
package mypack.lib1;
public class Parent
{
protected int i=100;
}
下面这个程序要访问Parent，但是和Parent不在同一个文件夹中：
import mypack.lib1.Parent;
public class Children extends Parent
{
public static void main(String[] args)
{
Children son=new Children();
Parent father=new Parent();
System.out.println("son.i= "+son.i); //success
System.out.println("father.i= "+father.i); // error
}
}
2、总结
public（类、类中的数据和方法）：任何类可访问
protected（类中的数据和方法）：继承类和同一软件包的类可访问
private（类中的数据和方法）：只能在其修饰的数据和方法所在的类内可访问
无存取控制符（类、类中的数据和方法）：同一软件包的类可访问

5.5 抽象类和抽象方法
1、abstract
使用关键字abstract修饰一个类，这个类就是抽象类；修饰一个方法，这个方法就是抽象方法。
astract class AbstractClassExample
{
int k;
abstract void Func();
}
注意：
1）若一个类是抽象类，就不能创建这个类的对象，必须使用继承的方法来访问抽象类
中的成员；
2）抽象方法没有方法的定义体；
3）若一个类中有一个抽象方法，那麽这个类就是抽象类；
4）直接继承抽象类的类必须实现抽象类中的抽象方法。
2、具体例子
abstract class AbstractClassExample
{
int i;
abstract void abstractFunc();
void notAbstractFunc1()
{
}
void notAbstractFunc2()
{
i = 0;
}
}
class Class1 extends AbstractClassExample
{
void abstractFunc()
{
i = 1;
}
}
class Class2 extends AbstractClassExample
{
void abstractFunc()
{
}
}
class Class3 extends Class1
{
void abstractFunc()
{
i = 3;
}
}
class Class4 extends Class3
{
}
3、尽管不能创建抽象类的对象，但是抽象类可以有一个main方法，即抽象类可以运行
public abstract class AbstractClass1
{
int j;
public abstract void func1( );
public static void main(String[] args)
{
System.out.println(" i am abstract class");
}
}

5.6 接口interface与多重继承
1、接口基础
interface InterfaceExample
{
int j = 4;
int k = 5;
void func1( );
int func2( int x );
}
接口中的所有数据成员都是static 和final，即静态常量，可以不用这两个关键字修饰，但并且必须给常量赋初值；接口中的方法都是抽象方法，并且全部为public。
2、类可以使用接口

注意：1）c.func2 (k) →由于k是接口中的数据成员，因此是静态常量，可以直接使用。
2）接口中的方法都是public，因此，必须在实现方法时加上关键字public。
3、抽象类可以执行接口，可以实现或者不实现接口中的方法

4、多重继承
Java不允许一个类继承多个类，即最多只能继承一个类。但是可以通过执行多个接口来达到多重继承的效果：
interface InterfaceExample1
{
int i=4;
void func1();
}
interface InterfaceExample2
{
int k=5;
void func2();
}
class Class3
{
public void func2()
{
System.out.println("func2 in class3");
}
}
public class InterfaceClass2 extends Class3 implements InterfaceExample1,InterfaceExample2
{
int j;
public void func1()
{
System.out.println("func1 in InterfaceClass2");
}
/* public void func2()
{
System.out.println("func2 in InterfaceClass2");
} */
public static void main(String[] args)
{
InterfaceClass2 c=new InterfaceClass2();
c.func1();
c.func2();
}
}
接口之间使用extends关键字表示继承，并且被继承的接口以逗号分隔：

5、接口的类型转换（Upcasting）
interface A
{
void f ( A a );
}
class C implements A
{
public void f ( A a )
{
System.out.println(" f( )");
}
public static void main(String[] args)
{
C c=new C ( );
c.f (c);
}
}
方法f的参数类型为A，但是可以用C来调用，即执行接口的类也是接口的一种类型，
和继承超类的子类原理想同。

5.7 内部类基础
1、内部类：定义在一个类内部的类。
2、例子：

内部类可以直接访问外部类的成员，不需要创建外部类的对象；而外部类则不能
外部类要想访问内部类：
1）创建外部类的对象如outer
Outer outer = new Outer( );
2）创建内部类的对象如inner
Outer . Inner inner = outer . new Inner( );
3）访问内部类成员
inner . m1( 2 );

5.8 Java的存储结构
Java把存储器分为：
1、 寄存器
2、栈
3、堆
4、静态存储区
5、常量存储区

5.9 编写类实现循环链表
1、节点类Note
class Note
{
public String data;
public int x;
public int y;
public Note next;

public Note( String d , int offset_x , int offset_y )
{
data = d;
x = offset_x;
y = offset_y;
}
}
2、循环链表类Query
class Query
{
final int wh = 10;

private Note head ;
private Note p ;
int num;

public Query()
{
head = new Note( "head" , wh , wh );
head.next = head;
num = 1;
}
public Query( int size )
{
head = new Note( "head" , ( size + 2 ) * wh , wh + 20 );
head.next = head;
num = 1;
int i,j;
Note[] add;
add = new Note[ size ];

for ( j = 1 ; j < size ; j ++ )
{
add[ j ] = new Note( String.valueOf( j ) , ( size + 2 ) * wh - j * wh , wh + 20 ) ;
//addElement( add[ j ] );
p = head;
for ( i = 1 ; i < num ; i ++ )
{
p = p.next;
}
add[ j ].next = head;
p.next = add[ j ];
num ++;
}
}
public void addElement( Note add )
{
p = head;
for ( int i = 1 ; i < num ; i ++ )
{
p = p.next;
}
add.next = head;
p.next = add;
head = add;
num ++
}
public void move( int x , int y )
{
p = head;
for ( int i = 0 ; i < num - 1 ; i ++ )
{
p = p.next;
}
p.x = head.x + x;
p.y = head.y + y;
head = p;
}
public int getX( int offset )
{
p = head;
for ( int i = 0 ; i < offset ; i ++ )
{
p = p.next;
}
return p.x;
}
public int getY( int offset )
{
p = head;
for ( int i = 0 ; i < offset ; i ++ )
{
p = p.next;
}
return p.y;
}
public void setElement( String d )
{
p = head;
for ( int i = 0 ; i < num - 1 ; i ++ )
{
p = p.next;
}
p.data = d;
}
}