public class Phone { String brand; double price; void call(){ System.out.println("hi,how are you doing"); 案例 3-2 对象的创建及对象内存图 1 考核知识点对象的创建和引用掌握创建对象的方式

Size: px

Start display at page:

Download "public class Phone { String brand; double price; void call(){ System.out.println("hi,how are you doing"); 案例 3-2 对象的创建及对象内存图 1 考核知识点对象的创建和引用掌握创建对象的方式"

粽段
5 years ago
Views:

1 第三章补充案例案例 3-1 类的定义 1 考核知识点类的定义掌握类定义的格式掌握如何在类中定义成员变量和成员方法 3 需求分析在程序中, 设计一个表示学生的类, 该类具有以下属性和方法 : 该类具有表示姓名的属性 name 该类具有表示年龄的属性 age 该类具有表示说话行为的方法 speak, 并且用于输出学生的姓名和年龄 1) 使用 class 关键字定义一个表示学生类型的类, 类名为 Student 2) 在 Student 类中定义两个成员变量 name 和 age, 分别用来表示姓名和年龄其中,name 的数据类型为 String, 变量 age 的数据类型为 int 3) 在 Student 类中定义一个表示说话行为的 speak() 方法, 用于输出学生的姓名和年龄 class Student{ String name; int age; void speak() { System.out.println(" 我的名字是 "+name+", 今年 "+age+" 岁 "); 1 Java 语言严格区分大小写,class 和 Class 是不同的, 在定义类是只能使用 class 关键字 2 在例程中, 成员变量 name 是 String 类型,String 表示一个字符串, 后面的章节会详细讲解 3 思考一下: 自己定义一个手机 (Phone) 类, 在类中定义品牌 (brand) 和价格 (price) 属性, 定义打电话的 call() 方法, 代码如下所示 1

2 public class Phone { String brand; double price; void call(){ System.out.println("hi,how are you doing"); 案例 3-2 对象的创建及对象内存图 1 考核知识点对象的创建和引用掌握创建对象的方式了解对象在内存中的状态 3 需求分析根据定义的 Student 类, 创建一个学生对象, 该学生对象的姓名为张三, 年龄为 18, 然后调用 speak 方法输出所创建对象的姓名和年龄 1) 定义一个类 Example01 对象 2) 在 Example01 类的 main() 方法中, 使用 new 关键字创建一个学生对象, 并定义变量 s1 引用该 3) 为变量 s1 所引用的学生对象赋值, 其中,name 属性的值为张三,age 属性的值为 19. 4) 通过变量 s1 调用 speak 方法, 输出 s1 对象的姓名和年龄定义 Example01 类, 其代码如下 : public class Example01 { public static void main(string [] args) { Student s1 = new Student(); s1.name=" 张三 "; s1.age=19; s1.speak(); 2

3 1 创建类的实例对象使用 new 关键字, 其格式为 : 类名变量名 = new 类名 () 2 在代码 Student s1 = new Student(); 中,new Student() 的作用是创建一个 Student 类的实例对象, 虚拟机会在内存中为这个对象开辟一块空间, 并给这块空间分配一个地址, = 的作用是将 Student 对象所占用内存空间的地址赋值给变量 s1, 这样 s1 便持有了 Student 对象的引用, 可以通过 s1 来访问该对象的成员并进行赋值为了更加深刻地了解这句代码的含义, 下面通过一张内存图来演示, 具体如下所示 : Student s1 内存 ( 对象的地址 ) 0x3000 0x3000 new Student() name= 张三 age=19 speak() 案例 3-3 一个类创建多个对象 1 考核知识点对象的创建和引用理解根据同一个类创建的不同实例对象, 各自拥有的成员变量和成员方法是独立的, 互不影响的 3 需求分析根据定义的 Student 类, 在例程 3-2 的基础上, 创建第二个学生对象, 该学生对象的姓名为李四, 年龄为 20, 然后通过调用 speak 方法输出第二个学生对象的姓名和年龄 1) 在 Example 类中创建第二个 Student 对象, 并使用变量 s2 引用该对象 2) 为变量 s2 所引用的学生对象赋值, 其中,name 的值为李四,age 的值为 20 3) 通过变量 s2 调用 speak 方法, 输出 s2 对象的姓名和年龄 3

4 1 对案例 3-2 中的代码进行修改, 如下所示 : public class Example01 { public static void main(string [] args) { Student s1 = new Student(); s1.name=" 张三 "; s1.age=18; s1.speak(); Student s2 = new Student(); s1.name=" 李四 "; s1.age=20; s1.speak(); 一个类可以创建多个对象, 虚拟机会为每一个对象分配一块内存空间, 在各自独立的空间中, 每个对象都拥有各自独立成员变量和成员方法, 彼此互不影响在上面的代码中, 创建了两个 Student 的实例对象, 由于每个对象拥有各自独立的属性, 因此在程序中使用 s2.name = " 李四 " 和 s2.age = 20 语句只是修改了第二个 Student 对象的属性, 对第一个 Student 对象的属性值没有任何影响为了更加直观地了解代码的运行情况, 下面我们画出两个 Student 实例对象在内存中的状态图, 如下所示 : s1 s2 内存 new Student() name= 张三 age=19 speak() new Student() name= 李四 age=20 speak() 4

5 案例 3-4 不同变量引用同一个对象 1 考核知识点对象的引用掌握使用两个或者多个变量引用同一个实例对象 3 需求分析在程序中, 一个对象可能在多处使用, 这样就可能需要有多个变量来引用这个对象例如, 在案例 3-2 的基础上, 创建第三个学生对象, 该对象使用变量 s3 引用, 请思考, 如果将 s2 对象赋值给 s3,s3 对象调用 speak() 方法后, 程序的运行结果是什么? 1) 在 Example01 类中创建第三个 Student 对象, 并使用变量 s3 引用该对象 2) 将 s2 的值赋给 s3, 然后使用 s3 调用 speak() 方法 1 对案例 3-3 中的代码进行修改, 如下所示 : public class Example01 { public static void main(string [] args) { Student s1 = new Student(); s1.name=" 张三 "; s1.age=18; s1.speak(); Student s2 = new Student(); s2.name=" 李四 "; s2.age=20; s2.speak(); Student s3 = new Student(); s3=s2; s3.speak(); 5

6 1 Student s3 = s2 这句代码的作用是将 s2 引用的内存地址赋值给 s3, 换句话说, 就是使变量 s3 和 s2 引用了同一个 Student 对象, 因此 s3.speak() 方法和 s2.speak() 方法打印的结果相同为了更加深刻地了解这句代码的含义, 下面通过一张内存图来演示, 具体如下所示 : s1 s2 s3 内存 new Student() name= 张三 age=19 speak() new Student() name= 李四 age=20 speak() 2 可以使用两个或者多个变量引用同一个实例对象, 只要通过其中一个变量对该对象的属性进行修改, 使用其它引用变量访问时, 访问的都是修改后的属性案例 3-5 垃圾对象 1 考核知识点垃圾对象理解对象不被任何对象引用时, 就会变成垃圾对象 3 需求分析每个创建的对象都有自己的生命周期, 对象只有在有效的生命周期内被使用请思考, 变量 s1 在指向 Student 对象和 null 两种情况下, 调用 speak() 方法有什么不同? 1) 定义测试类 Example02, 并在 main() 方法中创建一个 Student 对象, 该对象使用变量 s1 引用 2) 通过变量 s1 调用 speak() 方法 3) 将 s1 的值设置为 null 4) 再次通过 s1 调用 speak() 方法 6

7 定义 Example02 类, 代码如下所示 : public class Example02 { Student s1 = new Student(); s1.speak(); s1 = null; s1.speak(); 程序编译时发生了错误, 如下所示 : 1 null 是一种特殊的常量, 当一个变量的值为 null 时, 表示该变量不引用任何一个对象因此, 当执行完 s1 = null 语句后,s1 不再引用 Student 对象, 这时 Student 对象就变成了垃圾对象, 如果再次通过 s1 变量去调用它的 speak() 方法就会发生异常上面程序的运行过程, 可以通过一张图例来表示, 如下所示 : Student s1 = new Student();... s1 = null;... s1 s1 null Student 对象 Student 对象 2 思考一下 : 如果有两个 Student 类型的变量 s2 和 s3 引用同一个 Student 对象, 这时如果把 s2 置为 null, 那么这个 Student 对象会变成垃圾对象吗? 下面通过一张图例对这种情况进行演示, 如下所示 : Student s2 = new Student(); s2 Student 对象 Student s3 = s2; s3 s2 Student 对象 s2 = null; s3 s2 null Student 对象从图中可以看出, 当将变量 s2 置为 null 后, 变量 s3 仍然引用 Student 对象, 因此这个对象不会变成垃 7

8 圾对象 3 异常简单来说就是在程序执行过程中发生的错误, 空指针异常是异常的一种在本案例中, 大家不需要对异常进行深究, 后面的章节会进行详细地讲解案例 3-6 垃圾回收机制 1 考核知识点垃圾回收机制掌握垃圾回收机制的特点掌握垃圾回收相关的方法 3 需求分析垃圾对象会占用一定的内存空间, 当垃圾对象积累到一定程度后,Java 虚拟机会自动进行垃圾回收但是, 如果希望程序可以及时通知 Java 虚拟机回收垃圾对象, 可以通过 System.gc() 方法强制启动垃圾回收器回收垃圾需要注意的是, 在调用 System.gc() 方法之前, 还会调用 finalize() 方法请对 Student 类进行修改, 编写一个测试类观察 System.gc() 和 finalize() 方法的执行情况 1) 对 Student 类进行修改, 该类中对 finalize() 方法进行重写 2) 编写测试类 Example02, 创建若干个 Student 对象, 然后调用 System.gc() 方法通知垃圾回收期回收垃圾 3) 为了延长程序的执行时间, 可以编写一个简单的循环语句 1 对 Student 类进行修改, 代码如下所示 : class Student { public void finalize() { System.out.println(" 垃圾对象被回收了 "); 2 对 Example02 类进行修改, 代码如下所示 : public class Example02 { new Student(); new Student(); System.gc(); for (int i = 0; i < ; i++) { // 延长程序结束时间 8

9 1 从运行结果可以看到, 两个 Student 对象的 finalize() 方法都被调用了, 这表示两个对象作为垃圾被回收了如果把 System.gc() 这行代码注释, 会发现命令行窗口不会打印任何内容, 这说明对象在变成垃圾后不会被立即回收, 同时也验证了 System.gc() 方法的作用 2 由于 System.gc() 方法只是通知 Java 虚拟机尽快进行垃圾回收, 这意味着垃圾回收器也可能不会马上运行, 因此, 在程序的最后使用了一个 for 循环来延长程序运行的时间, 从而确保能够看到垃圾对象被回收的过程 3 Student 类中定义的 finalize() 方法其签名必须是 public(protected) void finalize()[throw Throwable]{, 这样做的原因会涉及到后面的一些知识, 比如类的继承 Object 类方法的重写异常等等, 同学们在学完这些内容后就会明白其中的道理案例 3-7 类的封装 1 考核知识点类的封装了解为什么要对类进行封装了解如何实现类的封装 3 需求分析在案例 3-2 中,s1 对象的年龄是可以随便赋值的, 如果将 age 的值赋值为 -30, 显然违背了事实请根据需求, 对 Student 类进行修改, 通过封装来实现对年龄的限制 1) 编写测试类 Example03, 将属性 age 的值设为 -30, 演示不合理现象 2) 对 Student 类进行修改, 将 name 和 age 属性使用 private 修饰, 然后定义 getname() setname(string n) getage() 和 setage(int a) 四个对外访问 name 和 age 的方法 3) 在 setage(int a) 方法中对传入的参数进行检查, 如果输入值为负数, 则打印出设置的年龄不合法, 如果不为负数, 才将其设置为 age 属性的值 4) 对 Example03 类进行修改, 在 main() 方法中创建 Student 类的实例对象, 通过调用对象的 setname(string n) 和 setage(int a) 方法来设置的 name 属性和 age 属性值, 并调用 speak() 方法 9

10 1 定义 Example03 类, 代码如下所示 : public class Example03 { Student s1 = new Student(); s1.name = " 小新 "; s1.age = -30; s1.speak(); 从上图可以看出, 当将 age 的值设置为 -30 后, 程序不会报错, 但却违背了现实 2 对 Student 类进行封装, 其代码如下 : class Student { private String name = " 张三 "; private int age = 19; public String getname() { return name; public void setname(string n) { name = n; public int getage() { return age; public void setage(int a) { // 对传入的参数进行检查 if(a < 0){ System.out.println(" 设置的年龄不合法 "); else{ age = a; void speak() { System.out.println(" 我的名字是 " + name + ", 今年 " + age + " 岁 "); 10

11 3 对 Example03 类进行修改, 代码如下所示 : public class Example03 { Student s1 = new Student(); s1.setname(" 小新 "); s1.setage(-30); s1.speak(); 4 运行程序, 结果如下图所示 : 1 Student 的 name 和 age 属性使用 private 关键字修饰为私有后, 在 Example03 类中不能再使用 s1.name 和 s1.age 的方式访问这两个属性, 只能通过 public 类型的 setname(string n) 和 setage(int a) 方法进行访问在上面的代码中, 调用 setage(int a) 方法时的传入参数为 -30, 由于参数小于 0, 会打印出设置的年龄不合法, 并不会被将负数赋值给 age 属性由此可见, 只要实现了封装就能对外界的访问进行控制, 避免对私有变量随意修改而引发问题 2 思考一下: 定义一个 Division 类 ( 除法 ), 类中定义两个 int 类型的私有成员变量 dividend( 被除数 ) 和 divisor( 除数 ), 默认值都为 1 定义四个公有方法 setdividend(int mdividend ) getdividend() setdivisor(int mdivisor) 和 getdivisor() 对这两个私有属性进行访问在 setdivisor(int mdivisor) 方法中对传入的参数进行检查, 如果传入值为零则打印除数不能为零, 如果不为零, 才将其设置为 divisor 属性的值定义 Example04 类, 在类的 main() 方法中创建 Division 对象, 分别调用 setdividend(int mdividend) 和 setdivisor(int mdivisor) 方法给两个私有属性 dividend 和 divisor 赋值, 然后打印出 dividend/divisor 的结果 (1) 定义 Division 类, 代码如下所示 : public class Division { private int dividend = 1; private int divisor = 1; public void setdividend(int mdividend) { dividend = mdividend; public int getdividend() { return dividend; public void setdivisor(int mdivisor) { if (mdivisor == 0) { System.out.println(" 除数不能为零 "); else { divisor = mdivisor; 11

12 public int getdivisor() { return divisor; (2) 定义 Example04 类, 代码如下所示 : public class Example04 { Division division = new Division(); division.setdividend(10); division.setdivisor(0); int dividend = division.getdividend(); int divisor = division.getdivisor(); System.out.println(dividend / divisor); 从运行结果可以看出, 由于实现了 Division 类的封装, 在 setdivisor(int mdivision) 方法中对传入的除数值进行检查, 从而避免了程序中出现除数为 0 的错误案例 3-8 定义无参的构造方法 1 考核知识点构造方法的定义掌握如何定义构造方法掌握构造方法的执行情况 3 需求分析当通过 new 关键字创建对象的时候, 都会调用类的构造方法请在 Student 类中定义一个无参的构造方法, 编写一个测试类, 演示创建 Student 对象时, 构造方法的调用情况 1) 定义一个 Student 类, 并在类中定义一个无参的构造方法 2) 编写一个测试类 Example05, 在 main() 方法中创建一个对象 12

13 1 对 Student 类进行修改, 代码如下所示 : class Student { public Student() { System.out.println(" 构造方法被调用了 "); 2 定义 Example05 类, 代码如下所示 : public class Example05 { Student s1 = new Student(); 1 代码 new Student() 会创建一个 Student 的实例对象, 同时会调用构造方法 Student(), 因此程序打印出了构造方法被调用了 2 构造方法名的前面没有返回值类型的声明, 也不能有 void 关键字案例 3-9 定义有参的构造方法 1 考核知识点构造方法的定义掌握有参构造方法的定义方式理解系统自动分配无参的构造方法 3 需求分析如果希望创建对象的时候, 可以为属性赋值, 可以定义有参的构造方法请在 Student 类中定义一个有参数的构造方法, 编写测试类 Example06, 并在创建 Student 对象时, 为对象的 age 属性赋值 1) 定义一个 Student 类, 并在类中定义一个有参数的构造方法, 该参数用于为 age 属性赋值 2) 编写一个测试类 Example06, 在 main() 方法中创建一个对象, 并为 age 属性赋值 13

14 1 对 Student 类进行修改, 代码如下所示 : class Student { int age; public Student(int mage) { age = mage; 2 定义 Example06 类, 代码如下所示 : public class Example06 { Student s1 = new Student(20); System.out.println("age 属性的值为 :"+s1.age); 1 从运行结果可以看出,new Student(20) 语句调用了有参的构造方法 Student(int mage), 动态地将 20 传递给了 age 属性和普通方法一样, 构造方法中同样可以接收多个参数, 只要在使用 new 关键字创建对象时, 传入数量相同和类型一致的参数, 就可以自动地调用对应的构造方法 2 思考一下: 在 Example06 的 main() 方法中是否能够使用 new Student() 创建对象呢? 答案是否定的, 因为 new Student() 会调用无参的构造方法, 而本案例的 Student 类中并没有定义无参的构造方法有些同学肯定会问, 案例 3-9 之前的 Student 类都没有定义无参的构造方法, 却能使用 new Student() 创建对象, 本案例为什么不行呢? 这是因为一个类中如果没有定义构造方法, 系统会默认为其分配一个方法体为空的无参构造方法, 而一旦定义了构造方法, 系统就不再提供默认的构造方法本案例中由于我们定义了一个有参的构造方法, 所以系统不会默认分配无参的构造方法, 如果通过 new Student() 去调用无参的构造方法, 程序就会发生错误案例 3-10 构造方法的重载 1 考核知识点构造方法的重载 14

15 掌握如何在类中定义重载的构造方法 3 需求分析和普通方法一样, 构造方法也可以重载通过调用不同的构造方法, 可以为不同的属性进行赋值请在 Student 类中定义三个重载的构造方法, 编写测试类 Example07, 通过创建对象的方式演示不同构造方法的调用情况 1) 对 Student 类进行修改, 在类中定义三个重载的构造方法, 包括无参的构造方法, 接收一个 String 类型参数的构造方法, 接收 String 类型和 int 类型两个参数的构造方法象 2) 编写测试类 Example07, 在 mian() 方法中, 分别使用三个重载的构造方法创建三个 Student 对 1 对 Student 类进行修改, 代码如下所示 : class Student { public Student() { System.out.println(" 无参的构造方法 "); public Student(String name) { System.out.println(" 一个参数的构造方法 "); public Student(String name, int age) { System.out.println(" 两个参数的构造方法 "); 2 定义 Example07 类, 代码如下所示 : public class Example07 { Student s1 = new Student(); Student s2 = new Student("Rose"); Student s3 = new Student("Rose", 23); 15

16 法在一个类中可以定义多个重载的构造方法, 在创建对象时, 根据传入参数的不同会调用相应的构造方案例 3-11 this 关键字访问类的成员 1 考核知识点 this 关键字访问类的成员掌握使用 this 关键字访问类的成员 3 需求分析在定义的方法中, 难免会出现局部变量和成员变量重名的现象, 为了避免这种现象, 可以使用 this 关键字例如, 在案例 3-7 定义的 setname(string n){name = n 方法中, 如果将参数 n 的名称修改为 name, 势必会造成参数名与成员变量名发生冲突请对案例 3-7 中 Student 类进行修改, 使用 this 关键字将 setname() 方法中的成员变量和局部变量加以区分 1) 对 Student 类进行修改, 将 setname() 方法中的参数名改为 name, 使用 this.name=name 区分成员变量和局部变量 2) 编写测试类 Example08, 在 main() 方法中创建 Student 对象, 并调用 setname() 方法和 getname() 测试程序 1 对 Student 类进行修改, 代码如下所示 : class Student { private String name; public void setname(string name) { this.name = name; public String getname() { return name; 2 定义 Example08 类, 代码如下所示 : public class Example08 { Student s1 = new Student(); s1.setname("lily"); 16

17 String name = s1.getname(); System.out.println(" 我的名字叫 " + name); 1 setname(string name) 方法中的参数名和成员变量相同, 为了区分两者, 在方法中使用了 this 关键字,this 可以理解为是调用这个方法的对象的引用, 因此 this.name 表示这个对象的成员变量 name 2 在 getname() 方法中, 使用 return 语句返回了一个 name 变量的值, 而在该方法中并没有定义名为 name 的局部变量, 因此, 返回的是成员变量 name, 即 this.name 由于在 getname() 方法中不存在同名的成员变量和局部变量的冲突,this 关键字是可以省略的 3 思考一下: 在一个方法中如何去访问其它的成员方法呢? 这和在方法中访问成员变量是一样的, 也可以使用 this 关键字例如在 Student 类中定义两个方法 sleep() 和 snore(), 如果要在 sleep() 方法中访问 snore() 方法, 可以通过 this.snore() 的方式, 代码如下所示 : class Student { void sleep() { this.snore(); void snore() { Java 语言中, 由于在方法中不能再定义方法, 所以不会出现类似成员变量和局部变量冲突的问题, 因此在一个方法中访问其它成员方法,this 关键字都可以省略案例 3-12 this 关键字访问构造方法 1 考核知识点 this 关键字访问构造方法掌握如何在构造方法中使用 this 关键字访问重载的构造方法 3 需求分析如果一个类中定义了多个重载的构造方法, 为了避免在重载的构造方法中书写重复的代码, 可以在一个构造方法中使用 this 关键字调用其它的构造方法请在 Student 类中创建多个重载的构造方法, 编写一个测试类演示如何使用 this 关键字访问构造方法 17

18 1) 在 Student 类中创建多个重载的构造方法, 2) 在重载的构造方法中使用 this 关键字调用其它的构造方法 3) 编写测试类 Example09, 在 mian() 方法中, 调用其中的一个构造方法创建对象, 演示使用 this 关键字访问构造方法的执行顺序 1 对 Student 类进行修改, 代码如下所示 : class Student { public Student() { System.out.println(" 无参的构造方法 "); public Student(String name) { this(); System.out.println(" 一个参数的构造方法 "); public Student(String name, int age) { this(name); System.out.println(" 两个参数的构造方法 "); 2 定义 Example09 类, 代码如下所示 : public class Example09 { Student s1 = new Student("Jack", 22); 1 从运行结果可以看出, 三个构造方法都被调用了, 为了更加清楚地了解三个构造方法的执行顺序, 下面通过一张图例进行说明 : 18

19 new Student("Jack",23) Student() this() Student(String name) this(name) Student(String name,int age) 执行顺序 2 在构造方法中, 使用 this 调用重载构造方法的代码必须放在第一行, 否则程序不能编译通过, 这就限定了在一个构造方法中只能调用一次重载的构造方法 3 在构造方法中可以通过 this. 方法名 ([ 参数 ]) 的方式调用普通的成员方法, 但是在普通的成员方法中不能使用 this([ 参数 ]) 的方式来调用构造方法案例 3-13 静态变量 1 考核知识点静态变量了解静态变量的作用掌握静态变量的定义和使用方式 3 需求分析当多个对象存储的数据相同时, 可以使用静态变量的方式存储例如, 有一个 Student 类具有 name classname 属性, 请根据该类创建出三个 Student 对象, 并将这些对象的 classname 值都设置为三年级二班 1) 定义 Student 类, 并在类中定义 name 和 classname 属性 2) 编写测试类 Example10, 在 main() 方法中创建三个学生对象, 并分别为这些对象的 name 和 classname 属性赋值, 然后输出这些对象的 name 和 classname 值 3) 对 Student 类进行修改, 将 classname 定义为静态变量 4) 修改测试类, 在 main() 方法中使用 Student.className = 三年级二班语句为静态变量 classname 进行赋值然后输出这些对象的 name 和 classname 值为了更好地理解 Student 类中静态变量 classname 和 Student 实例对象的关系, 下面通过一个图例进行演示, 如下所示 : Student { classname 三年级二班 Student 实例对象 { name name name s1 s2 s3 19

20 1 定义 Student 类, 代码如下所示 : class Student{ String name; String classname; 2 定义 Example10 类, 代码如下所示 : public class Example10 { Student s1 = new Student(); s1.name = " 张三 "; s1.classname = " 三年级二班 "; Student s2 = new Student(); s2.name = " 李四 "; s2.classname = " 三年级二班 "; Student s3 = new Student(); s3.name = " 王五 "; s3.classname = " 三年级二班 "; System.out.println(" 我的名字是 " + s1.name + ", 来自 " + s1.classname); System.out.println(" 我的名字是 " + s2.name + ", 来自 " + s2.classname); System.out.println(" 我的名字是 " + s3.name + ", 来自 " + s3.classname); 3 对 Student 类进行修改, 代码如下所示 : class Student { String name; static String classname; 4 对 Example10 类进行修改, 代码如下所示 : public class Example10 { Student.className = " 三年级二班 "; Student s1 = new Student(); s1.name = " 张三 "; Student s2 = new Student(); 20

21 s2.name = " 李四 "; Student s3 = new Student(); s3.name = " 王五 "; System.out.println(" 我的名字是 " + s1.name + ", 来自 " + s1.classname); System.out.println(" 我的名字是 " + s2.name + ", 来自 " + s2.classname); System.out.println(" 我的名字是 " + s3.name + ", 来自 " + s3.classname); 1 本案例中, 三个 Student 对象的 classname 属性值均为三年级二班, 对于这样的相同数据, 没有必要在每个对象中都开辟一块空间存储, 完全可以在内存中只用一块空间存储, 并使之被一个类的所有实例对象所共享在 Java 中提供了一个 static 关键字, 使用 static 关键字修饰的成员变量称为静态变量, 静态变量能被该类所有实例对象共享 2 静态变量可以使用类名. 静态方法名的方式访问, 也可以通过对象引用变量. 静态方法名的方式访问, 例如本例中的静态变量 classname, 通过 Student.className 或者 s2.classname 这两种方式访问都是可以的, 不过更推荐使用前一种方式 3 思考一下: 定义一个 Person 类, 在类中定义两个 String 类型的成员变量 name 和 nationality( 国籍 ), 变量 nationality 使用 static 关键字修饰为静态变量, 其值为中国定义 StaticExample 类, 在类的 main() 方法中创建 Person 类的两个实例对象, 并打印出这两个对象的姓名和国籍 (1) 定义 Person 类, 代码如下所示 : class Person { String name; static String nationality = " 中国 "; (2) 定义 StaticExample 类, 代码如下所示 : public class StaticExample { Person lily = new Person(); lily.name = " 丽丽 "; Person lucy = new Person(); lucy.name = " 露西 "; System.out.println(lily.name + " 的国籍是 " + lily.nationality); System.out.println(lucy.name + " 的国籍是 " + lucy.nationality); 21

22 案例 3-14 静态方法的定义和调用 1 考核知识点静态方法掌握静态方法的定义和使用 3 需求分析同静态变量类似, 静态方法的访问方式是类名. 静态方法名或对象引用变量. 静态方法名请对案例 3-13 进行修改, 在 Student 类中定义一个 sayhello() 的静态方法, 编写测试类, 演示如何调用该方法 1) 对 Student 类进行修改, 在类中定义一个 sayhello() 方法, 该方法使用 static 关键字修饰 2) 编写测试类 Example11, 在 main() 方法中创建一个 Student 对象, 该对象使用变量 s1 引用, 分别通过 Student.sayHello() 和 s1.sayhello() 的方式调用静态方法 sayhello, 观察程序的运行结果 1 对 Student 类进行修改, 代码如下所示 : class Student{ static void sayhello(){ System.out.println(" 马年大吉 "); 2 定义 Example11 类, 代码如下所示 : public class Example11 { Student s1 = new Student(); Student.sayHello(); s1.sayhello(); 22

23 和静态变量一样, 静态方法也推荐使用类名. 静态方法名的形式访问案例 3-15 静态方法中访问类的成员 1 考核知识点静态方法了解在静态方法中只能访问类的静态成员, 而不能访问非静态成员 3 需求分析在程序中经常需要方法间的互相访问, 对于静态方法之间静态方法和非静态方法之间, 它们是否能够互相调用呢? 请编写一个测试类, 在类中定义若干个静态方法和非静态方法, 通过方法之间的相关调用, 演示静态方法和非静态方法的调用情况 (1) 设计原理由于静态方法在没有创建对象时就可以通过类名直接访问, 而非静态方法只有通过对象或者对象的引用变量访问, 因此在静态方法中不能访问非静态方法, 只能访问静态方法而在非静态方法中, 既可以访问静态方法, 也可以访问非静态方法 (2) 设计思路 1) 定义 Example12 类, 在类中定义两个静态方法 staticmethod1() staticmethod2(), 两个非静态方法 nonstaticmethod1() nonstaticmethod2() 2) 将 Example13 类中的四个方法进行交叉访问 1 定义 Example12 类, 在类中定义上述的四个方法和一个 main() 方法, 代码如下所示 : public class Example12 { static void staticmethod1() { System.out.println(" 静态方法 1"); static void staticmethod2() { System.out.println(" 静态方法 2"); 23

24 void nonstaticmethod1() { System.out.println(" 非静态方法 1"); void nonstaticmethod2() { System.out.println(" 非静态方法 2"); 2 对静态方法 staticmethod1() 进行修改, 在方法中访问静态方法 staticmethod2() 在 main() 方法中调用静态方法 staticmethod1(), 代码如下所示 : public class Example12 { static void staticmethod1() { System.out.println(" 静态方法 1"); staticmethod2(); Example12.staticMethod1(); 从运行结果可以看到, 程序正常执行, 这说明在静态方法中可以方法静态方法 3 对静态方法 staticmethod1() 进行修改, 在方法中访问非静态方法 nonstaticmethod1(), 代码如下所示 : public class Example12 { static void staticmethod1() { System.out.println(" 静态方法 1"); nonstaticmethod1(); Example12.staticMethod1(); 程序编译时发生了错误, 如下所示 : 24

25 从错误提示信息可以清楚地看到, 发生错误的原因是在静态方法中访问了非静态的方法 4 在 staticmethod1() 方法中注释发生错误的代码 nonstaticmethod1(), 并对非静态方法 nonstaticmethod1() 进行修改, 在方法中分别调用静态方法 statimethod1() 和非静态方法 nonstaticmethod2() 在 main() 方法中创建 Example12 的实例对象, 调用 nonstaticmethod1() 方法, 代码如下所示 : public class Example12 { static void staticmethod1() { System.out.println(" 静态方法 1"); // nonstaticmethod1(); void nonstaticmethod1() { System.out.println(" 非静态方法 1"); staticmethod1(); nonstaticmethod2(); Example12 e = new Example12(); e.nonstaticmethod1(); 从运行结果可以看到, 程序正常执行, 这说明在非静态方法中既可以方法静态方法, 也可以访问非静态方法 1 在静态方法中只能访问静态方法, 在非静态方法中可以访问静态方法和非静态方法 2 思考一下: 在静态方法中是否能够访问静态变量和非静态变量? 其实和上面的讲解一样, 非静态变量只能通过对象或者对象的引用变量访问, 而静态方法在创建对象之前就可以通过类名直接访问, 因此在静态方法中不能访问非静态变量, 只能访问静态变量 25

26 案例 3-16 代码块 1 考核知识点代码块理解代码块的不同分类掌握不同代码块的作用及其执行时机 3 需求分析有时候, 需要将某一段关联紧密的或者实现了某一功能的代码封装的一个代码块中请定义一个包含了静态代码块, 局部代码和构造代码块的类, 演示不同代码之间的执行时机 (1) 设计原理在 Java 中, 代码块一般来说可以分为三种, 局部代码块构造代码块和静态代码块定义在一个方法内部的代码块称为局部代码块 ; 定义在方法外的代码块称为构造代码块 ; 使用 static 关键字修饰的构造代码块称为静态代码块, 这三种代码块的作用和执行时机各不相同 (2) 设计思路 1) 定义 Example13 类, 在类中定义一个静态代码块一个构造代码块一个无参的构造方法和一个成员方法 localblock(), 在 localblock() 方法中定义一个局部代码块 2) 创建 Example13 类的两个实例对象, 使用 Example13 类型的变量 e1 和 e2 引用, 并通过变量 e1 和 e2 调用这两个对象的 localblock() 方法定义 Example13 类, 代码如下所示 : public class Example13 { static { { System.out.println(" 静态代码块 "); System.out.println(" 构造代码块 "); public Example13() { System.out.println(" 构造方法 "); void localblock() { { System.out.println(" 局部代码块 "); 26

27 Example13 e = new Example13(); e.localblock(); 1 静态代码块在加载类的时候执行, 由于类只在第一次使用时被加载, 且只加载一次, 因此静态代码块只执行一次从运行结果可以看到, 虽然创建了两个 Example13 的实例对象, 由于 Example13 类只会加载一次, 所以静态代码块只打印一次在实际开发中, 经常有一些代码需要在类加载时就执行, 比如加载数据库驱动, 这些代码就应该放在静态代码块中 2 构造代码块在创建类的实例对象时执行, 也就是说每创建类的一个实例对象, 都会执行一次构造代码块从运行结果可以看到, 构造代码块先于构造方法执行, 因此在实际开发中, 可以把重载构造方法中重复的代码抽取到构造代码块中执行 3 局部代码块定义在方法中, 它在方法被调用的时候执行使用局部代码块是为了限制变量的生命周期, 使得变量在使用完毕后会被尽快回收, 从而节省内存空间, 前面学习的 if 语句 for 语句都使用了局部代码块案例 3-17 单例设计模式 1 考核知识点单例设计模式了解什么是单例设计模式掌握单例设计模式的特点掌握饿汉式单例设计模式的代码格式 3 需求分析在程序开发中, 经常需要保证类的实例对象只有一个, 这时, 可以将类设计为单例设计模式请编写一个实现了单例设计模式的类 1) 定义一个类 Singleton, 为了保证外界只创建一个该类的实例对象, 在类中定义一个私有的构 27

28 造方法 2) 在类中创建一个该类的实例对象, 并且定义一个静态变量 INSTANCE( 变量名随意 ) 引用此实例对象 3) 为了防止外界使用 Singleton.INSTANCE 的方式直接访问该实例对象, 将 INSTANCE 变量使用 private 关键字修饰为私有, 同时提供一个静态方法将这个实例对象返回 1 定义 Singleton 类, 在类中定义一个私有, 无参的构造方法, 代码如下 : public class Singleton { private Singleton() { 2 创建 Singleton 的一个实例对象, 定义一个私有的静态变量 INSTANCE 引用这个对象, 代码如下所示 : public class Singleton { private Singleton() { private static Singleton INSTANCE = new Singleton(); 3 定义一个静态方法 getinstance() 将实例对象返回, 代码如下 : public class Singleton { private Singleton() { private static Singleton INSTANCE = new Singleton(); public static Singleton getinstance() { return INSTANCE; 4 定义 Example14 类, 在类的 main() 方法中调用两次 getinstance() 方法, 获得两个 Singleton 的实例对象, 使用 == 比较这两个对象是否相等, 代码如下所示 : public class Example14 { Singleton s1 = Singleton.getInstance(); Singleton s2 = Singleton.getInstance(); System.out.println(s1 == s2); 从运行结果可以看到, 两个对象使用 == 比较的结果为 true, 说明两次获得的是同一个 Singleton 的实例对象 28

29 1 为了更加深刻的理解单例设计模式, 下面对单例设计模式的特点进行归纳 : 类中定义一个无参的构造方法, 并且声明为私有在类的内部创建该类的一个实例对象, 使用私有的静态变量引用该实例对象定义静态方法返回该实例对象 2 本案例中这种代码格式的单例设计模式被形象的称为饿汉式单例设计模式, 这是因为在程序中, 无论是否需要该类的实例对象, 在类加载时都会创建一个实例对象后面我们还会学习懒汉式单例设计模式, 懒汉式单例设计模式会在第一次需要时创建该类的实例对象案例 3-18 静态内部类成员的定义和访问 1 考核知识点静态内部类理解在静态内部类中可以定义静态成员和非静态成员掌握访问静态内部类中静态成员和非静态成员的方式 3 需求分析静态内部类中可以定义静态成员和非静态成员, 这两者的访问方式有所不同请设计一个静态内部类, 编写测试类演示如何访问静态内部类中的静态成员和非静态成员 1) 定义外部类 Outer, 在 Outer 类中定义一个静态内部类 Inner 2) 在 Inner 中定义两个 String 类型变量, 一个静态变量 staticfield, 其值为静态内部类的静态变量, 一个非静态变量 nonstaticfield, 其值为静态内部类的非静态变量定义两个方法, 一个静态方法 staticmethod(), 方法中打印静态内部类的静态方法, 一个非静态方法 nonstaticmethod(), 方法中打印静态内部类的非静态方法 3) 定义 Example15 类, 在类的 main() 方法中调用 Inner 类中的变量和方法 1 定义外部类 Outer 和静态内部类 Inner, 代码如下所示 : class Outer { static class Inner { static String staticfield = " 静态内部类的静态变量 "; String nonstaticfield = " 静态内部类的非静态变量 "; static void staticmethd() { System.out.println(" 静态内部类的静态方法 "); 29

30 void nonstaticmethod() { System.out.println(" 静态内部类的非静态方法 "); 2 定义 Example15 类, 在类的 main() 方法中, 通过外部类. 内部类. 静态成员的方式访问静态变量 staticfield 和静态方法 staticmethod(), 代码如下所示 : public class Example15 { System.out.println(Outer.Inner.staticField); Outer.Inner.staticMethd(); 3 对 Example15 类进行修改, 在 main() 方法中创建静态内部类 Inner 的实例对象, 使用 Outer.Inner 类型的变量 inner 引用, 通过变量 inner 访问非静态变量 nonstaticfield 和非静态方法 nonstaticmethod(), 代码如下所示 : public class Example15 { Outer.Inner inner = new Outer.Inner(); System.out.println(inner.nonStaticField); inner.nonstaticmethod(); 静态内部类中可以定义静态成员和非静态成员, 如果要访问非静态成员, 必须通过静态内部类的对象或者对象的引用变量如果要访问静态成员, 则可以直接通过外部类. 静态内部类. 静态成员的方式, 不需要创建静态内部类的实例对象 30

31 案例 3-19 方法内部类访问局部变量 1 考核知识点方法内部类掌握方法内部类中访问的局部变量需要使用 final 关键字修饰 3 需求分析在方法内部类中可以访问外部类的成员变量, 同样, 在方法内部类中也可以访问其所在方法中定义的局部变量, 但是局部变量必须使用 final 关键字来修饰请编写一个方法内部类, 演示如何在方法内部类中访问局部变量 1) 定义 Example16 类, 在类中定义一个 test() 方法,test() 方法中定义一个 int 类型的局部变量 num, 其值为 5 2) 在 test() 方法中定义一个方法内部类 Inner, 在 Inner 类中定义一个 show() 方法, 方法中访问局部变量 num 在 test() 方法中创建内部类 Inner 的实例对象, 调用其 show() 方法 3) 在 Example16 的 main() 方法中, 创建 Example16 的实例对象, 使用变量 e 引用该对象, 通过变量 e 调用 test() 方法 1 定义 Example16 类, 代码如下所示 : public class Example16 { void test() { int num = 5; class Inner { void show() { System.out.println(" 局部变量 num 的值为 " + num); ; Inner inner = new Inner(); inner.show(); Example16 e = new Example16(); e.test(); 程序编译时发生错误, 如下所示 : 31

32 从错误提示信息可以看到, 发生错误的原因是方法内部类中访问的局部变量 num 没有被声明为最终类型, 即没有使用 final 关键字修饰对程序进行修改, 将局部变量 num 使用 final 关键字修饰, 再次方法内部中访问的局部变量必须使用 final 关键字修饰, 否则程序在编译时会发生错误 32

教案模板4-2

教案模板4-2 传智播客 Java 基础入门教学设计课程名称 : Java 基础入门授课年级 : 2014 年级授课学期 : 2014 学年第一学期教师姓名 : 某某老师 2014 年 02 月 09 日课题名称第 3 章面向对象上计划学时 6 课时 Java 是一种面向对象的语言, 认识面向对象的编程思想对于 Java 学习至关重内容分析要在面向对象中, 有两个重要的概念, 分别是类和对象,

public class Phone { String brand; double price; void call(){ System.out.println("hi,how are you doing"); 案例 3-2 对象的创建及对象内存图 1 考核知识点对象的创建和引用 掌握创建对象的方式

public class Phone { String brand; double price; void call(){ System.out.println("hi,how are you doing"); 案例 3-2 对象的创建及对象内存图 1 考核知识点对象的创建和引用掌握创建对象的方式