method_01MethDemo
package com.basic.day04.method;
/**
* 方法的定义结构:
* [访问权限修饰词][其他修饰词]返回值类型 方法名(参数列表){
* //方法体
* [return]
* }
*/
public class _01MethDemo {
public static void main(String[] args) {
}
//定义一个方法:返回两个int类型里面变量中最大值
public static int max(int a, int b) {
if (a > b) {
return a;
} else {
return b;
}
}
//定义一个方法,打印两个变量a(int) 和b(long) 的最大值
public static void print(int a,long b){
System.out.println(a+b);
}
}
method_02MethDemo
package com.basic.day04.method;
/**
* 方法的返回值:
* 1. 方法在定义时,必须规定方法的返回值类型是什么
* 2. 方法的返回值类型位置可以书写两大类型
* 第一种方法: void,无类型,表示方法在执行完毕后,不需要返回任何数据
* 第二种类型: java中的任意类型,包括程序员自定义的类型
* 3. return关键字:
* -- 返回,归还的含义
* -- 在方法中,表示结束方法,因此,return后不能有代码,不执行
* -- void类型的方法,return 可加可不加
* -- 返回值类型是其他类型的方法,return后必须跟一个该返回值类型的变量
* 或者表达式。表示方法执行完毕,最终数据返回给调用者。
* <p>
* 注意:谁是调用者 调用该方法的所在处就是调用者
*/
public class _02MethDemo {
public static void main(String[] args) {
}
// 定义一个void形式的方法 m1,
public static void m1() {
int a = 1;
int b = 2;
int c = a + b;
return; //return关键字表示方法结束,可加可不加
}
public static int m2() {
int a = 1;
int b = 2;
byte c = (byte) (a + b);//隐式转换
return c;
}
public static String m3() {
int a = 1;
int b = 2;
int c = a + b;
return c+"";
}
}
method_03MethDemo
package com.basic.day04.method;
/**
* 方法的参数列表:
* 1. 参数列表具体指的是定义期间方法名后的参数类型列表
* 类型非常重要,列表指的是从左到右的顺序
* 名字不重要
* 2. 参数列表的语法: 是0个以上的变量的声明语法。没有初始化操作
* 3. 参数列表里的参数名,称为形式参数,简称形参。
* 4. 形式参数用于规定调用者在调用期间需要传入的数据的具体类型
* m1(int a, long b ,String c);
* <p>
* <p>
* <p>
* 拓展知识点:
* 方法签名: 方法名+参数类型
* 比如 m1(int a, long b ,String c)的方法签名: m1(int, long,String)
* 在同一个类体重,不能存在方法签名相同的方法
* m1( String a,long b,int c) m1(String,long,int)
* <p>
* 5. 方法的重载:
* 同一个类中,方法名相同,参数类型列表不同(方法签名不同)
*/
public class _03MethDemo {
public static void main(String[] args) {
}
//案例1:
public static void m1() {
System.out.println("m1方法");
}
//案例2:方法签名 : m2(int)
public static void m2(int a) {
System.out.println("m2方法" + a);
}
//案例3:方法签名 : m3(long)
public static void m3(int a) {
System.out.println("m3方法" + a);
}
//是上面m3的重载方法
public static void m3(int a, int b) {
System.out.println("m3方法" + a);
}
//定义方法:计算三个数中的最大值
public static int max(int a, int b, int c) {
int max = Integer.MIN_VALUE; //int 的最小值
if (a > b && a > c) {
max = a;
} else if (b > a && b > c) {
max = b;
} else {
max = c;
}
return max;
}
}
method_04MethDemo
package com.basic.day04.method;
/**
* 方法的调用: 没有学习面向对象之前 方法都用static修饰。
* 1. 调用语法: 方法名(有参传参)。
* 注意: viod修饰的方法,一般都是上述语法调用
* 其他返回值类型的方法,一般都是如下形式
* 返回值类型 变量 = 方法名(有参传参)
*/
public class _04MethDemo {
public static void main(String[] args) {
/* 先演示没有形参列表的方法调用*/
// void 形式的方法调用
System.out.println("前");
myMeth1();
System.out.println("后");
// 返回值是java类型的方法调用
int sum = myMeth2();
System.out.println("sum = " + sum);
System.out.println( myMeth2());
}
public static void myMeth1() {
int a = 10;
int b = 20;
int c = a + b;
System.out.println("a + b = " + c);
}
//计算1~100的和
public static int myMeth2() {
int sum = 0;
for (int i = 1; i < 101; i++) {
sum += i;
}
return sum;
}
}
branch_Exercise01
package com.basic.day04.branch;
import java.util.Scanner;
/**
* 开启控制台扫描功能,扫描两个数字
* year :表示年份
* month :月份
* <p>
* 打印 输入的年份 是否闰年还是平年
* 打印 输入的月份 是多少天。
* 样式:
* "2004是闰年,8月份有31天"
* <p>
* 闰年条件: 被4整除,不能被100整除
*/
public class Exercise01 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个年份");
int year = sc.nextInt();
System.out.println("请输入一个月份");
int month = sc.nextInt();
//return: 用于结束当前方法,也不用再继续执行后续代码
if (year % 4 == 0 && year % 100 != 0) {
System.out.println(year + "闰年");
} else {
System.out.println(year + "平年");
}
switch ((int) month) {
case 1:
case 3:
case 5:
case 7:
case 8:
case 10:
case 12:
System.out.println(month + "有31天");
break;
case 4:
case 6:
case 9:
case 11:
System.out.println(month + "有30天");
break;
}
if (year % 4 == 0 && year % 100 != 0) {
System.out.println(month + "有29天");
} else {
System.out.println(month + "有28天");
sc.close();
}
}
}
branch_Exercise02
package com.basic.day04.branch;
import java.util.Scanner;
/**
* 开启控制台扫描功能,扫描两个数字
* year:表示年份
* month:月份
* <p>
* 打印 输入的年份 是闰年还是平年
* 打印 输入的月份 是多少天
* <p>
* 样式: "2004是闰年,8月份有31天"
*/
public class Exercise02 {
public static void main(String[] args) {
//开启控制台扫描功能
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个有效年份:");
int year = sc.nextInt();
System.out.println("请输入一个有效月份:");
int month = sc.nextInt();
if (month < 1 || month > 12) {
System.out.println("输入不合理");
return; //关键字 用于结束所在的方法,也就是不再继续执行后续的代码
}
String str = "";
//定义一个变量flag,初始化为false,默认认为是平年
boolean flag = false;
if (year % 4 == 0 && year % 100 != 0 || year % 400 == 0) {
str = "闰年";
flag = true;//表示闰年
} else {
str = "平年";
}
switch (month) {
case 1:
case 3:
case 5:
case 7:
case 8:
case 10:
case 12:
System.out.println(year + "是" + str + "," + month + "有31天");
break;
case 4:
case 6:
case 9:
case 11:
System.out.println(year + "是" + str + "," + month + "有30天");
break;
case 2:
if (flag == true) { //括号里的表达式整体的返回值是true
System.out.println(year + "是" + str + "," + month + "有29天");
} else {
System.out.println(year + "是" + str + "," + month + "有28天");
}
sc.close();
}
}
}
loop_01ForDemo
package com.basic.day04.loop;
/**循环三要素:
* 1. 循环因子的定义和初始化
* 2. 循环条件
* 3. 循环步长:循环因子要向着循环结束的方向而改变
* 循环结构之for循环:
* 1 2 3
* for(循环因子的声明和初始化;循环条件;循环步长){
* 4循环体
* }
*
* 执行逻辑:
* 成立 成立 不成立
* 1 --> 2 --> 4 --> 3 --> 2 -->4 --> 3 --> 2 -->结束
*/
public class _01ForDemo {
public static void main(String[] args) {
/*使用for循环 打印10次 hello world*/
for (int i = 1; i < 11; i++) {
System.out.println("hello world");
}
/*使用for循环 打印1-10*/
for (int x = 1; x <= 10; x++) {
System.out.println(x);
}
/*使用for循环 打印2-20的偶数*/
for (int i = 2; i <= 20; i += 2){
System.out.println(i);
}
}
}
loop_02ForDemo
package com.basic.day04.loop;
/**
* *****
* *****
* *****
* *****
* *****
*/
public class _02ForDemo {
public static void main(String[] args) {
for (int i = 0; i < 5; i++) {
System.out.println("*****");
}
/*使用for循环计算1~100的和*/
int sum = 0;
for (int i = 1; i < 101; i++) {
sum = sum+i;
}
System.out.println(sum);
}
}
loop_03ForDemo
package com.basic.day04.loop;
/**
* for循环的其他写法
* 1. for循环的小括号里除了分号,其他都可以省略
* 2. 循环因子的声明和初始化,可以写在for循环之前
* 3. 循环步长可以写在循环体里
* 4. 循环条件可以不写,默认为true
*
*/
public class _03ForDemo {
public static void main(String[] args) {
//三部分和循环条件都省略,相当于true,死循环 程序避免死循环
/* for( ;; ) {
System.out.println("hello world");
}*/
//循环因子的声明和初始化写在了for循环之前
int i= 1;
for( ; i<10;i++ ) {
System.out.println(i);
}
//循环步长,写在循环体内
for(int m =1;m<10;) {
System.out.println(m);
m+=3; //循环步长
//循环体里面只有一行代码,可以省略花括号
for (int n = 1;n<10;n++)
System.out.println(n);//缩进且一行
//if分支只有一行代码 也可以省略花括号
int x = (int) (Math.random()*2);
int y = (int) (Math.random()*2);
if (x == y)
System.out.println("x==y");
else
System.out.println("x!=y");
}
}
}
loop_04WhileDemo
package com.basic.day04.loop;
/**
* 循环结构之while循环
* 语法:
* while (循环条件){
* 循环体
* }
*/
public class _04WhileDemo {
public static void main(String[] args) {
// 使用while循环打印5次的hello world
// int i = 0; //循环要素声明初始化卸载while之前
// while(i<5){
// System.out.println("hello world");
// i++;//写在循环体里面的循环步长
// }
//2 使用while循环 打印1~100以内能被5整除的数字
int i = 1;
while (i < 100) {
if (i % 5 == 0) {
}
i++;
System.out.println(i);
}
//3 使用while循环,计算1~100以内的能被3整除的数字之和
int sum = 0;
int x = 1;
while (x < 100) {
if (x % 3 == 0) {
sum = sum + x;
x++;
System.out.println(sum);
}
}
/*4使用while循环,判断一个整数,是几位数
19876 /10 1987 5
1987 /10 198 4
198 /10 19 3
19 /10 1 2
1 /10 0 1
*/
int num = 19876;
int count = 1; // 统计循环的次数,除10的次数
while (num /10 != 0) {//判断num是不是一位数,如果不是一位数就可以进入循环,是一位数则输出
num = num / 10;
count++;
}
System.out.println("是" + count + "位数");
}
}
loop_05DoWhileDemo
package com.basic.day04.loop;
import java.util.Scanner;
/**
* 循环结构之do-while循环
* 语法:
* do{
* 循环体
* }while(循环条件);
* <p>
* 特点:
* 先执行一次循环体,然后再判断循环条件是否成立
* 成立再次执行循环
*/
public class _05DOWhileDemo {
public static void main(String[] args) {
//使用for/while,来模拟一次ATM机输入密码操作,五次不正确结束循环。
String realPWD = "123456";
Scanner sc = new Scanner(System.in);
boolean flag = false;//定义一个开关
for (int i = 0; i < 5; i++) {
System.out.println("请输入密码:");
String inputPWD = sc.next();
if (inputPWD.equals(realPWD)) {
System.out.println("密码正确,欢迎进入!");
flag = true;
break;
}
}
if (flag) {
System.out.println("密码正确");
} else {
System.out.println("密码错误5次");
}
}
}
loop_06DeWhileDemo
package com.basic.day04.loop;
import java.util.Scanner;
/**
* 用do-while循环完场——05内容
*
* 总结:for while do-while 的应用场景或者区别
* 1. for循环适合知道循环次数的场景
* 2. while循环适合不知道循环次数的场景
* 3. do-while循环适合先执行循环体,再判断条件的场景, 比如 做一件事直到什么时候结束
*/
public class _06DoWhileDemo {
public static void main(String[] args) {
String str = "123456";
Scanner sc = new Scanner(System.in);
String inputPWD = "";
do {
System.out.println("请输入密码:");
inputPWD = sc.nextLine();
} while (!str.equals(inputPWD));
System.out.println("密码正确");
}
}
loop_07BreakDemo
package com.basic.day04.loop;
import java.util.Scanner;
/**
* 循环结构中的关键字之 break
* <p>
* break:打断,毁坏
* 在循环结构中,表示打断,结束循环,继续向下执行后续代码。
* <p>
* 注意,break只能打断当前所在的那一层循环,不能打断其他循环
*/
public class _07BreakDemo {
public static void main(String[] args) {
//从1开始打印到100,遇见10截止,结束循环
for (int i = 1; i <= 100; i++) {
if (i == 10) {
break;
}
System.out.println(i);
}
//猜数字游戏的模拟
Scanner sc = new Scanner(System.in);
//模拟输入的数字
int answer = (int) (Math.random() * 10);
while (true) {
System.out.println("猜数字");
int guess = sc.nextInt();
if (guess == answer) {
System.out.println("猜对了");
break;//打断跳出
} else if (guess > answer) {
System.out.println("猜大了");
} else {
System.out.println("猜小了");
}
}
}
}
loop_08ContinueDemo
package com.basic.day04.loop;
/**
* 循环结构中关键字只continue
* <p>
* 单词含义:继续
* 在循环结构里面表示终止打断本次循环,继续下一次的循环
*/
public class _08ContinueDemo {
public static void main(String[] args) {
//需求1 计算100以内的偶数和,排除50
int sum = 0;
for (int i = 1; i <= 100; i++) {
if (i == 50) {
continue;
}
if (i % 2 == 0) {
sum += i;
}
}
System.out.println(sum);
}
}
loop_09NextOfLoop
package com.basic.day04.loop;
/**
* 循环的嵌套
* 1. 循环结构是可以进行多层次嵌套的
* 2. 在生产环境中,尽量不要嵌套,因为非常耗性能
* <p>
* <p>
* <p>
* 执行逻辑:
* 外层循环执行一次,内层循环执行一遍(从开始到结束)
*/
public class _09NextOfLoop {
public static void main(String[] args) {
//案例
for (int i = 0; i < 10; i++) {
System.out.println("i=" + i);
for (int j = 0; j < 10; j++) {
System.out.println("j=" + j);
}
}
System.out.println("---------------------------------");
//使用输出语句打印一个*
//打出图形如下 五行五列的*
/*
*****
*****
*****
*****
*****
*/
for (int i = 0; i < 5; i++) {
for (int j = 0; j < 5; j++) {
System.out.print("*");
}
System.out.println("*");
}
//判断 57是不是质数 质数只能被1和本身整除
int num = 47;
boolean found = false;//设置为false
for (int i = 2; i < num; i++) {
if (num % i == 0) {
found = true; //不是质数
break;
}
}
if (found == true) {
System.out.println(num + "不是质数");
} else {
System.out.println(num + "是质数");
}
//打印100以内的所有质数
for (int x = 2; x < 101; x++) {
boolean temp = false; //设置为false
for (int i = 2; i < x; i++) {
if (x % i == 0) {
temp = true; //不是质数
break;
}
}
if (temp == false) {
System.out.println(x + "是质数");
}
}
}
}