01-Java基础语法
Java基础语法
1、注释
//单行注释
/*
* 多行注释
*/
/**
* 多行注释，该注释可被javadoc工具解析生成帮助文档 */
2、Java中基础关键字的意义
package test;
//public表示公开的
//class表示定义一个类
//helloworld表示一个类名
public class helloworld {//定义一个公开的类helloworld
//类体
/*
* 程序的入口，是一个方法，main，固定写法
* 其中args是可变的
*/
//public表示公开的
//static表示静态的
//void是main方法的返回值类型
//main是方法的名字
//String[] args 方法的参数列表
public static void main(String[] args){
//方法体
//方法体由Java语句构成。任何一个Java语句应以";"结束
System.out.println("Hello World!");
System.out.println("我是中国人");
//向控制台输出一句话
}
//类体中不能直接编写Java语句
//System.out.println("我是红花国人");
}
3、public class和class的区别
/*
* 一个.java源文件中可以定义多class，有多少class就会生成多少个.class文件
* 一个.java文源件中可以没有public的class
* public的class的名字要与文件名保持一致，如以下文件名为A.java，
若有public class B{}编译会报错，而public A{}则不会
*如果要定义public的class，这个public的class只能有一个
*当要运行.class文件时分别“java 类名(A\B\C\D)”
*/
class A{
public static void main(String[] ards){
System.out.println("A's main metond execute");
}
}
class B{
public static void main(String[] args){
System.out.println("B's main metond execute");
}
}
class C{
public static void main(String[] ards){
System.out.println("C's main metond execute");
}
}
class D{
public static void main(String[] ards){
System.out.println("D's main metond execute");
}
}
*当编译时，命令行窗口中写“java .java”可编译所有.java文件
4、数据类型
4.1 字面值
/*
关于Java中的字面值
*1.什么是字面值？
一眼看上去就知道是多少的数据，就是字面值，如10、3.14、true、false、a、hello
*2.字面值本质
字面值是有数据类型的：
整型 100
浮点型 3.14
布尔型 true/false
字符型 '中' 'a'
字符串型 "hello"
它在内存中占用空间
字面值就是内存中的一块空间，这一块空间有类型也有值
只有字面值无法重复利用，用过后再用则会开辟新的空间
Java中的所有字符用“单引号”括起来
Java中的所有字符串用“双引号”括起来
*/
public class ConstTest01{
public static void main(String[] args){
System.out.println(10);//整数型字面值
System.out.println(3.14);//浮点型字面值
System.out.println(true);//布尔型字面值
System.out.println(false);
System.out.println('a');//字符字面值
System.out.println("hello");//字符串字面值
System.out.println(10);//开辟出新内存空间
//Error
//System.out.println('AB')
//AB本身不是一个字符而是字符串
System.out.println("A");//这是一个字符串类型
}
}
4.2 变量
/*
关于Java语言中的变量
1.Java中如何定义变量，语法：
数据类型 变量名；
2.如何给变量赋值
变量名 = 值；
3.变量的本质
变量就是内存中的一块空间，这块空间有“类型”、“名字”和“值”
*/
public class VarTest01{
public static void main(String[] args){
//int是一种数据类型，是整型
int a;//相当于在内存中开辟一块空间，这块空间的类型是整型，给这块空间起名为a
//赋值
a = 100；
//通过变量名去访问那块内存
System.out.println(a);
//重复访问那块空间而不开辟新的空间
System.out.println(a);
System.out.println(a);
}
}
/*
深入变量
*/
public class VarTest01{
public static void main(String[] args){
int i=10;//申请一块int类型的空间起名为i，并赋值10
System.out.println(i);
//可重新赋值
i=100;
System.out.println(i);
//变量可以重新赋值，但不能重声明
//在同一个域中(即{}内算一个域)，变量名不能重复声明
//ERROR
//int i=20;此域不能再有int i=xxx
//Java语言中变量必须先声明，再赋值，才能使用,不能int a 之后就输出或者使用，还得赋值
int a;
a=89;
System.out.println(a);
//声明三个变量i1,i2,i3,类型都是int类，i1,i2都没有赋值（初始化），i3赋值456
int i1,i2,i3=456;
System.out.println(i3);//只能输出i3，不能有System.out.println(i1)
}
public static void m1(){
int i=20;//不在同一个域内可声明
}
}
4.3 关于变量的作用域：有效范围，作用范围
记：出了大括号就不认识了
public class VarTest03{
//类体所包含的母域中进行的变量声明可被其子域访问
//因为没出大括号
int m=100;
public static void m1(){
int m=20;
System.out.println(m);//此时输出m为20，Java遵从就近原则
}
public static void m(){
int k=100;
}
public static void main(String[] args){
int i=10;
System.out.println(i);
//ERROR
//无法访问m方法中的k变量
//即不能有System.out.println(k)语句
for(int j=0;j<10;j++){
System.out.println(j);//可访问
}
//ERROR
//System.out.println(j);j是在for循环中
int j;
for(j=0;j<10;j++){
System.out.println(j);//此时的j的作用域在整个main方法中
}
System.out.println(j);//此时的j的作用域在整个main方法中，可访问j
}
}
/*
* 根据出现的位置可以将变量分为两种
* 局部变量：在方法体中声明的变量，包括形式参数列表
* 成员变量：在类体中，方法体之外声明的变量统称成员变量
*/
public class VarTest04{
//成员变量
int i=10;
//成员变量
int m;//此时m被系统默认赋值为0
public void m1(int m){//m也是局部变量
int k=1;
}
public void m2(){
System.out.println(m);//m值为0
}
public static void main(String[] args){
VarTest04 vt=new VarTest04();
vt.m2();
}
}
4.4 字符
/*
*关于char类型
* char是字符类型，Java中采用UNICODE编码
* 底层占用两个字节
*
* char类型设计到编码方式：
*
* 1.字符编码方式是现实世界中文字和计算机的表示方式的转换规则
* ASCII：
* 'a'->97
* 'A'->65
* '0'->48
* ISO-8859-1
* GB2312<GBK<GB18030
* unicode UTF-8 UTF-16 UTF-32
*
* 2.字符如果采用的编码和解码不一致的话，会出现乱码
*/
public class CharTest{
public static void main(String[] args){
char c1='a';
//ERROR
//char c2='ab';
char c3='中';//汉字占两个字节，所以Java中的char可以存储一个汉字
System.out.println(c1);
System.out.println(c3);
}
/*
关于转义字符
*/
public class CharTest02{
public static void main(String[] args){
//右斜线在Java语言中有转义功能，可以将普通t字符，转换成制表符Tab
char c1='\t';
System.out.print(c1);
System.out.println("abc");
//这是一个普通的‘单引号’字符
char c2='\'';
System.out.println(c2);
//这是一个‘右斜杠\’字符
char c3='\\';
System.out.println(c3);
//双引号字符
char c4='\"';
System.out.println(c4);
//这是一个普通的换行符
char c5='\n';
System.out.println('abc');
System.out.println(c5);
System.out.println('def');
char c6='中';
char c7='\u4e2d';//'中'对应的unicode码是4e2d
//查汉字unicode码可用Java安装路径bin中的native2ascii.exe
在命令窗口启动然后输入汉字查询
}
}
/*默认值：
byte，short，int，long 0
float double 0.0
boolean false
char \u0000
*/
4.5 数据类型详解
/*
关于Java语言中的整型数据
byte 1byte(8bit) -128~127
short 2byte
int 4byte
long 8byte
有三种表示方法：
十进制
八进制 以0开头
十六进制 以0x开头
*/
public class DataTypeTest{
public static void main(String[] args){
//十进制
int i1=10;
//八进制
int i2=010;
//十六进制
int i3=0x10;
System.out.println(i1);//结果为10
System.out.println(i2);//结果为8
System.out.println(i3);//结果为16
//java中给出未知类型数值默认为int类型，
若给出的字面值大于int的取值范围，还没赋值就会报错，所以要看数值大小
//将一个int类型100字面值赋值给定义为int类型的i4
int i4=100;
//将一个int类型的123字面值赋值给long类型的l1
//因为int类型容量小于long类型的
//以下程序存在类型转换，只不过叫‘自动类型转换’
long l1=123;
//由于123后有一个L，所以上来就看成是long类型的数据
//所以以下程序没有类型转换，只有普通的赋值运算
long l2=123L;
}
}
4.6 强制类型转换
public class DataTypeTest02{
public static void main(String[] args){
long l1=1000L;
//将long类型转换成int类型，不能自动转换
//即不能有‘int i1=l1；’
//若想要转换，就需要强制类型转换
//加强制类型转换符
//以下程序虽然编译通过了，但是撤销在运行阶段可能损失精度，所以要谨慎
int i1=(int)l1;//大容量向小容量转换，需强制转换类型
//记忆一个规则：如果所赋的整数值没有超出被赋值所定义类型byte或short亦或char的取值范围，
//可以直接将这个整数赋值给所定义类型的变量，也就不必强制转换
}
}
/*
1.类型转换中小容量到大容量转换，小容量的值大小要在小容量类型取值范围内，若大于则要在其数值后加大容量标志，如L
2.大容量到小容量，分两种情况：
（1）在大容量类型的字面值已经确定为大容量类型，即加后缀L或d，需强制转换。
（2）在大容量的值默认为int型时，其值大小在小容量类型取值范围内不需强制转换，而默认为double型时需要强制转换
3.byte short char做混合运算时各自先转换成int类型再做运算
*/
public class DataTypeTest04{
public static void main(String[] args){
byte b1=10;
short s1=20;
int i1=b1+s1;
System.out.println(i1);
//java程序分编译阶段和运行阶段
//编译阶段以下代码它只知道b1+s1的结果是int类型的而不会去运算其得出结果
//由直接被定义成int类型的无法直接赋值给byte类型
byte b2=b1+s1;//此处编译会出错
byte b3=100;//默认的int可编译成功
}
}
5、 运算符
5.1 算数运算符
/*
关于算数运算符
+ 求和
- 相减
* 相乘
/ 相除
++ 自加1
-- 自减1
% 取余、求模
*/
package suanshuyunsuanfu;
public class OperatorTest01{
public static void main(String[] args){
int a=10,b=3;
System.out.println(a+b);//13
System.out.println(a-b);//7
System.out.println(a/b);//3
System.out.println(a*b);//30
System.out.println(a%b);//1
//关于++
int m=10;
m++;
System.out.println("m="+m);//11
//++出现在变量的后面
int k=10;
int e=k++;//出现在后面，k先赋值再自加1
System.out.println("k="+k);//11
System.out.println("e="+e);//10
//++出现在变量前面
int i=10;
int d=++i;//在变量前，i先自加1再赋值给d
System.out.println("i="+i);
System.out.println("d="+d);
}
}
5.2 布尔运算符
/*
* 布尔运算符
* & 逻辑与 两边都是true，结果就是true
* | 逻辑或 只要有一边是true，结果就是true
* ! 取反 !true-->false
* ^ 逻辑异或 两边只要不一致，就是true
*
* && 短路与 用法和&一样
* || 短路或 用法和|一样
*
* 布尔类型两边的算子必须是布尔类型（即true或false的类型），结果也必须是布尔类型
*/
package 布尔运算符;
public class Test01 {
public static void main(String[] args){
//关于短路
int a=10;
int b=10;
System.out.println(a<b & a++>=b);
System.out.println(a);//11
//短路：后面那个表达式不执行
//什么时候发生短路与？第一个算子是false的时候
//什么时候发生短路或？第一个算子是true的时候
System.out.println(b<a || b++>=a);
System.out.println(b);//10
/*通过实验发现，第一个算子是true，而布尔运算符
* 是“ && ”时，后面的算子也会执行；另一种情况也一样
*/
}
}
5.3 赋值运算符
/*
* 关于赋值运算符
* 基本的赋值运算符
* =
*
* 扩展的赋值运算符
* += 追加
* -=
* *=
* /=
*
* += 例子：
* int i=10;
* i += 10; 相当于i = i+10;
*
*/
package 赋值运算符;
public class Test {
public static void main(String[] args){
//基本赋值运算符
int i=10;
System.out.println(i);//10
//追加
i += 10;
System.out.println(i);//20
//-=
i-=5;
System.out.println(i);//15
//*=
i*=3;
System.out.println(i);//45
///=
i/=15;
System.out.println(i);//3
//%=
i%=2;
System.out.println(i);//1
//基本赋值运算符与扩展赋值运算符的区别
byte b=10;
//以下代码编译不通过，因为运算结果是int类型，而=前面是byte类型
//i = i+10;
//以下可编译通过
//语法：扩展赋值运算符不改变运算结果类型，但可能损失精度
b += 10;
System.out.println(b);//20
//编译通过，但严重损失精度
b+=1000;
System.out.println(b);//结果为-4
}
}
5.4 字符串连接符
/*
* 关于字符串连接运算符
* + 运算符可以：
* 1.做加法运算；(+两边都是数字类型，做加法运算)
* 2.做字符串连接(+两边只要有一边是字符串类型，一定做字符串连接)
*/
package 字符串连接运算符;
public class Test {
public static void main(String[] args){
//字符串连接
System.out.println("PI="+3.14);//"PI=3.14"运算结果是字符串类型
int a=10;
int b=12;
System.out.println("a+b=" + (a+b));//a+b=22
System.out.println("a+b=" + a + b);//a+b=1012
System.out.println(a + "+" + b + "=" + (a+b));//10+12=22
}
}
5.5 三目运算符（条件运算符）
/*
* 条件运算符(三目运算符)
* ?:
* 语法：
* Boolean表达式 ? 表达式1 : 表达式2
*
* Boolean表达式的结果是true，那么整个表达是的结果
* 就是表达式1的结果，反之就是表达式2的结果
*/
package 条件运算符;
public class Test {
public static void main(String[] args){
//判断以下语句是否编译通过
boolean sex=true;
//sex?"boy":"girl";//编译不通过，不是语句
//一定要清楚表达式1.2的结果类型，不然可能在定义整个表达式类型是犯错误
String result=(sex?"boy":"girl");
System.out.println(result);
}
}
6、条件控制语句
6.1 if和if else语句
/*
* 条件控制语句(流程控制语句)if...else
* 语法：
* 第一种结构：
* if(boolean表达式){
* java语句;
* }
*
* 第二种结构：
* if(boolean表达式){
* java语句;
* }else{
* java语句;
* }
*
* 第三种结构：
* if(boolean表达式){
* java语句;
* }else if(boolean表达式){
* java语句;
* }else if(boolean表达式){
* java语句;
* }else if(boolean表达式){
* java语句;
* }else if(boolean表达式){
* java语句;
* }
*
* 第四种结构：
* if(boolean表达式){
* java语句;
* }else if(boolean表达式){
* java语句;
* }else if(boolean表达式){
* java语句;
* }else if(boolean表达式){
* java语句;
* }else if(boolean表达式){
* java语句;
* }else{
* java语句;
* }
* 注意：在if语句中只要有一个分支执行，则整个if语句结束
* 上面的第二和第四结构可以保证一定有一个分支语句执行，因为他们都有else语句
*/
/*
* 条件控制语句(流程控制语句)if...else
* 语法：
* 第一种结构：
* if(boolean表达式){
* java语句;
* }
*
* 第二种结构：
* if(boolean表达式){
* java语句;
* }else{
* java语句;
* }
*
* 第三种结构：
* if(boolean表达式){
* java语句;
* }else if(boolean表达式){
* java语句;
* }else if(boolean表达式){
* java语句;
* }else if(boolean表达式){
* java语句;
* }else if(boolean表达式){
* java语句;
* }
*
* 第四种结构：
* if(boolean表达式){
* java语句;
* }else if(boolean表达式){
* java语句;
* }else if(boolean表达式){
* java语句;
* }else if(boolean表达式){
* java语句;
* }else if(boolean表达式){
* java语句;
* }else{
* java语句;
* }
* 注意：在if语句中只要有一个分支执行，则整个if语句结束
* 上面的第二和第四结构可以保证一定有一个分支语句执行，因为他们都有else语句
*/
package 条件控制语句ifelse;
public class Test {
public static void main(String[] args){
boolean isSuccess=true;
if(isSuccess){
System.out.println("登录成功");
}else {
System.out.println("登录失败");
}
if(isSuccess)//分支语句中，如果只有一条java语句，可把{}去掉
// 不推荐这样写，能看懂别人这样就够了，这样可读性不高
System.out.println("登录成功");
else
System.out.println("登录失败");
}
}
练习
/*
* 需求：
* 1.系统给定人的年龄。[1-100]
* 2.系统给定程序，通过人的年龄，来判断这个人处于哪个生命阶段
* [1-5] 幼年
* [6-16] 少年
* [17-25] 青少年
* [26-35] 青年
* [36-60] 中年
* [61-100] 老年
*/
package 条件控制语句ifelse;
import java.util.Scanner;
public class Test01 {
public static void main(String[] args){
Scanner scanner=new Scanner(System.in);
int i=scanner.nextInt();
if (i>100 && i<1){
System.out.println("错误");
}else if(i>=1 && i<=5){
System.out.println("幼年");
}else if(i<=16){
System.out.println("少年");
}else if(i<=25){
System.out.println("青少年");
}else if(i<=35){
System.out.println("青年");
}else if(i<=60){
System.out.println("中年");
}else if(i<=100){
System.out.println("老年");
}
}
}
简便的输出方法：
即在13行赋一个字符串型变量grade：String grade=“老年”；
幼年处改为grade=“幼年”，其余的也按规律改，在最后输出System.out.println("grade");
判断是否老年的语句可省略。
6.2 switch分支语句
/*
* 关于switch语句
* 1.语法
* switch(int类型值){
*
* case int类型值:
* java语句;
* java语句;
* break;
*
* case int类型值;
* java语句;
* java语句;
* break;
*
* case int类型值;
* java语句;
* java语句;
* break;
*
* default:
* java语句;
* }
* 思路： switch的int类型值与第一个case的int类型值匹配，成功的话
* 就执行其中的语句，遇到break，停止执行程序；如没有break，不用
* 匹配第二个case的int类型值直接执行第二个的语句；
* 当无法匹配所有case的int类型时就执行default的语句
*
* break;语句可以没有，有的话，只要程序执行碰到break下面的
* case中的语句就不执行了；没有的话，就发生case穿透现象；
* default 语句也可以没有
*
* switch后面的括号中可以填byte/short/char类型，因为可自动转换成int类型
* 具体还可以放什么类型可以根据自己的jdk版本决定
*
*/
package 条件控制语句switch;
public class Test01 {
public static void main(String[] args){
/*错误示范
long a=1000L;
switch (a){
case 100:
System.out.println("good");
}*/
char c='B';
switch(c){
/*
case 'A':
System.out.println("优秀");
break;
case 'B':
System.out.println("良好");
break;
case 'C':
System.out.println("及格");
break;
case 'D':
System.out.println("不及格");
break;
default:
System.out.println("不及格");
//输出为“良好”-->当char='B'
* 优秀-->当char='A'
*/
//case穿透
/* case 'A':
System.out.println("优秀");
case 'B':
System.out.println("良好");
case 'C':
System.out.println("及格");
break;
case 'D':
System.out.println("不及格");
break;
default:
System.out.println("不及格");
*/
/*输出为：
* 良好
* 及格
*/
//case可以合并
case 'A':case 'B':case 'C':
System.out.println("优秀");
break;
case 'D':
System.out.println("不及格");
//输出为：优秀-->当char='A' or 'B' or 'C'
// 不及格-->当char='D' or 其他
}
}
}
/*
* 需求：
* 1.系统给定学生的成绩，成绩可以带小数。[0,100]
* 2.编写程序根据学生成绩判断学生成绩等级
* [90,100] 优秀
* [70,90) 良好
* [60,70) 及格
* [0,60) 不及格
* 只允许使用switch语句
*/
package 条件控制语句switch;
import java.util.Scanner;
public class Test02 {
public static void main(String[] args){
Scanner input=new Scanner(System.in);
double core = input.nextInt();
int grade=(int)core/10;//将成绩除10在强制转换成int型，即9.5会转换成9这样子
switch(grade){
case 9: case 10:
System.out.println("优秀");
break;
case 7: case 8:
System.out.println("良好");
break;
case 6:
System.out.println("及格");
break;
default:
System.out.println("不及格");
}
}
}
7、循环语句
7.1 for循环
/*
* for循环
* 语法：
* for(表达式1;表达式2;表达式3){
* java语句;
* }
*
* 表达式1是初始化表达式，最先执行，只执行一次
* 表达式2必须是Boolean类型表达式。
*
* for循环开始执行，先执行表达式1，只执行一次；
* 进而判断表达2的结果，结果是true，则执行java语句，
* 再执行表达式3，然后再转到表达式2判断true或false；一直循环
* 直到表达式2为false，整个for循环结束
*/
package 条件控制for循环;
public class Test01 {
public static void main(String[] args){
//死循环
/*for(;;){
System.out.println("Good");
}得出三个表达式都不是必要的*/
for(int i=0;i<10;i++){
System.out.println("i="+i);
}
int k;
for (k=0;k<1953;k+=10){
System.out.println("k="+k);
}
}
}
/*
* 关于for的嵌套
*
* 所有的控制语句都可以嵌套在一起使用
*/
/*
* 关于for的嵌套
*
* 所有的控制语句都可以嵌套在一起使用
*/
package 条件控制for循环;
public class Test02 {
public static void main(String[] args){
for(int i=0;i<5;i++){
for(int j=0;j<i;j++){
System.out.print(i*j+" ");
}
//换行
//System.out.println();
System.out.println("\n");
}
}
}
练习题
//输出九九乘法表
package 条件控制for循环;
public class Test03 {
public static void main(String[] args){
for(int i=1;i<10;i++){
for(int j=1;j<=i;j++){
System.out.print(j+"*"+i+"="+(i*j)+" ");
}
System.out.println();
}
}
}
//1到100所有奇数求和
package 条件控制for循环;
public class Test04 {
public static void main(String[] args){
int sum=0;
/*
for(int i=1;i<100;i++){
if(i%2!=0){
sum+=i;//sum=sum+i
}
System.out.println(sum);
}*/
//下面有人为因素，但效率高
for(int j=1;j<=99;j+=2){
sum+=j;
}
System.out.println(sum);
}
}
7.2 while循环
/*
* 关于while循环
* 语法:
* while(bollean表达式){
* Java语句;
* }
*/
package 条件控制while;
public class Test01 {
public static void main(String[] args){
//死循环
/*while(true){
System.out.println("神之力量无敌");
}*/
/*
int i=0;
while(i<10){
i++;
System.out.println(i);//输出1 2 ... 9 10
}*/
int i=0;
while(i<10){
System.out.println(i);//输出0 1 ... 8 9
i++;
}
}
}
/*
* do..while..
* 语法:
* do{
* java语句;
* }while(boolean表达式);
* 该循环执行的次数是1-N次
*/
package 条件控制dowhile;
public class Test01 {
public static void main(String[] args){
int i=0;
do{
i++;
System.out.println(i);
//++i放这输出不一样
}while(i<10);
}
}
7.3 break语句
/*
* break;语句:
* 1.可以用在switch语句中，结束分支语句
* 2.break;语句可以出现在循环当中，默认结束离它最近的循环
*/
package 条件控制break;
public class Test01 {
public static void main(String[] args){
for(int i=0;i<10;i++){
System.out.println(i);
if(i==5){
break;//输出0 1 2 3 4 5 结束的是离它最近的循环
//return;若break换成return，结束的是main方法
//输出没有hello world
}
}
System.out.println("hello world");
}
}
/*
* 深入break
*/
package 条件控制break;
public class Test02 {
public static void main(String[] args){
Outfor: for(int i=5;i>0;i--){
for(int j=0;j<i;j++){
if(j==2){
break Outfor;
//可以给循环命名，且break后直接加其名字指定结束某个循环
}//continue也类似
System.out.println(j);//0 1
}
}
}
}
7.4 continue语句
/*
* continue
*/
package 条件控制continue;
public class Test {
public static void main(String[] args){
for(int i=0;i<10;i++){
if(i==5){
continue;
}
System.out.println(i);//结果为0 1 2 3 4 6 7 8 9
//continue语句可用来结束当前本一次的循环
//即执行了continue直接执行表达式3，continue后的不执行了
}
}
}
8、方法（函数）
8.1 方法的定义
package jiangtang.com.j方法初步;
/*
* 引入方法计算两个数的求和
* 什么是方法？
* 方法就是一段代码片段，其可以完成特定的功能，并且可重复利用
*/
public class MethodTest1 {
//入口
public static void main(String[] args){
//在main方法中调用sumInt方法，完成功能
//注意：加有static的方法，调用时必须采用"类名."的方式调用
MethodTest1.sumInt(10,20);
MethodTest1.sumInt(100,20);
MethodTest1.sumInt(101,201);
MethodTest1.sumInt(1011,250);
}
//在类体中定义一个方法，完成两数的求和
//注意：目前所有的方法定义成public static.以后会讲
public static void sumInt(int a,int b){
int c=a+b;
System.out.println(a+"+"+b+"="+c);
}
}
package jiangtang.com.j方法初步;
/*
* 定义方法的语法：
*
* [方法的修饰符列表] 方法返回值类型 方法名(方法的形式参数列表){
* java语句；
* }
*
* 1.[方法的修饰符列表]是可选项。现在暂时先写成public static
* 2.方法的返回值类型，可以是java语言中的任何一种数据类型(基本和引用数据类型)
* 3.如果该方法执行结束之后，没有任何返回值，定义方法时，返回值类型写：void
* 4.方法名只要是合法标识符即可
* 5.方法的形式参数列表，可以有参数，也可以没有参数，如果有多个参数用逗号隔开
*
* public static void m1(){}
* public static 修饰符
* void 该方法执行后没有返回值
* m1 就是方法名
* 没有形式参数
*
* public static int m2(int a,boolean b){}
* public static 修饰符
* int 该方法执行后返回值为int型
* m2 就是方法名
* int a,boolean b 是形式参数列表
*
* 6.如果一个方法的返回值类型不是void,那么在方法体中必须使用return
* 来返回数据，return语句一旦执行，则方法结束
*/
public class MethodTest2 {
public static void main(String[] args){
//方法调用
MethodTest2.println("新年好呀，新年好呀，我们大家新年好");
}
//定义方法
//方法的形式参数列表中起决定性作用的是参数的类型
//参数的名字(局部变量的名字)是随意的只要是合法标识符
public static void println(String mge){
System.out.println(mge);
}
}
8.2 方法的重载
package jiangtang.com.k方法的重载;
/*
* 关于方法重载(Overload)
*
* 以下程序使用方法重载，分析优缺点：
* 1.程序员只需要记忆很少的方法名，方便调用
* 2.代码更加美观
*
* 什么时候会发生方法的重载？
* 1.发生在同一个类中
* 2.方法名相同
* 3.参数列表不同(类型、数量、类型顺序)
* 4.和返回值类型无关
* 5.和修饰符列表无关
*/
public class Test1 {
//入口
public static void main(String[] args){
//对于程序员来讲只需要记忆一个方法名
System.out.println(Computer.sum(10,20));//是Computer.而不是Test01.
System.out.println(Computer.sum(10.2,20.3));
System.out.println(Computer.sum(10l,20l));
//分析System.out.println()是否构成方法的重载？
System.out.println(10);
System.out.println(3.14);
System.out.println(true);
System.out.println("hello world");
//System.out是sun提供的PrintStream类型
//println是printString类型的方法，该方法已经构成了重载
}
}
class Computer{
public static int sum(int a,int b){
return a+b;
}
public static double sum(double a,double b){
return a+b;
}
public static long sum(long a,long b){
return a+b;
}
}
8.3 方法的执行原理
package jiangtang.com.l方法的执行过程;
/*
* 使用图形画出以下程序的执行流程
*
* 方法的执行原理：
* 方法在调用的时候，才会给该方法在内存中分配空间。
* 如果这个方法只是定义没有调用，则不会在内存中分配空间
*
* 方法在调用的时候在“栈”中分配空间。(JVM内存中有一块内存是栈内存)
* 方法调用其实就是“压栈”
* 方法结束其实就是“弹栈”
*/
public class MethodProcess {
public static void main(String[] args){
int i=100;//局部变量，只在main方法中有效
m1(i);//压栈时，把i=100原原本本的复制给了m1中的局部参数变量i
System.out.println("hello world");//4.执行到此语句main方法结束
}
public static void m1(int i){
m2(i);//3.执行此调用语句m1方法结束
System.out.println("m1方法中的i="+i);
}
public static void m2(int i){
m3(i);//2.执行此调用语句m2方法结束
System.out.println("m2方法中的i="+i);
}
public static void m3(int i){
System.out.println("m3方法中的i="+i);//1.弹栈时，执行此java语句，然后m3方法结束
}
}
8.4 方法的递归
package jiangtang.com.m方法的递归;
/*
* 不使用递归计算1-N的求和
*/
public class Test {
public static void main(String[] args){
//非递归
int n=1999;
int A=m1(n);
System.out.println(A);
//递归
int m=1999;
int B=m1(m);//使用该方法完成1-N的求和
System.out.println(A);
}
//非递归
public static int m1(int n){
int sum=0;
for(int i =1;i<=n;i++){
sum+=i;
}
return sum;
}
/*
* 使用递归计算1-N的求和
*/
//该方法完成1-N的求和
public static int m2(int m){
if (m==1){
return 1;
}else{
return m+m2(m-1);
}
}
}
递归原理图
9、公共类和非公共类
package jiangtang.com.公共类与非公共类;
public class A {
public static void main(String[] args) {
System.out.println("A is a public class");
}
}
class B {
public static void main(String[] args) {
int a = 10;
System.out.println(a);
System.out.println("B is a class");
}
}
