• 1. 第6讲 Java面向对象程序设计 面向对象的程序设计方法按照现实世界的特点,把复杂的事务抽象为对象。对象具有自己的状态和行为,通过对消息的反应来完成一定的任务。面向对象是Java的重要特性。
  • 2. 一、 Java面向对象基础
  • 3. (一) 类的定义 Java的类是由类声明和类体二部分构成, 类声明定义的格式如下: [类修饰符] class 类名 [extends 父类名] [implements 接口名,[接口名]] {类体}例:HelloWorldApp.java public class HelloWorldApp { public static void main(String args[]) { System.out.println(“HelloWorld!”); } }
  • 4. 类体定义的格式: class 类名 { 变量声明; 方法声明; }例: class Point { int x,y; void init(int ix,int iy) { x=ix; y=iy; } }
  • 5. 例:public class Calculator{ private double result; public double a,b; public double Calculator(){ result=0; } public double Add(){ result=a+b; return result; } public double Minus(){ result=a-b; return result; } }
  • 6. 组成一个类的组件如下:[import包 ] [类修饰符] class xxxclass [extends父类] [implements 接口] { //类变量 或称类字段 //实例变量或称实例字段 //构造函数 //静态初始者 //类方法 //实例方法 //内部类 }
  • 7. (二) 类的修饰符public——提供给其他类完全的存取权限。 即:在同一包中的类可自由取用此类,而别的包中的类可通过import关键词来引入此类所属的包加以运用。
  • 8. 用public修饰的类有几个特性: 1. 一个程序里只能有一个类被修饰为public,否则编译会错。 public class xxxClass(){…} class aaaClass(){…} class bbbClass(){…} 2. 源文件存储文件名,必须是用public修饰的类名(xxxClass) 3. 若程序中没有任何public类,则文件名可任取。而如果文件名是程序中的一个类名,则该类被视作public,可供别的类存取。
  • 9. final——表示此类为“最终”类,别的类不能继承此类,其方法也不能被覆盖。 例如java.lang.System类即为final类: public final class System extends Object 注意:我们可使用该类,但不能继承并覆盖其内容。用重复的两个修饰符public+final的意思是:此final类可被import来引用,但不能被继承。System类关系到系统层级控制,为了安全性,故必须为final类,以避免被覆盖。但final与abstract就不能复合来用,因为二者是相冲突的。
  • 10. 另外:final关键字也可用于修饰方法和变量,用final修饰的方法不能被覆盖,用final修饰的变量定义的同时必须赋初值且在程序中不能被赋值,final变量被认为是符号常量,习惯上用大写字母表示这些变量。
  • 11. 例: FinalTest.javafinal class A { final double PI=3.1416; final double area(double r) { return(PI*r*r); } } class FinalTest { public static void main(String args[]) { A a=new A(); System.out.println("area="+a.area(5.0)); } }
  • 12. abstract——此字的英文意思是”抽象的”,”非实际的”。此修饰符可修饰类及方法。 用abstract修饰的类只是先定义一些方法规格,然后让继承此类的子类来覆盖此规格的内容。 即:抽象类不需给出类中每个方法的完整实现,要实现此方法必须要由子类的方法来覆盖。
  • 13. abstract类与方法有下列特性: 1. 一个抽象类里可以没有定义抽象方法。但只要类中有一个方法是被声明为abstract,则该类必须为abstract。 2. 抽象类不能被实例化,即不能被new成一个对象实例。 3. 若一个子类继承一个抽象类,则子类需用覆盖的方式来实化该抽象父类中的抽象方法。若没有完全实化所有的抽象方法,则子类仍是抽象的。 4.抽象方法可再与public、protected复合使用,但不能与final、private和static复合使用。
  • 14. 例:Abstract_Demo.java abstract class A{ abstract void callme(); void metoo(){ System.out.println("在A的metoo方法里"); } } class B extends A{ void callme(){ System.out.println("在B的callme方法里"); } }
  • 15. class Abstract_Demo{ public static void main(String args[]){ B a=new B(); a.callme(); a.metoo(); } }
  • 16. 例:抽象类示例
  • 17. 默认修饰符 如果一个类没有修饰符,就说明它具有默认的访问控制特性。这样的类只允许与该类处于同一个包中的类访问和调用,而不允许被其他包中的类使用。 注意:Java中,外部类不能用private和protected修饰,内部类可以用private和protected修饰。
  • 18. 二、对象的创建和引用
  • 19. (一)对象的定义 定义了用户自己的类之后,就可以用这个类去定义类的对象了。 如:Box myBox; 因为类可以当作是用户自行声明的复合数据类型,所以使用之前还需用new为其开辟存储空间。 如:myBox=new Box(); 注:以上两步可合而为一 Box myBox=new Box(); 接下来,可以利用成员运算符“.”来访问对象的各个成员变量。 如: myBox.color=“Blue”; myBox.width=10.5;
  • 20. 总结: 对象的创建包括“声明”、“实例化”、“初始化”三步: 声明:类型 对象名; 实例化:用new可以为一个类实例化多个 不同的对象,这些对象分别占 用不同的内存空间。 初始化:执行构造函数。
  • 21. (二) 对象成员变量的引用 引用格式:对象名.成员变量名(三) 对象方法的调用 调用格式:对象名.方法名
  • 22. 例:BoxClass.javaclass Box { String color; double width; double height; double depth; double volume() { return width* height*depth; } void BoxMessage() { System.out.println("盒子的颜色:"+color); System.out.println("盒子的宽度:"+width);
  • 23. System.out.println("盒子的高度:"+height); System.out.println("盒子的深度:"+depth); } } public class BoxClass { public static void main(String args[]) { Box myBox=new Box(); double myBoxVolume,Volume; myBox.color="Blue"; myBox.width=10.5; myBox.height=20.6; myBox.depth=15.7;
  • 24. myBoxVolume= myBox.volume(); Volume= myBox.width* myBox.height* myBox.depth; System.out.println("体积是:"+ myBoxVolume); System.out.println("体积是:"+ Volume); myBox.BoxMessage(); } }
  • 25. Java中的变量成员变量(在类中定义,不需要初始化)自动变量(在方法中定义,定义同时初始化)
  • 26. 三、 成员变量 成员变量是类的两大组成部分之一,因此类体中定义的变量都称之为成员变量,而方法体中定义的变量不能称之为成员变量。 类变量(由static修饰) 成员变量 实例变量(没有static修饰)
  • 27. (一) 成员变量的定义格式: [变量修饰符] 类型 变量名[=初值][,变量名[=初值]]; 如:public int a,b=12; protected String s="Hot Java";注意:若成员变量在定义时没有赋初值,则系统会为其 自动进行初始化,但方法中的自动变量必须人为的赋初值。
  • 28. (二) 成员变量修饰符1.存取性修饰符:控制类间的存取,包括public,protected,private; 2.存在性修饰符:成员变量本身在类中存在的特性,包括static和final。
  • 29. public修饰符 public变量和方法是“公开”的,既允许变量自身所属的类访问,也允许同一个包中的其他类访问,还允许其他包中的类访问。 protected修饰符 protected变量和方法是“受保护”的,它们仅能被与该类处于同一个包中的类所直接存取和使用。 private修饰符 private变量和方法是“私有的”,除了声明它们的类外,不能被任何其他的类直接存取和使用。 注:当变量和方法前不加以上三种修饰符时,被认为是默认访问级,只允许定义它的类自身以及在同一个包中的类访问和调用。
  • 30. static修饰符 用关键字static可以修饰类的成员变量及方法,使它们成为静态成员。 如:static int y=3; static showx() {…} 注意:用static修饰的变量称为类变量,用static修饰的方法称为类方法。类变量和类方法在使用时也和其他变量与方法不同。
  • 31. 例:UseStatic.java UseGeneral.java StaticTest.java
  • 32. final修饰符 将变量或方法声明为final,可以保证他们在使 用中不被改变。 注意:被声明为final的变量必须在声明时给定初值,而在以后的引用中只能读取,不可修改;被声明为final的方法也同样只能使用,不能重载或覆盖。
  • 33. 例: FinalTest.javafinal class A { final double PI=3.1416; final double area(double r) { return(PI*r*r); } } class FinalTest { public static void main(String args[]) { A a=new A(); System.out.println("area="+a.area(5.0)); } }
  • 34. 四、成员方法(成员函数) 在Java中,成员变量和成员方法(成员函数)是类的两大组成部分,成员变量反映了类的性质,而方法(函数)反映了类的行为。
  • 35. (一) 成员方法的声明声明格式: [方法修饰符] 返回值类型 方法名(参数表) {方法体} 说明:定义方法时一定要给出返回值类型和参数表;没有返回值时,返回值类型记为void。 如:public static void main(String args[]) {…} public int area(int length,int width) { return length,*width; }
  • 36. (二)成员方法修饰符 方法修饰符大部分的种类及意义与变量修饰符一样,不过多了一种存在性的abstract以及线程用的运作性修饰符—synchronized。 存取性:public,protected,private 存在性:static,abstract,final 运作性:synchronized
  • 37. 1.static修饰符 此修饰符会使方法成为唯一的。与类的地位等同。不会因实例的产生而受影响。static方法在使用上,有几点注意事项: (1)static方法中只能使用static变量,否则编译会出错。 (2)一个类的static变量和static方法,可直接用该类的 名称,按以下方法来使用: 类名.类方法 类名.类变量 类名.静态变量.静态方法
  • 38. 2.abstract修饰符 抽象方法存在于抽象类中,并不建立程序代码,而是留给继承的子类来覆盖。被声明为abstract的方法不需要实际的方法体,只需给出方法的名称、返回值类型和参数表。 格式: abstract 返回值类型 方法名(参数表); 注:声明抽象方法时,并不用写出大括号{}。定义了abstract抽象方法的类必须被声明为abstract的抽象类。 3.final修饰符 被声明为final的方法不能被其他类变更方法里的内容,即使是继承的子类。
  • 39. 4.synchronized修饰符 此方法修饰符用于同步化监控处理。被synchronized修饰的方法,一次只能被一个线程来使用。
  • 40. (三)成员方法调用1.简单调用:根据被调用的方法是否有返回值,有两种调用形式。 (1)作为一条单独的语句(void) 如:System.out.println(“…”); (2)作为一个表达式(有返回值) 如:s=area(3,4);
  • 41. 例:SquareDouble.java public class SquareDouble { public static void main(String arg[]) { double a=10.0,x=0.0; x=square(a); System.out.println(“正方形面积是:”+x); } public static double square(double y) { return y*y; } }
  • 42. 2.根据调用方法的所在位置及其本身的性质,又分为几种不同情况。(1)被调用的方法有可能是在本身这个类中,也有可能是在父类或其他的类中。 (2)被调用的方法有可能是类方法,也有可能是实例方法。 (3)主调方法有可能是类方法,也有可能是实例方法。 方法调用的写法就要根据方法所在的位置及它本身的性质来进行调用。
  • 43. 调用方法 被调用方法 类方法 实例方法本类类方法A直接调用:[类方法A]或[本类实例].[类方法A] 但不能用this。直接调用:[类方法A]或 [this].[类方法A] 均可。实例方法B[本类实例].[实例方法B],但不能用this,也不能直接调用。直接调用:[实例方法B]或 [this].[实例方法B] 均可。父类/其他类类方法C[父类实例].[类方法C] / [其他对象实例].[类方法C]。[父类实例].[类方法C]或 [super].[类方法C] / [其他对象实例].[类方法C]。实例方法D[父类实例].[实例方法D] / [其他对象实例].[实例方法D] 。[父类实例].[实例方法D]或 [super].[实例方法D] / [其他对象实例].[实例方法D] 。
  • 44. 上表的原则:1. this与super不能用在由static修饰的类方法里。若放在其中,则会产生编译错误信息: non-static variable this cannot be referenced from a static context non-static variable super cannot be referenced from a static context 2.在类方法中可直接调用本身类方法,但不可直接调用实例方法。 3.在实例方法中可直接调用本身类中的类方法与实例方法。 4. this与super只能用在实例方法中。 5. 〔xx对象〕.〔xx方法〕的方式可用于任何情况里。
  • 45. 例:TestMethod.java
  • 46. (四)成员方法参数的传递 参数可以是基本数据类型、数组和对象。
  • 47. 例:ArrayMaxMin.java(参数是数组)import java.applet.Applet; import java.awt.Graphics; public class ArrayMaxMin extends Applet { public void paint(Graphics g) { double Max,Min; double data[]={0.2,5.6,7.88,20.3,-0.234,3.22}; Max=ArrayMax(data); g.drawString("Max="+Max,10,20); Min=ArrayMin(data); g.drawString("Min="+Min,10,40); }
  • 48. double ArrayMax(double array[]) { double max=array[0]; for(int i=1;imax) max=array[i]; return max; } double ArrayMin(double array[]) { double min=array[0]; for(int i=1;i
  • 49. 方法参数是类对象 方法参数是类对象时,在方法体内可通过类的成员运算符“.”使用类的成员变量和方法。 如:public void paint(Graphics g) { g.drawString(“Hello Java!”,10,30); }
  • 50. 例: PassingParam.javapublic class PassingParam { static class OneObject { public String Y="a";} static void changeParam(int xx,OneObject oobject1) { xx=3; oobject1.Y="A"; }
  • 51. public static void main(String args[]) { int x=1; OneObject oobject=new OneObject(); //创建对象oobject System.out.println("传递前的参数值:x="+x+"y="+oobject.Y); PassingParam.changeParam(x,oobject); //传递变量x和对 象oobject地址 System.out.println("传递后的参数值:x="+x+"y="+oobject.Y); } }
  • 52. (五) finalize方法相当于C++中的析构方法,用来释放对象所占用的系统资源。 当对象实例不被任何变量使用时,Java对自动进行垃圾回收,因此该方法会被Java系统自动调用。