Java基础-对象与类
面向对象程序设计概述
面向对象的程序设计(简称oop)时当今主流的程序设计范型,已经取代了“结构化”过程化程序设计开发技术,java是完全面向对象的。
类
类设计构造对象的模板或蓝图,由类构造对象的过程称为创建类的实例。
封装(有时称为数据隐藏)是与对象有关的一个重要概念,从形式上看,封装不过是将数据行为组合在一个包中,并对对象的使用者隐藏了数据的实现方式,封装给对象赋予了“黑盒”特征,这是提高重用性和可靠性的关键。
对象
对象的三个主要特征:
1.对象的行为:可以对对象施加哪些操作,或者可以对对象施加哪些方法?
2.对象的状态:当施加那些方法时,对象如何响应?
3.对象的标识:如何辨别具有相同行为与状态的不同对象?
同一个类的所有对象实例,由于支持相同的行为而具有家族式的相似性,对象的行为是用可调用的方法定义的。
方法:在java中,方法就是用来完成解决某件事情或实现某个功能的办法。
类之间的关系
在类之间,最常见的关系如下:
1.依赖:即“uses-a”关系,是一种最明显的/最常见的关系。如果类b的方法操纵类a的对象,则说类b依赖于类a。
2.聚合(也叫关联):即“has-a”关系,是一种易于理解的关系。如果类b的对象包含类a的对象,则意味着聚合关系。
3.继承:即“is-a”关系,是一种用于表示特殊与一般的关系的。 如果类b扩展类a,类b不但包含从类a继承的方法,还可以拥有很多自定义的额外功能。
预定义类
预定义类,就是指jdk中或者其他的jar包中已经定义好可以直接使用的类(如:string类,math类,date类,arrays类等)。
在java中,没有类就无法做任何事情。
对象与对象变量
要想使用对象,就必须先构造对象,并指定其初始状态,然后对对象应用方法。
在java程序设计语言中,使用构造器构造新实例,构造器是一种特殊的方法,用来构造并初始化对象。
构造器具有以下特征:
1.构造器与类同名。
2.每个类可以有一个以上的构造器。
3.构造器可以有0个、1个或多个参数。
4.构造器没有返回值。
5.构造器总是伴随着new操作一起调用。
以date类为例,其构造器名为date,想要构造一个date对象,需要在构造器前面加上new操作符:
1 new date();
这个对象被初始化为当前的日期和时间。
如果需要的化,这个对象也可以作为一个参数传递给一个方法:
1 system.out.println(new date());
也可以将一个方法应用与这个对象,date类中有一个tostring方法:
1 string s = new date().tostring();
当希望构造的对象可以多次使用时,可以将对象存放在一个变量中:
1 date date = new date();
注意:
一个对象变量并没有实际包含一个对象,而仅仅引用一个对象。
在java中,任何对象变量的值都是对存储在另一个地方的一个对象的引用。new操作符的返回值也是一个引用。
1 date date;
声明了一个date类型的date变量,现在date作为一个对象变量,可以引用date类型的对象,但其本身不是一个对象,也没有引用对象。此时不能将任何date方法应用于这个变量上。
1 date date; 2 string str = a.tostring();
将会产生编译错误。
必须首先从初始化变量date,才能使用tostring方法:
1 date date = new date(); 2 string str = a.tostring();
用户自定义类
用户自己创建的类,按照类的定义标准,可以在类中包含多个方法与属性,来供用户使用。
java代码映射成现实事物的过程就是定义类的过程。
类的定义格式:
创建java文件,与类名相同:
1 public class 类名{ 2 数据类型 属性名称1; 3 数据类型 属性名称2; 4 … 5 }
例如:创建一个名为employee的类:
1 public class employee { 2 private string name; 3 private double salary; 4 5 public employee(string n, double s){ 6 name = n; 7 salary = s; 8 } 9 10 public string getname(){ 11 return name; 12 } 13 public void setname(string name) { 14 this.name = name; 15 } 16 17 public double getsalary(){ 18 return salary; 19 } 20 public void setsalary(double salary) { 21 this.salary = salary; 22 } 23 24 public void raisesalary(double bypercent){ 25 double raise = salary * bypercent / 100; 26 salary += raise; 27 } 28 }
这里自定义创建了的employee类,包含name和salary两个域(属性),employee()和raisesalary()两个方法,其中employee()方法为构造方法。
注意:
raisesalary()方法有两个参数。
第一个参数称为隐式参数,是出现在方法名前的employee类对象。
如下程序所示,关键字this表示隐式参数。
1 public void raisesalary(double bypercent){ 2 double raise = this.salary * bypercent / 100; 3 this.salary += raise; 4 }
第二个参数位于方法名后面括号中的数值(double bypercent),这是一个显式参数。
程序中getname()和getsalary()方法为访问器方法,setname()和setsalary()方法为更改器方法。
通过private私有化域name,在通过访问器方法和更改其方法进行访问和更改域值的方式,就是简单的封装了。
final实例域
可以将实例域定义为final,构建对象时必须初始化这样的域。
必须确保在每一个构造器执行后,这个域的值被设置,并且在后面的操作中,不能再对它进行修改。
final修饰符大都应用于**基本**类型域,或**不可变类**的域。(如果类中的每个方法都不会改变其对象,这种类就是不可变类,例如:string类。)
1 class employee { 2 private final string name; 3 4 public string getname(){ 5 return name; 6 } 7 }
将employee类中的name域声明为final,这样在对象构建之后,这个值不会再被修改,即没有setname()方法。
静态域与静态方法(static)
静态域
1 class employee { 2 private static int stacid = 1 3 private int id; 4 }
类中将stacid定义为static,那么这个类的所有的实例将共享一个static域stacid,即使一个实例对象都没有,这个静态域仍然存在。
但是如果这个类有2个实例对象,则有2个实例域id。
静态方法
静态方法是一种不能向对象实施操作的方法,可以认为静态方法是没有this参数的方法。
1 class employee { 2 private static int stacid = 1 3 private int id; 4 5 public static int getstacid(){ 6 return stacid; 7 } 8 }
静态方法getstacid 不能访问id实例域,因为它不能操作对象,但是可以访问自身类中的静态域。
对象构造
重载
java允许在一个类中定义多个名称相同的方法,但是参数的类型或个数必须不同,这就是方法的重载。
程序有可能针对各种(例如同类运算:加法)不同种情况(2个数相加、3个数相加)都各自定义一个方法,如果每个方法的名称都不相同,在调用时就很难分清哪种情况该调用哪个方法,重载存在的意义就是解决这个问题,使用相同的方法名对各种不同情况做处理。
默认域的初始化
如果再构造器中没有显式的给域赋予初值,那么就会被自动的赋予为默认值(数值型为0,布尔型为false,对象引用为null)。
无参数的构造器
很多类都包含一个无参数的构造器,对象由无参数构造器创建时,其状态会设置为适当的默认值(即构造器中初始化的值)。
若编写一个类时,没有编写构造器,那么系统就会提供一个无参数构造器。这个构造器将所有的实例域设置为默认值(数值型数据设置为0,布尔型数据设置为false,所有对象变量设置为null)。
若类中提供了至少一个构造器,但是没有提供无参数的构造器,则在构造对象时如果没有提供参数就会被视为不合法,将会产生错误。
参数名
首先是参数的命名问题。
1 public employee(string n, double s){ 2 name = n; 3 salary = s; 4 }
这样做有一个缺陷,只有阅读代码才能了解参数n和s的含义。
有两种方式避免这个问题:
1.在每个参数前面加一个“a”:
1 public employee(string aname, double asalary){ 2 name = aname; 3 salary = asalary; 4 }
2.基于这样的事实:参数变量用同样的名字将实例域屏蔽起来,但是可以采用this.xxx的形式:
1 public employee(string name, double salary){ 2 this.name = name; 3 this.salary = salary; 4 }
调用另一个构造器
关键字“this”引用方法的隐式参数,但是它还有另一个含义。
若构造器的第一个语句形如this(...),这个构造器将调用同一个类的另一个构造器。
1 public class employee { 2 private string name; 3 private double salary; 4 private static int stacid = 1; 5 6 public employee(string name, double salary){ 7 this.name = name; 8 this.salary = salary; 9 } 10 11 public employee(double salary){ 12 this("employee #" + stacid, salary); 13 stacid++; 14 } 15 16 public string getname(){ 17 return name; 18 } 19 public void setname(string name) { 20 this.name = name; 21 } 22 23 public double getsalary(){ 24 return salary; 25 } 26 public void setsalary(double salary) { 27 this.salary = salary; 28 } 29 30 public void raisesalary(double bypercent){ 31 double raise = this.salary * bypercent / 100; 32 this.salary += raise; 33 } 34 }
创建一个测试;employee类的测试类:
1 public class employeetest { 2 public static void main(string[] args){ 3 employee employee = new employee(100); 4 } 5 }
通过debug可以看到employee(double)构造器将调用employee(string,double)构造器,这样使用this关键字非常有用,对公共的构造器代码部分只需要编写一次即可。
包
使用包的主要原因时确保类名的唯一性。
类的导入
一个类可以使用所属包中的所有类,以及其他包中的公有类(public class)。
访问另一个包中的共有类有2中方式:
1.在每个类名之前添加完整的包名。
1 java.time.localdate today = java.time.localdate.now();
这显然很繁琐。
2.使用import语句。
可以使用import语句导入一个特定的类或者整个包。import语句应该位于源文件的顶部(但是位于package语句的而后面)。
注释位置
类注释必须放在import语句之后,类定义之前。
方法注释必须放在所描述的方法之前。
域注释通常只需对公有域(静态常量)进行注释。
类设计技巧
可以使得设计出来的类更具有oop专业水准的几点技巧:
1.一定要保证数据私有。这是最重要的,绝对不要破坏封装性。
2.一定要对数据初始化。java不对局部变量进行初始化,但是会对对象的实例域进行初始化。最好不要依赖于系统的默认值,而是应该显式的初始化所有的数据,具体的初始化方式可以是提供默认值,也可以是在所有构造器中设置默认值。
3.不要在类中使用过多的基本类型。可以根据基本类型特点自定义类进行使用。
4.不是所有的域都需要独立的域访问器和域更改器。
5.将职责过多的类进行分解。
6.类名和方法名要能够体现它们的职责。
7.优先使用不可变的类。
上一篇: MySQL数据库的定时备份
下一篇: 分分钟钟学会Python - 基础