Java编程入门指南-CSDN博客

1、Java本身半开源，开发更透明；

2、面向对象的编程语言：使得Java语言语言结构方便开发者接受，面向对象的设计思想还在不断扩充（不同JDK版本）；

3、提供有方便的内存回收处理机制：一些编程语言需要明确的手动进行对象的回收释放，否则程序无法正常提供支持，但是Java可以提供有自动的内存回收操作，这样处理会更加方便（涉及到性能问题）

4、避免复杂的指针问题，而使用简单的引用来代替指针：指针虽然是一种高效的内存处理模式，但是需要较强的逻辑分析，而Java在设计的时候充分考虑到这点，所以开发者直接利用引用就可以简化指针的处理；

5、Java是为数不多支持多线程编程的开发语言，可以使得单位时间内，处理的性能得到提升（非绝对）；多线程也是Java开发中最难以理解的部分，而正确的多线程处理才是提升处理性能的核心所在；

6、Java提供有高效的网络处理能力，可以基于NIO实现更加高效的数据传输处理；

7、Java具有良好的可移植性，可以提升程序适用范围。

Java可移植性

Java语言最大的特点在于可移植性，可移植性是指同一个程序可以在不同的操作系统之间进行部署，减少开发难度。在Java中主要依靠JVM（JAVA虚拟机）是实现可移植性的控制，Java虚拟机是一个由软件和硬件模拟出来的计算机，所有程序只要有JVM的支持，就可以执行程序，不同操作系统上有不同版本的JVM版本。

Java应用程序运行机制：

1、计算机高级编程语言类型：编译型和解释型

2、Java是两种语言的结合：编译命令：javac.exe 解释命令：java.exe

3、Java程序组成：Java源文件、字节码文件、机器码指令

所有Java程序的解释都要求放在Java虚拟机上处理。

java的源程序：.java 文件，程序员可读，程序员编写的程序的时候在 .java文件中编写。 java的可执行程序：.class文件，虚拟机可读，在不同的操作系统上面安装虚拟机。

JVM虚拟机的三大任务：加载代码（.class）、校验代码（头信息、版本）、执行代码

在一台计算机上由软件或硬件模拟的计算机，JVM读取并处理经过编译过的平台无关的字节码class文件。Java编译器针对JVM所产生class文件，因此是独立于平台的。Java解释器负责将JVM的代码在特定的平台上运行。所有的程序并不是直接运行在操作系统上，运行相比较慢，但是由于硬件快速发展，可以忽略，但依然会存在JVM调优问题

第二章搭建Java开发环境

JDK简介

JDK（Java Development Kit）：java开发工具包 JDK包含了JRE（java程序文件的可运行环境）。JRE（Java SE Runtime Environment）为Java运行时环境，只提供有程序的解释功能，不提供开发功能，其包含了JVM（Java Virtual Machine）。JVM包含了客户机和主机，而我们的java程序是运行在JVM中的。安装JDK后会自动更新JRE。

JDK安装与配置

下载地址：Java SE Development Kit 8 - Downloads | Oracle India（本文使用jdk1.8）

1、解压版：解压到指定路径（路径中不要有中文和特殊字符、空格）

2、配置环境变量：

JAVA_HOME: 你的java路径

配置PATH变量

如果之前配置了 classpath请删除，jdk8是不需要的。

测试是否成功：

常用命令：

where java // 查出java.exe可执行文件的路径

set java_home // 查看环境变量

set path // 查看PATH变量

第三章初识Java开发

Java编程起步

1、HelloWorld

/**
 多行注释：
 public： 访问修饰符,表示任何作用域都可以访问，了解一下
 class：类修饰
 HelloWorld：类名,如果前面有public修饰那么类的名称必须和文件名同名
*/
public class HelloWorld{
    // 单行注释： 类中的声明

    // main ： 主函数，程序的开始和结束
	public static void main(String args[]){
    // 程序中的代码 按行的顺序执行
    // pl ： 在控制台输出 hello world
		System.out.println("Hello World !");
	}
}

javac ：将源程序编译成可执行程序 java：运行.class可执行程序

Java程序是需要经过两次处理后才可以正常执行的：

（1）对源代码程序进行编译：javac Hello.java，会出现一个Hello.class的字节码文件（利用JVM进行编译，编译出一套与平台无关的字节码文件（*.class））；

（2）在JVM上进行程序的解释执行：java Hello（解释的是字节码文件，字节码文件的后缀不需要编写）；

2、对第一个程序进行完整解释：

在java程序开发中最基础的单元是类，所有的程序必须封装在类中执行，类的基本定义语法如下：

[public] class 类名称 {}

在本程序中定义的类名称为"Hello"，类的定义有两种形式：

（1）public class 类名称{}：类名称必须与文件名称保持一致

（2）class 类名称{}：类名称可以与文件名称不一致，但是编译后的*.class名称是class定义的类名称，解析的是生成的class文件的名称，在一个.java文件中可以有多个class定义，并且编译后会形成不同的.class文件；

提示：

1、关于源代码定义问题，在进行项目开发时，很少会出现一个*.java源代码里面定义有多个class的情况；

2、定义类名称时，要求每个单词首字母大写，如HelloWorld、TestDemo等；

主方法：主方法是所有程序运行的起点，并且一定要定义在类中

public class 类名称 {
	public static void main(String args[]){
		//程序的代码由此执行
	}
}

Java的主方法名称定义较长，约定俗成的主方法所在的类成为主类，所有的主类都用public class 定义。

屏幕打印（系统输出），可以直接在命令行方式下进行内容的显示，有两类语法形式：

输出之后追加换行：System.out.println()

输出之后不追加换行：System.out.print()

ln即line，换行

JShell工具

注：JDK9版本以上或者JDK9版本

Shell 是脚本程序的含义，在很多的编程语言里为了方便使用者进行代码的开发，都会有Shell交互式编程环境。有时候可能只是为了进行一些简单的程序验证，但是在Java里必须编写很多的结构代码，所以为了解决这样的问题，提供有JShell指令，直接运行即可。除了可以直接在JShell命令中进行程序编写之外，也可以将一些内容直接交由文件来保存。只需编写核心结构的代码即可，减少对结构化的需求。实用性不高

CLASSPATH 环境属性

简单介绍：假设目录下有一个HelloWorld.class字节码文件，当前用户所在目录为字节码所在目录，此时可使用java命令进行HelloWorld.class字节码文件的解释；当脱离了此目录，在其他目录执行程序解释，会出现下述情况：

[ 错误：找不到或无法加载主类 XXX 原因：java.lang.ClassNotFoundException: XXX （1.9版本以后才有原因显示）]

因为当前目录中没有字节码，如果要在不同的目录中都执行该字节码文件，则只能依靠CLASSPATH环境属性来完成。

在cmd中输入 SET CLASSPATH=[字节码文件所在目录]

默认情况下所有解释的类都是从当前目录中加载的，CLASSPATH默认设置为当前所在目录加载类文件。如果想只通过当前目录加载，则可以将CLASSPATH设置为"." 。

默认配置可能因为安装了一些由Java开发的程序软件被自动修改，这种情况下就必须用命令自己重新配置。

cmd命令行中配置会在cmd窗口关闭时消失，所以最好的做法是将其定义为全局属性，可以直接在系统中追加，新建用户的环境变量（变量名：CLASSPATH 变量值：.）

PATH 和 CLASSPATH 的区别：

PATH：是操作系统提供的路径配置，定义所有可执行程序的路径；

CLASSPATH：是由JRE提供的，用于定义Java程序解释时类加载路径，默认设置为当前所在目录加载，可以通过"SET CLASSPATH=路径"的命令形式来进行定义。

逻辑关系：JVM → CLASSPATH定义的路径 → 加载字节码文件

第四章 Java基本概念

注释

注释是程序开发中的重要组成技术，合理的注释可以使项目维护更加方便。

注释的本质在于，编译器在进行编译时，如果发现有注释的内容将不对此部分进行编译处理。 Java中注释共有三类：

单行注释：//

多行注释：/* ... */

文档注释：/** ... */，文档里面还有很多选项，一般建议通过开发工具控制。

单行注释提示下一行语句功能，多行注释可以标注修改信息等。

使用开发工具开发时，单行注释比较方便；对于一些重要的类或者方法建议使用文档注释。

标识符与关键词

在任何一个程序中，实际上都是一个结构的整合体。在Java中有不同的结构，例如：类、方法、变量等；对于不同结构要有不同说明，对于结构的说明就是标识符，标识符是有命名要求的，一般要求有意义的单词组成，但是标识符的组成在Java中的定义如下：由字母、数字、下划线和"$（不建议使用）"组成，其中不能使用数字开头，不能使用Java中的保留字（关键字）。

最简单的定义形式：使用英文字母开头，Student_Name、StudentName；

关键字是系统对于一些结构的描述处理，有着特殊的含义。Java中的关键字如下：

JDK 1.4 出现assert关键字，用于异常处理；

JDK 1.5 出现enum关键字，用于枚举定义上；

未使用到的关键字：goto、const；

有一些属于特殊含义的单词，严格来讲不是关键字：true、false、null

变量

变量：在高级语言中普遍使用变量来管理内存中的数据

1.变量和字面量

public static void main(String[] args) { 
    int i =100; 
}

代码解析：

i：表示变量，可变的量；

100：字面量，变量中存放的具体数据；

2.变量的命名

(1)首字母是英文字母、$或下划线，后面由字母、数字、 $、下划线组成；

(2)变量的命名遵循见名知义的原则。 String name = "jack"; //姓名 int age = 25; //年龄

(3)Java变量名建议不用中文。 (使用中文并没有语法错误)

(4)变量名首字母建议不用大写字母。

(5)用驼峰命名法命名多个单词组成的变量名，如String userName = "admin";

(6)变量名不能使用关键字

PS：有关关键字值得我们注意的地方：

（1）true、false和null为小写，而不是象在C++语言中那样为大写。

（2）无sizeof运算符，因为所有数据类型的长度和表示是固定的，与平台无关，不是象在C语言中那样数据类型的长度根据不同的平台而变化。这正是Java语言的一大特点。

（3）goto(保留字)和const不是Java编程语言中使用的关键字。

3.变量的定义：

类型变量名1，变量名2…变量名n；

int a,b,c;

4.变量的初始化：变量名=字面量字面量可以是具体数值，也可以是返回数组的表达式；

5.变量的作用域：

1、 Java用一对大括号作为语句块的范围，称为作用域。

2、作用域中的变量不能重复定义。

3、离开作用域，变量所分配的内存空间将被JVM（GC垃圾会是机制）回收。

第五章 Java数据类型划分

Java的内存划分

Java数据类型简介

在Java语言中对于数据类型一共分为两类：

1、基本数据类型：描述的是一些具体的数字单元

数值型：整型（byte、short、int、long，默认值：0）

浮点型（float、double，默认值：0.0）

布尔型：boolean，默认值：false

字符型：char，默认值：‘\u0000’。

2、引用数据类型：牵扯到内存关系的使用：数组、类、接口，默认值：null。

每一种基本数据类型都有各自的数据保存范围。

数据类型使用的参考原则：

1、描述数字首选int（整数）、double（小数）；

2、进行数据传输或文字编码转换使用byte类型（二进制处理操作）；

3、处理中文最方便的操作使用char完成（可选）；

4、描述内存或文件大小、描述表的主键列（自动增长）可以使用long。

整型数据类型

整型数据一共四种，保存范围由小到大：byte、short、int、long，那么在Java里任何整型常量的默认类型都是int型（只要是整数就是int类型的数据）

// 定义int型变量

// int 变量名称 = 常量（10是一个常量，整数类型为int）

int x =10; // 定义了一个整型变量

x = 20;

// int 变量 * int 变量 = int 型数据

System.out.println(x*x);

// 10永远不变，但x是一个变量，x的内容可变。

任何的数据类型都是有可以保存的数据范围（正常使用很少会超过此范围），如果超过了处理范围：

int max = Integer.MAX_VALUE; // 获取int的最大值

int min = Integer.MIN_VALUE; // 获取int的最小值

System.out.println(max); // 2147483647

System.out.println(min); // -2147483648

// int型变量 + int型变量 = int型计算结果

System.out.println(max+1); // -2147483648，最大值 + 1 = 最小值

System.out.println(min-1); // 2147483647，最小值 - 1 = 最大值

这些数字在处理的时候如果超过最大保存范围，将出现循环的问题，称为数据溢出，解决方法： 1、操作时预估数据范围，范围不够就使用更大范围；如int → long

int long = Integer.MAX_VALUE;

//long型变量 + int型常量 = long型计算结果

System.out.println(max+1); // 2147483648，超过int范围

2、除了定义long型变量之外，也可以直接在常量上处理，默认的整数常量都是int型，可以追加字母“L”或“l”转换常量，建议使用"L"，也可以直接使用"long"强制转换变量。

int max = Integer.MAX_VALUE;

//int型变量 + long型常量 = long型计算结果

System.out.println(max+1L);

数据类型之间可以转换，即范围小的数据类型可以自动转为范围大的数据类型，但是范围大的数据类型转换为范围小的数据类型，就必须采用强制数据转换，同时还需要考虑可能带来的数据溢出。

long num = 2147483649L; // 数据已经超过int范围，需加上L

int temp = (int)num; // long范围比int大，不能直接转换，需加上（int）

程序支持有数据转换处理，但是不是必须的情况不建议这种转换。

在进行整型处理时，byte需特别注意：范围：-128 ~ 127

byte num = 20;

System.out.println(num);

正常来说，20应该是int型，但为byte赋值时并没有因为是int型而发生强制类型转换，因为Java对byte做了特殊处理，即如果没超过byte范围的常量可以自动由int变为byte，如果超过就必须进行强制类型转换。

int x = 20;

byte num = (int)x;

System.out.println(num * num);

对于常量可以自动适配转换，但是对于变量还是必须强制类型转换。

浮点型数据

浮点型数据描述的是小数，而在Java里面任意的小数常量对应的类型为double，所以以后描述小数可直接用 double 定义变量。

// 10.2是一个小数，对应的类型为double

double x = 10.2;

int y = 10;

// double类型 * int类型 = double类型

double result = x*y;

System.out.println(result);

所有的数据类型转换都是由小类型向大类型进行自动转换。默认的类型是double，也可以定义为float变量，此时赋值应使用强制类型转换。

// 强制类型转换

float x = (float)10.2;

float y = 10.1F;

System.out.println(x * y); // float型，103.02004（Java诞生至今的bug，解决不了忽略）

// 整型除法计算结果不保存小数点

int x = 10;

int y = 4;

System.out.println(x / y); // 结果是2

// 将其中的一个数据类型转为double/float System.out.println((double)x / y); // 2.5

注：浮点运算就是实数运算，由于计算机只能存储整数，所以实数都是约数，这样浮点运算是很慢的而且会有误差。

字符型

字符型使用char定义，在Java中用" ' "定义的内容就是一个字符。

char c = 'A'; // 一个字符变量

System.out.println(c);

在任何的编程语言中，字符都可以与int进行互相转换，也就是说字符中所描述的内容可以通过int获取其内容对应的系统编码。

char c = 'A'; //一个字符变量

int num = c; //可以获得字符的编码

System.out.println(num); // 65

大写字母A-Z范围：65-90；

小写字母a-z范围：97-122；

数字字符0-9（'0'~'9'）范围：48-57

通过编码范围可以发现大小写字母相差32个数字长度，由此可以实现大小写的转换处理。

char c = 'x'; //一个字符变量

int num = c; //可以获得字符的编码

num = num -32; //编码减少32

System.out.println((char)num);

char主要是进行中文处理，可以保存中文数据，因为java使用的是unicode十六进制编码，特点是可以包括任意的文字内容，使开发方便、简单。

char c = '仁'; //一个字符变量

int num = c; //可以获得字符的编码

System.out.println(num); // 20161

布尔类型

布尔数据主要描述一种逻辑的处理结果，在java中使用boolean来进行布尔类型的变量定义，其取值范围只有两个：true和false。

boolean flag = true;

if (flag){

System.out.println("结果为真。");

}

有些编程语言没有提供布尔类型，会使用0表示false，用非0表示true，这样逻辑在java中不存在。

String字符串

在任何编程语言都没有提供所谓的字符串数据，但是在实际使用上来讲各个编程语言为方便开发，都提供有字符串的相应描述；Java中使用String作为字符串的定义。

由于String类型特殊，所以可以像普通变量一样采用直接赋值的方式进行字符串定义，并且要求使用双引号来描述字符串。

String str = "Hello World !"; // 使用“ "" ”进行描述

System.out.println(str);

可以使用"+"来进行字符串的连接处理。

String str = "Hello";

str = str + "World"; //字符串连接

str += "！！！" //字符串连接

System.out.println(str);

在Java语言中，数据范围大的数据类型和范围小数据类型计算时，范围小的自动转换为范围大的数据类型，当有String字符串时，所有类型无条件转换为String类型，此时“+”变为字符串连接处理操作。

double x = 10.1;

int y = 20;

String str = "计算结果：" + x + y;

System.out.println(str); //结果为10.120

String str = "计算结果：" + (x + y);

System.out.println(str); //结果为30.1

转义字符：”\”，通过转义字符，可表示一些特殊的字符。或者将本身具有特殊含义的字符的特殊含义取消。
例如：

'\n' 表示回车
'\t' 表示制表位字符，一个制表符表示向右跳8-10个字符
'\\' 表示\
'\' ' 表示单引号
'\"' 表示双引号

第六章 Java运算符

运算符简介

程序开发实质上是数据处理，对数据处理都有一定的操作模式，而操作模式就是运算符。对于运算符而言，存在优先关系，尽量不要背，也不要写逻辑过于复杂的代码，记住（）优先级最高即可。

数学运算符

在Java中数学运算符都提供标准的支持，包括四则运算。

在进行变量计算时，编程语言一般也提供简化的运算符支持。加减乘除、取余、++、–。

int num = 10; // 操作步骤多，取出num数据，加上20后，再改变

num num = num + 20;

编程语言会提供简化的运算符（+=、*=、-=、/=、%=）支持。

// 操作步骤少，结果相同

num += 20 ;

System.out.println(num);

++变量、-- 变量：先进行变量的自增或者自减，而后再进行数字的计算；

变量 ++、变量--：先使用变量进行计算，而后再进行自增或自减。

关系运算符

关系运算主要特征是大小比较处理：

注：单个等于号是赋值，内容相同的比较是双等于号。所有关系运算返回数据是布尔类型。关系运算可以针对所有基本数据类型，也可以直接使用字符进行关系运算。 char c ='建'; boolean flag = 24314 == c; //true System.out.println(flag);

数据类型之间提供转型支持，在判断时字符会直接转换为int进行比较。

逻辑运算符

短路现象：&&、||、!（短路运算方式）对“或运算”如果运算符左边的表达式的值为 true，则整个表达式的结果为true，不必对运算符右边的表达式再进行运算；同样，对“与运算”，如果左边表达式的值为false，则不必对右边的表达式求值，整个表达式的结果为false。

在程序开发时三目运算符使用的非常多，合理使用三目运算可以避免大范围的程序编写。

三目是一种所谓的赋值运算处理，它需要设置一个逻辑关系的判断之后才可以进行赋值操作，基本语法如下：

关系运算?关系满足时的内容:关系不满足时的内容

int x = 10;

int y = 20;

int max = x > y ? x : y;

System.out.println(max); // 20

三目运算本身可以进行嵌套处理，即可以在赋值语句上进一步编写三目运算。虽然允许嵌套，但是程序可读性差。

// 保存三个数字之中最大值

int x = 10;

int y = 20;

int z = 15;

int max = x>y?(x>z?x:z):(y>z?y:z);

System.out.println(max);

位运算符

位运算指的是可以直接进行二进制数据的计算处理，主要有：

1、按位与运算（&）
参与运算的两个值，如果两个相应位都为 1，则该位的结果为1，否则为0。
即：0&0=0，0&1=0，1&0=0，1&1=1
2、按位或运算（|）
参与运算的两个值，如果两个相应位都是 0，则该位结果为0，否则为1。
即：0|0=0，0|1=1，1|0=1，1|1=1
3、按位异或运算（^）
参与运算的两个值，如果两个相应位的某一个是1，另一个是0，那么按位异或（^）在该位的结果为1。也就是说如果两个相应位相同，输出位为0，否则为1。
即：0^0=0，0^1=1，1^0=1，1^1=0
4、按位取反运算（~）
按位取反运算（~）属于一元运算符，它只对一个自变量进行操作（其他所有运算符都是二元运算符）。按位取反生成与输入位的相反的值——若输入0，则输出1；输入 1，则输出0。
即：~0=1，~1=0
5、左移位运算符（<<）
运算符<<执行一个左移位。作左移位运算时，，高位溢出，低位补零，右边的空位补0。在不产生溢出的情况下，数据左移1位相当于乘以2。
6、右移位运算符（>>与>>>）
运算符>>执行一个右移位（带符号），操作数的构成二进制位右移若干位，地位溢出舍弃，高位补充原来高位的值。（右移一位相当于除2取商）
7、位运算进行取模

System.out.println(16&(16-1)); // 16%16 = 0
System.out.println(18&(16-1)); // 18%16 = 2

&和&&、|和||的区别：

&和|两个运算符可以进行位运算和逻辑运算：

在进行逻辑运算的时候所有的判断条件都要执行；在进行位运算的时只是针对当前的数据进行与和或处理；

在逻辑运算上还可以使用&&和||：

&&在若干个条件判断时，如果前面的条件返回了false，后续条件不再判断，结果为false；||在若干个条件判断时，如果前面的条件返回true，后续条件不再判断，结果为true。

第七章 Java程序控制逻辑

程序开发过程中的三种逻辑：顺序结构、分支结构、循环结构

if分支结构

if分支结构主要是针对于关系表达式进行判断处理的分支操作。

if判断：

if(布尔表达式){

//条件满足时执行;

}

if、else判断

if(布尔表达式){

//条件满足时执行;

}else{

//条件不满足时执行;

}

多条件判断

if(布尔表达式){

        //条件满足时执行;

}else if (布尔表达式){

        //条件满足时执行;

}else{

        //上述条件都不满足时执行

}

switch开关语句

switch是一个开关语句，它主要是根据内容来进行的判断，但需要注意的是switch中可以判断的只能是数据（int、char、枚举（jdk1.5）、String（jdk1.7））而不能使用逻辑判断。

switch(数据){

        case 数值:{

                // 数值满足时执行;

                [break;]

        }

        case 数值:{

                // 数值满足时执行;

                [break;]

        }

        [ default:

                // 所有判断数值不满足时执行;

                [break;]

        ]

}

在每个case后面没有追加break语句的话，会在第一个匹配的case之后继续执行，知道后续代码全部执行完，或者遇到break结束。

while循环

所谓循环结构是指某一段代码被重复执行的处理操作。

while循环

while(布尔表达式){

//条件满足时执行;

//修改循环条件

}

do…while循环

do{

//条件满足时执行;

//修改循环条件

}while(布尔表达式);

实现1-100累加

int sum = 0;

int num = 1; // 进行循环控制

while(num<=100){

sum += sum;

num++;

}

System.out.println(sum);

int sum = 0;

int num = 1; // 进行循环控制

do{

sum += sum;

num++;

}while(num<=100)

System.out.println(sum);

两者区别：while循环先判断后执行（首选），do…while先执行后判断。

for循环

for 循环也是常规的使用结构，使用语法如下：

for(定义循环的初始化数值;循环判断;修改循环数据){

//循环语句执行

}

for循环实现1-100累加

int sum = 0;

for(int x = 1; x <= 100 ; x++){

sum += x;

}

System.out.println(sum);

对于while和for循环的选择的参考标准：明确循环次数的情况下优先选择for循环，不知道循环次数但是知道循环结束条件的情况下使用while循环。

循环控制

在循环语句定义的时候还有两个控制语句：break、continue。

break主要功能是退出整个循环结构

continue只结束当前的一次调用（结束当前循环）：当执行到continue时表示当前语句的后续代码不再执行，而直接进行后续循环判断处理。

可以用continue执行部分go to 的功能，但程序结构被破坏，不建议使用，最好别会。

循环嵌套

在一个循环语句中嵌套其他循环语句就称为循环嵌套处理，嵌套层数越多，时间复杂度越高。

打印乘法口诀表

for(int x=1 ; x<=9 ; x++){

        for(int y=1 ; y<=x ;y++){

                System.out.print(y + "" + x + "=" + xy + "\t");

        }

        System.out.println();

}

第八章方法的定义和使用

方法的定义

方法（method）有可能需要重复执行一些代码，在有些书上也称函数（function）。

方法的基本定义：

public/protected/private [static] 返回值类型方法名称([参数类型变量名, ...]){

// 执行代码

[return [返回值];]

}

对于返回值而言，可以使用Java中定义的数据类型（基本数据类型、引用数据类型），在方法中可以进行返回数据的处理，如果要返回数据可以用return描述，return所返回到数据类型与方法的返回值类型相同，如果不返回数据，则可以使用void声明。

关于方法名称与变量的定义命名要求：在定义方法名时要求第一个单词的字母小写，而后每个单词的首字母大写。在定义变量名时要求相同。

定义并调用一个无参无返回值的方法

public static void main(String[] args) {

printMessage();

} p

ublic static void printMessage(){

System.out.println("Hello World!");

}

方法的本质就是方便重复调用，并且所有程序一定都是通过主方法开始执行的。

定义方法时，如果方法的返回值为void，可以利用return结束调用。

public static void get(num){

        if (num>=10.0){

                System.out.println("Hello World!" + num);

        } else {

                return ;

        }

}

方法重载

方法重载的定义：当方法名称相同，参数的类型或个数不同的时候就称为方法重载。

加法处理方法（两个int变量，三个int变量，两个double变量）

public static void main(String args[]){

        int resultA = sum(10,20); //调用两个int参数的方法

        int resultB = sum(10,20,30); //调用三个int参数的方法

        double resultC = sum(10.2,20.3);//调用两个double参数的方法

}

public static int sun(int x,int y){

        return x+y;

}

public static int sun(int x,int y,int z){

        return x+y+z;

}

public static double sun(double x,double y){

        return x+y;

}

同一个方法名称可以根据调用时传递的不同参数的类型或个数实现不同方法体的调用，从而实现了方法重载的定义。

方法的重载与方法的返回值类型没有关系，只与参数有关，但在实际开发中，只要是方法重载，建议返回值类型相同。

System.out.println(1);

System.out.println(1.1);

System.out.println('A');

System.out.println("Hello World!“);

可以发现，所有的输出操作支持各种数据类型，所以System.out.println()就属于方法重载。

方法递归调用（了解）

方法的递归调用指的是一个方法自己调用自己的情况，利用递归调用可以解决一些重复且麻烦的问题。

需要考虑这些问题：

1、设置方法递归调用的结束条件；

2、每次调用的过程中要修改传递的参数条件；

递归实现1-100的累加

public static void main(String args[]){

        sum(100);

}

public static int sum(int num){ //执行累加

        if(num == 1)

                return 1;

        return num + sum(--num);

}

第一次执行sum()，由主方法调用：return 100 + sum(99);

第二次执行sum()，由sum()递归调用：return 99 + sum(98);

…

第九十九次执行sum()，由sum()递归调用：return 2 + sum(1);

第一百次次执行sum()，由sum()递归调用：return 1;

整体形式： return 100 +99 + 98 + … … + 2 + 1；

递归操作虽然可以简化调用，但是大部分情况下考虑的是简单的处理逻辑，不必使用递归，因为处理不当容易造成内存溢出（java.lang.StackOverflowError）。

计算 1! + 2! + 3! + 4! + 5! + … … + 90!

在实现阶乘的时候要考虑选择的数据类型

//递归实现

public static void main(String args[]){

        sum(90);

}

public static double fan(int num){

        if(num == 1)

                return 1;

        return num * fan(num -1);

}

public static sum(int num){

        if(num == 1)

                return 1;

        return fan(num)+sum(num-1);

}