1 类的严谨定义格式如下： [ 类修饰符 ] class 类名 [extends 父类名 ] [implements 接口列表 ] { 数据成员 成员方法 } 类的严谨定义.

Presentation on theme: "1 类的严谨定义格式如下： [ 类修饰符 ] class 类名 [extends 父类名 ] [implements 接口列表 ] { 数据成员 成员方法 } 类的严谨定义."— Presentation transcript:

1 1 类的严谨定义格式如下： [ 类修饰符 ] class 类名 [extends 父类名 ] [implements 接口列表 ] { 数据成员 成员方法 } 类的严谨定义

2 2 访问修饰符 信息隐藏是 OOP 最重要的功能之一，也是 使用访问修饰符的原因。 信息隐藏的原因包括： – 对任何实现细节所作的更改不会影响使用该类 的代码 – 防止用户意外删除数据 访问修饰符 private protectedpublic 默认

3 3 访问修饰符 该类或非该类均 可访问 public 只有该类可以访 问 private 相同数据包中的 类可以访问 默认 该类及其子类的 成员可以访问， 同一个包中的类 也可访问 protected

4 4 6.1 类修饰符 类的修饰符用于说明对它的访问限制，一个类可以没有修饰符，也可以有 public 、 final 、 abstract 等几种不同的修饰符。 1 ．无修饰符的情况 如果一个类前无修饰符，则这个类只能被同一个包里的类使用。 Java 规定， 同一个程序文件中的所有类都在同一个包中。这也就是说，无修饰符的类可以被 同一个程序文件中的类使用，但不能被其他程序文件中的其他包中的类使用。 类访问修饰符

5 5 【示例程序 C3_1.java 】 class Aa { // 无修饰符的类 Aa int a=45; //Aa 类的数据成员 a } public class C3_1{ // 公共类 C3_1 public static void main(String[ ] args) { Aa a1=new Aa( );// 类 C3_1 中创建了一个无修饰符类 Aa 的对象 a1 System.out.println(a1.a); }

6 6 2 ． public 修饰符 如果一个类的修饰符是 public ，则这个类是公共类。公共类不但可供它所在包中 的其他类使用，也可供其他包中的类使用。在程序中可以用 import 语句引用其他包 中的 public 类。 Java 规定，在一个程序文件中，只能定义一个 public 类，其余的类可 以是无修饰符的类，也可以是用 final 修饰符定义的最终类，否则编译时会报错。 类访问修饰符 6-4

7 7 【示例程序 C3_2.java 】 class Fp { C3_2 f1=new C3_2( ); int add( ) { return(f1.b+f1.c); } public class C3_2 { int b=20,c=3; public static void main(String[ ] args) { Fp p1=new Fp( ); System.out.println(p1.add( )); } 运行结果： 23

8 8 3 ． final 修饰符 用 final 修饰符修饰的类被称为最终类。最终类是不能被任何其他类所继承的。 定义最终类的目的有三： (1) 用来完成某种标准功能。将一个类定义为 final 类，则可以将它的内容、属 性和功能固定下来，与它的类名形成稳定的映射关系，从而保证引用这个类时所实 现的功能是正确无误的。 类访问修饰符

9 9 (2) 提高程序的可读性。从父类派生子类，再从子类派生子类，使软件变得越 来越复杂。而在必要的层次上设置 final 类，可以提高程序的可读性。 (3) 提高安全性。病毒的闯入途径之一是在一些处理关键信息的类中派生子类， 再用子类去代替原来的类。由于用 final 修饰符定义的类不能再派生子类，截断了病 毒闯入的途径，因而提高了程序的安全性。

10 10 4 ． abstract 修饰符 用 abstract 修饰符修饰的类称为抽象类。其作用在于将许多有关的类组织在一 起，提供一个公共的基类，为派生具体类奠定基础。另外，当一个类中出现一个 或多个用 abstract 修饰符定义的方法时，则必须在这个类的前面加上 abstract 修饰符， 将其定义为抽象类。 访问修饰符

11 11 5 ．类修饰符使用注意事项 可以同时使用两个修饰符来修饰一个类，当使用两个修饰符修饰一个类时，这 些修饰符之间用空格分开，写在关键字 class 之前，修饰符的顺序对类的性质没有任 何影响。 需要注意的是：一个类可以被修饰为 public abstract ，也可以被修饰为 public final ， 但不能被修饰为 abstract final ，这是因为 abstract 类自身没有对象，需要派生子类后再 创建子类的对象，而 final 类不能派生子类，所以不存在用 abstract final 两个修饰符修 饰的类。 访问修饰符

12 12 1. 无修饰符：具有包访问特性。 2. public 访问修饰符：用 public 修饰的数据成员称为公有数据成员，使用时危险，通 常不使用。 3. private 访问修饰符：用 private 修饰的数据成员称为私有数据成员。私有数据成员只 能在定义它的类中使用，不能在类外使用，是对类进行封装时使用的主要方法。 4. protected 访问修饰符：用 protected 修饰的数据成员可以被该类及其子类的成员访问， 同一个包中的类也可访问。主要作用是允许其他包中的子类访问父类。 数据成员访问修饰符

13 13 class ClassA{ private int k; private void methodA(){ System.out.println(“ 私有方法 ”) ； } class ClassB{ void methodB(){ ClassA a=new ClassA(); a.k=10; // a.methodA(); // } 数据成员访问修饰符示例

14 14 5. static 修饰的静态数据成员 用 static 修饰符修饰的数据成员不属于任何一个类的具体对象，而是属于类的静 态数据成员。其特点如下： (1) 它被保存在类的内存区的公共存储单元中, 而不是保存在某个对象的内存区中。 因此, 一个类的任何对象访问它时，存取到的都是相同的数值。 (2) 可以通过类名加点操作符访问它。 (3) static 数据成员仍属于类的作用域，还可以使用 public static 、 private static 等进 行修饰。修饰符不同，可访问的层次也不同。 数据成员修饰符

15 15 class Pc { static double ad=8; } public class C3_5 { public static void main(Stringargs[]) { Pc m=new Pc( ); Pc m1=new Pc( ); m.ad=0.2; System.out.println("m1="+m1.ad); System.out.println("Pc="+Pc.ad); System.out.println("m="+m.ad); } 【示例程序】 对上述 (1) 和 (2) 的示例。 运行结果： m1=0.2 Pc=0.2 m=0.2

16 16 6. final 修饰符：用 final 修饰符修饰的数据成员称 为最终数据成员。最终数据成员可以在声明 时进行初始化，也可以通过构造方法赋值， 但不能在程序的其他部分赋值，它的值在程 序的整个执行过程中是不能改变的。 用 final 修饰符说明常量时，需要注意： 需要说明常量的数据类型并指出常量的具体 值。 数据成员修饰符 6-9

17 17 class Ca { static int n=20; final int n1; final int k=40; Ca( ) { n1= ++n; } } public class C3_6 { public static void main(String args[]) { Ca m1=new Ca( ); Ca m2=new Ca( ); // m1.n1=90; System.out.println("m1.n1="+m1.n1); System.out.println("m1.k="+m1.k); System.out.println("m2.n1="+m2.n1); System.out.println("m2.k="+m2.k); } 【示例程序 C3_6.java 】 运行结果 : m1.n1=21 m1.k=40 m2.n1=22 m2.k=40

18 18 在成员方法头中： 修饰符可以是公共访问控制符 public 、私有访问控制符 private 、保护访问控 制符 protected 等访问权限修饰符，也可以是静态成员方法修饰符 static 、最终成员 方法修饰符 final 、本地成员方法修饰符 native 、抽象成员方法修饰符 abstract 等非 访问权限修饰符。访问权限修饰符指出满足什么条件时该成员方法可以被访问。 非访问权限修饰符指明数据成员的使用方式。 成员方法修饰符

19 19 方法修饰符 staticfinal abstractnative

20 20 static 修饰符 3-1 static 修饰符修饰的方法叫静态方法。 静态方法是属于整个类的类方法，不用 static 修 饰符限定的方法，是属于某个具体类对象的方 法。 static 方法使用特点如下： (1) static 方法是属于整个类的，它在内存中的 代码段将随着类的定义而分配和装载。而非 static 的方法是属于某个对象的方法，当这个对 象创建时，在对象的内存中拥有这个方法的专 用代码段。 (2) 引用静态方法时，可以使用对象名做前缀， 也可以使用类名做前缀。

21 21 static 修饰符 (3) static 方法只能访问 static 数据成员，不能访问 非 static 数据成员，但非 static 方法可以访问 static 数据成员。 (4) static 方法只能访问 static 方法，不能访问非 static 方法，但非 static 方法可以访问 static 方法。 (5) main 方法是静态方法。在 Java 的每个 Application 程序中，都必须有且只能有一个 main 方法，它是 Application 程序运行的入口点。

22 22 例： class F { int d1; static int d2; void me( ){ ┅ } static void me1( ){ ┅ } static void me2( ) { me1( ); // 合法引用 d1=34; // 错，引用了非 static 数据成员 me( ); // 错，引用了非 static 方法 d2=45; }

23 23 final 修饰符 final 不能修改变量 子类不能重写方法

24 24 final 修饰的最终方法 : 用 final 修饰符修饰的方法称为最终方法，如果类的某个方法被 final 修饰符所限 定，则该类的子类就不能覆盖父类的方法，即不能再重新定义与此方法同名的自 己的方法，而仅能使用从父类继承来的方法。可见，使用 final 修饰方法，就是为 了给方法 “ 上锁 ” ，防止任何继承类修改此方法，保证了程序的安全性和正确性。 final 修饰符

25 25 native 修饰的本地方法 : 修饰符 native 修饰的方法称为本地方法，此方法使用的目的是为了将其他语言 ( 例如 C 、 C ＋＋、 FORTRAN 、汇编等 ) 嵌入到 Java 语言中。这样 Java 可以充分利用已 经存在的其他语言的程序功能模块，避免重复编程。 native 修饰符

26 26 abstract 修饰符 由 abstract 修饰的方法叫抽象方法；由 abstract 修饰的类叫抽象类 抽象方法必须声明在抽象类中 抽象方法语法： abstract 返回值类型 方法名 ( 形式参数列表 ); 声明抽象类语法： abstract class{…… } 抽象方法不具有任何实现代码

27 27 abstract 修饰符 abstract 抽象类不能被 实例化 构造方法 和 static 方法不能是抽象的 父类的抽象方法往 往在子类中实现

28 28 构造方法 每当创建类的对象时就调用的方法 与类同名，但没有返回类型 Java 为对象分配内存，初始化实例变量并调 用构造方法 两种构造方法 – 参数化构造方法 – 隐式构造方法

29 29 参数化构造方法的示例 class Sdate { int month; int day; int year; Sdate(int m,int d,int y) { month=m; day=d; year=y; System.out.println(" 日期是 " + m + "/" + d + "/" + y + "."); } public static void main(String args[]) { Sdate S1,S2; S1=new Sdate(5,27,2009); S2=new Sdate(8,8,2008); } 参数化构造方法

30 30 隐式构造方法的示例 class Sdate { int month=5; int day=27; int year=2009; public static void main(String args[ ]){ Sdate S1; S1=new Sdate(); } } 隐式构造方法

31 31 1. 定义年、月、日三个变量； 2. 定义一个构造方法，给三个变量赋初值； 3. 定义 main 方法，输出今天的日期。 构造方法练习

32 32 包 包允许将类组合成较小的单元（类似文件夹），使其易于 找到和使用相应的类文件 有助于避免命名冲突。在使用许多类时，类和方法的名称 很难决定。有时需要使用与其他类相同的名称。包基本上 隐藏了类并避免了名称上的冲突 包允许在更广的范围内保护类、数据和方法，可以在包内 定义类，而在包外的代码不能访问该类 “ 包将类名空间划分为更加容易管理的块， 包既是命名机制也是可见度控制机制 ” “ 包将类名空间划分为更加容易管理的块， 包既是命名机制也是可见度控制机制 ”

33 33 创建包 package mypackage; public class Calculate { public double volume(double height, double width, double depth) { …… } …… } 声明包

34 34 导入包 import mypackage.Calculate; public class PackageDemo { public static void main(String args[]) { Calculate calc=new Calculate( ); …… } 导入包

35 35 总结 对象由状态和行为组成 类是具有相同属性和行为的一组对象的集 合 封装是隐藏对象实现细节的过程，以便不 让用户看到 类的变量和方法可被该类的实例访问 圆点符号用于访问对象的成员 构造函数在创建对象时初始化对象