JavaSE基础篇【3】
2022年6月6日
第五部分 类和对象
5.1 面向对象概述
- 1. 对象
在现实世界中，随处可见的一种事物就是对象。对象是事物存在的实体。人类通过探讨对象的属性和观察对象的行为来了解对象。类实质上就是封装对象属性和行为的载体，而对象则是类抽象出来的一个实例。
在计算机的世界中，面向对象程序设计的思想要以对象来思考问题，首先要将现实世界的实体抽象为对象，然后考虑这个对象具备的属性和行为。
如，一只大雁就是一个对象。对象具备的属性都是静态属性，如大雁有黑色的翅膀等。而这个对象的动态行为，如飞行、觅食等，这些行为都是这个对象基于其属性而具有的动作。这样一个对象就被定义完毕， - 2. 类
类是同一类事物的统称，也就是说类是同一类对象的统称。类是封装对象的属性和行为的载体，反过来说，具有相同的属性和行为的一类实体被称为类。 - 3. 封装
面向对象程序设计具有以下特点：
- 封装性
- 继承性
- 多态性
封装是面向对象编程的核心思想。将对象的属性和行为封装起来，其载体就是类，类通常对客户隐藏实现细节，这就是封装的思想。
采用封装的思想保证了类内部数据结构的完整性，应用该类的用户不能轻易地直接操作此数据结构，只能执行类允许公开的数据。这样就避免了外部操作对内部数据的影响，提高了系统的可维护性。
- 4. 继承
类与类之间具有同样的关系，这种关系被称为关联。关联主要描述两个类之间的一般二元关系。当处理一个问题时，可以将一些有用的类保留下来，在遇到同样的问题时拿来复用，节省定义共同具有的属性和行为的时间。继承性主要利用特定对象之间的共有属性，继承关系可以使用树形关系来表示，父类和子类存在一种层次关系。 - 5. 多态
将父类对象应用于子类的特征就是多态。
5.2 类
类是封装对象的属性和行为的载体。
- 1. 成员变量
在Java中对象的属性也称成员变量，使用 class 关键词来定义类。
public class Book{
private String name;
public String getName(){
int id=0;
setName("java");
return id+this.name;
}
private void setName(String name){
this.name=name;
}
public Book getBook(){
return this;
}
}
Book 是类名称。同时在 Book 类中定义了一个成员变量，成员变量的类型可以设置为Java中合法的数据类型，其实成员变量就是普通的变量，可以为它设置初始值。如果不设置初始值，则会有默认值。
- 2. 成员方法
在Java语言中使用成员方法对应于类对象的行为。以 Book 类为例，它包含 getName( ) 和 setName( ) 两个方法，这两个成员方法分别为获取图书名称和设置图书名称的方法。
定义成员变量的语法格式通常为：
权限修饰符 返回值类型 方法名（参数类型 参数名）{
…//方法体
return 返回值；
}
一个方法成员可以有参数，这个参数可以是对象，也可以是基本数据类型的变量，同时成员方法有返回值和不返回值的选择，如果方法需要返回值，可以在方法体中使用 return 关键字，使用这个关键字后，方法的执行将被终止。
成员方法的返回值可以是计算结果，也可以是其他想要的数据和对象，返回值的类型要于方法返回的值的类型一致。
在成员方法中可以调用其他成员方法和类成员变量。
- 3. 权限修饰符
Java中的权限修饰符主要包括 private、public 和 protected，这些修饰符控制着对类和类的成员变量以及成员方法的访问。
| 访问包位置 | private | protected | public |
|---|---|---|---|
| 本类 | 可见 | 可见 | 可见 |
| 同包其他类或子类 | 不可见 | 不可见 | 不可见 |
| 其他包的类或子类 | 不可见 | 不可见 | 不可见 |
- 4. 局部变量
如果在成员方法内定义一个变量，那么这个变量被称为局部变量。
例如在前述的 Book 类中，getName( ) 方法的 id 变量即为局部变量。实际上方法中的形参也可作为一个局部变量，如在定义 setName(String name) 方法时，String name 这个形参就被看作是局部变量。
局部变量是在方法被执行时创建，在方法执行结束时被销毁。局部变量在使用时必须进行赋值操作或被初始化，否则会出现编译错误。
public String getName(){
int id=0;
setName("java");
return id+this.name;
}
如果将 id 这个局部变量的初始值去掉，编译器将出现错误。
- 5. 局部变量的有效范围
可以将局部变量的有效范围称为变量的作用域，局部变量的有效范围从该变量的声明开始到该变量的结束为止。
在相互不嵌套的作用域中可以同时声明两个名称和类型相同的局部变量。 - 6. this 关键字
在Java语言中规定使用 this 关键字来代表本类对象的引用，this 关键字被隐式地用于引用对象地成员变量和方法。
如在前述代码中，this.name 指的就是 Book 类中的 name 成员变量，而 this.name=name 语句中的第二个 name 则指的是形参 name。实质上 setName( ) 方法实现的功能就是将形参 name 的值赋予给成员变量 name。
事实上，this 引用的就是本类的一个对象。
5.3 类的构造方法
在类中除了成员方法之外，还存在一种特殊类型的方法，那就是构造方法。构造方法是一个与类同名的方法，对象的创建就是通过构造方法完成的。每当类实例化一个对象时，类都会自动调用构造方法。
构造方法的特点如下：
- 构造方法没有返回值
- 构造方法的名称要与本类的名称相同
构造方法的定义语法格式如下：
public book( ){
…
}
- public：构造方法修饰符
- book：构造方法的名称
在构造方法中可以为成员变量赋值，这样当实例化一个本类的对象时，相应的成员变量也将被称为初始化，
如果类中没有明确定义构造方法，编译器会自动创建一个不带参数的默认构造方法。此外，this 也可以调用类中的构造方法。
public class AnyThing{
public AnyThing(){ //定义无参构造方法
this("this调用有参构造方法"); //使用this调用有参构造方法
System.out.println("无参构造方法");
}
public AnyThing(String name){ //定义有参构造方法
System.out.println("有参构造方法");
}
}
5.4 静态变量、常量和方法
由 static 修饰的变量、常量和方法被称为静态变量、常量和方法。这样可以使得两个类在同一个区域共享一个数据。
被声明为 static 的变量、常量和方法被称为静态成员。静态成员属于类所有，区别于个别对象，可以在本类或其他类使用类名和 “.” 运算符调用静态成员。
语法如下：
类名.静态类成员
public class StaticTest{
final static double PI=3.1415; //在类中定义静态变量
static int id; //在类中定义静态变量
public static void method1(){ //在类中定义静态方法
// do Something
public void method2(){
System.out.println(StaticTest.PI);//调用静态常量
System.out.println(StaticTest.id);//调用静态变量
StaticTest.method1();
}
}
上述例子设置了3个静态成员，分别为常量、变量和方法，然后在 method2( ) 方法中分别调用3个静态成员，直接使用“类名.静态成员”形式调用即可。
静态数据与静态方法的作用通常是为了提供共享数据或方法，如数学计算公式等，以 static 声明并实现，这样当需要使用时，直接使用类名调用这些静态成员即可。尽管使用这种方式调用静态成员比较方便，但静态成员仍然遵循着 public、private 和 protected 修饰符的约束。
此外需要注意的是：
- 在静态方法中不可以直接使用 this 关键字
- 在静态方法中不可以直接调用非静态方法
5.5 类的主方法
主方法是类的入口点，它定义了程序从何处开始；主方法提供对程序流向的控制，Java编译器通过主方法来执行程序。主方法的语法如下：
public static void main(String args){
//主方法
}
- 主方法是静态的，所以如要直接在主方法中调用其他方法，则该方法必须也是静态的。
- 主方法没有返回值。
- 主方法的形参为数组。其中 args[0]~args[n] 分别代表程序的第一个参数到第 n 个参数，可以使用 args.length 来获取参数个数。
public class TestMain{
public static void main(String[] args){
for(int i=0;i<args.length;i++){
System.out.println(args[i])
}
}
}
5.6 对象
1. 对象的创建
在Java语言中通过 new 操作符来创建对象。每实例化一个对象会自动调用一次构造方法，实质上这个过程就是创建对象的过程。语法如下：
Test test=new Test( );
Test test=new Test(“a”);
其中 Test 是类名，test 是创建的 Test 类对象。
test 对象被创建出来时，就是一个对象的引用，这个引用在内存中为对象分配了存储空间。每个对象都是相互独立的，在内存中占据独立的内存地址，并且每个对象都具有自己的生命周期，当一个对象的生命周期结束时，对象就变成垃圾，由Java虚拟机自带的垃圾回收机制处理。
public class CreateObject{
public CreateObject(){
System.out.println("创建对象");
}
public static void main(String[] args){
new CreateObject();
}
}
2. 访问对象的属性和行为
使用 new 操作符创建一个对象后，可以使用“对象.类成员”来获取对象的属性和行为。对象的属性和行为在类中是通过类成员变量和成员方法的形式来表示的，所以当对象获取类成员时，也相应地获取了对象的属性和行为。
public class TransferProperty{
int i=47; //定义成员变量
public void call(){ //定义成员方法
System.out.println(i+"");
if(i==2){
System.out.println("\n");
}
}
}
public TransferProperty(){ //定义构造方法
}
public static void main(String[] args){
TransferProperty t1 = new TransferProperty(); //创建一个对象
TransferProperty t2 = new TransferProperty(); //创建另一个对象
t2.i = 60; //将类成员变量赋值为60
//使用第一个对象调用类成员变量
System.out.println("第一个实例对象调用变量i的结果："+t1.i++t1.call);
System.out.println("第一个实例对象调用变量i的结果："+t2.i++t2.call);
}
}
如果希望成员变量不被其中任何一个对象改变，可以使用 static 关键字。
3. 对象的引用
在Java语言中尽管一切都可以看作对象，但真正的操作标识实际上是一个引用。语法如下：
类名 对象引用名称
如一个 Book 类的引用可以使用以下代码：
Book book;
通常一个引用不一定需要有一个对象相关联。引用与对象相关联的语法如下：
Book book = new book;
引用只是存放一个对象的内存地址，并非存放一个对象。
4. 对象的比较
在Java语言中有两种比较对象的方式，分别为 “==” 运算符与 equals( ) 方法。
public class Compare{
public class void main(String[] args){
String c1 = new String("abc");
String c2 = new String("abc");
String c3 = c1;
//使用 “==” 运算符比较 c2 与 c3 的结果
System.out.println("c2==c3 的运算结果为："+(c2==c3));
//使用 equals() 方法比较 c2 与 c3
System.out.println("c2.equals(c3)的运算结果为："+(c2.equals(c3)));
}
}
equals( ) 方法是 String 类中的方法，它用于比较两个对象引用所指的内容是否相等；而 “==” 运算符比较的是两个对象引用的地址是否相等。
5. 对象的销毁
每个对象都有自己的生命周期，当对象的生命周期结束时，分配给该对象的内存地址需要被收回。Java垃圾回收器会自动回收无用且占用内存的资源。当以下情况时，资源会被视为垃圾：
- 对象引用超过其作用范围
- 将对象赋值为 null
虽然垃圾回收机制已经很完善，但垃圾回收器只能回收那些由 new 操作符创建的对象。某些对象不是通过 new 操作符在内存中获取存储空间的，这种对象无法被垃圾回收机制识别。在 Java 中提供
了一个 finalize( ) 方法，这个方法是 Obiect 类的方法，它被声明为 protected，用户可以在自已的类中定义这个方法。如果用户在类中定义了 finalize( ) 方法，在垃圾回收时会首先调用该方法，在下一次垃
回收动作发生时，才真正回收被对象占用的内存。
由于垃圾回收不受人为控制，具体执行时间也不确定，所以 finalize( ) 方法也就无法执行。为此，Java提供了 System.gc( ) 方法来强制启动垃圾回收器，这与给120打电话通知医院来救护病人的道理一样，主动告知垃圾回收器来进行清理。
第六部分 包装类
6.1 Integer
Java.lang 包中的 Integer 类、 Long 类和 Short 类，可将基本类型 int、long 和 short 封装成一个类。这些类都是 Number 的子类，区别就是封装了不同的数据类型。
Integer 类在对象中包装了一个基本类型 int 值。该类的对象包含了一个 int 类型的字段。此外，该类提供了多个方法，能在 int 类型和 String 类型之间相互转换，同时还提供了其他一些处理 int 类型时非常有用的常量和方法。
1. 构造方法
Integer 类有以下两种构造方法。
- Integer(int number)
- Integer(String str)
第一个方法以 int 型变量为参数来获取 Integer 对象；第二个方法以 String 型变量为参数来获取 Integer 对象。
2. 常用方法
Integer 类型的常用方法如下表所示。
| 方法 | 返回值 | 功能描述 |
|---|---|---|
| byteValue( ) | byte | 以 byte 类型返回该 Integer 的值 |
| compareTo(Integer anotherInteger) | int | 在数字上比较两个 Integer 对象。如果这两个值相等，则返回0；如果调用对象的数值小于 anotherInteger 的数值，则返回负值；如果调用对象的数值大于 anotherInteger 的数值，则返回正值 |
| equals(Object IntegerObj) | boolean | 比较此对象与指定的对象是否相等 |
| intValue( ) | int | 以 int 型返回此 Integer 对象 |
| shortValue( ) | short | 以 short 型返回此 Integer 对象 |
| toString( ) | String | 返回一个表示该 Integer 对象的 String 对象 |
| valueOf(String str) | Integer | 返回保存指定的 String 值得 Integer 对象 |
| parseInt(String str) | int | 返回包含在由 str 指定得字符串中得数字的等价整数值 |
public class Summation{
public static void main(String[] args){
String str[] = {"89","12","10","18","35"};
int sum = 0;
for(int i=0;i<str.length;i++){
int myint = Integer.parseInt(str[i]);
sum = sum + myint;
}
System.out.println("数组中各元素的和为："+sum);
}
}
Integer 类的 toString( ) 方法，可以将 Integer 对象转换为十进制字符串表示。 toBinaryString( )、toHexString( ) 和 toOctalString ( ) 方法分别将值转换为二进制、十六进制和八进制字符串。
3. 常量
Integer 类提供了以下4个常量。
- MAX_VALUE：表示 int 类型可取的最大值，即231-1
- MIN_VALUE：表示 int 类型可取的最小值，即-231
- SIZE：用来以二进制补码形式表示 int 值的位数
- TYPE：表示基本类型 int 的 Class 实例
6.2 Boolean
Boolean 类将基本类型为 boolean 的值包装在一个对象之中。一个 Boolean 类型的对象只包含一个类型为 boolean 的字段。此外，此类还未 boolean 和 String 的相互转换提供了许多方法，并提供了处理 boolean 时非常有用的其他一些常量和方法。
1. 构造方法
- Boolean(boolean value)
- Boolean(String str)
第一个方法创建一个表示 value 参数的 Boolean 对象。
第二个方法以 String 变量作为参数创建 Boolean 对象。如果 String 参数不为 null 且在忽略大小写时等于 true，则分配一个表示 true 值的 boolean 对象，否则获得一个 false 值得 Boolean 对象。
2. 常用方法
Boolean 类的常用方法如下表所示。
| 方法 | 返回值 | 功能描述 |
|---|---|---|
| booleanValue( ) | boolean | 将 Boolean 对象的值以对应的 boolean 值返回 |
| equals(Object obj) | boolean | 判断调用该方法的对象与 obj 是否相等。当且仅当参数不是 null，而且与调用该方法的对象一样都表示同一个 boolean 值的 Boolean 对象时，才返回 true |
| parseBoolean(String str) | boolean | 将字符串参数解析未 boolean 值 |
| toString( ) | String | 返回表示该 boolean 值的 String 对象 |
| valueOf(String s) | boolean | 返回一个用指定的字符串表示值的 boolean 值 |
3. 常量
Boolean 提供了以下3个常量。
- TRUE：对应基值 true 的 Boolean 对象
- FALSE：对应基值 false 的 Boolean 对象
- TYPE：基本类型 boolean 的 Class 对象
6.3 Byte
Byte 类将基本类型为 byte 的值包装在一个对象之中。一个 Byte 类型的对象只包含一个类型为 byte 的字段。此外，此类还未 byte 和 String 的相互转换提供了许多方法，并提供了处理 byte 时非常有用的其他一些常量和方法。
1. 构造方法
- Byte(byte value)
- Byte(String str)
第一个方法创建一个表示 value 参数的 Byte 对象。
第二个方法以 String 变量作为参数创建 Byte 对象，可表示 String 参数所指示的 byte 值。
2. 常用方法
Byte 类的常用方法如下表所示。
| 方法 | 返回值 | 功能描述 |
|---|---|---|
| byteValue( ) | byte | 将 Byte 对象的值以对应的 byte 值返回 |
| compareTo(Byte anotherByte) | int | 在数学上比较两个 Byte 对象 |
| equals(Object obj) | boolean | 判断调用该方法的对象与 obj 是否相等。如果相等，则返回 true |
| parseByte(String str) | byte | 将字符串参数解析未 byte 值 |
| toString( ) | String | 返回表示该 byte 值的 String 对象 |
| valueOf(String s) | byte | 返回一个用指定的字符串表示值的 Byte 对象 |
| doubleValue | double | 以一个 double 值返回此 Byte 的值 |
| intValue | int | 以一个 int 值返回此 Byte 的值 |
3. 常量
Byte 提供了以下4个常量。
- MIN_VALUE：byte 类型可取的最小值
- MAX_VALUE：byte 类型可取的最大值
- TYPE：基本类型 byte 的 Class 对象
- SIZE：用于以二进制补码形式表示 byte 值的位数
6.4 Character
Character 类将基本类型为 char 的值包装在一个对象之中。一个 Character 类型的对象只包含一个类型为 char 的字段。该类提供了几种方法，以确定字符的类别（小写字母、数字等），并将字符从大写转换成小写，反之亦然。
1. 构造方法
- Character(char value)
该类的构造函数必须时一个 char 类型的数据。通过该构造函数创建的 Character 类对象包含由 char 类型参数提供的值。一旦 Character 类被创建，它包含的数值就不能改变了。
2. 常用方法
Character 类的常用方法如下表所示。
| 方法 | 返回值 | 功能描述 |
|---|---|---|
| charValue( ) | char | 将 Character 对象的值以对应的 char 值返回 |
| compareTo(Character anotherCharacter) | int | 在数学上比较两个 Character 对象，若这两个对象相等则返回0 |
| equals(Object obj) | byte | 判断调用该方法的对象与 obj 是否相等。如果相等，则返回 true |
| toString( ) | String | 返回表示该 char 值的 String 对象 |
| toUpperCase(char ch) | char | 将字符参数转换为大写 |
| toLowerCase(char ch) | char | 将字符参数转换为小写 |
| isUpperCase(char ch) | boolean | 判断指定字符是否为大写 |
| isLowerCase(char ch) | boolean | 判断指定字符是否为小写 |
3. 常量
Character 类提供了以下3个常量。
- CONNECTOR_PUNCTUATION：返回 byte 类型值，表示 Unicode 规范中的常规类别 “Pc”
- UNASSIGNED：返回 byte 类型值，表示 Unicode 规范中的常规类别 “ Cn”
- TITLECASE_LETTER：返回 byte 类型值，表示 Unicode 规范中的常规类别 “Lt”
6.5 Double
Double 和 Float 包装类是对 double、float 基本类型的封装，它们都是 Number 类的子类，又都是对小数进行操作，所以常用方法基本相同。Double 类在对象中包装了一个基本类型为 double 的值。每个 Double 类的对象都包含一个 double 类型的字段。此外，该类还提供多个方法，可以将 double 转换为 String，也可以将 String 转换为 double，也提供了其他一些处理 double 时有用的常量和方法。
1. 构造方法
Double 类提供了以下两种构造方法来获得 Double 类对象。
- Double(double value)：基于 double 参数创建 Double 类对象
- Double(String str)：构造一个新分配的 Double 对象，表示用字符串表示的 double 类型的浮点值。
2. 常用方法
| 方法 | 返回值 | 功能描述 |
|---|---|---|
| byteValue( ) | byte | 以 byte 形式返回 Double 对象值（通过强制转换） |
| compareTo(Double d) | int | 对两个 Double 对象进行数值比较。如果两个值相等，则返回0；如果调用对象的数值小于 d 的数值，则返回负值；如果调用对象的数值大于 d 的值，则返回正值 |
| equals(Object obj) | boolean | 将此类对象与指定对象相比较 |
| intValue( ) | int | 以 int 类型返回 double 的值 |
| isNaN() | boolean | 如果此 double 值是非数字（NaN）值，则返回 true；否则返回 false |
| toString( ) | String | 返回此 Double 对象的字符串表示形式 |
| valueOf(String str) | Double | 返回保存用参数字符串 str 表示的 double 值的 Double 对象 |
| doubleValue( ) | double | 以 double 形式返回此 Double 对象 |
| longValue( ) | long | 以 long 形式返回此 double 的值（通过强制转换为 long 型） |
3. 常量
Double 类提供了以下4个常量。
- MAX_EXPONENT：返回 int 值，表示有限 double 变量可能具有的最大指数
- MIN_EXPONENT：返回 int 值，表示标准化 double 变量可能具由的最小指数
- MEGATIVE_INFINITY：返回 double 值，表示保存 double 类型的负无穷大值的常量
- POSITIVE_INFINITY：返回 double 值，表示保存 double 类型的正无穷大值的常量
6.6 Number
抽象类 Number 是 BigDecimal、BigInteger、Byte、Double、Float、Integer、Long 和 Short 类的父类，Number 的子类必须提供将表示的数值转换为 byte、double、float、int、long 和 short 的方法。例如 doubleValue( ) 方法返回双精度值，floatValue( ) 方法返回浮点值。这些方法如下表所示：
| 方法 | 返回值 | 功能描述 |
|---|---|---|
| byteValue( ) | byte | 以 byte 形式返回指定的数值 |
| intValue( ) | int | 以 int 形式返回指定的数值 |
| floatValue( ) | float | 以 float 形式返回指定的数值 |
| shortValue( ) | short | 以 short 形式返回指定的数值 |
| longValue( ) | long | 以 long 形式返回指定的数值 |
| doubleValue( ) | double | 以 double 形式返回指定的数值 |
扫一扫
876
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
