Java第四天学习内容：
掌握方法的定义和使用以及IDEA的使用
一、IDEA集成开发工具
IDEA安装：看文档步骤一步一步的进行即可
1.IDEA项目结构
Project(项目、工程)
–Module(模块)
–Package(包)
–Class(类)
–Class(类)
…
–Package(包)
– Class(类)
– Class(类)
…
IDEA的项目结构：
2.创建项目：详细步骤见下图
1)新建Project(项目)
2)新建Module(模块)
3)新建Package(包)
4)新建Class(类)
编写源代码
5)编译：自动编译
6)运行：右键–>Run
或者 点击工具栏 【绿色三角形按钮】
创建Project项目
创建Module模块
创建Package模块
创建Class类
例如：
运行代码
方式1：右键运行
方式2：工具栏按钮运行
在已有的项目中创建Module
从已有项目中删除Modlue
注意：删除只是从IDEA当中删除，并没有从硬盘中删除
如果想删除的更彻底，建议手动找到项目所在硬盘中的位置，把Module删除
从项目中导入Modlue
后面一路下一步即可
==注意：导入Module不能和已有的Module重名 ==
关闭项目
打开已有的项目
删除已有的项目
找到项目所在硬盘的路径，在系统中删除
3.IDEA的设置
1)字体大小设置
IDEA界面的字体大小：File–>Setting–>Appearance–> 字体(Consolas)–>字号(12)
编辑区域字体大小：File–>Setting–>Editer–>Font–>字体(Consolas)–>字号(12)
2)功能辅助键配置(alt+/)
File–>Setting–>keymap–>Main menu–>Code–>Complention
–>Basic(双击)–>Remove ctrl+空格
–>Basic(双击)–>Add keyboard shortcut
4)常用的快捷键
psvm+alt+/ 自动完成主方法
sout+alt+/ 自动完成打印语句
ctrl+/ 单行注释(取消)
ctrl+shift+/ 多行注释(取消)
ctrl+d 复制代码
ctrl+alt+L 格式化代码
shift+f6 重命名
5)修改快捷键
如果有快捷键用不了，可以自己配置快捷键
File–>Setting–>keymap–>找放大镜(搜索你要改的快捷键)
(双击)–>Remove 原来捷键
(双击–>Add keyboard shortcut 添加自己快捷键
注意：如果快捷键弄乱了，可以恢复默认设置
File-->Setting-->keymap-->小齿轮-->Restore Defaults
6)修改注释的颜色
File–>Setting–>Editor–>Color Scheme–>Language Defaults–>Comments–>
Block comment 多行注释
Line comment 单行注释
Doc comment 文档注释
7)IDEA可以安装一些插件（扩展功能）
File–>Setting–>Plugins–>Browse Repositories–>搜索插件名称–>Install安装即可–>重启IDEA生效
二、方法的定义和使用
方法：可以对特定功能的代码进行封装，提高代码的复用性
方法的定义格式
修饰符 返回值类型 方法名(形式参数){//小括号内容可为空
方法体;
return 返回值;
}
格式解析：
修饰符：public static
返回值类型: 方法执行完后，结果的数据类型
方法名：自己取名（见名知意，小驼峰）
形式参数：方法执行需要哪些数据
方法体： 完成功能的代码
return : 结束方法，并带回结果
如果返回值类型是void类型表示该方法没有返回值，可以有return;但return后面不能有任何值(如return a;)
方法定义的注意事项
1)方法不调用不执行
2)方法不能嵌套定义
3)方法定义没有顺序(但方法的调用有顺序)
4)方法调用的时候，形式参数和实际参数要一一对应
形式参数：定义方法时(int a,int b)里面的参数(要指明形参的类型)
实际参数：调用方法时(3,4)里面传递的参数(即根据形参的类型和个数，在main方法中调用该方法时传入具体参数)
总结：实际参数用来给形式参数赋值(或者可理解为实参就是形参的具体实例)
【形参：(int a,int b)表示：给我两个int类型的数值a和b
实参：(3,4)表示：好的，我赋值给你例如这两个数值3和4就是你想要的数值】
5)一个方法如果有返回值类型，必须写return语句
如果返回值类型是void类型表示该方法没有返回值，但可以有return;但不能是return a;（a是数据值)
(static修饰的方法叫静态方法，可以直接在main方法中调用，如果方法还含有void关键字修饰，就只能单独调用，不可输出调用或赋值调用)
调用方法的三种方式：
a.单独调用
//在main方法中调用的格式
方法名();//方法没有形参时，调用该方法时就不用传入实参
方法名(实参);//方法有形参时，调用该方法时就要传入实参
b.打印(输出)调用
//在main方法中调用的格式
System.out.println(方法名(实参));//方法有形参时，调用该方法时就要传入实参
System.out.println(方法名());方法没有形参时，调用该方法时就不用传入实参
c.赋值调用
数据类型 变量名 = 方法名();
数据类型 变量名 = 方法名(实参);
System.out.println(变量名 );
代码测试：
package com.itheima01;
public class Demo04 {
public static void main(String[] args) {
//程序执行从main方法开始，执行顺序：从上到下
test01();//该方法时void修饰的方法-->直接调用
System.out.println("---------------");
test02( 10);//传入一个实参：10//该方法时void修饰的方法-->直接调用
System.out.println("------求1~100之间的偶数和---------");
test03();//直接调用(由该方法知只是调用该方法执行，并不会打印结构)
System.out.println(test03());//输出(打印)调用
int enensum = test03();//赋值调用//调用方法test03()，返回一个int类型的结果并赋值给enensum
System.out.println("1~100之间的偶数和："+enensum);
System.out.println("-------------------");
int num = printFlower();
System.out.println("水仙花数有"+num+"个");//赋值调用//如果方法没有返回值是不能在打印语句中写方法名的
System.out.println("------------");
System.out.println("质数的个数有："+primeNmu(100)+"个");//赋值调用//privameNmu()方法是void类型的方法没有返回值就不能写在打印语句中
System.out.println("**********************");
printPrimeNum( 100);
}
//循环打印出10个“HelloWorld”
public static void test01(){
for (int i = 0; i < 5; i++) {
System.out.println("HelloWorld...!");
}
}
//打印输出n个我爱Java
public static void test02(int n){
for (int i = 0; i < n; i++) {
System.out.println("我爱Java！ -->"+i);
}
}
//打印1~100之间的偶数和，并把结果返回
//偶数：enen，和：sum
public static int test03(){//返回一个int类型的结果
int total=0;
for (int i = 1; i <=100; i++) {//如果for循环的条件判断语句中只有两个;，那么这个循环就是死循环
if(i%2==0){
total += i;
}
}
return total;//返回total是一个int类型结果
}
//求100~999水仙花的个数，并打印出来
public static int printFlower(){
int count = 0;
for (int i = 100; i <= 999; i++) {
int a = i%10;
int b = i/10%10;
int c = i/100%10;
if(i==(a*a*a+b*b*b+c*c*c)){
System.out.println("水仙花数有："+i);
count++;
}
}
// System.out.println("水仙花数有："+count+"个");
return count;//没有返回值是不能有返回语句的
}
//打印1~n之间的质数
//prime：质数，数字：num
public static int primeNmu(int n){//传入一个int类型的形式参数n（参数的类型与该方法是否有无返回值类型无关）
int count=0;
for (int i = 2; i <= n; i++) {
int j;
boolean flag = true;
for( j = 2;j<i;j++){//j<=i?
if(i%j==0){//内层循环找出一个比i小数j能否整除i
flag=false;//内层循环中如果判断条件j=i，flag就为false，这样下面的if语句就不会执行
break;
}
}
if(flag){//j==i
System.out.println(i+"是质数");
count++;
}
}
return count;
}
//参考代码
public static void printPrimeNum(int n){
//1不是质数，从2开始
for (int i = 2; i < n; i++) {
//判断整数 i 是否为质数
//只要i 能被 2~(i-1)当中的任意一个数整数，就说明i不是质数
boolean flag=true; //true 表示i为质数
for(int j=2;j<=i-1;j++){
if(i%j==0){
flag=false;
break;
}
}
if(flag){
System.out.println(i+"是质数");
}
}
}
}
在方法中引入参数的意义和作用：
是为了让方法使用起来更加灵活！
举例：写一个方法，求两个整数的和
/*
明确参数和返回值
参数：两个整数，int类型
返回值类型：和，int类型
*/
public static int sum(int a,int b){
int result=a+b;
return result; //求和的结果
}
public static void main(String[] args){
//赋值调用【推荐写法】
int result=sum(3,4);
System.out.println(result); //7
//输出调用
System.out.println(sum(3,4)); //7
}
案例代码：
public class Demo3 {
public static void main(String[] args) {
//定义两个变量，表示矩形的宽和高
int width=4;
int height=8;
//调用方法，求矩形的面积
int result=rectArea(width,height);
System.out.println("矩形的面积为："+result);
//调用方法，求矩形的周长
int perimeter = rectPerimeter(width, height);
System.out.println("矩形的周长为："+perimeter);
//调用方法，求圆形的面积
double area = circleArea(2);
System.out.println("圆形的面积："+area);
}
//写一个方法：求矩形的面积
/*
* 参数：宽和高
* */
public static int rectArea(int width,int hegiht){
int area=width*hegiht;
return area;//area就是int类型的结果
}
//写一个方法：求矩形的周长
public static int rectPerimeter(int width,int hegiht){
int perimeter=(width+hegiht)*2;
return perimeter;
}
//写一个方法，求圆形的面积
public static double circleArea(int r){
//面积公式：3.14*r*r;
return Math.PI*r*r;
}
}
方法的重载：
在同一个类中的多个方法，方法名相同，形参列表不同(即形参的个数和类型不同)，与返回值无关
【方法的重写：一般是子类中对对父类的方法的重新定义】
Java第五天学习内容链接：
https://blog.csdn.net/LJN951118/article/details/88771119
1352
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
