《计算概论》课程第十九讲 C 程序设计语言应用

Size: px

Start display at page:

Download "《计算概论》课程第十九讲 C 程序设计语言应用"

刃荤
5 years ago
Views:

1 Java 高级技术课程第二讲 Java 语言的面向对象特性 (4) 李戈北京大学信息科学技术学院软件研究所 2010 年 3 月 28 日

2 嵌套类嵌套类在一个类的内部定义的类 ; 相应的, 直接定义在包级的类称为顶层类 ; 嵌套类可分为两种 : 成员类 : 直接定义在类作用域范围的嵌套类, 是类的成员, 所以称为成员类, 而定义它的类称为该成员类的外围类 ; 局部类 : 定义在类的某个方法体甚至某个花括号对括起来的局部作用域块的嵌套类

3 成员类 class Outer { int outer_x = 100; void test() { Inner inner = new Inner(); inner.display(); class Inner { void display() { System.out.println("display: outer_x = " + outer_x); class InnerClassDemo { public static void main(string args[]) { Outer outer = new Outer(); outer.test();

4 局部类 public class Parcel4 { public Destination dest(string s) { class PDestination implements Destination { private String label; private PDestination(String whereto) { label = whereto; public String readlabel() { return label; return new PDestination(s); public static void main(string[] args) { Parcel4 p = new Parcel4(); Destination d = p.dest("tanzania");

5 关于成员类和局部类关于成员类非静态成员类的对象实例必须在有定义它的外围类的对象实例存在的情况下才能创建 ; 静态成员类的对象实例创建则不受此限制 ; 关于局部类有名局部类 ; 匿名局部类 ; 非静态成员类和局部类统称为内部类

6 匿名局部类 public class Parcel6 { public Contents cont() { return new Contents() { private int i = 11; public int value() { return i; ; public static void main(string[] args) { Parcel6 p = new Parcel6(); Contents c = p.cont();

7 内部类内部类的特性它可访问外围类的所有成员, 包括私有成员内部类对象实例总在存在外围类对象实例时才能创建在外围类以外的地方创建内部类的对象实例, 也要先创建外围类的对象实例, 再使用该对象实例创建内部类的对象实例

8 内部类的作用是什么? 内部类的作用将某个类对某些操作的细节完全封装在类内部, 则可以在类内部定义内部类典型用法 : 将某个接口的实现完全封装在一个类里面 ;

9 class Parcel3 { private class PContents implements Contents { private int i = 11; public int value() {return i; private class PDestination implements Destination { private String label; public PDestination(String whereto) { label = whereto; public String readlabel() { return label; public Destination dest(string s) { return new PDestination(s); public Contents cont() { return new PContents(); public class TestParcel { public static void main(string[] args) { Parcel3 p = new Parcel3(); Contents c = p.cont(); Destination d = p.dest("tanzania"); System.out.println(d.readLabel()); System.out.println(c.value());

10 class Parcel3 { class PContents implements Contents { private int i = 11; public int value() {return i; class PDestination implements Destination { private String label; public PDestination(String whereto) { label = whereto; public String readlabel() { return label; public Destination dest(string s) { return new PDestination(s); public Contents cont() { return new PContents(); public class TestParcel { public static void main(string[] args) { Parcel3 p = new Parcel3(); Parcel3.PContents pc = p.new PContents(); System.out.println(pc.value()); Parcel3.PDestination pd = p.new PDestination("Test"); System.out.println(pd.readLabel());

11 class Parcel3 { private class PContents implements Contents { private int i = 11; public int value() {return i; private class PDestination implements Destination { private String label; public PDestination(String whereto) { label = whereto; public String readlabel() { return label; public Destination dest(string s) { return new PDestination(s); public Contents cont() { return new PContents(); public class TestParcel { public static void main(string[] args) { Parcel3 p = new Parcel3(); Parcel3.PContents pc = p.new PContents(); System.out.println(pc.value()); Parcel3.PDestination pd = p.new PDestination("Test"); System.out.println(pd.readLabel());

12 内部类的作用内部类的作用屏蔽接口实现者的实现细节 ; 避免其他类对接口实现者的依赖 ; Thinking in Java private 内部类给类的设计者提供了一种途径, 以完全阻止任何依赖于类型的编码, 并且完全隐藏了实现的细节

13 内部类举例 // 迭代器接口 public interface Iterator { // 判断是否有下一个元素 boolean hasnext(); // 给出下一个元素 Object next( ); // 内部类的使用 ObjectSet set = new ObjectSet(10); Iterator iterator001 = set.getiterator( ); iterator001.hasnext( ); class ObjectSet { private Object[] objects; private int next = 0; public ObjectSet(int size) { public void add(object element) { private class InternalIterator implements Iterator { int index; public InternalIterator() { public boolean hasnext() { public Object next() { public Iterator getiterator() { return new InternalIterator

14 静态类静态类声明在外围类中, 作为外围类的静态成员静态类是外围类的静态成员, 因此它遵守类的静态成员所应遵守的规则静态类的对象实例可以独立创建, 没有指向外围类的对象实例的引用, 也不与任何外围类的对象实例相关联总之, 静态类类似于顶层类, 只是恰巧被定义在另外一个类的内部而已

15 class Statistics { public static class Result { public static Result scan (int data[]) { Result r = new Result(); return r; 静态类 public class StatisticsDemo { public static void main(string[] args) { int[ ] data = {90, 77, 89, 83, 92; Statistics.Result r = Statistics.scan(data); r.display(); Statistics.Result obj = new Statistics.Result(); Statistics outobj = new Statistics(); Statistics.Result inobj = outobj.new Result();

16 静态类的作用返回数据 Java 语言的一个方法无法简单地返回多个基本数据类型的数据使用静态类可以很好地解决这一问题, 可将多个基本数据类型的数据封装在一个静态类中, 返回对该静态类的引用就可以返回多个基本数据类型的数据

17 Java 语言的面向对象特性 (5) 运行期类型识别

18 运行期类型识别 RTTI ( Run-Time Type Identification ) 在运行期间, 识别一个对象的类型

19 RTTI 的三种方法强制类型转换利用 Class 对象通过比较识别类型运行期类型识别

20 class Shape { (1) 利用强制类型转换判别运行期类型 void draw() { System.out.println ( this + ".draw()"); class Circle extends Shape { public String tostring() { return "Circle"; class Square extends Shape { public String tostring() { return "Square"; class Triangle extends Shape { public String tostring() { return "Triangle"; public class Shapes { public static void main(string[] args) { // Array of Object, not Shape: Object[ ] shapelist = { new Circle(), new Square(), new Triangle() ; for (int i = 0; i < shapelist.length; i++) ((Shape) shapelist[i]).draw();

21 强制类型转换并不彻底问题 Object 被转型为 Shape, 而不是转型为 Circle, Square, 或者 Triangle 假如能够知道某个引用的确切类型, 则可以进行更加个性化的处理程序中有一段代码用来旋转列表中的所有图形, 但你想跳过圆形, 因为对圆形作旋转没有意义如果你可以获取到某个 Shape 引用所指向的对象的确切类型, 就可以选择或者剔除这个特例那么, 类型信息在运行期是如何表示的?

22 Class 对象类型信息的表示方式对象的类型信息是由被称为 Class 对象的特殊对象表达 ; Class 对象描述了运行中的 classes 和 interfaces 的相关信息 ; 通过 Class 对象可以在运行中取得这些信息 ; Class 对象被用来创建类的常规对象 ; 每个类都有一个 Class 对象, 保存在与其同名的.class 文件中 ; 所有 Class 对象都属于 Class 类 ;

23 Class 对象的作用类型信息的表示方式在运行期间, 一旦我们想生成某个类的一个对象 : 运行这个程序的 Java 虚拟机 (JVM) 首先检查这个类的 Class 对象是否已经加载如果尚未加载,JVM 就会根据类名查找.class 文件, 并将其载入一旦某个类的 Class 对象被载入内存, 它就被用来创建这个类的所有对象

24 步骤 : (2) 利用 Class 对象识别对象的类型获取某个对象的 Class 对象 ; 获取 Class 对象中的类型相关信息 ; 例如 : Class 类的 getname() : 以 String 的形式返回此 Class 对象所表示的实体 ( 类接口数组类基本类型或 void) 名称 void printclassname(object obj) { System.out.println("The class of " + obj + " is " + obj.getclass().getname());

25 类型信息的获取方式如何获取一个 class 的 Class 对象通过 Object.getClass( ) 方法来获得通过 Class.forName( ) 方法获得通过类字面常量 (Class Literals) 获得

26 类型信息的获取方式通过 Class.forName( ) 方法获得 Class 类的 forname( ) 方法 forname(string classname) : 返回与带有给定字符串名的类或接口相关联的 Class 对象例如 : class Dog {.. Class referencetodog = Class.forName( Dog );

27 类型信息的获取方式通过类字面常量 (Class Literals) 获得字面常量的形式为 :classname.class 对于基本类型, 每种基本类型的包装类都有一个名为 TYPE 的标准数据, 能够产生一个指向相应的基本类型的 Class 对象的引用 Integer.TYPE 等同于 int.class 例如 : class dog {.. Class referencetodog = dog.class;

28 class Cat { Cat( ) { System.out.println("Init Cat()"); static { System.out.println("Loading Cat"); class Dog { Dog( ) { System.out.println("Init Dog()"); static { System.out.println("Loading Dog"); class Duck { Duck( ) { System.out.println("Init Duck()"); static { System.out.println("Loading Duck"); in main() Loading Cat Init Cat() After create Cat() Loading Dog After Class.forName("Dog") Loading Duck Init Duck() After create Duck() After d.getclass("duck")

29 public class LetterClass { public static void main(string[] args) { System.out.println("in main()"); new Cat(); System.out.println("After create Cat()"); try { Class c1 = Class.forName("Dog"); //System.out.println(c1.getName()); Class c2 = Dog.class; //System.out.println(c2.getName()); catch (ClassNotFoundException cnfe) { cnfe.printstacktrace(); System.out.println("After Class.forName(\"Dog\")"); Duck d = new Duck(); System.out.println("After create Duck()"); Class c3 = d.getclass(); //System.out.println(c3.getName()); System.out.println("After d.getclass(\"duck\")");

30 (3) 通过比较识别对象类型比较的方式直接比较 ; 利用 isinstance( ) 函数进行比较 ; 利用 instanceof 操作符进行比较 ;

31 类型直接比较的方法 boolean equals(object obj) 直接比较指示其他某个对象是否与此对象相等 A.equals(B); 利用 == 运算符进行比较 If the operands of an equality operator are both of either reference type or the null type, then the operation is object equality. 注意 : 两个 Class 对象不论是通过 equals() 函数还是直接用 == 运算符进行比较, 比较的都是类型是否相同

32 利用 isinstance( ) 函数进行比较 boolean isinstance(object obj) 判定指定的 Object 是否与此 Class 所表示的对象赋值兼容 class Cat{ class Dog{ class Duck{ public class Test{ public static void main(string[] args){ Class c2, c3; Duck d = new Duck(); c2 = Dog.class; c3 = d.getclass(); 运行结果为 : c2.isintance(d):false c3.isintance(d):true System.out.println("c2.isIntance(d):" + (c2.isinstance(d))); System.out.println("c3.isIntance(d):" + (c3.isinstance(d)));

33 instanceof 利用 instanceof 操作符进行比较 Java 语言的保留字, 用于检测一个对象引用是否是某个类的实例 ; 当这个对象引用的类型是这个类或者是这个类的子类型时返回 true, 否则返回 false class Cat{ class Dog{ class Duck{ public class Test{ public static void main(string[] args){ Class c3; Object d = new Duck(); // Duck d = new Duck();????? c3 = d.getclass(); System.out.println("d instanceof Dog:" + (d instanceof Dog));//(3)

34 RTTI 有一个限制问题对象的类型在编译期必须是已知的, 但是假设你获取了一个指向某个并不在你的程序空间中的对象的引用例如, 假设你从磁盘文件, 或者网络连接中获取了一串字节, 并且你被告知这些字节代表了一个类编译器在编译你的程序代码的时候不可能了解有关这个在后面才会出现的类的信息你怎样才能使用这样的类呢?

35 Class 类支持反射的概念, 反射 (Reflection) Java 附带的库 java.lang.reflect 包含了 Field,Method 以及 Constructor 类这些类型的对象是由 JVM 在运行期创建的, 用以表示未知类里对应的成员可以实现 : 使用 Constructor 创建新的对象 ; 用 get() 和 set() 方法读取和修改与 Field 对象关联的属性, 用 invoke() 方法调用与 Method 对象关联的方法 ; 调用 getfields(),getmethods(),getconstructors() 方法, 以返回表示属性方法以及构造器的对象数组 ; 匿名对象的类信息就能在运行期被完全确定下来, 而在编译期不需要知道任何事情

36 反射 (Reflection) Java 反射机制主要提供了以下功能 : 在运行时判断任意一个对象所属的类 ; 在运行时构造任意一个类的对象 ; 在运行时判断任意一个类所具有的成员变量和方法 ; 在运行时调用任意一个对象的方法 ; 生成动态代理

37 反射 (Reflection) JDK 中主要由以下类实现 Java 反射机制 : Class 类 : 其实例表示正在运行的 Java 应用程序中的类和接口 Field 类 : 提供有关类或接口的单个字段的信息, 以及对它的动态访问权限 ; Method 类 : 提供关于类或接口的某个方法 ( 以及如何访问该方法 ) 的信息 ; Constructor 类 : 提供关于类的单个构造方法的信息以及对它的访问权限 ; Array 类 : 提供了动态创建和访问 Java 数组的方法

38 import java.lang.reflect.*; 例 1: 获取类信息 public class DumpMethods { public static void main(string args[]) throws Exception { // 加载并初始化命令行参数指定的类 Class classtype = Class.forName(args[0]); // 获得类的所有方法 Method methods[] = classtype.getdeclaredmethods(); for (int i = 0; i < methods.length; i++) System.out.println(methods[i].toString()); 输入 :java DumpMethods java.util.stack 输出 : public synchronized java.lang.object java.util.stack.pop() public java.lang.object java.util.stack.push(java.lang.object) public boolean java.util.stack.empty() public synchronized java.lang.object java.util.stack.peek() public synchronized int java.util.stack.search(java.lang.object)

39 import java.lang.reflect.*; public class InvokeTester { 例 2: 调用类方法 public int add(int param1, int param2) { return param1 + param2; public String echo(string msg) { return "echo:" + msg; public static void main(string[] args) throws Exception { Class classtype = InvokeTester.class; Object invoketester = classtype.newinstance(); // 调用 InvokeTester 对象的 add() 方法 Method addmethod = classtype.getmethod("add", new Class[] { int.class, int.class ); Object result = addmethod.invoke(invoketester, new Object[] { new Integer(100), new Integer(200) ); System.out.println((Integer) result); // 调用 InvokeTester 对象的 echo() 方法 Method echomethod = classtype.getmethod("echo", new Class[] { String.class ); result = echomethod.invoke(invoketester, new Object[] { "Hello" ); System.out.println((String) result);

40 // Customer 类是一个 JavaBean class Customer { private Long id; private String name; private int age; public Customer() { public Customer(String name, int age) { this.name = name; this.age = age; public Long getid() { return id; public void setid(long id) { this.id = id; public String getname() { return name; 例 3: 综合应用目标 : 构造一个 copy(object object) 方法, 这个方法能够创建一个和参数 object 同样类型的对象, 并把 object 对象中的所有属性复制到新建的对象中, 并将它返回 public void setname(string name) { this.name = name; public int getage() { return age; public void setage(int age) { this.age = age;

41 import java.lang.reflect.*; public class ReflectTester { public Object copy(object object) throws Exception { // 获得对象的类型 Class classtype = object.getclass(); System.out.println("Class:" + classtype.getname()); // 通过默认构造方法创建一个新的对象 Object objectcopy = classtype.getconstructor(new Class[] {).newinstance(new Object[] {); // 获得对象的所有属性 Field fields[] = classtype.getdeclaredfields(); for (int i = 0; i < fields.length; i++) { return objectcopy; public static void main(string[] args) throws Exception {

42 import java.lang.reflect.*; public class ReflectTester { public Object copy(object object) throws Exception { // 获得对象的类型 Class classtype = object.getclass(); System.out.println("Class:" + classtype.getname()); // 通过默认构造方法创建一个新的对象 Object objectcopy = classtype.getconstructor(new Class[] {).newinstance(new Object[] {); // 获得对象的所有属性 Field fields[] = classtype.getdeclaredfields(); for (int i = 0; i < fields.length; i++) { Field field = fields[i]; String fieldname = field.getname(); String firstletter = fieldname.substring(0, 1).toUpperCase(); // 获得和属性对应的 getxxx() 方法的名字 String getmethodname = "get" + firstletter + fieldname.substring(1); // 获得和属性对应的 setxxx() 方法的名字 String setmethodname = "set" + firstletter + fieldname.substring(1); // 获得和属性对应的 getxxx() 方法 Method getmethod = classtype.getmethod(getmethodname, new Class[] {); // 获得和属性对应的 setxxx() 方法 Method setmethod = classtype.getmethod(setmethodname, new Class[] { field.gettype() ); // 调用原对象的 getxxx() 方法 Object value = getmethod.invoke(object, new Object[] {); System.out.println(fieldName + ":" + value); // 调用复制对象的 setxxx() 方法 setmethod.invoke(objectcopy, new Object[] { value ); return objectcopy; public static void main(string[] args) throws Exception {

43 import java.lang.reflect.*; public class ReflectTester { public Object copy(object object) throws Exception { // 获得对象的类型 Class classtype = object.getclass(); System.out.println("Class:" + classtype.getname()); // 通过默认构造方法创建一个新的对象 Object objectcopy = classtype.getconstructor(new Class[] {).newinstance(new Object[] {); // 获得对象的所有属性 Field fields[] = classtype.getdeclaredfields(); for (int i = 0; i < fields.length; i++) { Field field = fields[i]; String fieldname = field.getname(); String firstletter = fieldname.substring(0, 1).toUpperCase(); // 获得和属性对应的 getxxx() 方法的名字 String getmethodname = "get" + firstletter + fieldname.substring(1); // 获得和属性对应的 setxxx() 方法的名字 String setmethodname = "set" + firstletter + fieldname.substring(1); // 获得和属性对应的 getxxx() 方法 Method getmethod = classtype.getmethod(getmethodname, new Class[] {); // 获得和属性对应的 setxxx() 方法 Method setmethod = classtype.getmethod(setmethodname, new Class[] { field.gettype() ); // 调用原对象的 getxxx() 方法 Object value = getmethod.invoke(object, new Object[] {); System.out.println(fieldName + ":" + value); // 调用复制对象的 setxxx() 方法 setmethod.invoke(objectcopy, new Object[] { value ); return objectcopy; public static void main(string[] args) throws Exception { Customer customer = new Customer("Tom", 21); customer.setid(new Long(1)); Customer customercopy = (Customer) new ReflectTester().copy(customer); System.out.println("Copy information:" + customercopy.getname() + "" + customercopy.getage());

44 RTTI vs. Reflection 重要的是, 反射机制并没有什么魔法当你通过反射与一个未知类型的对象打交道时,JVM 只是简单地检查这个对象, 看它属于哪个特定的类 ( 就象 RTTI 那样 ) 在这之后, 在做其它事情之前, 必须加载那个类的 Class 对象因此, 那个类的.class 文件对于 JVM 来说必须是可获取的, 要么在本地机器上, 要么可以通过网络取得所以 RTTI 和反射之间真正的区别只在于, 对 RTTI 来说, 编译器在编译期打开和检查.class 文件, 而对于反射机制来说是在运行期打开和检查.class 文件

45 什么是泛型泛型泛型是一种可变的类型, 可以用在类接口和方法的创建中, 分别称为泛型类泛型接口泛型方法泛型的本质是参数化类型, 也就是说所操作的数据类型被指定为一个参数泛型是 Java SE 1.5 的新特性, 引入泛型的好处是安全简单

46 import Java.util.Hashtable; class TestGen0<K,V>{ 泛型实例 public Hashtable<K,V> h=new Hashtable<K,V>(); public void put(k k, V v) { h.put(k,v); public V get(k k) { return h.get(k); public static void main(string args[]){ TestGen0<String,String> t=new TestGen0<String,String>(); t.put("key", "value"); String s = t.get("key"); System.out.println(s);

47 泛型的安全性 import Java.util.Hashtable; class Test { public static void main(string[] args) { Hashtable h = new Hashtable(); h.put( key, value ); String s = (String)h.get( key ); // 需要强制类型转换 System.out.println(s); import Java.util.Hashtable; class Test { public static void main(string[] args) { Hashtable<String,Integer> h = new Hashtable<String,Integer> (); h.put( key, new Integer(123)); int s = h.get( key ).intvalue(); // 无需强制类型转换 System.out.println(s);

48 应用规则关于泛型 1 泛型的类型参数只能是类类型 ( 包括自定义类 ), 不能是简单类型 2 同一种泛型可以对应多个版本 ( 因为参数类型是不确定的 ), 不同版本的泛型类实例是不兼容的 3 泛型的类型参数可以有多个 4 泛型的参数类型可以使用 extends 语句, 例如 : <T extends superclass>, 习惯上称为有界类型 5 泛型的参数类型还可以是通配符类型例如 : List<? extends Number> List<? super Number>

49 public class SuperClass { public void firstmethod() { System.out.println("SuperClass.firstMethod()"); public static void main(string[] args){ SubClass subobj = new SubsubClass( ); SuperClass superref = subobj; superref.firstmethod( ); class SubClass extends SuperClass{ public void firstmethod() { System.out.println("SubClass.firstMethod()"); class SubsubClass extends SubClass{ public void firstmethod() { System.out.println("SubsubClass.firstMethod()");

50 好好想想, 有没有问题? 谢谢!

<4D F736F F F696E74202D20A1B64A617661B8DFBCB6BCBCCAF5A1B7B5DA31312E35BDB220B6AFCCACC0E0D0CDBCECB2E92E707074>

<4D F736F F F696E74202D20A1B64A617661B8DFBCB6BCBCCAF5A1B7B5DA31312E35BDB220B6AFCCACC0E0D0CDBCECB2E92E707074> Java 高级技术课程 Java 语言的高级特性 (8) 李戈北京大学信息科学技术学院软件研究所 2008 年 5 月 11 日运行期类型识别 RTTI ( Run-Time Type Identification ) 在运行期间, 识别一个对象的类型运行期类型识别 RTTI 的三种方法强制类型转换利用 Class 对象通过比较识别类型 (1) 利用强制类型转换判别运行期类型 class

《计算概论》课程 第十九讲 C 程序设计语言应用

《计算概论》课程第十九讲 C 程序设计语言应用