public class Main {

public static void main(String[] args) {

//+号连接字符串

String myName="王小明";code>

String myTel="189XXXXXXXX";code>

String contactStr=myName+myTel;

System.out.println(contactStr);

//concat 连接字符串

String contactStr1=myName.concat(myTel);

System.out.println(contactStr1);

}

}

3.9.1.4 格式化字符串

<code>public class Main {

public static void main(String[] args) {

/*Math类*/

System.out.println("90 度的正弦值：" + Math.sin(Math.PI/2));

System.out.println("0度的余弦值：" + Math.cos(0));

System.out.println("60度的正切值：" + Math.tan(Math.PI/3));

System.out.println("1的反正切值： " + Math.atan(1));

System.out.println("π/2的角度值：" + Math.toDegrees(Math.PI/2));

System.out.println("圆周率："+Math.PI);

}

}

 3.9.4.3 Number &Math类方法

xxxValue方法

<code>

public class Main {

public static void main(String[] args) {

/*Math类方法*/

//xxxValue() 将 Number 对象转换为xxx数据类型的值并返回

Integer x = 5;

System.out.println("返回 byte 原生数据类型:"+ x.byteValue());

System.out.println("返回 double 原生数据类型:"+x.doubleValue());

System.out.println( "返回 long 原生数据类型:"+x.longValue());

//compareTo() 将 Number 对象与方法的参数进行比较

// 如果指定的数与参数相等返回 0。

//如果指定的数小于参数返回 -1。

//如果指定的数大于参数返回 1。

System.out.println(x.compareTo(3));

System.out.println(x.compareTo(5));

System.out.println(x.compareTo(8));

//valueOf 返回给定参数的原生 Number 对象值，参数可以是原生数据类型, String等

Integer d =Integer.valueOf(9);

Double c = Double.valueOf(5);

Float a = Float.valueOf("80");

Integer b = Integer.valueOf("444",16); // 使用 16 进制

System.out.println(d);//9

System.out.println(c);//5.0

System.out.println(a);//80.0

System.out.println(b);// 1092

// toString

System.out.println("toString方法："+x.toString());

System.out.println("带参 toString方法："+Integer.toString(12));

//parseInt 将字符串解析为int类型

System.out.println("parseInt："+Integer.parseInt("15"));

System.out.println("parseInt 16进制："+Integer.parseInt("15",16));

// abs 返回绝对值

System.out.println("double 绝对值："+Math.abs(-80.0));

System.out.println("float 绝对值："+Math.abs(-70.0f));

System.out.println("int 绝对值："+Math.abs(-9));

System.out.println("long 绝对值："+Math.abs(-1234567890333337777l));

/*Math 的 floor,round 和 ceil 方法实例比较

ceil() 对一个数进行上舍入，返回值大于或等于给定的参数，类型为双精度浮点型

floor() 对一个数进行下舍入，返回给定参数最大的整数，该整数小于或等给定的参数

round() 方法返回一个最接近的 int、long 型值，四舍五入

* */

double dx=1.4;

System.out.println("Math.ceil："+Math.ceil(dx));//2.0

System.out.println("Math.floor："+Math.floor(dx));//1.0

System.out.println("Math.round："+Math.round(dx));//1

double dx1=-1.4;

System.out.println("Math.ceil："+Math.ceil(dx1));//-1.0

System.out.println("Math.floor："+Math.floor(dx1));//-2.0

System.out.println("Math.round："+Math.round(dx1));//-1

}

}

3.9.5 日期和时间

3.9.5.1 Date的创建和方法

java.util 包提供了 Date 类来封装当前的日期和时间。 Date 类提供两个构造函数来实例化 Date 对象

第一个构造函数使用当前日期和时间来初始化对象：Date()

第二个构造函数接收一个参数，该参数是从 1970 年 1 月 1 日起的毫秒数：Date(long millisec)

<code>

import java.util.Date;

import java.util.Calendar;

public class Main {

public static void main(String[] args) {

/*日期Date*/

var currDate = new Date();//当前日期

System.out.println("当前日期："+currDate);

var msDate = new Date(currDate.getTime());

System.out.println("当前日期(带有毫秒参数)："+msDate);

//after 若当调用此方法的Date对象在指定日期之后返回true,否则返回false

Calendar calendar = Calendar.getInstance(); // 获取当前日期

calendar.add(Calendar.DATE, -1); // 将日期减去一天

Date yesterday = calendar.getTime(); // 获取前一天的Date对象

System.out.println("今天在昨天之后："+currDate.after(yesterday));// true

System.out.println("昨天在今天之后："+yesterday.after(currDate));// false

//before 若当调用此方法的Date对象在指定日期之前返回true,否则返回false

System.out.println("今天在昨天之前："+currDate.before(yesterday));// false

System.out.println("昨天在今天之前："+yesterday.before(currDate));// true

//clone 拷贝副本

System.out.println("今天日期的副本是："+currDate.clone());

//compareTo(Date date) 比较当调用此方法的Date对象和指定日期。两者相等时候返回0。调用对象在指定日期之前则返回负数。调用对象在指定日期之后则返回正数。

System.out.println("currDate和msDate一样："+currDate.compareTo(msDate)); //0

System.out.println("昨天和今天一样："+yesterday.compareTo(currDate));// -1

//equals 当调用此方法的Date对象和指定日期相等时候返回true,否则返回false

System.out.println("currDate equals msDate："+currDate.equals(msDate)); // true

System.out.println("昨天 equals 今天："+yesterday.equals(currDate));// false

//getTime() 返回自 1970 年 1 月 1 日 00:00:00 GMT 以来此 Date 对象表示的毫秒数

System.out.println("当前日期的毫秒数："+currDate.getTime());

//hashCode() 返回此对象的哈希码值

System.out.println("当前日期的哈希码值："+currDate.hashCode());

//setTime(long time) 用自1970年1月1日00:00:00 GMT以后time毫秒数设置时间和日期

Date yesterday1 = (Date)yesterday.clone();

yesterday1.setTime(5000);

System.out.println("time毫秒数设置时间和日期："+yesterday1);

//toString() 日期转换为字符串

// 把此 Date 对象转换为以下形式的 String： dow mon dd hh:mm:ss zzz yyyy 其中： dow 是一周中的某一天 (Sun, Mon, Tue, Wed, Thu, Fri, Sat)。

System.out.println("当前日期字符串："+currDate);

//sleep()使当前线程进入停滞状态（阻塞当前线程），让出CPU的使用、目的是不让当前线程独自霸占该进程所获的CPU资源，以留一定时间给其他线程执行的机会。

//注：必须添加 try catch 容错语句

try{

System.out.println("休眠前的时间："+new Date());

Thread.sleep(3000); // 休眠3秒

System.out.println("休眠3s后的时间："+new Date());

}

catch ( Exception e ) {

System.out.println("Got an exception!");

}

//计算时间差 注：必须添加 try catch 容错语句

try {

long start = System.currentTimeMillis( );

System.out.println(new Date());

Thread.sleep(3000);

System.out.println(new Date());

long end = System.currentTimeMillis( );

long diff = end - start;

System.out.println("Difference is : " + diff);

} catch (Exception e) {

System.out.println("Got an exception!");

}

}

}

3.9.5.2 日期格式化

使用 SimpleDateFormat 格式化日期

SimpleDateFormat 是一个以语言环境敏感的方式来格式化和分析日期的类。SimpleDateFormat 允许你选择任何用户自定义日期时间格式来运行。

日期和时间的格式化编码：

<code>

import java.text.SimpleDateFormat;

import java.util.Date;

import java.util.Calendar;

public class Main {

public static void main(String[] args) {

/*使用 SimpleDateFormat 格式化日期*/

var currDate = new Date();//当前日期

System.out.println("当前日期："+currDate);

//12小时制格式化

SimpleDateFormat ft = new SimpleDateFormat ("yyyy-MM-dd hh:mm:ss");

System.out.println("当前时间为(12小时制): " + ft.format(currDate));

//24小时制格式化

SimpleDateFormat ft24 = new SimpleDateFormat ("yyyy-MM-dd HH:mm:ss");

System.out.println("当前时间为(24小时制): " + ft24.format(currDate));

//带有毫秒的格式化

SimpleDateFormat ftMs24 = new SimpleDateFormat ("yyyy-MM-dd HH:mm:ss:SS");

System.out.println("当前时间为(24小时制 毫秒): " + ftMs24.format(currDate));

//带有 星期的日期格式化

SimpleDateFormat ftXq24 = new SimpleDateFormat ("yyyy-MM-dd HH:mm:ss EE");

System.out.println("当前时间为(24小时制 星期): " + ftXq24.format(currDate));

//纯星期的日期格式化

SimpleDateFormat ftXq = new SimpleDateFormat ("EE");

System.out.println("今天是星期几中的: " + ftXq.format(currDate));

//字符串转日期 注：必须添加 try catch 容错语句

try{

SimpleDateFormat ftStr = new SimpleDateFormat("yyyy-MM-dd");

String strDate="2024-02-03";code>

Date dt=ftStr.parse(strDate);

System.out.println("字符串转日期："+dt);

}

catch ( Exception e ){

System.out.println("Unparseable using " + ft);

}

}

}

使用printf格式化日期

printf 方法可以很轻松地格式化时间和日期。使用两个字母格式，它以 %t 开头并且以下面表格中的一个字母结尾。

日期格式化转换符

<code>

import java.util.Date;

public class Main {

public static void main(String[] args) {

/*使用 printf 格式化日期*/

var currDate = new Date();//当前日期

System.out.println("当前日期："+currDate);

//%ta 输出星期的缩写

System.out.printf("星期的缩写: %ta "+"\n", currDate);

//%tA 输出星期的全名

System.out.printf("星期的全名：%tA"+"\n",currDate);

//%tb 输出月份的缩写

System.out.printf("月份的缩写: %tb "+"\n", currDate);

//%tB 输出月份的全名

System.out.printf("月份的全名：%tB"+"\n",currDate);

//%tc 包括全部日期和时间信息

System.out.printf("日期和时间信息：%tc"+"\n",currDate);

//%td 输出当前两位数日期（Day）

System.out.printf("当前两位数日期（Day）：%td"+"\n",currDate);

//%tD 输出"月/日/年"格式

System.out.printf("月/日/年信息：%tD"+"\n",currDate);

//%te 一位或两位数的日期（Day）

System.out.printf("一位或两位数的日期（Day）：%te"+"\n",currDate);

//%tF 输出"年-月-日"格式

System.out.printf("年-月-日：%tF"+"\n",currDate);

//%tH 输出24小时制的小时数

System.out.printf("24小时制的小时数：%tH"+"\n",currDate);

//%tl 输出12小时制的小时数

System.out.printf("12小时制的小时数：%tl"+"\n",currDate);

//%tm 输出两位数的月份

System.out.printf("两位数的月份：%tm"+"\n",currDate);

//%tM 输出分钟数

System.out.printf("分钟数：%tM"+"\n",currDate);

//%tp 输出上午或下午

System.out.printf("上午或下午：%tp"+"\n",currDate);

//%tr 输出本地化的"HH:MM:SS PM"格式（12小时制）

System.out.printf("HH:MM:SS PM：%tr"+"\n",currDate);

//%tR 输出HH:MM 24小时制

System.out.printf("HH:MM：%tR"+"\n",currDate);

//%tS 输出秒数

System.out.printf("秒数：%tS"+"\n",currDate);

//%tT 输出输出本地化的"HH:MM:SS PM"格式（24小时制）

System.out.printf("HH:MM:SS：%tT"+"\n",currDate);

//%ty 输出两位年份

System.out.printf("两位年份：%ty"+"\n",currDate);

//%tY 输出四位年份

System.out.printf("四位年份：%tY"+"\n",currDate);

//%tZ 输出时区

System.out.printf("时区：%tZ"+"\n",currDate);

}

}

如果想使用字符串日期格式化，转换字符同printf

import java.util.Date;

public class Main {

public static void main(String[] args) {

/*使用 printf 格式化日期*/

var currDate = new Date();//当前日期

System.out.println("当前日期："+currDate);

String strDate=String.format("当前日期：%tF",currDate);

System.out.println(strDate);

String strXq=String.format("今天是：%tA",currDate);

System.out.println(strXq);

}

}

3.9.5.3 Calendar类

当我们想获取或者设置日期的特定部分内容，需要使用Calendar类，比如获取日期的年份，设置年份加1等。

Calendar类对象的字段类型

//创建一个代表系统当前日期的Calendar对象，默认是当前日期

Calendar c = Calendar.getInstance();

//创建一个代表2009年6月12日的Calendar对象

Calendar c1 = Calendar.getInstance();

c1.set(2009, 6 - 1, 12);

对象类型的设置通过set或者add实现

一些set方法

set(int field,int value)：将给定的日历 对象字段值 设置为给定的 valueset(int year, int month, int date)：设置日历字段 年、月、日 的值set(int year,int month,int date,hourOfDay,int minute)：置日历字段 年、月、日、小时、分钟  的值set(int year,int month,int date,hourOfDay,int minute,int second)：设置日历字段 Y年、月、日、小时、分钟、秒 的值setFirstDayOfWeek(int value)： 设置一周的第一天setLenient(boolean lenient):指定日期/时间解释是否宽松setMinimalDaysInFirstWeek(int value):设置一年中第一周所需的最少天数setTime(Date date):用给定的 Date. 设置日历的时间setTimeInMillis(long millis)：根据给定的 毫秒 值设置 Calendar 的当前时间setTimeZone(TimeZone value)：使用给定的时区 value 设置时区

add方法

add(int filed,int amount)：根据日历的规则在给定的日历字段中添加或减去指定的时间量

日期指定内容的获取通过get实现

一些get方法

get(int field)：返回给定日历字段的值Date getTime()：此日历时间值的 Date 对象TimeZone getTimeZone()：获取时区

import java.text.SimpleDateFormat;

import java.util.Date;

import java.util.Calendar;

import java.util.TimeZone;

public class Main {

public static void main(String[] args) {

/*Calendar类*/

Calendar c1 = Calendar.getInstance();

System.out.println("Calendar对象日期："+c1.getTime());

//set(int field,int value)

c1.set(Calendar.YEAR,2020);

System.out.println("Calendar set(int field,int value) 对象日期："+c1.getTime());

// set(int year,int month,int date)

c1.set(2022,5,25);

System.out.println("Calendar set(int year,int month,int date) 对象日期："+c1.getTime());

//set(int year,int month,int date,hourOfDay,int minute)

c1.set(2022,6,30,16,30);

System.out.println("Calendar set(int year,int month,int date,hourOfDay,int minute) 对象日期："+c1.getTime());

//set(int year,int month,int date,hourOfDay,int minute,int second)

c1.set(2022,7,31,16,30,30);

System.out.println("Calendar set(int year,int month,int date,hourOfDay,int minute,int second) 对象日期："+c1.getTime());

//setTime(Date date);

try{

String strDate="2020-01-05 14:30:30";code>

SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

Date dt=sdf.parse(strDate);

c1.setTime(dt);

System.out.println("Calendar setTime(Date date) 对象日期："+c1.getTime());

}

catch ( Exception e ){

System.out.println(e.getMessage());

}

// 设置一周的第一天：setFirstDayOfWeek(int value);

Calendar c2 = Calendar.getInstance();

c2.setFirstDayOfWeek(Calendar.FRIDAY);

System.out.println("Calendar setFirstDayOfWeek(int value) 对象日期："+c2.getTime());

System.out.println("一周的第一天: " +c2.getFirstDayOfWeek());

//指定日期/时间解释是否宽松 setLenient(boolean lenient);

System.out.println("当前日期/时间解释是否宽松: " +c1.isLenient());

c1.setLenient(!c1.isLenient());

System.out.println("修改指定日期/时间解释是否宽松:："+c1.isLenient());

//setMinimalDaysInFirstWeek(int value)

//setTimeInMillis(long millis)

//etTimeZone(TimeZone value)

//setWeekDate(int weekYear,int weekOfYear,int dayOfWeek)

//isSet(int field)

//根据日历的规则在给定的日历字段中添加或减去指定的时间量 add(int filed,int amount)

Calendar c3 = Calendar.getInstance();

System.out.println("当前日期: " +c3.getTime());

c3.add(Calendar.YEAR,-1);

System.out.println("年份减1后的日期: " +c3.getTime());

c3.add(Calendar.YEAR,1);

System.out.println("年份加1后的日期: " +c3.getTime());

c3.add(Calendar.MONTH,2);

System.out.println("月份加2后的日期: " +c3.getTime());

c3.add(Calendar.DATE,2);

System.out.println("日期加2后的日期: " +c3.getTime());

}

}

import java.text.SimpleDateFormat;

import java.util.Date;

import java.util.Calendar;

import java.util.Locale;

import java.util.TimeZone;

public class Main {

public static void main(String[] args) {

/*Calendar类*/

Calendar c1 = Calendar.getInstance();

//get(int field)：返回给定日历字段的值

System.out.println("Calendar get(int field) 获取当前年份："+c1.get(Calendar.YEAR));

System.out.println("Calendar get(int field) 获取当前月份："+(c1.get(Calendar.MONTH)+1));

// Date getTime()：此日历时间值的 Date 对象

System.out.println("Calendar对象日期："+c1.getTime());

//TimeZone getTimeZone()：获取时区

System.out.println("Calendar getTimeZone() 获取时区："+c1.getTimeZone());

}

}

3.9.5.4 GregorianCalendar类

<code>import java.util.GregorianCalendar;

public class Main {

public static void main(String[] args) {

/*GregorianCalendar*/

GregorianCalendar gcalendar = new GregorianCalendar();//默认本地时间和时区

System.out.println("当前时间："+gcalendar.getTime());

System.out.println("是否闰年："+gcalendar.isLeapYear(2024));

}

}

3.9.6 Stream & File & IO

Java.io 包通过数据流、序列化和文件系统为系统输入和输出提供类

3.9.6.1 控制台输入/输出

读取控制台输入

Java 的控制台输入由 System.in 完成。

为了获得一个绑定到控制台的字符流，你可以把 System.in 包装在一个 BufferedReader 对象中来创建一个字符流

BufferedReader语法：

BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

从控制台读取多字符输入

从 BufferedReader 对象读取一个字符要使用 read() 方法，其语法为：

 int read( ) throws IOException

每次调用 read() 方法，它从输入流读取一个字符并把该字符作为整数值返回，当流结束的时候返回 -1，该方法抛出 IOException

从控制台读取字符串

从标准输入读取一个字符串需要使用 BufferedReader 的 readLine() 方法：语法为：

String readLine( ) throws IOException

代码实例：

import java.io.*;

public class Main {

public static void main(String[] args) throws IOException {

/*读取控制台输入*/

char c;

//使用 System.in创建 BufferedReader

BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

System.out.println("输入字符, 按下 'q' 键退出。");

//读取多字符

do{

c = (char) br.read();

System.out.println(c);

}

while (c!='q');

System.out.println("读取多字符结束");

//读取字符串

BufferedReader brStr = new BufferedReader(new InputStreamReader(System.in));

String str;

System.out.println("输入一行字符串文本");

System.out.println("输入 'end' 退出");

do {

str = br.readLine();

System.out.println(str);

} while (!str.equals("end"));

System.out.println("读取字符串结束");

}

}

执行示例

控制台输出

控制台的输出由 print( ) 和 println() 完成。这些方法都由类 PrintStream 定义，System.out 是该类对象的一个引用。

PrintStream 继承了 OutputStream类，并且实现了方法 write()。这样，write() 也可以用来往控制台写操作。

PrintStream 定义 write() 的最简单格式如下所示：

<code>void write(int byteval)

该方法将 byteval 的低八位字节写到流中 

注意：write() 方法不经常使用，因为 print() 和 println() 方法用起来更为方便

public class Main {

public static void main(String[] args) {

/*控制台输出*/

int b;

b = 'A';

System.out.write(b);

System.out.write('\n');

}

}

3.9.6.2 读写文件

一个流被定义为一个数据序列。输入流用于从源读取数据，输出流用于向目标写数据。

下图是一个描述输入流和输出流的类层次图。

读写文件，我们主要使用FileInputStream 和 FileOutputStream，java.io 包中的 File 文件类允许我们处理文件

FileInputStream

该流用于从文件读取数据，它的对象可以用关键字 new 来创建。

有多种构造方法可用来创建对象。

使用字符串类型的文件名来创建一个输入流对象来读取文件：

<code>InputStream f = new FileInputStream("C:/java/hello");

使用一个文件对象来创建一个输入流对象来读取文件。我们首先得使用 File() 方法来创建一个文件对象：

File f = new File("C:/java/hello");

InputStream in = new FileInputStream(f); 

InputStream 方法及描述

 注：除了InputStream外还包括DataInputStream、 ByteArrayInputStream

<code>import java.io.*;

import java.nio.charset.StandardCharsets;

public class Main {

public static void main(String[] args) {

/*FileInputStream try catch容错必须要有*/

try{

InputStream fis = new FileInputStream("D:/Java.txt");

int size=fis.available();

byte[] buffer=new byte[size];

//读取txt内容并输出字符串

int readResult=fis.read(buffer);

String content = new String(buffer, StandardCharsets.UTF_8);

fis.close();

System.out.println(content);

}

catch (Exception ex){

System.out.println(String.format("错误：%s",ex.getMessage()));

}

}

}

 FileOutputStream

该类用来创建一个文件并向文件中写数据。

如果该流在打开文件进行输出前，目标文件不存在，那么该流会创建该文件。

有两个构造方法可以用来创建 FileOutputStream 对象。

使用字符串类型的文件名来创建一个输出流对象：

OutputStream f = new FileOutputStream("C:/java/hello")

使用一个文件对象来创建一个输出流来写文件。我们首先得使用File()方法来创建一个文件对象：

File f = new File("C:/java/hello");

OutputStream fOut = new FileOutputStream(f);

OutputStream方法及描述

 注：除了OutputStream外还包括DataOutputStream、 ByteArrayOutputStream

<code>

import java.io.*;

import java.nio.charset.StandardCharsets;

public class Main {

public static void main(String[] args) {

/*FileOutputStream try catch容错必须*/

try{

String strPath="D:/MyJava.txt";code>

OutputStream os = new FileOutputStream(strPath);

//写入内容

StringBuilder sb=new StringBuilder();

sb.append("Java是一种流行的编程语言，创建于1995年。\r\n");

sb.append("它是一种非常流行的语言，尽管它已经很老了。\r\n");

sb.append("它归甲骨文所有，现有30多亿台设备运行Java。\r\n");

os.write(sb.toString().getBytes());

os.close();

//读取内容

InputStream fis=new FileInputStream(strPath);

int size=fis.available();

byte[] buffer=new byte[size];

//读取txt内容并输出字符串

int readResult=fis.read(buffer);

String content = new String(buffer, StandardCharsets.UTF_8);

fis.close();

System.out.println(content);

}

catch (Exception ex){

System.out.println(String.format("错误：%s",ex.getMessage()));

}

}

}

读写文件除了FileInputStream 和FileOutStream，我们还可以通过File类来实现，java.io 包中的 File 文件类允许我们处理文件。

File类基础方法及描述

<code>

import java.io.*;

public class Main {

public static void main(String[] args) {

/*File类*/

try{

String strPath="D:/HelloJava.txt";code>

File myFile = new File(strPath);

//如果文件不存在则创建文件

if(!myFile.exists()){

boolean isCreate= myFile.createNewFile();

}

//写入内容

StringBuilder sb=new StringBuilder();

sb.append("Java是一种流行的编程语言，创建于1995年。\r\n");

sb.append("它是一种非常流行的语言，尽管它已经很老了。\r\n");

sb.append("它归甲骨文所有，现有30多亿台设备运行Java。\r\n");

FileWriter fw=new FileWriter(strPath,false);

fw.write(sb.toString());

fw.close();

//读取内容

FileReader fr=new FileReader(strPath);

BufferedReader br=new BufferedReader(fr);

StringBuilder sb2=new StringBuilder();

String line;

while ((line=br.readLine())!=null){

sb2.append(line+"\r\n");

}

fr.close();

System.out.println(sb2.toString());

//删除文件

String fileName=myFile.getName();

boolean isDelete=myFile.delete();

if(isDelete){

System.out.printf("文件%s已删除",fileName);

}

else {

System.out.printf("文件%s删除失败",fileName);

}

}

catch (Exception ex){

System.out.printf("错误：%s",ex.getMessage());

}

}

}

3.9.7 Scanner 类

什么是方法：方法是一个代码块，只在运行时调用。可以将数据（称为参数）传递到方法中。方法用于执行某些操作，它们也称为函数。

方法的优点：

使程序变得更简短而清晰有利于程序维护可以提高程序开发的效率提高了代码的重用性

方法命名规则：

方法的名字的第一个单词应以小写字母作为开头，后面的单词则用大写字母开头写，不使用连接符。例如：addPerson。下划线可能出现在 JUnit 测试方法名称中用以分隔名称的逻辑组件。一个典型的模式是：test<MethodUnderTest>_<state>，例如 testPop_emptyStack。

方法的语法：

<code>修饰符 返回值类型 方法名(参数类型 参数名){

    ...

    方法体

    ...

    return 返回值;

}

方法包含一个方法头和一个方法体。下面是一个方法的所有部分：

修饰符：修饰符，这是可选的，告诉编译器如何调用该方法。定义了该方法的访问类型。返回值类型 ：方法可能会返回值。returnValueType 是方法返回值的数据类型。有些方法执行所需的操作，但没有返回值。在这种情况下，returnValueType 是关键字void。方法名：是方法的实际名称。方法名和参数表共同构成方法签名。参数类型：参数像是一个占位符。当方法被调用时，传递值给参数。这个值被称为实参或变量。参数列表是指方法的参数类型、顺序和参数的个数。参数是可选的，方法可以不包含任何参数。方法体：方法体包含具体的语句，定义该方法的功能。

4.0.1 方法定义及调用

要在Java中调用一个方法，请编写该方法的名称，后跟两个括号()和。

Java 支持两种调用方法的方式，根据方法是否返回值来选择。

当程序调用一个方法时，程序的控制权交给了被调用的方法。当被调用方法的返回语句执行或者到达方法体闭括号时候交还控制权给程序。

public class Main {

public static void main(String[] args) {

/*调用方法*/

SetName();

int sum=CalSum(2,5);

System.out.println(sum);

}

/*

定义 void类型的无返回值，无参数的方法

* */

private static void SetName(){

String strName="Hello Java Method";code>

System.out.println(strName);

}

/*定义 int 类型的，带返回值，带参数的方法*/

private static int CalSum(int a,int b){

int sum=a+b;

return sum;

}

}

4.0.2 方法的重载