第3章 面向对象(上)

发布时间:2024年01月18日

3.1 面向对象的思想

面向过程: 分析出解决问题所需要的步骤,然后用函数把这些步骤一一实现,使用的时候依次调用就可以了。

面向对象: 把构成问题的事务按照一定规则划分为多个独立的对象,然后通过调用对象的方法来解决问题。

面向对象是一种符合人类思维习惯的编程思想。现实生活中存在各种形态不同的事物,这些事物之间存在着各种各样的联系。在程序中使用对象映射现实中的事物,使用对象的关系描述事物之间的联系,这种思想就是面向对象。

面向对象具有三大特性:封装,继承,多态

1.封装性 封装是面向对象的核心思想,它有两层含义,一是指把对象的属性和行为看成是一个密不可分的整体,将这两者“封装”在一起(即封装在对象中);另外一层含义指“信息隐藏”,将不想让外界知道的信息隐藏起来。例如,驾校的学员学开车,只需要知道如何操作汽车,无需知道汽车内部是如何工作的。

2.继承性 继承性主要描述的是类与类之间的关系,通过继承,可以在无需重新编写原有类的情况下,对原有类的功能进行扩展。例如,有一个汽车类,该类描述了汽车的普通特性和功能。进一步再产生轿车类,而轿车类中不仅应该包含汽车的特性和功能,还应该增加轿车特有的功能,这时,可以让轿车类继承汽车类,在轿车类中单独添加轿车特性和方法就可以了。继承不仅增强了代码的复用性、提高开发效率,还降低了程序产生错误的可能性,为程序的维护以及扩展提供了便利。

3.多态性 多态性指的是在一个类中定义的属性和方法被其它类继承后,它们可以具有不同的数据类型或表现出不同的行为,这使得同一个属性和方法在不同的类中具有不同的语义。例如,当听到“Cut” 这个单词时,理发师的行为是剪发,演员的行为表现是停止表演,不同的对象,所表现的行为是不一样的。多态的特性使程序更抽象、便捷,有助于开发人员设计程序时分组协同开发。

3.2 类与对象

在面向对象中,为了做到让程序对事物的描述与事物在现实中的形态保持一致,面向对象思想中提出了两个概念,即类和对象。在Java程序中类和对象是最基本、最重要的单元。类表示某类群体的一些基本特征抽象,对象表示一个个具体的事物。

例如,在现实生活中,学生就可以表示为一个类,而一个具体的学生,就可以称为对象。一个具体的学生会有自己的姓名和年龄等信息,这些信息在面向对象的概念中称为属性;学生可以看书和打篮球,而看书和打篮球这些行为在类中就称为方法。类与对象的关系如右图。

在上图中,学生可以看作是一个类,小明、李华、大军都是学生类型的对象。类用于描述多个对象的共同特征,它是对象的模板。对象用于描述现实中的个体,它是类的实例。对象是根据类创建的,一个类可以对应多个对象。

在面向对象的思想中最核心的就是对象,而创建对象的前提是需要定义一个类,类是Java中一个重要的引用数据类型,也是组成Java程序的基本要素,所有的Java程序都是基于类的。

3.2.1 类的定义

类是对象的抽象,用于描述一组对象的共同特征和行为。类中可以定义成员变量和成员方法,其中,成员变量用于描述对象的特征,成员变量也被称作对象的属性;成员方法用于描述对象的行为,可简称为方法。

类的定义格式如下所示:

class 类名{
   成员变量;
   成员方法;
}

根据上述格式定义一个学生类,成员变量包括姓名(name)、年龄(age)、性别(sex);成员方法包括读书read()。学生类定义的示例代码如下所示。

class Student {
    String name;    	// 定义String类型的变量name
    int age;        	// 定义int类型的变量age
    String  sex;    	// 定义String类型的变量sex
	// 定义 read () 方法
	void read() {  
		System.out.println("大家好,我是" + name + ",我在看书!");
	}
}

脚下留心:局部变量与成员变量的不同

在Java中,定义在类中的变量被称为成员变量,定义在方法中的变量被称为局部变量。如果在某一个方法中定义的局部变量与成员变量同名,这种情况是允许的,此时,在方法中通过变量名访问到的是局部变量,而并非成员变量。

class Student {
	int age = 30;       		// 类中定义的变量被称作成员变量
	void read() {  
		int age = 50;  	// 方法内部定义的变量被称作局部变量
		System.out.println("大家好,我" + age + "岁了,我在看书!");
	}
}

上面的代码中,在Student类的read ()方法中有一条打印语句,访问了变量age,此时访问的是局部变量age,也就是说当有另外一个程序调用read ()方法时,输出的age值为50,而不是30。

3.2.2 对象的创建与使用

在Java程序中可以使用new关键字创建对象,具体格式如下:

类名 对象名称 = null;
对象名称 = new 类名();

上述格式中,创建对象分为声明对象和实例化对象两步,也可以直接通过下面的方式创建对象,具体格式如下:

类名 对象名称 = new 类名();

例如,创建Student类的实例对象,示例代码如下:

Student stu = new Student();

上述代码中,new Student() 用于创建Student类的一个实例对象,Student stu则是声明了一个Student类型的变量stu。运算符 “=”将新创建的Student对象地址赋值给变量stu,变量stu引用的对象简称为stu对象。

class Student {
	String name;       			 // 声明姓名属性
	void read() {  
		System.out.println("大家好,我是" + name + ",我在看书!");
	}
}
public class Test {
    public static void main(String[] args[]) {  
		Student stu = new Student(); //创建并实例化对象
	}
}

上述代码在main()方法中实例化了一个Student对象,对象名称为stu。使用new关键字创建的对象是在堆内存分配空间。stu对象的内存分配如下图。

创建Student对象后,可以使用对象访问类中的某个属性或方法,对象属性和方法的访问通过“.”运算符实现,具体格式如下:

对象名称.属性名
对象名称.方法名

接下来通过一个案例学习对象属性和方法的访问。

1 class Student {
2	String name;       		// 声明姓名属性
3	void read() {  
4		System.out.println("大家好,我是" + name);
5	}
6 }
7 class Example01 {
8	public static void main(String[] args) {
9		Student stu1 = new Student(); 	// 创建第一个Student对象
10	Student stu2 = new Student(); 		// 创建第二个Student对象
11	stu1.name = "小明";                 	// 为stu1对象的name属性赋值
12	stu1.read();                  		// 调用对象的方法
13	stu2.name = "小华";
14	stu2.read();
15	}
16 }

上述代码中,第2~5行代码声明了一个String类型的name属性和一个read()方法,第9~10行代码创建了stu1对象和stu2对象;第11行代码为stu1对象name属性赋值;第12行代码通过stu1对象调用read()方法。第13行代码为stu2对象name属性赋值;第14行代码通过stu2对象调用read()方法。

从运行结果可以看出,stu1对象和stu2对象在调用read()方法时,打印的name值不相同。这是因为stu1对象和stu2对象是两个完全独立的个体,它们分别拥有各自的name属性,对stu1对象的name属性进行赋值并不会影响到stu2对象name属性的值。

为stu1对象和stu2对象中的属性赋值后,stu1对象和stu2对象的内存变化如下图。

3.2.3 对象的引用传递

类属于引用数据类型,引用数据类型就是指内存空间可以同时被多个栈内存引用。接下来通过一个案例为大家详细讲解对象的引用传递。

1 class Student {
2	  String name;       	// 声明姓名属性
3     int age;           		// 声明年龄属性
4	  void read() {  
5		  System.out.println("大家好,我是"+name+",年龄"+age);
6	  }
7 }
8 class Example02 {
9	public static void main(String[] args) {
10		Student stu1 = new Student (); //声明stu1对象并实例化
11		Student stu2 = null;          //声明stu2对象,但不对其进行实例化
12		stu2 = stu1;                       // stu1给stu2分配空间使用权。
13		stu1.name = "小明";          // 为stu1对象的name属性赋值
14		stu1.age = 20;
15		stu2.age = 50;
16		stu1.read();                  	  // 调用对象的方法
17		stu2.read();
18	}
19 }

上述代码中,第2~3行代码分别声明了一个String类型的name属性和一个int类型的age属性;第4~6行代码定义了一个read()方法。第10行代码声明stu1对象并实例化;第11行代码声明stu2对象,但不对其进行实例化。第12行代码把stu1对象的堆内存空间使用权分配给stu2。第13~14行代码为stu1对象的name属性和age属性赋值;第15行代码为stu2对象的age属性赋值;第16~17行代码分别使用stu1对象和stu2对象调用read()方法。

上述代码中,对象引用传递的内存分配如下图。首先声明对象stu1并为stu1对象开辟空间。

然后stu1对象为stu2对象分配使用权,stu1和stu2指向同一内存。

stu1对象为属性赋值。

通过stu2修改age属性的值。

一个栈内存空间只能指向一个堆内存空间,如果想要再指向其它堆内存空间,就必须先断开已有的指向才能分配新的指向。

3.2.4 访问控制

针对类、成员方法和属性,Java提供了4种访问控制权限,分别是private、default、protected和public。这4种访问控制权限按级别由小到大依次排列,如下图。

4种访问控制权限,具体介绍如下。 (1)private(当前类访问级别):private属于私有访问权限,用于修饰类的属性和方法。类的成员一旦使用了private关键字修饰,则该成员只能在本类中进行访问。 (2)default:如果一个类中的属性或方法没有任何的访问权限声明,则该属性或方法就是默认的访问权限,默认的访问权限可以被本包中的其它类访问,但是不能被其他包的类访问。

(3)protected:属于受保护的访问权限。一个类中的成员使用了protected访问权限,则只能被本包及不同包的子类访问。 (4)public:public属于公共访问权限。如果一个类中的成员使用了public访问权限,则该成员可以在所有类中被访问,不管是否在同一包中。

访问范围privatedefaultprotectedpublic
同一类中
同一包中的类
不同包的子类
全局范围

下面通过一段代码演示四种访问控制权限修饰符的用法。

public class Test {
    public int aa;			//aa可以被所有的类访问
    protected boolean bb; 		//可以被所有子类以及本包的类使用
    void cc() { 			//default 访问权限,能在本包范围内使用
        System.out.println("包访问权限");
    }
    //private权限的内部类,即这是私有的内部类,只能在本类使用
    private class InnerClass {
    }
}

类名Test只能使用public修饰或者不写修饰符。局部成员是没有访问权限控制的,因为局部成员只在其所在的作用域内起作用,不可能被其他类访问到。错误示例代码如下所示:

public class Test {
{
    public int aa;			//错误,局部变量没有访问权限控制
    protected boolean bb; 		//错误,局部变量没有访问权限控制
}
    void cc() { 			//default 访问权限,能在本包范围内使用
        System.out.println("包访问权限");
    }
private class InnerClass {  //private权限的内部类,即这是私有的内部类,只能在本类使用
    }
}

运行上述代码,程序会报错,如下图。

如果一个Java源文件中定义的所有类都没有使用public修饰,那么这个Java源文件的文件名可以是一切合法的文件名;如果一个源文件中定义了一个public修饰的类,那么这个源文件的文件名必须与public修饰的类名相同。

3.3 封装

3.3.1 为什么要封装

在Java面向对象的思想中,封装是指一种将抽象性函数式接口的实现细节部分包装、隐藏起来的方法。封装可以被认为是一个保护屏障,防止本类的代码和数据被外部类定义的代码随机访问。

1 class Student{
2	String name;       		// 声明姓名属性
3  	 int age;           		// 声明年龄属性
4	void read() {  
5		System.out.println("大家好,我是"+name+",年龄"+age);
6	}
7 }
8 public class Example03 {
9	public static void main(String[] args) {
10		Student stu = new Student();	// 创建学生对象
11		stu.name = "张三";	              	// 为对象的name属性赋值
12		stu.age = -18;	                  // 为对象的age属性赋值
13		stu.read();	                       	// 调用对象的方法
14	}
15 }

在上述代码中,第12行代码将年龄赋值为-18岁,这在程序中是不会有任何问题的,因为int的值可以取负数。但是在现实中,-18明显是一个不合理的年龄值。为了避免这种错误的发生,在设计Student类时,应该对成员变量的访问作出一些限定,不允许外界随意访问,这就需要实现类的封装。

3.3.2 如何实现封装

类的封装是指将对象的状态信息隐藏在对象内部,不允许外部程序直接访问对象的内部信息,而是通过该类提供的方法实现对内部信息的操作访问。 在Java开发中,在定义一个类时,将类中的属性私有化,即使用private关键字修饰类的属性,被私有化的属性只能在类中被访问。如果外界想要访问私有属性,则必须通过setter和getter方法设置和获取属性值。

1 class Student{
2   private String name;       		// 声明姓名属性
3	private  int age;           		// 声明年龄属性
4	public String getName() {
5    	return name;
6   }
7   public void setName(String name) {
8      this.name = name;
9   }
10  public int getAge() {
11       return age;
12  }
13  public void setAge(int age) {
14       if(age<=0){
15          System.out.println("您输入的年龄有误!");
16       } else {
17          this.age = age;
18       }
19    }
20    public void read() {  
21		System.out.println("大家好,我是"+name+",年龄"+age);
22	}
23 }
24 public class Example04 {
25	public static void main(String[] args) {
26		Student stu = new Student();	// 创建学生对象
27		stu.setName("张三");	              	// 为对象的name属性赋值
28		stu.setAge(-18);	               	// 为对象的age属性赋值
29		stu.read();	               // 调用对象的方法
30	}
31 }

使用private关键字将属性name和age声明为私有变量,并对外界提供公有的访问方法,其中,getName()方法和getAge()方法用于获取name属性和age属性的值,setName()方法和setAge()方法方法用于设置name属性和age属性的值。程序运行结果如下图。

【案例3-1】 基于控制台的购书系统

伴随互联网的蓬勃发展,网络购书系统作为电子商务的一种形式,正以其高效、低成本的优势逐步成为新兴的经营模式,人们已经不再满足互联网的用途仅仅局限于信息的浏览和发布,更渴望着能够充分享受互联网带来的更多便利。网络购书系统正适应了当今社会快节奏地生活,使顾客足不出户便可以方便快捷轻松地选购自己喜欢的图书。

本案例要求,使用所学知识编写一个基于控制台的购书系统,实现购书功能。程序输出所有图书的信息,包括每本书的编号、书名、单价、库存。 顾客购书时,根据提示输入图书编号选购需要的书,并根据提示输入购买书的的数量。购买完毕后输出顾客的订单信息,包括订单号、订单明细、订单总额。

 1 public class Book {
 2     private int id;    // 编号
 3     private String name;  // 书名
 4     private double price;  // 价格
 5     private int storage;   // 库存
 6     // 有参构造
 7     public Book(int id, String name, double price, int storage) {
 8         this.id = id;
 9         this.name = name;
 10         this.price = price;
 11         this.storage = storage;
 12     }
 13     // 获取书号
 14     public int getId() {
 15         return id;
 16     }
 17     // 获取书名
 18     public String getName() {
 19         return name;
 20     }
 21     // 获取价格
 22     public double getPrice() {
 23         return price;
 24     }
 25     // 获取库存
 26     public int getStorage() {
 27         return storage;
 28     }
 29 }
 1 public class OrderItem {
 2     private Book book;
 3     private int num;
 4     // 有参构造方法
 5     public OrderItem(Book book, int num) {
 6         this.book = book;
 7         this.num = num;
 8     }
 9     // 获取图书对象
 10 public Book getBook() {
 11       return book;
 12 }
 13     // 获取订购图书数量
 14 public int getNum() {
 15       return num;
 16     }
 17 }
 1 public class Order {
 2     private String orderId;
 3     private OrderItem items[];
 4     private double total;
 5     // 有参构造
 6     public Order(String orderId) {
 7         this.orderId = orderId;
 8         this.items = new OrderItem[3];
 9     }
 10 // 获取订单号
 11 public String getOrderId() {
 12         return orderId;
 13 }
 14 // 获取订单列表
 15 public OrderItem[] getItems() {
 16         return items;
 17 }
 18 // 获取订单总额
 19 public double getTotal() {
 20         calTotal();
 21         return total;
 22 }
 23 // 指定一个订单项
 24 public void setItem(OrderItem item, int i) {
 25         this.items[i] = item;
 26 }
 27 // 计算订单总额
 28 public void calTotal() {
 29 double total = 0;
 30 for (int i = 0; i < items.length; i ++) {
 31       total += items[i].getNum() * items[i].getBook().getPrice();
 32 }
 33       this.total = total;
 34 }
 35 }
 1 import java.util.Scanner;
 2 public class PayBooks {
 3     public static void main(String[] args) {
 4         Book books[] = new Book[3];
 5         //模拟从数据库中读取图书信息并输出
 6         outBooks(books);
 7         // 顾客购买图书
 8         Order order = purchase(books);
 9         // 输出订单信息
 10         outOrder(order);
 11     }
 12     // 顾客购买图书
 13     public static Order purchase(Book books[]) {
 14         Order order = new Order("00001");
 15         OrderItem item = null;
 16         Scanner in = new Scanner(System.in);
 17         for (int i = 0; i < 3; i ++) {
 18             System.out.println("请输入图书编号选择图书:");
 19             int cno = in.nextInt();
 20             System.out.println("请输入购买图书数量:");
 21             int pnum = in.nextInt();
 22             item = new OrderItem(books[cno-1],pnum);
 23             order.setItem(item, i);
 24             System.out.println("请继续购买图书。");
 25         }
 26         in.close();
 27         return order;
 28     }
 29     // 输出订单信息
 30     public static void outOrder(Order order) {
 31         System.out.println("\n\t图书订单");
 32         System.out.println("图书订单号:"+order.getOrderId());
 33         System.out.println("图书名称\t购买数量\t图书单价");
 34         System.out.println("--------------------------------------");
 35         OrderItem items[] = order.getItems();
 36         for(int i = 0; i < items.length; i ++) {
 37 System.out.println(items[i].getBook().getName()+"\t"+items[i].getNum(
 38 )+"\t"+items[i].getBook().getPrice());
 39             //System.out.println("\n");
 40         }
 41 System.out.println("---------------------------------------");
 42  System.out.println("订单总额:\t\t"+order.getTotal());
 43 }
 44     // 模拟从数据库中读取图书信息并输出
 45     public static void outBooks(Book books[]) {
 46         books[0] = new Book(1,"Java教程",30.6,30);
 47         books[1] = new Book(2,"JSP教程",42.1,40);
 48         books[2] = new Book(3,"SSH架构",47.3,15);
 49         System.out.println("\t图书列表");
 50         System.out.println("图书编号\t图书名称\t\t图书单价\t库存数量");
 51         System.out.println("---------------------------------------");
 52         for (int i = 0; i < books.length; i ++) {
 53             System.out.println(i+1+"\t"+books[i].getName()+"\t"+
 54                         books[i].getPrice()+"\t"+books[i].getStorage());
 55         }
 56         System.out.println("---------------------------------------");
 57     }
 58 }

3.4 构造方法

实例化一个对象后,如果要为这个对象中的属性赋值,则必须通过直接访问对象的属性或调用setter方法才可以,如果需要在实例化对象的时为这个对象的属性赋值,可以通过构造方法实现。构造方法(也被成为构造器)是类的一个特殊成员方法,在类实例化对象时自动调用。

3.4.1 定义构造方法

构造方法是一个特殊的成员方法,在定义时,有以下几点需要注意: (1)构造方法的名称必须与类名一致。 (2)构造方法名称前不能有任何返回值类型的声明。 (3)不能在构造方法中使用return返回一个值,但是可以单独写return语句作为方法的结束。

接下来通过一个案例演示构造方法的定义。

1 class Student{
2	public Student() {  
3		System.out.println("调用了无参构造方法");
4	}
5 }
6 public class Example05 {
7	public static void main(String[] args) {
8             System.out.println("声明对象...");
9		    Student stu = null;           	//声明对象
10         System.out.println("实例化对象...");
11         stu = new Student();     			//实例化对象
12	}
13 }

在一个类中除了定义无参的构造方法外,还可以定义有参的构造方法,通过有参的构造方法可以实现对属性的赋值。接下来演示有参构造方法的定义与调用。

1 class Student{
2    private String name;
3    private int age;
4    public Student(String n, int a) 5{
6       name = n;
7       age = a;
8   }
9 	 public void read(){
10        System.out.println("我是:"+name+",年龄:"+age);
11    }
12 }
13 public class Example06 {
14      public static void main(String[] args) {
15         Student stu = new Student("张三",18);    // 实例化Student对象
16         stu.read();
17      }
18 }

Student类增加了私有属性name和age,并且定义了有参的构造方法Student (String name, int a)。第14行代码实例化Student对象,该过程会调用有参的构造方法,并传入参数“张三”和18,分别赋值给name和age。 由运行结果可以看出,stu对象在调用read()方法时, name属性已经被赋值为张三,age属性已经被赋值为20。

3.4.2 构造方法的重载

与普通方法一样,构造方法也可以重载,在一个类中可以定义多个构造方法,只要每个构造方法的参数或参数个数不同即可。在创建对象时,可以通过调用不同的构造方法为不同的属性赋值。

接下来通过一个案例学习构造方法的重载。

1 class Student{
2    private String name;
3    private int age;
4    public Student() { }
5    public Student(String n) {
6             name = n;
7    }
8    public Student(String n, int a) {
9             name = n;
10        age = a;
11    }
12 	 public void read(){
13       System.out.println("我是:"+name+",年龄:"+age);
14    }
15 }
16 public class Example07 {
17      public static void main(String[] args) {
18         Student stu1 = new Student("张三");
19         Student stu2 = new Student("张三",18);   // 实例化Student对象
20         stu1.read();
21         stu2.read();
22      }
23 }

上述代码中,第5~11行代码声明了Student类的两个重载的构造方法。在main()方法中,第18~21行代码在创建stu1对象和stu2对象时,根据传入参数个数不同,stu1调用了只有一个参数的构造方法;stu2调用的是有两个参数的构造方法。

多学一招:默认构造方法

在Java中的每个类都至少有一个构造方法,如果在一个类中没有定义构造方法,系统会自动为这个类创建一个默认的构造方法,这个默认的构造方法没有参数,方法体中没有任何代码,即什么也不做。

下面程序中Student类的两种写法,效果是完全一样的。

第一种写法:

class Student {				
}		

第二种写法:

class Student{
	public Student(int age){
        System.out.println(age);
    }
}

第二种写法:对于第一种写法,类中虽然没有声明构造方法,但仍然可以用new Student()语句创建Student类的实例对象,在实例化对象时调用默认构造方法。

上面的Student类中定义了一个有参构造方法,这时系统就不再提供默认的构造方法。接下来再编写一个测试程序调用上面的Student类。

public class Example08 { 
	public static void main(String[] args) {
		Student stu = new Student(); 	// 实例化 Student对象
	}
}

运行程序,编译器报错,如下图。

编译器提示无法将Student类的无参构造方应用到有参构造方法,原因是调用new Student ()创建Student类的实例对象时,需要调用无参构造方法,而Student类中定义了一个有参的构造方法,系统不再提供无参的构造方法。为了避免上面的错误,在一个类中如果定义了有参的构造方法,最好再定义一个无参的构造方法。 需要注意的是,构造方法通常使用public进行修饰。

【案例3-2】 银行存取款

对于银行存取款的流程,人们非常熟悉,用户可在银行对自己的资金账户进行存款、取款、查询余额等操作,极大的便利了人民群众对资金的管理。 本案例要求,使用所学知识编写一个程序实现银行存取款功能。案例要求如下: (1)创建账户,初始存款为500。 (2)向账户存入1000元。 (3)从账户取出800元。

 1 public class BankAccount {
 2     int account_number;//账号
 3     double leftmoney;//存款余额
 4 public double getleftmoney () { ????//查询余额
 5     return leftmoney;
 6 }
 7 public void savemoney(double money) { ??//存款
 8     leftmoney+=money;
 9 }
 10 public void getmoney (double money){ ?//取款
 11     leftmoney-=money;
 12 }
 13 public BankAccount (int number, double money){ //构造方法,用来初始化变量
 14     account_number=number;
 15     leftmoney=money;
 16 }
 17 public static void main(String[] args) {
 18     BankAccount ba=new BankAccount(123456,500);
 19     ba.savemoney(1000);
 20 ???System.out.println("存入1000元后,您的余额为:"+ba.getleftmoney());
 21 ???ba.getmoney(2000);
 22 ???System.out.println("取款800元后,您的余额为:"+ba.getleftmoney());
 23 }
 24 }

【案例3-3】查看手机配置与功能

随着科技的发展,手机的使用已经普及到每个人,手机的功能越来越多并且越来越强大,人们在生活中越来越依赖手机。 有两款配置和功能都不同的手机,配置信息包括品牌、型号、操作系统、价格和内存;手机功能包括自动拨号、游戏和播放歌曲。本案例要求使用所学知识编写一个程序实现手机配置及功能查看,并将查看结果打印在控制台。

 1 public class Phone {
 2     String brand;  // 品牌
 3     String type;   // 型号
 4     String os;     // 操作系统
 5     int price;    // 价格
 6     int memorySize;   // 内存
 7     // 无参构造
 8     public Phone(){   
 9     }
 10     // 有参构造
 11     public Phone(String brand, String type, String os, int price, int
 12  memorySize) {
 13         this.brand = brand;
 14         this.type = type;
 15         this.os = os;
 16         this.price = price;
 17         this.memorySize = memorySize;
 18     }
 19     // 关于本机
 20     public void about() {
 21         System.out.println("品牌:"+brand+"\n"+"型号:"+type+"\n"+
 22                             "操作系统:"+os+"\n"+"价格:"+price+"\n"+"内存:
 23 "+memorySize+"\n");
 24     }
 25     // 打电话
 26     public void call(int num) {
 27         System.out.println("使用自动拨号功能:");
 28         String phoneNo = "";
 29         switch (num) {
 30         case 1: phoneNo = "爸爸的号。";break;
 31         case 2: phoneNo = "妈妈的号。";break;
 32         case 3: phoneNo = "爷爷的号。";break;
 33         case 4: phoneNo = "奶奶的号。";break;
 34         }
 35         System.out.println(phoneNo);
 36     }
 37     // 打游戏
 38     public void playGame() {
 39         System.out.println("玩扫雷游戏。");
 40     }
 41     // 下载音乐
 42     public void downloadMusic(String song) {
 43         System.out.println("开始下载。。。。");
 44         System.out.println("下载完成。。。。");
 45     }
 46     // 播放音乐
 47     public void playMusic(String song) {
 48         System.out.println("播放歌曲:"+song);
 49     }
 50 }
 1 public class PhoneTest {
 2 	public static void main(String[] args) {
 3         // 通过无参构造创建手机对象一
 4         Phone p1 = new Phone();
 5         p1.brand = "苹果";
 6         p1.type = "iphoneX";
 7         p1.os = "ios";
 8         p1.price = 8888;
 9         p1.memorySize = 16;
 10         // 测试p1的各项功能
 11         p1.about();
 12         p1.call(3);
 13         p1.playGame();
 14         p1.playMusic("我的中国心");
 15         System.out.println("********************");
 16         Phone p2 = new Phone("华为","华为荣耀20","Android",6666,16);
 17         // 测试p2 的各项功能
 18         p2.about();
 19         p2.call(4);
 20         p2.playGame();
 21         p2.playMusic("北京欢迎你");
 22     }
 23 }

3.5 this关键字

在Java开发中,当成员变量与局部变量发生重名问题时,需要使用到this关键字分辨成员变量与局部变量, Java中的this关键字语法比较灵活,其主要作用主要有以下3种。 (1)使用this关键字调用本类中的属性。 (2)this关键字调用成员方法。 (3)使用this关键字调用本类的构造方法。

3.5.1 使用this关键字调用本类中的属性

在类的构造方法中,如果参数名称与类属性名称相同,则会导致成员变量和局部变量的名称冲突。

1 class Student {
2     private String name;
3     private int age;
4   // 定义构造方法
5    public Student(String name,int age) {
6           name = name;
7           age = age;
8     }
9    public String read(){
10        return "我是:"+name+",年龄:"+age;
11    }
12 }
13 public class Example09 {
14     public static void main(String[] args) {
15         Student stu = new Student("张三", 18);
16         System.out.println(stu.read());
17     }
18 }

从运行结果可以看出,stu对象姓名为null,年龄为0,这表明构造方法中的赋值并没有成功。这是因为参数名称与对象成员变量名称相同,编译器无法确定哪个名称是当前对象的属性。为了解决这个问题,Java提供了关键字this指代当前对象,通过this可以访问当前对象的成员。

使用this关键字指定当前对象属性。

1 class Student {
2     private String name;
3     private int age;
4   // 定义构造方法
5    public Student(String name,int age) {
6       this.name = name;
7       this.age = age;
8     }
9 public String read(){
10        return "我是:"+name+",年龄:"+age;
11    }
12 }
13 public class Example10 {
14     public static void main(String[] args) {
15         Student stu = new Student("张三", 18);
16         System.out.println(stu.read());
17     }
18 }

在构造方法之中,使用this关键字明确标识出了类中的两个属性“this.name”和“this.age”,所以在进行赋值操作时不会产生歧义。程序运行结果如下图。

3.5.2 使用this关键字调用成员方法

通过this关键字调用成员方法,具体示例代码如下:

class Student {
	public void openMouth() {
		...
	}
	public void read() {
		this.openMouth();
	}
}

3.5.3 使用this关键字调用构造方法

构造方法是在实例化对象时被Java虚拟机自动调用,在程序中不能像调用其他成员方法一样调用构造方法,但可以在一个构造方法中使用“this(参数1,参数2…)”的形式调用其他的构造方法。接下来通过一个案例演示使用this关键字调用构造方法。

class Student {
	private String name;
	private int age;
	public Student () {
		System.out.println("实例化了一个新的Student对象。");
	}
	public Student (String name,int age) {
		this();                  // 调用无参的构造方法
this.name = name;
    this.age = age;
	}
	public String read(){
        return "我是:"+name+",年龄:"+age;
	}
}
public class Example11 { 
	public static void main(String[] args) {
	    Student stu = new Student ("张三",18); // 实例化 Student对象
         System.out.println(stu.read());
	}
}

在使用this调用类的构造方法时,应注意以下几点: (1)只能在构造方法中使用this调用其他的构造方法,不能在成员方法中通过this调用其他构造方法。 (2)在构造方法中,使用this调用构造方法的语句必须位于第一行,且只能出现一次。下面程序的写法是错误的:

public Student(String name) {
   System.out.println("有参的构造方法被调用了。");
   this(name); 			//不在第一行,编译错误!
}

(3)不能在一个类的两个构造方法中使用this互相调用,错误程序如下。

class Student {
	public Student () {
         this("张三");  		    		// 调用有参构造方法
		System.out.println("无参的构造方法被调用了。");
	}
	public Student (String name) {
		this();                  		// 调用无参构造方法
		System.out.println("有参的构造方法被调用了。");
	}
}

3.6 代码块

代码块,简单来讲,就是用“{}”括号括起来的一段代码,根据位置及声明关键字的不同,代码块可以分为4种:普通代码块、构造块、静态代码块、同步代码块。

3.6.1 普通代码块

普通代码块就是直接在方法或是语句中定义的代码块,具体示例如下。

public class Example12 { 
	public static void main(String[] args) {
	   {
         int age = 18;
         System.out.println("这是普通代码块。age:"+age);
        } 
         int age = 30;
         System.out.println("age:"+age);
	}
}

在上述代码中,每一对“{}”括起来的代码都称为一个代码块。Example12是一个大的代码块,在Example12代码块中包含了main()方法代码块,在main()方法中又定义了一个局部代码块,局部代码块对main()方法进行了“分隔”,起到了限定作用域的作用。局部代码块中定义了变量age,main()方法代码块中也定义了变量age,但由于两个变量处在不同的代码块,作用域不同,因此并不相互影响。

3.6.2 构造块

构造代码块是直接在类中定义的代码块。接下来通过一个案例演示构造代码块的作用。

1 class Student{
2    String name;    				//成员属性
3    {
4        System.out.println("我是构造代码块");       //与构造方法同级
5    }
6    //构造方法
7    public Student(){
8        System.out.println("我是Student类的构造方法");
9    }
10 }
11 public class Example12  {
12    public static void main(String[] args) 13{
14        Student stu1 = new Student();
15        Student stu2 = new Student();
16    }
17}

上述代码中,第3~5行表示的代码块定义在成员位置,与构造方法、成员属性同级,这就是构造块。 由运行结果可以得出以下两点结论: (1)在实例化Student类对象stu1、stu2时,构造块的执行顺序大于构造方法(这里和构造块写在前面还是后面没有关系)。 (2)每当实例化一个Student类对象,都会在执行构造方法之前执行构造代码块。

3.7 static关键字

在定义一个类时,只是在描述某事物的特征和行为,并没有产生具体的数据。只有通过new关键字创建该类的实例对象时,才会开辟栈内存及堆内存,在堆内存中要保存对象的属性时,每个对象会有自己的属性。如果希望某些属性被所有对象共享,就必须将其声明为static属性。如果属性使用了static关键字进行修饰,则该属性可以直接使用类名称进行调用。除了修饰属性,static关键字还可以修饰成员方法。

3.7.1 静态属性

如果在Java程序中使用static修饰属性,则该属性称为静态属性(也称全局属性),静态属性可以使用类名直接访问,访问格式如下:类名.属性名

在学习静态属性之前,先来看一个案例。

1 class Student {
2    String name;                    	// 定义name属性
3    int age;                         	// 定义age属性
4    String school = "A大学";    	// 定义school属性
5    public Student(String name,int age){
6        this.name = name;
7        this.age = age;
8    }
9 public void info(){
10   System.out.println("姓名:" + this.name+",年龄:" +this. age+",学校:" + school);  
11  }
12 }
13 public class Example13 {
14    public static void main(String[] args) {
15        Student stu1 = new Student("张三",18);    // 创建学生对象
16        Student stu2 = new Student("李四",19);
17        Student stu3 = new Student("王五",20);
18        stu1.info();
19        stu2.info();
20        stu3.info();
21    }
22 }

上述代码中,第5~7行代码声明了Student类的有参构造,第9~12行代码输出了name和age属性的值。第16~21行代码分别定义了Studen类的三个实例对象,并分别使用三个实例对象调用info()方法。

上述案例中,三名均学生均来自于A大学。下面,我们考虑一种情况:假设A大学改名为了B大学,而且此Student类已经产生了10万个学生对象,那么意味着,如果要修改这些学生对象的学校信息,则要把这10万个对象中的学校属性全部修改,共修改10万遍,这样肯定是非常麻烦的。 为了解决上述问题,可以使用static关键字修饰school属性,将其变为公共属性。这样,school属性只会分配一块内存空间,被Student类的所有对象共享,只要某个对象进行了一次修改,全部学生对象的school属性值都会发生变化。

接下来修改上述代码,使用static关键字修饰school属性。

1 class Student {
2    String name;                          	// 定义name属性
3    int age;                               	// 定义age属性
4    static String school = "A大学";    	// 定义school属性
5    public Student(String name,int age){
6        this.name = name;
7        this.age = age;
8    }
9 public void info(){
10   System.out.println("姓名:" +this. name+",年龄:" +this.age+",学校:" + school);  
11 }
12 }
13 public class Example14 {
14    public static void main(String[] args) {
15        Student stu1 = new Student("张三",18);        // 创建学生对象
16        Student stu2 = new Student("李四",19);
17        Student stu3 = new Student("王五",20);
18        stu1.school = "B大学";
19        stu1.info();
20        stu2.info();
21        stu3.info();
22    }
23 }

在上述代码中,第4行代码使用static关键字修饰了school属性,第19行代码使用stu1对象为school属性重新赋值。 在运行结果中可以发现,只修改了一个stu1对象的学校属性,stu1和stu2对象的school属性内容都发生了变化,说明使用static声明的属性是对所有对象共享的。

school属性修改前的内存如下图。

3.7.2 静态方法

如果想要使用类中的成员方法,就需要先将这个类实例化,而在实际开发时,开发人员有时希望在不创建对象的情况下,通过类名就可以直接调用某个方法,要实现这样的效果,只需要在成员方法前加上static关键字,使用static关键字修饰的方法通常称为静态方法。

同静态变量一样,静态方法也可以通过类名和对象访问,具体如下所示。 类名.方法 或 实例对象名.方法

接下来通过一个案例来学习静态方法的使用。

1 class Student {
2    private String name;                         		// 定义name属性
3    private int age;                              		// 定义age属性
4    private static String school = "A大学";   	// 定义school属性
5    public Student(String name,int age){
6        this.name = name;
7        this.age = age;
8    }
9    public void info(){
10      System.out.println("姓名:" +this.name+",年龄:" + this.age+",学校:" + school);
12    }
13   public String getName() {
14     return name;
15   }
16   public void setName(String name) {
17     this.name = name;
18   }
19 public void setName(String name) {
20     this.name = name;
21   }
22   public int getAge() {
23     return age;
24   }
25   public void setAge(int age) {
26     this.age = age;
27   }
28   public static String getSchool() {
29      return school;
30   }
31   public static void setSchool(String school) {
32      Student.school = school;
33   }
34 }
35 class Example15 {
36    public static void main(String[] args) {
37        Student stu1 = new Student("张三",18);      // 创建学生对象
38        Student stu2 = new Student("李四",19);
39        Student stu3 = new Student("王五",20);
40	   stu1.setAge(20);
41        stu2.setName("小明");
42	   Student.setSchool("B大学");
43        stu1.info();
44        stu2.info();
45        stu3.info();
46    }
47 }

Student类将所有的属性都进行了封装,所以想要更改属性就必须使用setter方法。第13~30行代码声明了name、age和school属性的getter和setter方法,第37~39行代码分别对name、age和school属性的值进行修改,但是school属性是使用static声明的,所以可以直接使用类名Student进行调用。

静态方法只能访问静态成员,因为非静态成员需要先创建对象才能访问,即随着对象的创建,非静态成员才会分配内存。而静态方法在被调用时可以不创建任何对象。

3.7.3 静态代码块

在Java类中,用static关键字修饰的代码块称为静态代码块。当类被加载时,静态代码块会执行,由于类只加载一次,因此静态代码块只执行一次。在程序中,通常使用静态代码块对类的成员变量进行初始化。

接下来通过一个案例学习静态代码块的使用。

class Student{
    String name;    				//成员属性
    {
        System.out.println("我是构造代码块");
    }
    static {
        System.out.println("我是静态代码块");
    }
    public Student(){      			//构造方法
        System.out.println("我是Student类的构造方法");
    }
}
class Example16{
    public static void main(String[] args) {
        Student stu1 = new Student();
        Student stu2 = new Student();
        Student stu3 = new Student();
    }
}

上述代码中,第3~5行代码声明了一个构造代码块,第6~8行声明了一个静态代码块,第15~17行代码分别实例化了3个Student对象。 从运行结果可以看出,代码块的执行顺序为静态代码块、构造代码块、构造方法。 static修饰的量会随着class文件一同加载,属于优先级最高的。在main()方法中创建了3个Student对象,但在3次实例化对象的过程中,静态代码块中的内容只输出了一次,这就说明静态代码块在类第一次使用时才会被加载,并且只会加载一次。

【案例3-4】:学生投票系统

某班级投票竞选班干部,班级学生人数为10人,每个学生只能投一票,投票成功提示“感谢你的投票”。若重复投票,提示“请勿重复投票”。当投票总数达到10或者主观结束投票时,统计投票学生人数和投票结果。本案例要求编程一个程序实现学生投票。

 1 import java.util.HashSet;
 2 import java.util.Set;
 3 public class Voter {
 4     // 属性的定义
 5     private static final int MAX_COUNT = 100;    // 最大投票数
 6     private static int count;                   // 投票数
 7     // 静态变量,存放已经投票的学生
 8     private static Set<Voter> voters = new HashSet<Voter>();
 9     private String name;
 10     private String answer;
 11     // 构造方法
 12     public Voter(String name) {
 13         this.name = name;
 14     }
 15     // 投票
 16     public void voterFor(String answer) {
 17         if (count == MAX_COUNT){
 18             System.out.println("投票结束。");
 19             return ;
 20         }
 21         if (voters.contains(this)){
 22             System.out.println(name+",请勿重复投票。");
 23         } else {
 24             this.answer = answer;
 25             count ++;
 26             voters.add(this);
 27             System.out.println(name+" 感谢你的投票。");
 28         }
 29     }
 30     // 打印投票结果
 31     public static void printVoterResult() {
 32         System.out.println("当前投票数为:"+count);
 33         System.out.println("参与投票的学生和结果如下:");
 34         
 35         for (Voter voter: voters) {
 36             System.out.println(voter.name+" 意见 "+voter.answer);
 37         }
 38     }
 39     public static void main(String[] args) {
 40         // 创建参与投票的学生对象
 41         Voter tom = new Voter("Tom");
 42         Voter jack = new Voter("Jack");
 43         Voter mike = new Voter("Mike");
 44         // 学生开始投票
 45         tom.voterFor("是");
 46         tom.voterFor("否");
 47         jack.voterFor("是");
 48         mike.voterFor("是");
 49         // 打印投票结果
 50         Voter.printVoterResult();
 51     }
 52 }

3.8 本章小结

本章详细介绍了面向对象的基础知识。首先介绍了面向对象的思想;其次介绍了类与对象之间的关系,包括类的定义、对象的创建与使用等;接着介绍了类的封装;然后介绍了构造方法,包括构造方法的定义与重载;最后介绍了代码块的使用以及static关键字的使用。通过本章的学习,读者已经对Java中面向对象的思想有了初步的认识,熟练掌握好这些知识,有助于学习下一章的内容。深入理解面向对象的思想,对以后的实际开发也是大有裨益的。

文章来源:https://blog.csdn.net/u010321564/article/details/135666653
本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。