Your SlideShare is downloading. ×
Sun java
Upcoming SlideShare
Loading in...5
×

Thanks for flagging this SlideShare!

Oops! An error has occurred.

×

Introducing the official SlideShare app

Stunning, full-screen experience for iPhone and Android

Text the download link to your phone

Standard text messaging rates apply

Sun java

155
views

Published on

Published in: Technology, News & Politics

0 Comments
0 Likes
Statistics
Notes
  • Be the first to comment

  • Be the first to like this

No Downloads
Views
Total Views
155
On Slideshare
0
From Embeds
0
Number of Embeds
0
Actions
Shares
0
Downloads
3
Comments
0
Likes
0
Embeds 0
No embeds

Report content
Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
No notes for slide

Transcript

  • 1. JAVA 程序设计 清华万博
  • 2. 课程内容: 一 Java 简介 二 类,方法和构造函数 三 高级语言特性 四 数组, Collection 五 异常
  • 3. 一 Java 简介 概述 Java 的特点 JDK , JVM , JRE 概念 Java 的垃圾回收机制
  • 4. 概述- Java 版本Java 1.0Java 1.1 Java 1Java 1.2 Java 2Java 1.3Java 1.4Java 1.5 (Java 5.0)
  • 5. 概述 J2SE 标注版(Java 2 Standard Edition) •适用于开发用户端程序 J2EE 企业版(Java 2 Enterprise Edition) •适用于开发 Server 端程序 J2ME 手持设备版 (Java 2 Micro Edition) •适用于开发手机 ,无线设备程序
  • 6. IDE NetBean/Jbuilder/Eclipse (IDE) JDK (Java Development Kit) JRE (Java Runtime Environment) Java Java VM Runtime (JVM) Classes
  • 7. Java 的优点 简单,上手快 面向对象 平台无关 垃圾自动回收 安全,不支持指针,避免内存泄漏
  • 8. Java 的不足 解释执行比编译解释执行慢 部分功能不能实现
  • 9. Java Runtime Enviornment(JRE) *.java 编译器 javac *.java平台无关 字节码 *.class平台相关 解释器 JVM for 1. 执行字节码 2. 对底层硬件做适 当调整 Dos Unix Windows
  • 10. Java 的垃圾回收机制 提供自动垃圾收集来进行内存的管理 java 不支持指针,一切对内存的访问都 必须通过对象 在 JVM 空闲周期,垃圾收集线程 检查,释放内存 时间不固定
  • 11. 二 面向对象编程 类 (Class) ,实例 / 对象 (Instance) super/this 方法 instanceof ,类型转换 参数传递-值传递 多态 重载 重写 封装 命名规范 Java 注释
  • 12. 类 类是一个用来创建对象的模板 每个 java 文件只能有一个 public 的类 类包含方法和成员变量 文件名必须与公有类类名一致例如:文件名: Application.java public Application{ public static void main(String[] args) { System.out.println("Hello World!") ; } }
  • 13. 实例 / 对象( Instance ) 对象是一个类的具体实例,是对类中属 性的实化 使用 new 关键字创建 Instance 的三个作 用 1. 为对象实例分配内存空间 2. 调用构造函数 3. 返回对象实例的引用
  • 14. 封装 (Information Hiding) 类 / 对象封装了数据和方法 尽量缩小成员的可访问性 实现了模块化和信息隐藏
  • 15. Not Hidingpublic class MyDate { public int day; public int month; public int year;}
  • 16. Hidingpublic class MyDate { private int day; private int month; private int year; public void setDay(int day){ ... } public int getDay(){ return day; } ...}
  • 17. 构造函数 构造函数的访问权限不仅仅是 public 总有一个 default 的构造函数 每个类的构造函数体的第一条语句都是 缺省调用 super(), 故如果父类中无此形 式的构造函数则编译出错
  • 18. 构造函数public class Thing { private int x; public Thing() { x = 47; } public Thing(int new_x) { x = new_x; } public int getX() { return x; }}
  • 19. Java Document APIpublic 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(); …
  • 20. Java Document APIpublic 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. …
  • 21. 继承 单一继承 构造函数不被继承 private 修饰的成员不被继承 构造子类对象时,缺省沿继承链调用父 类无参的构造方法 super() Java 中,所有的类都是通过直接或间接 的继承 java.lang.Object 得到的
  • 22. 多态父类引用指向子类对象 引用可以点取父类中的成员(编译时指 向父类成员,运行时动态绑定到子类中 的成员) 不可以点取子类扩充的成员
  • 23. 多态 Employee e = new Manager(); 1. 是 Manager 对象 2. 编译器认为是 Employee 对象 3. 方法覆盖时 , 指向 Manager 类中的方 法
  • 24. Heterogeneous CollectionsEmployee[] staff = new Employee[1024];staff[0] = new Manager();staff[1] = new Employee();staff[2] = new Engineer();…
  • 25. 例子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();} }
  • 26. 上例说明a 为 Parent 类型的变量,用 new 建立Parent 类型的子类 Child 的一个实例,并将其引用存储到 a 中。编译时a.callme() 指向父类 Parent 的成员方法,而运行时,则动态绑定到子类 Child 中的 成 员 方 法 。 故 程 序 将 调 用 Child 的callme() 方法。
  • 27. Class Castpublic void doSomething(Employee e) { if (e instanceof Manager) { Manager m = (Manager)e; … }}
  • 28. 成员权限(数据成员,方法成 员) 本类 同包 非同包 非同包 类 子类 非子类 public √ √ √ √protected √ √ √(default) √ √ private √
  • 29. 参数传递-值传递 被调用方法不能改变参数 当参数为对象时,传递的是对象引用 当参数为基本类型时,传递的是值
  • 30. 问题: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; }}
  • 31. 方法重载( overloading ) 在同一个类中 方法名相同 参数的个数或类型不同 重载是编译时问题注:只有返回值类型不同,不叫方法重 载,编译时会报错
  • 32. 重载方法 public void println(int i) public void println(float f) public void println()
  • 33. 重载构造函数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); }}
  • 34. this 关键字 this 指代对象实例自身 静态方法中不存在 this 的使用 使用 this 简化构造函数的编写 当不能事先知道实例名时使用 this 代替 使用 this 区别成员变量和自动变量
  • 35. 方法重写( overriding ) 方法声明形式一致 方法权限不允许缩小 覆盖的方法不允许抛出比父类方法更多 的异常
  • 36. 方法重写例子 class Parent { public void Parent() {System.out.println(“Parent”);} } class Child extends Parent { public void Child () {System.out.println(“Child ”);} }
  • 37. 问题 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;)
  • 38. super 关键字 super 用来引用父类的变量或方法 通常用来扩展父类方法的功能 super() 表示调用父类的构造函数(如果 父类存在缺省的构造函数) 子类的构造函数会自动调用 super()
  • 39. Object 类 所有的类都是从 Object 类继承 数组也是一种 Object ,例如: int[] public boolean equals(Object obj) 方法 toString() 方法
  • 40. equals 方法和“ ==” “==” 可用于基本数据类型及引用类型 equals() 只能用于引用类型 equals() 表示逻辑上的“相等” “==” 对于任何引用值 X , Y ,当且仅当 X 和 Y 指向同一对象时,“ X==Y” 返回 true Object 类的 equals 方法相当于“ ==” “==” 用于引用类型时 ,“==” 两边的类型必 须一致 , 否则编译报错
  • 41. 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
  • 42. 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
  • 43. 命名规范 包名 : 全小写 , 一般为名词 , 如 : package shipping.objects 类名 (Class) :首字母大写(如 System , Date ) 方法名 (Method) :首字母小写 ,由大写字母 区分词 ( 如 sayHello()) 变量 (Variable) :首字母小写 ,由大写字母区 分词 ( 如 currentCustomer) 常量 (Constant): 全部大写,并下划线连接词 ( 如 MAX_SIZE)
  • 44. Java 注释 // 单行注释 /* 单、多行注释 */ /** 文档注释 */ (放在变量、方法、 类的前面,通过 javadoc 命令自动被包 含在所产生的 HTML 文档中)
  • 45. 三 数组,集合类 Collection 数组 List Map Set
  • 46. 数组 下标从 0 开始 声明int a[ ] ;int[ ] a ;String[] s; 创建数组a = new int[5] ; 数组一旦被创建 , 大小无法改变
  • 47. 数组初始化int a[]={1 , 2 , 3 , 4 , 5} ;String s[]={“abc” ,“ def”}Circle[] c = {new Circle(),new Circle()};
  • 48. 数组初始化 数组中的每个元素具有相同的数据类型,包括基本数 据类型和对象 对于基本数据类型,系统会自动初始化 如上例: 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;
  • 49. 多维数组 定义:int[][] a;int a[][]; 创建多维数组时 , 必须指明第一维的大小int twoDim[][] = new int [4][];int twoDim[0] = new int[5];或: int twoDim[][] = new int[4][5];
  • 50. 数组拷贝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};
  • 51. 问题: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 objects2) Arrays are initialized to default values wherever they are created3) An array may be dynamically resized using the setSize method4) You can find out the size of an array using the size method
  • 52. Collection 框架四个接口 Collection 接口: 元素可重复 , 无序 Set 接口: 元素不重复 , 无序 List 接口: 元素可重复 , 有序 Map 接口: key/value 对
  • 53. Collection 框架 Vector List ArrayListCollection HashSet Set TreeSet HashMa pMap Hashtable
  • 54. 问题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.
  • 55. 问题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.
  • 56. 四 高级语言特性 static 关键字 final 关键字 接口 (interface) 内部类
  • 57. static 关键字 只能修饰成员 , 不能修饰方法变量 static 方法不能被覆盖使用场合: 类变量 类方法 static 块
  • 58. 实例变量的访问public class Circle{ int x,y; public int x(){return x;} public void setX(int newX){x=newX;} public static void main(String args[]){ Circle myCircle=new Circle(); myCircle.setX(23); System.out.println("myCircle.x="+myCircle.x()); }}
  • 59. 类变量的访问public class Circle{ static int x,y; public int x(){return x;} public void setX(int newX){x=newX;} public static void main(String args[]){ Circle myCircle=new Circle(); myCircle.setX(23); System.out.println("myCircle.x="+myCircle.x()); }}
  • 60. static 方法Public class GeneralFunction{ public static int addUp(int x,int y){ return x + y; }}
  • 61. 静态方法不能访问非静态变量class Circle{ private int x; public static int x() {return x;}} //Wrong!!!!!!
  • 62. 非静态方法可以访问静态变量class Circle{ private static int x; public int x() {return x;}} //right!!
  • 63. static 块Public class StaticInitDemo{ static int i = 5; static{ System.out.println(“i=“ + i); }}
  • 64. 问题 非静态方法能不能访问静态变量?
  • 65. 问题Which of the following statements are true?1) static methods do not have access to the implicit variable called this2) A static method may be called without creating an instance of its class3) A static method may not be overriden to be non-static4) A static method may not be overloaded
  • 66. final 关键字使用场合: 终极类 (final class) 终极方法 (final method) 常量 (const) ( 例: final int MAX_SIZE= 10)
  • 67. final 类 / 方法 final 类不被继承 final 方法不被重写 声明为 static 或 private 的方法自动地声 明为 final例: java 中的 String 类为 final 类,不能被继 承。
  • 68. abstract 类和方法 abstract 类必须被继承 abstract 方法必须被重写 abstract 类中可以包含 abstract 方法 abstract 方法只需声明,不需实现。 abstract 类中不一定要包含 abstract 方 法,但某个类中如包含了 abstract 方法 ,则这个类必须声明为 abstract 类。
  • 69. abstract 例子abstract class AbstractParent{ abstract void callme();}class Child extends AbstractParent{ void callme(){ System.out.println("Invoke Child’s callme()");}}public class Test{ public static void main(String args[]){ AbstractParent c=new Child(); c.callme(); }}
  • 70. interface interface 是抽象类地变体 interface 中的所有方法都是抽象的 inteface 只可定义 static final 的成员变量 inteface 是多继承的
  • 71. 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();}
  • 72. interface类实现接口( interface ):public class MyApplet extends Applet implements Runnable, MousListener{ …}
  • 73. 问题Which of the following statements are true?1) An interface can only contain method and not variables2) Interfaces cannot have constructors3) A class must extend only one other class and implement only one interface4) Interfaces are the Java approach to addressing its lack of multiple inheritance, but require implementing classes to create the functionality of the Interfaces.
  • 74. 内部类 内部类可以访问外部类的所有成员 , 包括 private 成员,内部类可以互相调用 内部类可以定义在方法中 , 但只能使用方 法中的 final 常量 可以被定义为 abstract 抽象类 内部类不能声明任何 static 成员 编译后 : A$B.class ( B 为内部类)
  • 75. 内部类class TopClass{ … class InnerClass { }}
  • 76. 本地类public class TopClass{ public void methodA{ class LocalClass{ …… } …… }……}
  • 77. 匿名类 匿名类 (anonymouse class)— 内部类的一种 特殊形式 匿名类没有自己的名字 匿名类不能有构造函数 匿名类不能定义静态的成员 只可以创建一个匿名类实例
  • 78. 匿名类 (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) { } });}
  • 79. 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.
  • 80. 五 异常 什么是异常 异常处理结构 finally 语句 异常类的继承关系 创建自定义异常 常见异常的理解
  • 81. 什么是异常 在程序执行过程中,任何中断正常程序流程的 错误条件就是异常: 想打开的文件不存在 网络连接中断 受控操作数超出范围 正在装载的类文件丢失
  • 82. 调用栈机制 顶部 connect() init() 异常调 传递用栈 MyDialog() main() 底部异常向下通过调用堆栈直到它被一个方法处理,如果到了 main 还没有方法处理,该异常会中断程序
  • 83. 异常处理结构try{ …}catch( 异常类 e){ 异常处理 ;} finally{ 终止处理 ;}
  • 84. catch 语句的顺序捕获例外的顺序和不同 catch 语句的顺序有关 , 当捕获到一个例外时 , 剩下的catch 语句就不再进行匹配。因此,在安排 catch 语句的顺序时,首先应该捕获最特殊的例外,然后再逐渐一般化。也就是一般先安排子类,再安排父类
  • 85. finally 语句 finally 语句总是执行,不考虑异常是否被 捕获 finally 唯一不被执行的情况是 System.exit() 在保护码内执行
  • 86. 异常类的继承关系 ErrorThrowable RuntimeException Exception 。。。
  • 87. 常见的 Exception ArithmeticException NullPointerException NegativeArraySizeException ArrayIndexOutOfBoundsException SecurityException
  • 88. 方法声明异常 方法可以声明抛出的 Exception 比如:public void callsTroublesome() throws IOException异常应该不从 RuntimeException 继承
  • 89. 创建异常类继承 Exception 类,或 RuntimeException 类class MyException extends Exception{ public MyException(){ super(); } }
  • 90. 使用异常 方法声明时使用 throws 抛出异常 方法体中需要产生异常的地方抛出异常对象 throwclass A{ public void a(int number)throws MyException{ if (number) throw new MyException(); …… }}
  • 91. 使用异常//b ()中不处理 Exception ,继续向上抛class B{ void b() throws MyException{ A a=new A(); a.a(-1); }}
  • 92. 结束