1 / 55

第 4 章 学习目的、知识点、基本要求

第 4 章 学习目的、知识点、基本要求. 学习目的： 理解面向对象 的基本概念以及 Java 系统对 类与对象概念的实现，进一步掌握面向对象的程序开发技术。 基本知识点： * 数据抽象、封装、类、对象等概念； * 数据成员的定义及非访问权限修饰符； * 成员方法的定义及非访问权限修饰符、成员方法和 构造方法； * 创建类、对象并使用之。. 第 4 章 学习目的、知识点、基本要求. 基本要求： * 掌握抽象和封装的基本概念； * 掌握类与对象的基本概念以及他们之间的关系；

wayne
Download Presentation

第 4 章 学习目的、知识点、基本要求

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. 第4章 学习目的、知识点、基本要求 学习目的： 理解面向对象的基本概念以及Java系统对类与对象概念的实现，进一步掌握面向对象的程序开发技术。 基本知识点： * 数据抽象、封装、类、对象等概念； * 数据成员的定义及非访问权限修饰符； * 成员方法的定义及非访问权限修饰符、成员方法和 构造方法； * 创建类、对象并使用之。

  2. 第4章 学习目的、知识点、基本要求 基本要求： * 掌握抽象和封装的基本概念； * 掌握类与对象的基本概念以及他们之间的关系； * 掌握在Java程序中定义类与创建对象技术； * 区分系统类与用户定义类，初步了解Java类库； * 掌握数据成员和方法成员的定义技术； * 初步掌握各种修饰符的作用及其使用技术。

  3. 第4章Java类与对象 4.1 抽象与封装 4.2 类与对象的概念 4.3 Java程序的类 4.4 Java对象的定义 4.5 Java程序的变量 4.6 Java程序的方法

  4. 4.1 抽象与封装 1 数据抽象 面向对象程序设计采用的抽象方法学是数据抽象。 数据抽象把需要处理的数据和施加于这些数据之上的操作结合一起，并强调结合为一个不可分割的系统单位——对象，对象的外部只需要知道这个对象能做什么，而不必知道它是如何做的。

  5. 4.1 抽象与封装 2 封装的概念 封装是利用抽象数据类型将数据和基于数据的操作封装在一起，使其构成一个不可分割的独立实体，数据被保护在抽象数据类型的内部，尽可能地隐藏内部的细节，只保留一些对外接口，使之与外部发生联系。系统的其它部分只能通过包裹在数据外面的被授权的操作来与这个抽象数据类型交流与交互。 返回

  6. 4.2 类与对象的概念 1 类——class 类是对一组相似对象的描述，这些对象具有相同的属性和行为、相同的变量（数据结构）和方法实现。类定义就是对这些变量和方法实现进行描述。

  7. 实体抽象——属性和行为。 属性：表示实体的静态特征，所有属性的组合反映 实体的状态； 行为：表示实体的动态特征，一个行为的过程可能 会影响或改变实体的状态。 4.2 类与对象的概念 2 对象——object

  8. 4.2 类与对象的概念 2 对象——object 是对客观世界里的任何实体的抽象。 是对客观世界实体的软件模型， 由数据和方法组成。 是数据与方法的封装体。

  9. 对象：桑塔纳 类：汽车 抽象 属性：颜色 型号 马力 生产厂 静态 黑色 特征：2000 80 上海大众 数据成员 数据值 实例化 方法成员 执行操作 服务：运输 动态特征：载人 4.2 类与对象的概念 3 类与对象的关系 类给出了属于该类的全部对象的抽象定义，而对象则是符合这种定义的一个实体。 *在面向对象的程序设计中，对象被称作类的一个 实例（instance）； * 而类是创建对性的模板（template）。 返回 （类与对象的关系示例）

  10. 4.3Java的类 Java的程序设计就是定义类的过程。 4.3.1 系统定义的类 4.3.2用户程序自定义类

  11. 4.3.1 系统定义的类 系统定义好的类就是Java类库中的类。 根据实现功能不同，划分不同的集合，每个集合是一个包，合称为类库。又称为：API---application program interface SUN 公司提供的类库称为基础类库JFC。

  12. Java.sun.com/j2se/1.4.1/docs/api/index.html 自学所有类库的查找方法 列出Java中所有软件包页面 软件包（总说明、包内容说明）页面: 接口Interfaces/类classes/异常Exceptions/错误Errors 所有不推荐使用类的功能页面提示。 说明有哪些软件包、类、方法等用了该类的任何一部分内容的页面。 类和接口页面: 最顶级的类为Object/直接继承的类是Panel/．．． 按字母顺序列出Java中的所有类、接口、构造方法、方法和域。 软件包、类和接口的层次图页面。 （比class页面详细） 参考资料： Java2 API大全 电子工业出版社

  13. 4.3.1.1常用系统定义的包简介 1) java.lang 2) java.lang.reflect 3) java.io 4) java.util 5) java.util.zip 6) java.awt 7) java.awt.image 8) java.awt.datatransfer 9) java.awt.event 1. 核心类库： 含数据类型、 基本数学函数、 字符串 、 处理、 线程、 异常处理类等 2.核心类库： 是反射对象工具， 监视正在运行的对象并获得它的构造函数、方法和属性。 • 3.标准I/O类库： • 基本I/O流、 • 文件I/O流、 • 过滤I/O流、 • 管道I/O流、 • 随机I/O流等。 4低级实用工具类库： 处理时间Date类 变长数组Vector类 栈Stack类 杂凑表HashTable类 5低级实用工具类库 实现文件压缩类 6.构建图形用户： 低级汇图操作 图形界面组件、 布局管理 界面用户交互、 事件响应等 7.构建图形用户 处理、操作网上图片的工具 8.构建图形用户 处理剪贴板、字符串发送器等 9.构建图形用户 Event类的扩充 处理不同类型的事件

  14. 4.3.1.1常用系统定义的包简介 10. 实现运行于 Internet浏览器中的Java Applet的工具 类库。 10) java.applet 11) java.net 12) java.corba 13) java.corba.orb 14) java.rmi 15) java.rmi.reistry 16) java.rmi.server 17) java.security 18) java.security.acl 19) java.security.interfaces 20) java.sql 11.网络功能类库低层网络通信编写FTP,Telnet等网上通信类访问网上资源进行CGI网关调用的类等。 12,13.其他面向对象语言开发的 部件。（可方便、动态地利用已经存在的软件） 14~16.远程方法调用用户程序可以在远程计算机（服务器）上创建对象，在本地计算机上使用该对象。 17~19.安全控制管理对程序加密把Java Applet 进行标记，使之具有与完整的Java程序有相同的安全性。 20. 访问各种数据库包JDBC。 可访问： Oracle, Sybase， DB2, SQLServer等

  15. 4.3.1.2 常用java子包汇总 包接口和类的用途 包 接口和类的用途 java.applet applet java.rmi 远程方法调用 java.awt 图形和图形用户接口 java.rmi.dgc 支持java.rmi java.awt.datatranster 剪切和粘贴功能 java.rmi.registry 同上 java.awt.event事件处理 java.rmi.server 同上 java.awt.image 图像处理 java.security 安全 java.awt.peer平台无关图形 java.security.acl 支持java.security java.beans软件组件 java.security.interfaces 同上 java.io输入输出 java.sql 数据库 java.lang 语言的核心功能java.text国际化 java.lang.reflect映射（“自省”） java.util 各种工具 java.math任意精度算术运算 java.util.zip 压缩和解压缩 java.net 连网

  16. 4.3.1.2 常用javax子包汇总 包 包中接口和类的用途 javax.accessibility 判定技术 javax.swing “轻便”的图形和图形用户 javax.swing.border 专用边界 javax.swing.colorchooser 颜色选择 javax.swing.event 扩展java.awt.event的事件处理 javax.swing.filechooser 文件选择 javax.swing.plaf 可插入的外观和效果 javax.swing.plaf.basic 基本的外观和效果 javax.swing.plaf.metal 金属的外观和效果 javax.swing.plaf.multi 复合体的外观和效果 javax.swing.table 数据的表单表示 javax.swing.text 文本的表示和处理 javax.swing.text.html HTML文本 javax.swing.text.rtf RTF（Rich Text Format）文本 javax.swing.tree 数据的树型表示 javax.swing.undo 文本编辑中的撤消功能

  17. 重 点 4.3.4.3使用系统定义类的三种方式 1 继承系统类 例：每个Java Applet的主类都是Java.applet 包中 Applet类的子类。 2 直接使用系统类 例：字符界面系统标准输出的方法引用 System.out.println( ) 3 创建系统类的对象 例：图形界面接受输入时创建系统类的对象 TextField input

  18. 系统定义类小结 使用系统类的前提条件： * 必须用import语句引入所用到的系统类等。 类库包中的程序都是字节码形式的程序，利用import语句将一个包引入到程序里来，就相当于在编译过程中将该包中所有系统类的字节码加入到用户的Java程序中，这样用户Java程序就可以使用这些系统及其类中的各种功能。

  19. <构造方法> <静态初始化方法> <方法定义> 4.3.2用户程序自定义类 4.3.2.1 类的创建 [修饰符] <class> <类名>[extends 父类][implements接口] { <类体(成员变量)> <类体(成员方法)> } 说明： 1. 类修饰符：用于规定类的一些特性和对它的访问限制等。 2. extends：继承父类（已经被定义的或系统的类）。 5. implements：实现接口，告诉编译器类实现的接口。

  20. 例题4-1程序分析1————改 import java.awt.*; import java.applet.Applet; public class Class1 extends Applet { private int x, y, width, height; //成员变量声明 public void init() //初始化方法 { width=60; height=60; } public void setPosition(int xPos, int yPos) //设置点位置方法 { x=xPos; y=yPos; }

  21. 4.3.2.2 类修饰符 1 无修饰符的情况 如果一个类前无修饰符，则这个类只能被同一个包里的类使用。 2 public修饰符 由public修饰的类为公共类。它可以被其它包中类使用。 3 final修饰符 由final修饰的类为最终类。它不能被任何其它类所继承，即它不能派生子类。 4 abstract修饰符 由abstract修饰的类为抽象类。其作用在于将许多有关的类组织在一起，提供一个公共的基类，为派生类奠定基础。

  22. 4.3.2.2 类修饰符 5 类修饰符的使用注意事项 可以同时使用多个修饰符来修饰一个类。 当使用多个修饰符修饰一个类时，这些修饰符之间用空格分开，写在关键字class之前，修饰符出现的顺序对类的性质没有任何影响。但是，不能同时用abstract和final两个修饰符同一个类。 返回

  23. 4.4对象的定义1 4.4.1 对象的创建 1 对象的声明 2 对象的实例化 3 对象的使用 4 对象的清除

  24. 4.4对象的定义1 4.4.1 对象的创建 （1）用类名定义所引用的对象 格式：类名 对象名； 举例：Textfield input； （2）创建并初始化对象 格式：new 构造方法（实参表）； 举例：new Textfield(10)； （3）把new运算的返回值赋给引用的对象 格式：引用对象名=new 构造方法（实参表） 举例：input=new Textfield(10); 对象创建时的简化格式—上述三步汇总 类名 对象名=new 构造方法（[实参表]）； 举例：Textfield input=new Textfield(10);

  25. 4.4对象的定义1 4.4.1 对象的创建 创建对象小结 创建对象有3个部分组成： 声明对象、实例化、初始化 <类名><对象名>=new <类名>（[参数列表]） 举例： （1）声明对象： <类名><对象名> 例：MyBox b1; （2）实例化对象和初始化对象 <对象名>=new <类名>( [参数列表] ) 例：MyBox b2=new MyBox(20,20,100,100)

  26. 4.4对象的定义2 4.4.2 对象初始化的说明 （1）系统自动初始化（０，空格，空，假）； （2）利用构造方法进行初始化； * 构造方法名与类名相同； * 构造方法的修饰符总是public； * 构造方法不返回任何值，也不能有void关键字； * 每一个类可以有零个或多个构造方法； * 构造方法在创建时自动调用执行，一般不 能显式的直接调用。 重点记忆 ！

  27. 4.4对象的定义2 4.4.2 对象初始化的说明 MyBox( ) { x=0; y=0; width=0; height=0; } （默认构造方法） 例如：class MyBox MyBox (int xx,int yy, intWidth,int Height ) { x=xx; y=yy; width=Width; height=Height; } （构造方法）

  28. 4.4对象的定义3 4.4.3. 对象的使用 （1）<对象名>．<变量名> （2）<对象名>．<方法名>([参数列表]) 例题: Graphics g; g.drawRect (x, y, width, height);

  29. 4.4对象的定义4 4.4.4. 对象的清除 把一个空值赋给要清除的对象。 例如: Rectangle r=new Rectangle(5,5,5,5); …… r = null; 返回

  30. 4.5 Java程序的变量1 1 变量的定义：变量是内存中的存储区域，存储区的大小取决于变量的类型。 2 变量按类型分类： 基本类型、复合类型； 3 变量按定义位置分类： 局部变量、类变量、实例变量 4 变量的使用：必须先定义，后使用。

  31. 4.5 Java程序的变量2 变量的定义： 1) <类型><变量名>[＝<表达式>][, <变量名>[＝<表达式>]…] 2) [<修饰符>…]<类型名><变量名>[=<初始化表达式>] [，<变量名>[=<初始化表达式>]]…； 举例：int x; public float y; private double a=0, b=0, c=10;

  32. 4.5 Java程序的变量2 变量的作用域：（变量的有效范围） 1) 局部变量—作用域是从定义位置至它所在的块语句 （由大括号括起来的一组语句）的结尾处。 2)成员变量—作用域是在类体中但在方法体外。 <修饰符> <方法名>（参数列表） { 局部变量； 方法体语句; …… } <修饰符> class <类名> { 成员变量；//数据成员 成员方法； …… }

  33. 4.5 Java程序的变量3 成员变量的修饰： 1）静态变量（类变量）—由static修饰的变量。 2）实例变量—没有被static修饰的成员变量。 3）有名常量—用final修饰的变量＝最终变量。 （局部变量或成员变量） 4）暂时变量—transient修饰，对象序列化时不考虑。 5）共享变量—volatile修饰，其值易被改动。

  34. 例题4-2程序分析 class Example4_2 //类1 { int x=1; //实例变量初始化 static int y=2; //类变量初始化 } public class Example4_1Demo//主类2 { public static void main(String[] args) //主方法 { System.out.println(“y=”+Example4_2.y);//类变量输出y=2 Example0401.y*=2; //类变量计算,y=4 Example4_2 o1=new Example4_2(); //o1实例化x=1,y=2 o1.x=10; System.out.println(“o1.x=”+o1.x); //输出o1.x=10 System.out.println(“y=”+o1.y); //输出o1.y=4 Example4_2 o2=new Example4_2(); //o2实例化x=1,y=4 System.out.println(“o2.x=”+o2.x); //输出o2.x=1 System.out.println(“y=”+o2.y); //输出o2.y=4 } }

  35. 例题4-3程序分析 class Example4_3 { static int x=1; final int CONS=x*100; public static void main(String[] args) { Example4_3 o1=new Example4_3(); System.out.println("o1.CONS="+o1.CONS); x++; Example4_3 o2=new Example4_3(); System.out.println("o2.CONS="+o2.CONS); } }

  36. 例题4-4程序分析 class Example4_4 { static int i=5; static int j=6; static int k; //静态变量定义 static void aprint() //静态方法 { System.out.println("k="+k); } static //静态初始化块 { if(i*5>=j*4)k=9; } public static void main(String[] args) //主方法 { Example0403.aprint(); } }

  37. 例题4-5程序分析 class Example4_5 { static int x; //类变量 int y; //实例变量 void aprint() { int k=0; //局部变量 x++; y++; k++; System.out.print("x="+x); System.out.print("y="+y); System.out.println("k="+k); } void bprint() { aprint(); aprint(); } public static void main(String[] args) { Example4_5 o1=new Example4_5(); o1.bprint(); Example4_5 o2=new Example4_5(); o2.bprint(); } }

  38. 4.5 Java程序的变量4 成员变量的访问： 1) 对实例变量的访问 在类体外访问: <引用类型变量名><实例变量名> 在类体内访问: <实例变量名> this . <实例变量名> 2) 对类变量的访问 <类名>.<类变量名> 在类体内访问: <类变量名>

  39. 例题4-6程序分析 class Example4_6 { int x; void method(int x) { x=x+this.x; //x是局部变量, this.x是实例变量 this.x=(int)(x>=0?Math.sqrt(x):Math.abs(x)); System.out.println("x="+this.x); } public static void main(String[] args) { Example4_6 eee=new Example4_6(); eee.method(25); eee.method(-1); } } 返回

  40. 4.6 Java程序的方法1 方法定义 [<修饰符>…]<返回类型><方法名>([形参表])<方法体> 修饰符：static, final, abstract, native, synchronized, public, private, protected abstruct：抽象方法只提供方法名、形参表、返回类型 等它不提供方法的实现。 包含抽象方法的一定是抽象类： （1）抽象类不能生成实例 （2）抽象类的子类必须实现父类中声明的所有抽象 方法或者自己也定义成abstruct。 返回类型：返回数据类型（基本、引用），或没有返回值 形参表：参数表可有可无，多个时用逗号分隔。 方法体：所有的方法代码放在{ }内，它代表具体行为。

  41. 例题4-7程序分析 class Example4_7 { private int hour; private int minute; private int second; public void setMyTime(int h,int m,int s) { hour=((h>=0&&h<24)?h:0); minute=((m>=0&&m<60)?m:0); second=((s>=0&&s<60)?s:0); } public int getHour(){ return hour;} public int getMinrte(){return minute;} public int getSecond(){return second;} public String toString() { return((hour==12||hour==0?12:hour%12)+ ":"+(minute<10?"o":"")+minute+ ":"+(second<10?"0":"")+second+ (hour<12?"AM":"PM")); } }

  42. 例题4-7程序分析 public class Example4_7Demo { public static void main(String args[]) { Example4_7 time=new Example4_7(); time.setMyTime(17,25,50); System.out.println("time="+time.toString()); } }

  43. 4.6 Java程序的方法2 方法调用 1)在类体内调用： <方法名>([实参表]) 2)在类体外调用： <对象名>.<方法名>([实参表]) <类名>.<方法名>([实参表]) 构造方法 （复习：特征是方法名与类名相同）

  44. 4.6 Java程序的方法3 方法重载（overload） 一个类内可以定义几个方法名相同而形参不同（数目不同、类型不同或者次序不同）的几个方法，这种情形称为重载。 在方法调用时到底调用哪个方法是由编译器在编译时完成。

  45. 4.6 Java程序的方法4 类方法（静态方法） 用static修饰的方法称为类方法。 （1）在类体内不管是实例方法还是类方法 都可以直接调用其他类方法； （2）在类体外则可以通过实例也可以通过 类名调用类方法； （3）实例方法与类方法不同，实例方法总 是通过实例调用。

  46. 例题4-8程序分析 class Example4_8 { int i; void print(){i++;System.out.println(“i=”+i);} //实例方法 static Example4_8 method1() //类方法 { Example4_8 eee=new Example4_8(); //创建实例对象 eee.print(); //调用实例方法(i=1) return eee; } static void method2(Example4_8 o) //类方法 { o.print(); } //引用作为形参,调用实例方法(i=2) } public class Example4_8Demo { public static void main(String[] args) { Example4_8 eee=Example4_8.method1(); Example4_8.method2(eee); } }

  47. 4.7 以对象为单位的信息传递１ class Example4_91 { int x,y; } class Example4_92 { void method1(int x,int y) //参数为基本类型 { x=1; y=2; } void method2(Example4_91 obj) //参数为引用类型 { obj.x=10; obj.y=20; } } 用对象作为参数---例题9

  48. 4.7 以对象为单位的信息传递１ 用对象作为参数---例题9 class Example4_93 { Example4_93() { Example4_91 o1=new Example4_91(); //o1.x=0,o1.y=0 Example4_92 o2=new Example4_92(); //o2.x=0,o2.y=0 o2.method1(o1.x,o1.y); //o2.x=1,o2.y=2 System.out.println("x="+o1.x+" "+"y="+o1.y); o2.method2(o1); //o1→ obj,(o1.x=0,o1.y=0) //obj.x=o1.x=10,obj.y=o1.y=20 System.out.println("x="+o1.x+" "+"y="+o1.y); } public static void main(String[] args) { new Example4_93(); } //执行Example4_93方法 }

  49. // c=c2; // (r+c.r,i+c.i) // (c1.r+c2.r,c1.i+c2.i) // c3.r=4, c3.i=6 4.7 以对象为单位的信息传递2 将对象作为返回值---例题10 class Example4_10 { double r,i; public Example4_10(double r, double i) { this.r=r; this.i=i; } public Example4_10add(Complex c) { return new Complex(r+c.r, i+c.i); } public void print() { System.out.println(r+"+"+i+"i"); } } class Example4_10Demo { public static void main(String[] args) { Example4_10 c1=new Example4_10(1,2); //c1.r=1,c1.y=2 Example4_10c2=new Example4_10(3,4); //c2.r=3,c2.y=4 Example4_10 c3=new c1.add(c2); c3.print(); } }

  50. 本章难点说明 静态与非静态成员方法的区分 类变量与实例变量的区分 构造方法的继承说明

More Related