Java面向对象程序设计复习自用_java面向对象程序设计复习资料-CSDN博客

第一章初识Java与面向对象程序设计

1. “计算机之父”之称的冯·诺伊曼

2.Java语言的特点：

具有跨平台性、可移植性、安全性、健壮性、编译和解释、共性能和动态性等特点。

3. JDK与JRE关系：

JRE是Java程序的运行环境，它包含了Java虚拟机、Java基础类库，当一台计算机想运行java编写的程序时，至少需要安装JRE。JDK是Java开发工具包，它包含了JRE，同时还包含了编译器以及很多Java程序调试和分析的工具，是提供给开发者用来编写Java程序的。如果想运行Java程序，在计算机中安装JRE即可，如果想开发Java程序，就需要在计算机中安装JDK。

4. public static void main是Java的main（）方法。

main（）方法是程序的入口，是固定的格式。

5. 编写代码时，注意以下书写规范：

类名首字母大写，单词之间的第一个字母也需要大写，这称作驼峰规则。
类名只能由数字、字母、下划线、美元符号$组成，并且第一个字符不能是数字。因为类名要与文件名一致，因此文件名也需要遵守这个规则。
一个Java源文件中至少只有一个类能用public声明，并且public修饰的类必须和文件名保持一致。
花括号用于划分程序的各个部分，方法和类的代码都必须以“{”开始，以“}”结束。
代码中的每一条语句以英文的分号“;”结束。
Java代码对字母大小写敏感，如果出现大小写拼写错误，程序无法运行。

第二章 Java编程基础

2.1 变量与常量

1. 标识符规则：

标识符只能由字母、数字、下划线、美元符号组成，并且不能以数字开头。

Java标识符大小写敏感，长度无限制。

标识符不可以是Java关键字和保留字。

2. 变量声明

声明变量后，仅仅是在内存中开辟了一块储存空间（过程是JDK的工作），必须对其进行赋值才能使用。变量的赋值使用“=”，复制的数据类型必须与声明的数据类型一致。

//声明变量

数据类型变量名；

//赋值

变量名 = 变量值；

//声明变量时就赋值

数据类型变量名 =变量值；

//一次声明多个变量并赋值

数据类型变量名1 = 变量值1，变量名2 = 变量值2；

3. 常量声明

//声明一个常量

final 数据类型常量名 = 常量值；

4. Scanner的使用

//引用

Scanner sc = new Scanner(System.in);

//输入

数据类型 sum = sc.next数据类型（）；

2.2 运算符表达式

1. 算术运算符

运算符		描述
二元运算	+	可以进行加法运算，也可以进行字符串的拼接
	-	减法运算
	*	乘法运算
	/	除法运算，需要注意整数之间除法运算的结果依然是整数
	%	取模运算，即求余数
一元运算	num++	自增运算符，先返回num的值，再将num加1
	++num	自增运算符，先将num加1，再返回num的值
	num--	自减运算符，先返回num的值，再将num减1
	--num	自减运算符，现将num减1，再返回num的值

2. 赋值运算符

运算符	描述
=	将右边的值赋值给左边的变量,如num=5
+=	如num+=5,相当于num=num十5
-=	如num-=5,相当于num=num-5
*=	如num=5,相当于num=num5
/=	如num/=5,相当于num=num/5
%=	如 num%=5,相当于num=num%5

3. 逻辑运算符

运算符	描述
&	与运算。当两边表达式都为true时,结果为true,否则结果为false
\|	或运算。当两边表达式都为false时,结果为false,否则结果为true
^	异或运算。当两边结果不同时,结果为true,否则结果为false
!	非运算。如果表达式结果为true,那么计算结果为false,反之亦然
&&	短路与运算。计算结果与&运算符一致,但当第一个表达式为false时,第二个表达式就不再运算
\|\|	短路或运算。计算结果与\|运算符一致,但当第一个表达式为true时,第二个表达式就不再运算

4. 三元运算

条件表达式？表达式1：表达式2；

当条件表达式为true时，执行表达式1，否则执行表达式2。（数据类型不限，条件表达式不限）

2.3 选择结构

1. if语句

if(条件表达式1){

//代码块1

}else if(条件表达式2){

//代码块2

}else if(条件表达式3){

//代码块3

}else{

//代码块n

}

程序执行到 if 语句后会进行判断：当条件表达式1为 true 时，执行代码块1；否则，当条件表达式2为 true 时，执行代码块2；否则，当条件表达式3为 true 时，执行代码块3；否则执行代码块 n 。其中，一个 if 语句之后可以有0至多个 else if 语句，可以有0或1个 else 语句。

2. switch语句

switch(变量){

case 值 1：

        代码块1；

break；

case 值 2：

        代码块2；

break；

case 值 3：

        代码块3；

break；

...

default：

代码块n；

break；

}

switch 语句会根据表达式的值从相匹配的 case 标签处开始执行，一直执行到 break 语句处或者switch 语句的末尾。如果 case 全都不匹配，则进入 default 语句。

2.4 循环结构

1. for语句

for(循环初始化表达式；循环条件表达式；循环后的操作表达式){
//循环体

}

首先执行一次循环初始化表达式，接着判断循环条件表达式，如果为 false，则结束循环。如果为true，则执行循环体，之后执行循环后的操作表达式，重复以上操作，直到条件表达式的值为 false 为止。

2. while语句

while(条件表达式){
//循环体

}

while语句的执行规则：只要条件表达式的值为 true，就会执行循环体，直到条件表达式的值为 false 时才退出循环。while循环一般用于不确定循环次数的场景。

算法思路：

1. 判断题型

循环，非循环；如果逻辑中出现多次重复，那么判定为循环

2. 选择循环关键字

for，while；for 用于知道重复次数，while 用于不知道重复次数

3. do...while语句

do{

//循环体

}while(条件表达式)；

首先执行循环体，之后再判断条件表达式，如果结果为 true，就重复上述步骤，直到条件表达式的值为 false 为止。do…while 语句的语法比较简单，但需要注意的细节是条件表达式最后有一个分号。

4. break 和 continue 语句

在任何循环语句的主体部分，均可用 break 控制循环的流程。break 用于强行退出循环（最近的一个循环），不执行循环中剩余的语句。而 continue 则只能终止某次循环，继续下一次循环。

return最强；return>break>continue

2.5 方法

1. 方法声明与调用

(1)修饰符：用于控制方法的访问权限，目前学习阶段全部写为 public static 即可。

(2)返回值类：方法需要返回给调用者数据的数据类型，如无返回值，必须声明返回值类型为void。

(3)方法名：方法的名字，命名规范在标识符规范的基础之上，采用首字母小写的驼峰命名规则。

(4)形参列表：由参数类型和参数名组成，也称作形式参数(形参)，形参可以为任意多个，用于调用者给方法内部传递数据。

(5)方法体：该方法需要实现的具体逻辑。

(6)返回值：方法执行完毕后提供给调用者的数据。如果定义了返回值类型，那么返回值和返回值类型必须保持一致；如果定义的返回值类型为 void，那么需要省略返回值，也就是直接用语句 “return;” 返回或者省略该语句直至该方法执行结束。当方法在执行过程中遇到return 语，就会返回而结束该方法的执行。

调用格式：

方法名(实际参数1，实际参数2，…);

方法调用时的参数列表称为实际参数(实参)。实参列表的数据类型和参数个数必须与方法声明时完全一致。

补充：普通代码块、静态代码块，构造代码块，都属于方法

2. 方法重载

①在一个类中，允许存在一个以上的②同名方法，只要它们的③参数个数或者参数类型不同即可，这种现象称作方法重载。需要三个同时满足才可。

2.6 数组

1. 数组语法格式

//一、创建出指定长度的数组,数组有多长,就能存储多少数据

数据类型[] 数组名 = new 数据类型[数组长度]；

//二、创建数组的同时向数组中存储数据,此时不需要指定数组长度,有多少元素则数组就多长
数据类型[] 数组名 = new 数据类型门{元素1，元素2，元素3,…};

//方式三、方式二的简写方式
数据类型[] 数组名 = {元素1，元素2，元素3,…};

注意： int[][] arr = new int[2][3]；//数组容量长度为2，2个

2.7JVM中的堆内存与栈内存

1. 堆和栈

JVM是基于堆栈的虚拟机，堆栈是一种数据结构,是用来存储数据的。

虚拟机栈（保存正在运行的方法）先进后出；堆（保存数据实体）方法里的变量存在堆里。

注意：在方法里面运的值才在械里

引用类型、数组都在堆里面

基本数据类型在或不在栈里

基本数据类型如果是属性则不在栈里

第三章面对对象程序设计（基础）

3.1 面对对象的概念

1. 面对对象的特性

封装、继承、多态

3.2. 面对对象编程

1. 类的定义

Java使用 class 关键字定义一个类。一个Java文件中可以有多个类，但最多只能有个 public 修饰的类，并且这个类的类名必须与文件名完全一致。此外，类名需要符合标识符规则，并且遵循大写字母开头的驼峰规则。

pubhc class DemoObject{

}

class Demo1{

}

class Demo2{

}

类主要由变量(字段)和方法组成。

变量(字段 field)，其定义格式；（也称为属性、域）

修饰符变量类型变量名 = [默认值];

方法(行为 action)，其定义格式；（也称为函数）

修饰符返回值类型方法名(形参列表) {}

//例子

public class Demo{

// 属性

public int 属性名;

// 方法

public void 方法名（）{

int num = 2;

}

}

2. 成员变量默认值

数据类型	默认值
整型（short、byte、int、long）	0
浮点型（float、double）	0.0
字符型	'\u0000'
布尔型	false
引用类型	null

3.3 构造方法

1. 什么是构造方法

用于给对象进行初始化操作，即为对象成员变量赋初始值。构造方法的名称必须与类型相同，并且不能定义返回值，不能出现 return 关键字。构造方法的调用必须通过 new关键字调用。

修饰符类名(形参列表) {}

2. 构造方法的使用

当不在类中定义构造方法时，编译器会自动为类提供一个默认的无参数构造方法，一般简称为“无参构造方法”。

3. 构造方法的重载

在Java中，构造方法也可以重载。当创建一个对象时，JVM会自动根据当前对方法的调用形式在类的定义中匹配形式相符合的构造方法，匹配成功后执行该构造方法。

3.4 this关键字

this 关键字可以调用成员变量、成员方法、构造方法。成员方法中不能使用 this 关键字调用构造方法，当使用 this 关键字调用构造方法时，它必须出现在构造方法的第一行。this 关键字不可省略。

3.5 static 关键字

1. 静态变量

在类中，将与成员变量同级的用 static 修饰的变量称为静态变量或类变量。静态变量扫一扫优先于对象存在，随着类的加载就已经存在了，该类的所有实例共用这个静态变量，即共用同一份地址空间。

当想调用静态变量时，可以使用对象名，变量名进行调用，但不推荐，建议使用类名.变量名进行调用。

2. 静态方法

静态方法同样是属于类的，优先于对象存在，调用方式与静态变量相同，也是建议使用类名.方法名进行调用。

3. 静态代码块

在类中，与成员变量和静态变量同级，使用大括号包裹起来的代码块称作构造代码块，当构造代码块使用 static 关键字修饰时，称作静态代码块。

同一个类中,成员变量不能赋值给静态变量,静态变量可以赋值给成员变量和静态变量。
同一个类中,静态方法不能调用成员变量和成员方法,成员方法可以调用静态或非静s态的方法和变量。
同一个类中,静态代码块不能调用成员变量和成员方法,构造代码块可以调用静态或非静态的方法和变量，

4. 构造代码块和静态代码块

构造代码块和静态代码块只能定义在类中，与成员变量和静态变量平级，并且可以定义多个。不同的是，构造代码块随着对象的创建而加载，每创建一个对象就会执行一次；而静态代码块随着类的加载而加载，每个类中的静态代码块只会执行一次。

3.6 包

包是Java中重要的类管理方式，开发中会遇到大量同名的类，通过包给类加上一个命包对于类，相当于文件夹名空间，很容易解决类重名的问题，也可以实现对类的有效管理。

包的导入语法格式：

import 包名.类名；//在类，在同路径，在外部 lang 中，不会import

第四章面对对象程序设计（进阶）

4.1 封装

1. 什么是封装

需要让用户知道的才暴露出来，不需要让用户知道的全部隐藏起来，这就是封装。

2. 访问修饰符

Java中的访问修饰符有4个，分别为private、默认(无修饰符)、protected、public

注意：~~default 是访问修饰符中的包级访问权限~~（×）

private：表示私有的，被它修饰的方法、变量只能被当前类访问，因此也称作类的见性。
无修饰符：表示默认的，被它修饰的方法、变量只能被当前包下的类访问，因此也称作包可见性(用来限制，跨包了，就不给看 [ default ]）
Protected：表示受保护的，被它修饰的方法、变量可以被当前包下所有的类，以及其他包下的子类访问到，因此也称作子类可见性。
public：表示公开的，被它修饰的方法、变量可以被当前项目下所有的类访问，因此也称作项目可见性。

3. get()/set()方法

将变量私有化，取而代之的是提供一些 public 的方法，用于给变量赋值或者获取变量，这些方法一般称为 “get()方法(getter)” 和 “set()方法(setter)”。其中，get() 方法用于获取值，set() 方法用于赋值。

get() 方法和 set() 方法的命名是有要求的，比如 get() 方法，方法名必须以 get 开头，后面跟对应变量的变量名，并将变量名首字母大写。

//例子

public String getName(){

return name;

}

public void setName(){

this.name = name;

}

注意：当一个类中拥有__成员变量,但没有 get__() 和 set__() 方法时，认为这个类中没有 __ 属性，只有 __ 变量。而如果拥有 get__() 和 set__() 方法，不管类中是否有 __ 成员变量，该类都拥有 __ 属性。这就是属性和成员变量的区别。

通过 private 修饰成员变量后，这些成员变量就不能在其所在的类之外的地方被直接访问了,必须通过 get()方法和 set()方法访问。

4.2 继承

1. 什么是继承

在Java中，继承使用 extends 关键字。现有类被称作父类(也称作超类、基类等)，新类称为子类(派生类)，子类拥有父类所有的属性和方法，并且还可以拥有自己独特的属性和方法。

2. 继承的使用

Java 中类之间只有单继承，因此一个子类只能有一个直接父类。但是 Java 支持多层继承，即A类继承B类，B类还可以继承C类，此时C类称为A类的间接父类。此外，如果一个类没有继承任何类，那么它会默认继承 java.lang.Obiect。

3. 方法的重写

方法的重写需要注意以下四点：

子类重写的方法必须与父类方法的方法名和参数列表完全一样。
子类重写的方法修饰符权限要大于或等于父类方法的修饰符权限，如父类的修饰符是 protected，那么子类重写该方法的修饰符必须是 public 或者 protected，但父类方法如果是 private 或者 static 修饰，则不能重写。
子类重写方法的返回值所属的类型必须小于或等于父类方法的返回值所属的类型，如父类方法的返回值是 People 类,则子类重写该方法的返回值必须是People类或者其子类。
父类方法的返回值所属的类型如果是基本数据类型,子类重写该方法时,返回值类型必须与父类方法完全一致。

//重写

有条件 void 不可改{

_____________; //（无条件）

}

4.3 super 关键字

super可以理解为直接父类对象的引用，除 private 修饰的属性和方法外，子类可以通过 super 关键字调用父类中的属性和方法，它的作用是解决子类和父类中属性、方法重名问题的。

4.4 final 关键字

● final修饰的类不可以被继承，但是可以继承其他类。
● final 修饰的方法不可以被重写。
● final修饰的变量是常量，只能被赋值一次。
●final修饰的引用类型变量不能改变它的引用地址，但是可以改变对象内部属性的值。

补充：

被final修饰过的类、变量、方法都不能被改变
类的改变指的是继承
基本数型数据变量的改变，指值的变化
引用数据类型的改变，指地址的变化；
方法改变指重写；

final可以修饰：类、属性、方法
属性/变量的改变：指被重新赋值
方法的改变：指被重写

4.5 Object 类

如果一个类没有用 extend 关键字继承其他类，那么他默认继承 Object 类。

Object类的常见方法：

方法签名	方法描述
String toString( )	返回该对象的字符串表示形式
boolean equals(Object obj)	判断两个对象的地址是否相同
native int hashCode()	返回该对象的哈希码值
final native Class<?> getClass( )	得到一个对象或者类的结构信息
final void wait( )	使当前线程进入等待
final native void notify()	唤醒一个等待的线程

4.6 多态

1. 什么是多态

多态即多个状态的意思，在继承的基础上，基本内涵是父类引用指向子类对象。

父类的引用去操作子类对象的实体（只限于普通的重写方法）
多态的前提是必须存在继承，并且子类重写了父类的方法，最重要的一点是父类引用要指向子类对象。同一方法的调用，由于对象不同，可能会有不同的行为。

2. 多态的实现

多态是为了兼容一些方法去调用的

3. 引用类型数据转换

向上转型：父类引用指向子类对象，属于自动类型转换。

父类类型变量名 = 子类对象；

向下转型：子类引用指向父类对象，属于强制类型转换。

子类类型变量名 = (子类类型）父类对象；

补充：

1.所有引用类型的地址，都是十六进制的数字
2.无论什么样的类型变量，它的值就是一个十六进制的数字。
3.不同的对象，占用空间堆的大小是不一样的
4.JDK拿到一个引用类型变量的16进制后，会根据这个变量前的那个类，来判断要访问的空间范围

多态只和成员方法有关

4.7 抽象类

1. 什么是抽象类

不能被实例化，即不能使用 new 创建一个对象，只能被继承，没有具体的方法体的为抽象类。

2. 抽象类的定义与使用

ps：某些方法父类不好实现，由子类实现更合适

抽象的关键字是 abstract，不管是抽象类还是抽象方法，都用 abstract 关键字修饰

权限修饰符 abstract class 类名 {}

权限修饰符 abstract 返回值类型方法名(参数列表);

注意以下4点（判断）：

(1) 抽象方法只有方法声明，没有方法体，它必须交给子类重写。子类重写抽象方法，也称作 “实现” 抽象方法。
(2) 子类如果也是抽象类，则不一定需要实现父类的抽象方法，而如果不是抽象类，则必须实现父类中所有的抽象方法。
(3) 抽象方法必须被子类重写，因此抽象方法的访问修饰符不能是 private。
(4) 由于抽象方法没有具体的方法体，无法用一个抽象的对象调用它，因此抽象类不能被实例化。
(5) 抽象类可以有构造方法，它的构造方法的作用是便于子类创建对象时给抽象类的属性赋值。

补充：有抽象方法一定有抽象类，抽象类里不一定有抽象方法

4.8 接口

1. 什么是接口

接口内部不要参考类，在老版本里面，一个接口被定义后，且被子类实现后，完全不能修改，JDK8以后，增加了2个方法：static方法，default方法（这个方法有初始实现，这里的默认与default关键字不是一回事）

1.接口可以多实现，比类的单继承更好
2.接口刚开始发明出来的时候，全是抽象的，一个不实现（JDK8以前）

2. 接口的定义与使用

接入的返回值类型左边没写东西
1.默认 public abstract；
2.接口没有访问修饰符；
所有引用类型的变量保存的是一个16进制的数字，这个16进制就是对象的实体在堆里面的起始地址

“继承” 操作就变成了实现一个接口，“重写” 方法称为实现方法。

3. 接口的多实现

Java中类与类之间只有单继承，但是类与接口之间却允许有多实现。当一个类实现了多个接口时，只用逗号将这些接口隔开即可

class 类 implements 接口1，接口2{

}

//例子

package com.yyds.unit4.demo;

public interface Acting{
        void action();

}
package com.yyds.unit4.demo;

public interface Sing {

        void sing();

}
package com.yyds .unit4.demo;

public class Artist implements Acting, Sing {

        @ Override

        public void action(){

                System.out.println("艺人在拍电影");

        }
        @ Override
        public void sing(){
                System.out.println("艺人在唱歌");

        }

}

4. 接口的继承

接口也允许继承，并且接口之间的继承允许多继承。

package com.yyds.unit4.demo;

public interface USB2 extends USB{
void slowTransfer();

}
package com.yyds.unit4.demo;

public interface USB3 extends USB2,USB {

void fastTransfer();

}

4. 接口的 static 方法和 default 方法

接口里的静态方法只能由接口访问（static)；类里面，没写访问修饰符，就是 default

4.9 内部类概述

内部类分为成员内部类（少）、静态部类、局部内部类、匿名内部类（多）四种。

内部类可以访问外部类的方法，有点破坏封装的特性
凡是静态的东西要通过类调用非静态的通过对象访问，调用

第五章异常

5.1 异常概述

当程序出现问题时，就会创建异常类对象并抛出异常相关的信息(如异常出现的位置、原因等)，从而能够更迅速地定位到问题原因。

这里需要区分异常和错误的概念：

异常指的是程序运行过程中出现的不正常现象。比如文件读不到、链接打不开，影响了正常的程序执行流程，但不至于程序崩溃，这些情况对于程序员而言是可以处理的。而错误则是程序脱离了程序员的控制，一般指程序运行时遇到的硬件或操作系统的错误，如内存溢出、不能读取硬盘分区、硬件驱动错误等。错误是致命的，将导致程序无法运行，同时也是程序本身不能处理的。

5.2 异常处理

1. 抛出异常

throw new异常名称(参数列表);

2. 异常声明

修饰符返回值类型方法名(参数列表) throws 异常类名1，异常类名2，… { }

第六章 Java 常用类

6.1 包装类

1. 什么是包装类

让基本数据类型也可以像对象一样进行操作，在设计类时为每个基本数据类型设计了一个对应的类，这样，与这8个基本数据类型对应的类统称为包装类。

包装类	基本数据类型
Integer	int
Boolean	boolean
Long	long
Character	char
Float	float
Byte	byte
Double	double
Short	short

包装类的作用：让基本数据类型可以像对象一样进行操作，提供了更多方便的方法提供了 null 值，让基本数据类型可以表示 “未填写” 的状态。

2. 自动装箱与拆箱

拆箱和装箱的概念：比喻对象实体叫做箱子

装箱：把基本类型放入包发类里面

拆箱：从包装类里面把基本类型拿出来

3. 大数字运算

BigInteger是Java中表示大整型的类， BigInteger 参与算术运算时，并不是用传统的加、减、乘、除符号，而是调用它的方法。

补充：

int是4个字节，
最高位用来表示正负，31个bit表示数字，
凭空出来的整数都是 int，小数都是 double；
long：_____l；float：_____f

6.2 String 类概述

String 类对象代表不可变的 Unicode 字符序列，内部使用了一个用 final 修饰的字符数组存储数据，一旦 String 的值确定了，就不能再改变了，每次通过截取、拼接等操作字符串时，都产生一个新的字符串。

String的构造方法

方法签名	方法描述
String()	创建一个空字符串
String(String s)	创建一个字符串对象,该字符串的内容与s相同
String(char[] value)	创建一个字符串对象,使用字符数组作为该字符串的内容
String(byte[] bytes)	创建一个字符串对象,使用默认编码将字节数组转换成字符串

String类中与查找相关的方法

方法签名	方法描述
int length()	获取字符串长度
char charAt(int i)	获取字符串指定索引位置的字符
int indexOf(int ch)	查找指定字符在字符串中的索引位置
boolean startsWith(String s)	判断字符串是否以指定字符串开头
boolean endsWith(String s)	判断字符串是否以指定字符串结尾
boolean contains(String s)	判断字符串中是否包含指定字符串

String类中的转换方法

方法签名	方法描述
String[]split(String regex)	将一个字符串按照某些字符分隔成字符串数组
char[] toCharArray( )	将字符串转换成字符数组
byte[] getBytes( )	将字符串按照默认编码转换成字节数组
String trim()	去除字符串前后的所有空格
String toUpperCase( )	将字符串中所有小写字母转换为大写
String toLowerCase()	将字符串中所有大写字母转换为小写
String substring(int index)	从 index 开始截取字符串,直到字符串末尾结束
String substring(int beginIndex, int endIndex)	从 beginIndex 开始截取字符串,到索引 endIndex-l 结束
String replace(String target, String value)	将字符串中所有的 targe t替换成 value

String类中的其他方法

方法签名	方法描述
boolean isEmpty()	判断一个字符串是否为空字符串
boolean equals(String s)	判断两个字符串内容是否相同
boolean equalslgnoreCase(String s)	判断两个字符串内容是否相同,忽略大小写
int compareTo(String s)	按照字典顺序比较两个字符串的前后顺序

6.3 StringBuffer 类与 StringBuilder 类（补充 String 的不足）

1. StringBuffer 类（慢，线程安全）

StringBuffer 类是抽象类 AbstractStringBuilder 的子类，代表可变的 Unicode 字符序列，即对 StringBuffer 执行转换操作时，都不会创建新的 StringBuffer 对象，自始至终操作的都是同一个字符串。StringBuffer 并没有像 String 一样提供简单的赋值方式，必须创建它的构造方法才可以。

StringBuffer类中的构造方法

方法签名	方法描述
StringBuffer()	创建一个没有字符的 StringBuffe r对象
StringBuffer(String s)	创建一个字符串为 s 的 StringBuffer 对象

StringBuffer 类中的主要方法

方法签名	方法描述
StringBuffer append(Type t)	将指定内容添加到字符串末尾
StringBuffer delete(int start, int end)	删除从 star t开始到 end-l 结束的字符串
int indexOf(String s)	获取指定字符串在该 StringBuffer 中第一次出现的索引位置
StringBuffer replace(int start,int value,String value)	将 start 到 end-1位置的字符串替换成 value
StringBuffer reverse( )	反转当前字符串
void setLength(int length)	设置字符串长度,超出长度的内容会被舍弃

2. StringBuilder 类（快，线程不安全）

StringBuffer 类和 StringBuilder 类非常类似，都继承自抽象类 AbstractStringBuilder 均代表可变的 Unicode 字符序列。StringBuilder 类和 SuingBufier 类方法一模一样（用法一样，原理不一样），
但是，StringBuilder 不是线程安全的，这是与 StringBuffer 的主要区别。

StringBuffer 做线程同步检查,因此线程安全，效率较低。
StringBuilder 不做线程同步检查，因此线程不安全，效率较高。

在开发中，如果不涉及字符串的改变，建议使用 String，如果涉及并发问题，建议使用 StringBuffer，如果不涉及并发问题，建议使用 StringBuilder（可被对象改变另一个对象）。

6.4 时间与日期相关类

1. 时间戳

时间戳中 867686400000 代表的就是1997年7月1日0时0分0秒，香港回归祖国怀抱的时间。

时间戳可能非常长，Java 中使用 long 类型记录时间戳。

//获取时间戳

System.currentTimeMillis();

2. Date 类

方法签名		方法描述
构造方法	Date()	创建一个Date 对象,该对象代表着当前时间
构造方法	Date(long time)	创建一个Date 对象,该对象代表着传人的时间戳对应的时间
成员方法	boolean before(Date when)	判断当前Date是否在指定时间之前
	boolean after(Date when)	判断当前 Date 是否在指定时间之后
	boolean equals(Object obj)	比较两个日期是否相等
	long getTime()	返回当前 Date 对应的时间戳
	long setTime(long time)	将当前 Date 时间修改为指定的时间戳