java笔记
一、认识java语言
1、Java平台-Java语言特性
2、DOS命令指示符使用
3、Java集成开发环境
4、Java程序结构组成-类
5、Java程序结构组成-方法
6、Java程序结构组成-语句
7、Java程序结构组成-注释
8、命名规范
二、运算符与表达式
1、算术运算符
2、赋值运算符
3、关系运算符
4、逻辑运算符
5、条件运算符
6、Java中运算符的优先级
补充
1、位运算符的种类
2、&、|、^、~ 的用法
3、<<、>>、>>> 的用法
4、三目运算符与格式
三、分支结构
1、if分支结构
2、switch分支结构
3、两个关键字的使用[break continue]
四、循环结构
1、while循环
2、do…while循环
3、for循环
4、foreach循环
5、两个关键字的使用[break continue]
五、数组
一、一维数组
1、什么是数组?
2、数组的使用
2.1、静态初始化：简单
2.2、动态初始化：第一步:声明一个数组 两种写法
3、实际应用
3.1、静态声明，并拿值
3.2、动态声明，并拿值
4、求最值
4.1、求最大值
4.2、求最小值 跟最大值一样的思路
4.求和 跟平均值
4.1、平均值
4.2、循环输入求平均值
5、冒泡排序
5、排序
二、二维数组
1、两种方式：动态及静态
1.1、格式1: 动态初始化
1.2、格式2: 静态初始化
2、实际应用
2.1、求和跟平均值
2.2、求最大值
2.3、最小值
3、数组的使用
六、方法
1、什么是方法？
2、方法的声明（定义）
3、方法的访问权限：用来控制方法是否在其它类中使用
3.1、方法的返回值类型
4、方法的定义
4.1方法的分类：
4.2、方法的调用
一、认识java语言
1、Java平台-Java语言特性
Java是众多高级语言中的一种，由SUN公司开发
Java是面向对象的编程语言，也是一个平台
Java技术基于Java虚拟机（JVM）
Java语言特点：
Java语言特点：
平台无关
简单
面向对象
可移植性
健壮性
安全性
多线程
2、DOS命令指示符使用
命令 功能 说明
dir 显示指定路径下磁盘目录 DIR [盘符：][路径][文件名][参数]
cd 进入指定目录 cd只能进入当前盘符下目录，cd…返回上级目录
md 创建目录 可以通过\创建多及目录：md 一级目录\二级目录
rd 删除子目录 只能删除当前路径下的空目录
copy 拷贝文件 COPY [源目录或文件][目的目录或文件]
del 删除文件 只能删除指定目录下的文件
cls 清空屏幕 清空命令窗口的内容
exit 退出命令窗口 关闭命令窗口
3、Java集成开发环境
文本编辑器： UltraEdit，Notepad++等
Web开发工具： Hbuilder，Sublime等
集成开发工具： IntelliJ IDEA，Eclipse等
4、Java程序结构组成-类
程序以类的方式组织，放在.java文件中
public class Hello{}
public class Student{}
//class:用于定义一个类
//public：代表这个类是公有的
//源文件名与类名一致
1
2
3
4
5
5、Java程序结构组成-方法
方法就是这个类能做的事
main方法为主方法，是程序的入口 main+alt+/ 快捷方式
public static void main(String[] args){}
1
6、Java程序结构组成-语句
语句是方法做事的体现
语句以分号结尾
真正跑程序 syso+alt+/ 打印输出
System.out.println("Hello，world! ") ;
1
7、Java程序结构组成-注释
注释向阅读人员提供说明信息，增强程序可读性
注释不会执行
单行注释
单行注释：快捷键Ctrl+/ 再次按撤销注释
一般用来注释局部变量。
//这是单行注释
int a = 5;
a = a + 6;
1
2
3
多行注释
多行注释：Ctrl+Shift+/ 撤销Ctrl+Shift+\
可用来注释文件头、算法实现、方法中的复杂代码块、修改记录
/*
这个是多行注释，此区域全部都不会被编译
int a = 5;
a = a + 6;
*/
int j = 0;
j++;
System.out.println(j);
1
2
3
4
5
6
7
8
文档注释
文档注释：Shift+Alt+J
可用来注释类、接口、静态方法、成员方法、静态变量、成员变量、常量
或者在定义完：注释类、接口、静态方法、成员方法、静态变量、成员变量、常量后，在上面加上/**在按Enter建也能生成
/**
* 这个是文档注释，此处描述此类的作用及其他信息
*/
public class Hello{
public static void main(String[] args){
System.out.println("HelloWord!");
}
}
1
2
3
4
5
6
7
8
8、命名规范
二、运算符与表达式
1、算术运算符
算术运算符 名称 举例
+ 加法 5+12=17
- 减法 25-10=15
* 乘法 5*5=25
/ 除法 25/5=5
% 求余 24%7=3
++ 自增 int i=5 ; i++
– 自减 int i=5 ; i–
其中四个运算符是需要我们特别注意的
/ 除法运算符:此运算符我们需要考虑数据类型的问题
5 / 2 = ? ;
1
在我们以前的数学运算中它的结果是：2.5
而在我们Java中要考虑除数和被除数的数据类型的问题，5、2默认都是整型的，所以结果也必须是整型的，可是结果计算出来是2.5，那程序就在这个结果中取整数部分所以最终的结果为2
% 取余也叫取模运算符，我觉得叫取余数更好理解，顾名思义就是两个数做除法，求最终剩下几
5 % 2 = ?;
1
对2求余，商2 余1所以最后的结果就是1
++ 自增运算符
i++;
//此句话我们对它进行一下翻译
i = i + 1;
1
2
3
在原有的基础上做+1的操作，在使用++符号一定注意一个问题 i++ 和 ++i 的区别，i++先使用i完成其他运算再自增，++i先自增再参加其他运算
–- 自减运算符，同上
+±-运算符的用法
++：自加。对原有的数据进行+1 ; --：自减。对原有数据进行-1
放在操作数的前面和后面效果一样
注：放在操作数的前面，先自增或者自减，然后再参与运算; 放在操作数的后面，先参与运算，再自增或者自减。
注：
整数相除只能得到整数，如果想得到小数，就要使用浮点数（float、double）；
/是获得除法的商；%获取的是除法操作的余数（4%5=8），运算结果的符号取决于参与运算的左边的符号。
2、赋值运算符
算术运算符 名称 举例
= 赋值 c=a+b 将a+b得到的值赋值给c
+= 加等于 c+=a等价于c=c+a
-= 减等于 c-=a等价于c=c-a
*= 乘等于 c*=a等价于c=c*a
/= 除等于 c/=a等价于c=c/a
%= 模等于 c%=a等价于c=c%a
赋值运算符中最熟悉也是最不熟悉的就是=，大部分人认为这不就是等号吗？其实它在java中我们称之为赋值符号
//1. 赋值符号 =
i = i + 1;
//2. += 这是一个缩写的形式
i+=1;
//等同于
i = i + 1;
/
1
2
3
4
5
6
7
8
赋值运算符的注意事项
注意事项
基本的赋值运算符=：把=右边的数据赋值给左边。
扩展的赋值运算符+=,-=,*=,/=,%=：把左边和右边做加法，然后赋值给左边。
赋值运算符要求左边的数据必须是一个变量
3、关系运算符
判断两个操作之间的关系,结果是一个boolean的结果(只会是ture or false)
这里边我们看一个之前不太常见的==,这个才是我们之前一直脑子里的等号
int a = 5;
int b = 6;
if(a > b){
System.out.println("a 比 b大");
}
if(a == b){
System.out.println("a 和 b一样大");
}
if(a != b){
System.out.println("a 和 b不一样大");
}
1
2
3
4
5
6
7
8
9
10
11
符号 说明
== a==b，判断a和b的值是否相等，成立为true，不成立为false
！= a!=b，判断a和b的值是否不相等，成立为true，不成立false
> a>b，判断a是否大于b，成立为true，不成立为false
>= a>=b，判断a是否大于等于b，成立为true，不成立为false
< a<b，判断a是否小于b，成立为true，不成立为false
<= a<=b，判断a是否小于等于b，成立为true，不成立为false
关系运算符的注意事项
注意事项
无论你的操作是简单还是复杂，结果是boolean类型
“==“不能写成”=”
4、逻辑运算符
对两个布尔类型的操作数进行操作,其结果也是boolean
运算符 用法 含义 说明 实例 结果
&& a&&b 短路与 ab 全为 true 时，计算结果为 true，否则为 false。 2>1&&3<4 true
|| ab 短路或 ab 全为 false 时，计算结果为 false，否则为 true。。 2<1||3>4 false
! !a 逻辑非 a 为 true 时，值为 false，a 为 false 时，值为 true !(2>4) true
| ab 逻辑或 ab 全为 false 时，计算结果为 false，否则为 true 1>2|3>5 false
& a&b 逻辑与 ab 全为 false 时，计算结果为 false，否则为 true 1<2&3<5 true
&& 与 & 区别：如果 a 为 false，则不计算 b（因为不论 b 为何值，结果都为 false）
|| 与 | 区别：如果 a 为 true，则不计算 b（因为不论 b 为何值，结果都为 true）
逻辑运算符的注意事项
注意事项
逻辑运算符一般用于连接boolean类型的表达式或者值
在Java中我们要表示一个数大于3并且小于6 ，不可以写成3<x<6，应该写成 x>3 & x<6
&逻辑与:有false则false
逻辑或:有true则true
逻辑与或:相同为false，不同为true 举例：情侣关系:男男,男女,女男,女女
逻辑非:非false则true，非true则false 特点：偶数个不改变本身。
逻辑运算符&&和&的区别
&&（短路与）与 &（与）的区别
最终结果一样
&&具有短路效果，左边是false，右边不执行
逻辑运算符||和|的区别
||(短路或) |(或)的区别
最终结果一样
||具有短路效果，左边是true，右边不执行
5、条件运算符
条件运算符也称之为三目运算符,也是以后我们会常用的一种运算符
Test？语句块1：语句块2；
Test是boolean结果的表达式
结果为true时执行语句块1
结果为false时执行语句块2
//需求：比较a b两个数的大小,将大的数存入c中
int a = 5;
int b = 6;
int c = 0;
c = a>b?a:b;
//此时c中存储的就是最大的值也就是6
System.out.println(c);
1
2
3
4
5
6
7
6、Java中运算符的优先级
1的级别最高，11的级别最低
优先级 运算符
1 （）
2 ！； +（正） ；-（负）； ++； –
3 * ；/ ； %
4 +（加）； -（减）
5 < ； <= ； >； >=
6 == !=
7 ^
8 &&
9 ||
10 ?:
11 = ； += ；-=；*=；/=；%=
补充
1、位运算符的种类
~(按位取反) <<(左移) &(与) (或) >>(右移) ^(异或) >>>(无符号右移)
注意事项：位运算是直接对二进制补码进行运算。
2、&、|、^、~ 的用法
用法
&:有0则0
^:相同则0，不同则1
~:按位取反 0变1 1变0
:有1则1
位异或运算符^的特点：一个数据被另一个数据位异或两次，该数本身不变。
3、<<、>>、>>> 的用法
用法 用法
<<:左移 空位补0，被移除的高位丢弃
>>:右移 被移位的二进制最高位是0，右移后，空缺位补0；最高位是1，高位补1。
>>>:无符号右移 被移位二进制最高位无论是0或者是1，空缺位都用0补。
注：
<< : 把<<左边的数据乘以2的移动次幂 例如 10<<3 结果 10*2^3=80
>> : 把>>左边的数据除以2的移动次幂 例如 40>>3 结果 40/2^3=5
4、三目运算符与格式
格式
(关系表达式) ？ 表达式1 ： 表达式2
如：int a=(10>20)?30:50; a=50
流程
计算关系表达式的值，如果为true， 运算后的结果是表达式1； 如果为false，运算后的结果是表达式2；
三、分支结构
1、if分支结构
单if分支结构
int a =6;
if(a>10){
Syste.out.println("a 大于 10");
}
1
2
3
4
if-else分支结构
int a =6;
if(a>10){
Syste.out.println("a 大于 10");
}else{
Syste.out.println("a 不大于 10");
}
1
2
3
4
5
6
多重if-else分支结构
int a =6;
if(a>10){
Syste.out.println("a 大于 10");
}else if(a == 10){
Syste.out.println("a 等于 10");
}else{
Syste.out.println("a 小于 10");
}
1
2
3
4
5
6
7
8
2、switch分支结构
案例
令狐冲参加比武大会
如果获得第一名，将出任武林盟主
如果获得第二名，将出任武当掌门
如果获得第三名，将出任峨嵋掌门
否则，将被逐出师门
使用switch代码实现如下:
int mingCi = 1;
switch (mingCi){
case 1:
System.out.println("出任武林盟主");
break;
case 2:
System.out.println("出任武当掌门");
break;
case 3:
System.out.println("出任峨嵋掌门");
break;
default:
System.out.println("被逐出师门");
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
3、两个关键字的使用[break continue]
break 跳出当前循环或者代码段
continue 跳过本次循环,继续下次循环
//使用break --> 1-10中只要遇到有偶数就停止
int i = 1;
for(;i<11;i++){
if(i%2==0){
break;
}
}
System.out.println(i+"是偶数!");
//使用continue --> 查找1-10之间所有的偶数和
int i = 1;
int total = 0;
for(;i<11;i++){
if(i%2!=0){
continue;
}
total+=i;
}
System.out.println("所有的偶数和为:"+total);
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
四、循环结构
1、while循环
while 循环只最基本也是最简单的一种循环结构:
语法:
while(布尔型表达式){
//循环体
}
1
2
3
此处的布尔表达式可以理解为:一个只要结果为布尔值的任何内容
int i = 5;
while(i<4){
//循环体
System.out.println("这句话不会执行的");
}
1
2
3
4
5
2、do…while循环
对于 while 语句而言,如果不满足条件,则不能进入循环。
但有时候我们需要即使不满足条件,也至少执行一次。
do…while 循环和 while 循环相似,不同的是 do…while 循环至少会执行一次
语法：
do{
//循环体
}while(布尔表达式);
1
2
3
do…while 循环先进行一次循环体的执行,然后才会进行布尔表达式的判断,如果结果为 true 则继续下一次循环,
如果为false则直接退出循环
int i = 5;
//while 循环
while(i<4){
//循环体
System.out.println("这句话不会执行的");
}
//do while循环
do{
//循环体
System.out.println("不管下边条件真不真,我肯定会执行一次的!");
}
while(i<4);
int i = 5;
//while 循环
while(i<4){
//循环体
System.out.println("这句话不会执行的");
}
//do while循环
do{
//循环体
System.out.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
3、for循环
for 循环是使用率最高的一种循环,语法相对 while 循环稍微复杂一点
for(初始化循环参数;循环条件;更新循环变量){
//循环体
}
1
2
3
4
初始化循环参数
这是第一步参数: int i = 0;
循环条件
初始化参数之后需要判断此条件是否为 true ,如果为 true则执行下一步,如果为 false 则退出循环
循环体
这是循环体 执行完执行下一步
更新循环变量
待循环体执行完毕,要对循环变量进行更新,一般为自增或者自减:i++ or i–,之后进入第二步进行条件判断
for(int i = 0;i<10;i++){
System.out.println("我要被输出10遍");
}
1
2
3
4、foreach循环
这个循环是for循环的一种升级用法,一般针对数组和集合使用,简化普通for循环
String[] str = {"你","好","啊","!"};
for(String s : str){
System.out.println(s);
}
1
2
3
4
其中 s 代表数组 str 中的每一个被循环到的内容,这种写法比之前的for更加的简介,
5、两个关键字的使用[break continue]
break 跳出当前循环或者代码段
continue 跳过本次循环,继续下次循环
//使用break --> 1-10中只要遇到有偶数就停止
int i = 1;
for(;i<11;i++){
if(i%2==0){
break;
}
}
System.out.println(i+"是偶数!");
//使用continue --> 查找1-10之间所有的偶数和
int i = 1;
int total = 0;
for(;i<11;i++){
if(i%2!=0){
continue;
}
total+=i;
}
System.out.println("所有的偶数和为:"+total);
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
五、数组
数组也是一种变量,它可以存储一组固定长度、相同数据类型的数据
一、一维数组
1、什么是数组?
数组对象是使用单独的变量名来存储一系列的值。
数组可以用一个变量名存储所有的值，并且可以用变量名访问任何一个值。
一组数据 ：相同数据类型的时候 而且数据还比较多的 时候 存放一组数据
2、数组的使用
第一步：声明一个数组 ；
第二步：向数组里面写入数据： 2种写法 静态和动态
2.1、静态初始化：简单
double [] score4 = {}; 要求必须一行写完
1
2.2、动态初始化：第一步:声明一个数组 两种写法
第二步：创建内存空间 new
这里的数值是固定的
int[] score1 =new int[6];
score1 [1]=10;
score1 [2]=20;
score1 [3]=30;
score1 [4]=40;
score1 [5]=50;
1
2
3
4
5
6
用Scanner自己输入数值 这里的数值不是固定的
int [] score1 = new int[5];
Scanner sc = new Scanner(System.in) ;
for (int i = 0; i <= 4 ; i++) { //循环i表示的是 数组的下标 从0开始的 0 1 2 3 4
System.out.println("请输入第"+(i+1)+"位同学的成绩");
int score = sc.nextInt();
score1[i] = score;
1
2
3
4
5
6
第三步：怎么使用：需要将数组中 的下标指定元素 从0开始 递增 0 1 2 3 4
到底放没放进去 打印输出 遍历数组
for (int i = 0; i <= 4; i++) {
System.out.println(score1[i]);
}
1
2
3
3、实际应用
3.1、静态声明，并拿值
//声明一个int类型的数组
int [] a={10,20,30,40,50};
//拿值时 索引下标从0开始计算
// System.out.println(a[3]);
for (int i = 0; i < a.length; i++) {
System.out.println(a[i]);
}
1
2
3
4
5
6
7
3.2、动态声明，并拿值
//动态初始化
int [] shuzu=new int[5];
Scanner sc=new Scanner(System.in);
for (int i = 0; i <=4; i++) {//循环i表示的是 数组的下标 从0开始的 0 1 2 3 4
System.out.println("请输入第"+(i+1)+"位同学的成绩");
int a=sc.nextInt();
shuzu[i]=a;
}
//到底数组里面有没有数 打印输出 遍历数组
for (int i = 0; i < shuzu.length; i++) {
System.out.println(shuzu[i]);
}
1
2
3
4
5
6
7
8
9
10
11
12
4、求最值
4.1、求最大值
求一组数据中的最大值 3 5 7 9 12 15 1 3 4 一次只能比较2个数
1
打擂台的思维： 首先先假设1号是最大值 然后 让1和轮流和后面的值进行比较 ，如果出现一个数比1号还大 那么就让最大值 设定这个数
//静态初始化
int[] a={15,54,48,445,125,665,999,1111,455,78};
int max=a[0];
for (int i = 0; i < a.length; i++) { //然后 让1和轮流和后面的值进行比较
//如果出现一个数比1号还大 那么就让最大值 设定这个数
if (a[i]>max) {
max=a[i];
}
}
System.out.println("最大值为"+max);
1
2
3
4
5
6
7
8
9
10
4.2、求最小值 跟最大值一样的思路
//静态初始化
int[] a={15,54,48,445,125,665,999,1111,455,78,1};
int min=a[0];
for (int i = 0; i < a.length; i++) { //然后 让1和轮流和后面的值进行比较
//如果出现一个数比1号还小 那么就让最 xiao值 设定这个数
if (a[i]<min) {
min=a[i];
}
}
System.out.println("最小值为"+min);
1
2
3
4
5
6
7
8
9
10
4.求和 跟平均值
4.1、平均值
求班级5位同学的成绩的平均值
分析：1. 5位–数组 --初始化： 静态 动态 （scanner）
2. 成绩–double
3.求和 思想
4.求平均
//求和 与平均值
int[] a={454,541,55,13,152,474,66,12,322,1445,11};
int sum=0;
for (int i = 0; i < a.length; i++) {
sum +=a[i];
}
System.out.println("和为"+sum);
int avg=sum/a.length;
System.out.println("平均值为"+avg);
1
2
3
4
5
6
7
8
9
4.2、循环输入求平均值
循环录入5位同学的成绩 然后计算平均分 15分
循环 for
录入 scanner
成绩 double
5位同学 —一维数组
求平均分–》求总分
double[] arr=new double[5];
Scanner sc=new Scanner(System.in);
int sum=0;
for (int i = 0; i < arr.length; i++) {
System.out.println("请输入第"+(i+1)+"位同学成绩");
arr[i]=sc.nextDouble();
sum +=arr[i];
}
int avg=sum/arr.length;
System.out.println(avg);
1
2
3
4
5
6
7
8
9
10
5、冒泡排序
一次只能比较两个数
数组排序从小到大（口诀）：n个数字来排序，两两相比小靠前，外层循环n-1,内层循环n-1-i
array[j]=array[j+1];
array[j+1]=array[j];
int[] a= {16,54,32,64,778,4524528,24524512,4245252,6554,1414,222154};
for (int i = 0; i < a.length-1; i++) {
for (int j = 0; j < a.length-1-i; j++) {
int teep;
if (a[j]>a[j+1]) {
teep=a[j];
a[j]=a[j+1];
a[j+1]=teep;
}
}
}
System.out.println("排序后");
for (int i = 0; i < a.length; i++) {
System.out.println(a[i]);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
5、排序
排序 Arrays.sort()方法 只会从小到大
注意：考试的时候 ：如果题目说 使用冒泡排序实现从下到大 0
实现从小到大 的排序 看分值 10~15 20 冒泡排序
int [] array = {4,5,66,7,8,60,5,43,3};
//对他进行 排序 从小到大 冒泡排序
Arrays.sort(array);
for (int i = 0; i < array.length; i++) {
System.out.println(array[i]);
}
1
2
3
4
5
6
二、二维数组
1、两种方式：动态及静态
1.1、格式1: 动态初始化
数据类型 数组名 [ ][ ] = new 数据类型[m][n]
int a[][]=new int[][];
1
数据类型 [ ][ ] 数组名 = new 数据类型[m][n]
int [][]a=new int[][];
1
举例：
举例：int [ ][ ] arr=new int [5][3]; 也可以理解为“5行3例”
1
1.2、格式2: 静态初始化
数据类型 [ ][ ] 数组名 = {{元素1,元素2…},{元素1,元素2…},{元素1,元素2…}…};
int[][]a={ {},{},{} };
1
举例：
举例：int [ ][ ] arr={{22,15,32,20,18},{12,21,25,19,33},{14,58,34,24,66},};
1
2、实际应用
2.1、求和跟平均值
//先定义一个二维数组 静态动态
int [][]a={{1,2,3},{4,5,6},{7,8,9}};
int sum=0;
for (int i = 0; i < a.length; i++) {
for (int j = 0; j < a[i].length; j++) {
sum +=a[i][j];
}
}
System.out.println("和为"+sum);
int avg=sum/a.length;
System.out.println("平均值为"+avg);
1
2
3
4
5
6
7
8
9
10
11
2.2、求最大值
int [][]a={{1,2,3},{4,5,6},{7,8,9}};
int max=0;
for (int i = 0; i < a.length; i++) {
for (int j = 0; j < a[i].length; j++) {
if (a[i][j]>max) {
max=a[i][j];
}
}
}
System.out.println(max);
1
2
3
4
5
6
7
8
9
10
11
2.3、最小值
int [][]a={{1,2,3},{4,5,6},{7,8,9}};
int min=1; //min值等于什么都可以
for (int i = 0; i < a.length; i++) {
for (int j = 0; j < a[i].length; j++) {
if (a[i][j]<min) {
min=a[i][j];
}
}
}
System.out.println(min);
1
2
3
4
5
6
7
8
9
10
11
3、数组的使用
以上数组演示的都是int类型的,我们还可以用其他任意的类型,包括但不限于八种基本数据类型、String、类等。
数组是内存中有序数据的集合，数组中的每个元素具有相同的数据类型。
数组必须先声明，对其初始化以后才能使用。对数组初始化有静态初始化和动态初始化两种方式。
通过下标来访问数组中的每个元素。
数组可以分为一维数组和多维数组。二维数组可以理解为一维数组的集合。
六、方法
1、什么是方法？
函数： 是一段可以重复调用的代码，通过名字来进行调用。它能将数据传递进去进行一些处理，然后返回数据（或者没有返回值），函数和对象无关。
方法： 也是一段可以重复调用的代码，也通过名字来进行调用的，但是它跟一个对象相关联。方法可以操作类内部由private封装的数据。
2、方法的声明（定义）
修饰符 返回值类型 方法名([参数类型 参数名1, 参数类型 参数名2, ...]){
执行语句 方法体
...
[return 返回值;]
}
// []中的数据可以没有
1
2
3
4
5
6
7
我们可以看到方法的基本组成包括：名称、参数、返回值和方法体。
修饰符：方法的修饰符较多，有对访问权限进行限定的，有静态修饰符static，public static 公共的，还有最终修饰符final等。
返回值类型：用于限定方法返回值的数据类型。void 空 没有返回值
参数类型：用于限定调用方法时参数参数的类型。
( )参数名：() 参数 数据类型 变量名 是一个变量，用于接收调用方法时传入的数据。
{ }方法体 : 里面主要写该方法的作用
return关键字：用于结束方法以及返回方法指定类型的值。当方法以void关键字声明，那么此方法没有返回值；但可以使用return来结束调用。
3、方法的访问权限：用来控制方法是否在其它类中使用
四种类型：public、private、protected、默认不写
例如：由public定义的方法可以在其他类中使用，由private定义的方法只能在本类中使用。
3.1、方法的返回值类型
如果方法没有返回值，则返回值类型为void，例如main方法
若返回值为基本数据类型，则返回值类型为基本数据类型或长度比当前返回值类型大的数据类型
例如：
public double print(double a,int b){
return a+b;
}
1
2
3
如果返回值类型是引用类型，则方法返回值类型要么与数据类型一致，要么是数据类型的父类（Object是所有类的父类）
4、方法的定义
权限修饰符 返回值类型 方法名（参数…）{方法体…}
4.1方法的分类：
没有返回值（viod) —没有参数
有返回值 —没有参数
没有返回值 (void) —有参数
有返回值 —有参数
4.2、方法的调用
直接调用 —没有返回值
赋值调用 —有返回值 更灵活
输出调用 ----有返回值
例子
定义方法
—有返回值 返回一个字符串 没有参数
public static String Name(){
//返回一个值 而且值是string
return "hello world";
}
1
2
3
4
5
–没有返回值 (void) 有参数 打印输出一个数
--没有返回值 (void) 有参数 打印输出一个数
1
–有返回值 (int return ) 有参数
public static int sum(int a , int b){
return a+b;
}
————————————————
版权声明：本文为CSDN博主「q1427094386」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/z1427094386/article/details/117656373
255
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
