Java教程
Java-day-06
本文主要是介绍Java-day-06，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！
package com.yonyou;
import java.util.Scanner;
/**
* 编写for循环找出1~100中所有的素数
* 素数：又被称为质数，能够被1和自身整除，不能被其他数字整除的数字被成为素数
* 该题目主要掌握的知识点：
* * for循环的使用
* * for循环嵌套
* * 编辑
* * break；
* * 统计
*/
@SuppressWarnings("all")
public class ForTest09 {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("--------------------------------------");
System.out.println("获取键盘输入值：");
System.out.println("请输入起始值:");
int start = scanner.nextInt();
System.out.println("请输入结束值:");
int end = scanner.nextInt();
// /**
// * 先编写程序，验证？这个数字是否为素数
// * 构建思路：
// * 7/1【不需要】
// * 7/2【7 % 2】
// * 7/3【7 % 3】
// * 7/4【7 % 4】
// * 7/5【7 % 5】
// * 7/6【7 % 6】
// * 7/7【不需要】
// */
//
// /**
// * 默认将i看做一个素数【0表示素数，1表示非素数】
// */
//
// /**
// * 默认将i看做一个素数【标记在开发中比较常用】
// */
// boolean isSuShu = true;
// for (int j = 2; j < start; j++) {
// /**
// * j是什么：2 3 4 5 6
// */
// if (start % j == 0) {
// /**
// * 非素数
// */
// isSuShu = false;
// /**
// * 已经知道i是非素数，跳出循环
// */
// break;
// }
// }
// System.out.println(isSuShu ? start + "是素数" : start + "不是素数");
// for (int i = start; i <= end; i++) {
// boolean usSuShu = true;
// for (int j = start; j < i; j++) {
// if (i % j == 0) {
// usSuShu = false;
// break;
// }
// }
// if (usSuShu) {
// /**
// * 素数
// */
// System.out.println(i);
// }
// System.out.println();
// }
// /**
// * 升级版：
// * 编写for循环找出1~10000中所有的素数
// * 要求每8个换一行输出
// */
// for (int j = start; j < i; j++) {
// if (i % j == 0) {
// usSuShu = false;
// break;
// }
// }
// }
/**
* 升级版【加入统计机制]
*/
int count = 0;
for (int i = start; i <= end; i++) {
/**
* 判断的这段代码只判断i是否为素数
*/
boolean isSuShu = true;
for (int j = start; j < i; j++) {
if (i % j == 0) {
isSuShu = false;
break;
}
}
if (isSuShu) {
count++;
System.out.println(i + "\t");
if (count == 8) {
System.out.println();
/**
* 归0
*/
count = 0;
}
}
}
System.out.println("--------------------------------------");
}
}
package com.yonyou;
import java.util.Scanner;
/**
* 以下程序不使用”方法“，分析程序存在哪些缺点？
* * 一下的代码都是完成两个int类型数据的和，相同的代码写了三遍(只不过每一次参与求和的数据不同)
* 代码没有得到重复使用
* * 应该在Java语言当中有这样的一种机制：
* - 某个功能代码只需要写一遍
* - 要使用这个功能，只需要给功能传递具体的数据
* - 这个功能完成之后返回一个最终的结果
* 这样代码九可以重复利用了，提高代码复用性【这就是方法】
* * 使用这个方法我们成为调用
*/
@SuppressWarnings("all")
public class MethodTest01 {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("--------------------------------------");
System.out.println("获取键盘输入值：");
System.out.println("请输入起始值:");
int start = scanner.nextInt();
System.out.println("请输入结束值:");
int end = scanner.nextInt();
System.out.println("--------------------------------------");
/**
* 需要1：请编写程序计算10和20的和，并将结果输出
*/
int numc = start + end;
System.out.println(start + "+" + end + "=" + numc);
/**
* 需求2：编写程序计算666和888的和，并将结果输出
*/
int starts = start * 100;
int ends = end * 100;
int numcs = starts + ends;
System.out.println(starts + "+" + ends + "=" + numcs);
/**
* 需求：编写程序计算111和222的和，并将结果输出
*/
int startsh = start * 111;
int endsh = end * 111;
int numcsh = starts + ends;
System.out.println(startsh + "+" + endsh + "=" + numcsh);
/**
* 以上的三个需求其实就是一个需求，
* 这个需求是：计算两个int类喜欢那个的和，功能相同。
* 只不过每一次参与计算的具体数据不同
*/
System.out.println("--------------------------------------");
}
}
package com.yonyou;
import java.util.Scanner;
/**
* 以下直接使用方法这种机制，分析程序的优点？
* 方法的本质是什么？
* * 方法就是一段代码片段，并且这段代码片段可以完成某个特定的功能，并且可以被重复的使用。
* 方法，对应的英语单词为：method
* 方法在c语言叫做函数/Function
* 方法定义子啊类体当中。在一个类当中可以定义多个方法，方法编写的位置没有先后顺序，可以随意。
* 方法体当中不能再定义
* 方法体由Java语句构体，方法体当中的代码遵守自上而下的顺序依次执行
*/
@SuppressWarnings("all")
public class MethodTest02 {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("--------------------------------------");
System.out.println("获取键盘输入值：");
System.out.println("请输入起始值:");
int start = scanner.nextInt();
System.out.println("请输入结束值:");
int end = scanner.nextInt();
System.out.println("--------------------------------------");
/**
* 单独的定义一个方法
* 该方法完成计算两个int类型数据的和，并且将结果输出
*/
MethodTest02.sumInt(start, end);
System.out.println("--------------------------------------");
}
public static void sumInt(int a, int b) {
int c = a + b;
System.out.println(a + "+" + b + "=" + c);
}
}
package com.yonyou;
import java.util.Scanner;
/**
* 关于java语言当中的方法：
* 1、方法怎么定义，语法结构：
* 【修饰符列表】返回值类型 方法名（形式参数列表）{
* 方法体；
* return
* }
* 2、对以上的语法结构进行解释说明：
* 2.1、关于修饰列表
* * 可选项，不是必须的
* * 目前统一写成：public static
* * 方法的修饰符列表当中有static关键字的话，怎么调用这个方法？
* - 类名的方法名(实际参数列表)；
* 2.2 返回值类型
* * 什么是返回值？
* 一个是可以完成某个特定功能的，这个功能结束之后大多数都是需要返回最终执行结果的，执行结果可能是一个具体存在的数据。
* 而这个具体存在的数据就是返回值
* * 返回值类型？
* 返回值是一个具体存在的数据，数据都是由类型的，此处需要使用指定的返回值的具体类型。
* * 返回值类型都可以指定那些雷丁呢？
* java任意一种类型都可以，包括基本数据类型和所有的引用数据类型。
* * 也可能这个方法执行结束之后不反悔任何数据，Java中规定，当一个方法执行结束之后不返回任何数据的话，返回值类型位置必须编写，void关键字
* * 返回类型可以是：
* byte,short,int,long,float,double,boolean,char,String,void......
* * 返回值类型若不是void，表示这个方法执行结束之后必须返回一个具体的数值。
* 当方法执行结束的时候没有返回任何数据的话编译器报错,
* 返回值类型是void的时候，在方法体当中不能编写“return”；值：这样的语句，但是要注意
* * 只要带有return关键字的语句执行，return语句所在的方法结束
* 2.3、方法名：
* * 只要是合法的标识符就行
* * 方法名最好见名知意
* * 方法名最好是动词
* * 方法名首字母要求小写，后面每个首字母大写
* 2.4、形式承诺书列表：简易形参
* * 形参是局部变量：int a;double e;float c;String s;.....
* 形参的个数可以是：0-N个
* 多个形参之间用”逗号“隔开
* 形参中起决定性作用是形参的数据类型，形参的名字就是局部变量的名字。
* * 方法在调用的时候，实际给这个传递的真是数据被称为：实际数据，简称
* 2.5、方法体必须由大括号括起来，方法体当中的代码有顺序，遵循自上而下的顺序的依次执行。
* 并且方法体由java语句构成，每一个java语句以”；“结尾
* 3.方法怎么调用？
* 方法只定义不去调用时是不会执行的，只有在调用的时候才会执行
* 语法规则：<>方法的修饰符列表当中static</>
* 类名：方法名（实参列表：这是一条Java语句，表示某个类的某个方法，传播想这样的实参）
*/
@SuppressWarnings("all")
/**
* public表示公开的
* class表示定义类
* MethodTest03表示一个类名
* public class MethodTest03表示定义一个公开的类起名MethodTest03，由于是公开额类型
* 所以源文件名必须：MethodTest03.java
*/
public class MethodTest03 {
/**
* 类体
* 类体中不能直接编写java语句，除声明变量之外
* 方法出现在类体当中
* <p>
* 方法
* public表示公开的
* static表示静态的
* void表示方法执行结束之后不返回任何数据
* main是方法名：主方法
* String[] args：形式参数列表，其中string【】是一种引用数据类型，atgs是一个局部变量的变量名
* 所以以下只有args这个局部变量的变量名是随意的
* 主方法就需要这样编写，这是程序的入口【SUN公司规定的，必须这样写】
*
* @param args
*/
public static void main(String[] args) {
/**
* 获取键盘输入值
*/
System.out.println("--------------------------------------");
Scanner scanner = new Scanner(System.in);
System.out.println("获取键盘输入值：");
System.out.println("请输入起始值:");
int start = scanner.nextInt();
System.out.println("请输入结束值:");
int end = scanner.nextInt();
System.out.println("--------------------------------------");
/**
* 这里的程序是一定会执行的
* main方法是JVM负责调用的，是一个入口位置
* 从这里作用起吊开发执行程序
* 既然是这样，我们就可以在这里编写来调用其他的方法
* 调用
*/
MethodTest03.sumInt(start, end);
/**
* 一个方法可以被重复使用，重复调用
* 再次调用方法
* 注意：方法当中的代码是有顺序的，遵循自上而下的顺序的依次执行
*/
System.out.println("--------------------------------------");
}
/**
* 自定义
* 计算两个int类型参数的合，不要求返回结果，但是要求将结果直接输出到控制台
* 修饰符类型：public static
* 返回值类型：void
* 方法名：sumInt
* 形式参数列表：{int x ， int y}
* 方法体：主要任务是求和之后输出计算结果
*/
public static void sumInt(int x, int y) {
/**
* 自定义初始版本结果：直接输出结果的加法
*/
System.out.println(x + "+" + y + "=" + (x + y));
}
}
package com.yonyou;
import java.util.Scanner;
@SuppressWarnings("all")
/**
* 方法的调用不一定在main方法当中，可以在其他方法当中。
* 只要是程序可以执行到额位置，都可以去调用其他方法
*/
public class MethodTest04 {
public static void main(String[] args) {
/**
* 获取键盘输入值
*/
System.out.println("--------------------------------------");
Scanner scanner = new Scanner(System.in);
System.out.println("获取键盘输入值：");
System.out.println("请输入起始值:");
int start = scanner.nextInt();
System.out.println("请输入结束值:");
int end = scanner.nextInt();
System.out.println("--------------------------------------");
MethodTest04.sumInt(start, end);
System.out.println("你好，世界");
System.out.println("--------------------------------------");
}
public static void sumInt(int x, int y) {
/**
* 自定义初始版本结果：直接输出结果的加法
*/
System.out.println(x + "+" + y + "=" + (x + y));
}
public static void doSome() {
System.out.println("do some!");
}
}
package com.yonyou;
import java.util.Scanner;
/**
* 方法调用的时候和形参要求个数进行格式的自动类型转换，数据类型相同
*/
@SuppressWarnings("all")
public class MethodTest05 {
public static void main(String[] args) {
/**
* 获取键盘输入值
*/
System.out.println("--------------------------------------");
Scanner scanner = new Scanner(System.in);
System.out.println("获取键盘输入值：");
System.out.println("请输入起始值:");
int start = scanner.nextInt();
System.out.println("请输入结束值:");
int end = scanner.nextInt();
System.out.println("--------------------------------------");
/**
* 编译错误：参数数量不同
* MethodTest05.sum；
* 更改签名类型的错误问题：MethodTest05.sum(true,false);
*/
MethodTest05.sum(10L, 20L);
MethodTest05.sum(10, 20);
/**
* 编译错误：参数类型不是对应相同的
* MethodTest05.sum(3.0,20);
*/
MethodTest05.sum((long) 3.0, 20);
System.out.println("--------------------------------------");
}
public static void sum(long x, long y) {
System.out.println(x + "+" + y + "=" + (x + y));
}
}
package com.yonyou;
import java.util.Scanner;
/**
* 方法调用:
* 1、方法的修饰列表当中有static关键字，完整的调用方式是：类名.方法名(实参列表)；
* 2、但是，有的时候“类名”.“可以省略，什么情况下㐓省略呢？‘
* m1(){
* m2();
* }
* 吗1方法和m2方法在同一个类当中的时候，”类名.“”可以省略不写“
*/
@SuppressWarnings("all")
public class MethodTest06 {
public static void main(String[] args) {
/**
* 获取键盘输入值
*/
System.out.println("--------------------------------------");
Scanner scanner = new Scanner(System.in);
System.out.println("获取键盘输入值：");
System.out.println("请输入起始值:");
int start = scanner.nextInt();
System.out.println("请输入结束值:");
int end = scanner.nextInt();
System.out.println("--------------------------------------");
/**
* 调用方法
*/
MethodTest06.m();
/**
* 对于方法的修饰符列表当中有static关键字的：“类名：”可以省略不写吗
*/
m();
/**
* 调用其他类【不是本类中的】中的方法
*/
A.doOther();
/**
* 省略“类名.”试试
* 编译报错，“类名。”省略之后，默认从当前中找“doOther”方法，在当前类中该方法不存在
* doOther();
*/
System.out.println("--------------------------------------");
}
public static void m() {
System.out.println("m method excute!");
/**
* 完整的方法
*/
MethodTest06.m2();
/**
* 省略的方法
*/
m2();
/**
* 不想调用当前本类的m2方法，这个时候必须要添加“类名”
*/
A.m2();
}
public static void m2() {
System.out.println("m2!");
}
}
class A {
public static void doOther() {
System.out.println("A's doOther method invoke!'");
}
public static void m2() {
System.out.println("A 'm2'");
}
}
package com.yonyou;
import java.util.Scanner;
/**
* 分析以下程序的输出结果
* main begin
* m1 begin
* m2 begin
* m3 begin
* m3 over
* m2 over
* m1 ov er
* main over
* 对，当前的程序来说，main方法最先被调用，main方法也是最后一个结束
* 最先调用的方法是m3，该方法最先结束
* main方法结束之后，整个程序结束了
* 自上而下的顺序依次执行
* 当前行的程序在没有结束的时候，下一行的代码是无法执行
*/
@SuppressWarnings("all")
public class MethodTest07 {
public static void main(String[] args) {
/**
* 获取键盘输入值
*/
System.out.println("--------------------------------------");
Scanner scanner = new Scanner(System.in);
System.out.println("获取键盘输入值：");
System.out.println("请输入起始值:");
int start = scanner.nextInt();
System.out.println("请输入结束值:");
int end = scanner.nextInt();
System.out.println("--------------------------------------");
System.out.println("begin");
m1();//暂停
System.out.println("end");
System.out.println("--------------------------------------");
}
/**
* m1一旦over，整个进程就会结束
*/
public static void m1() {
System.out.println("m1 begin");
m2();//暂停
System.out.println("m2 over");
}
public static void m2() {
System.out.println("m2 begin");
m3();//活跃
System.out.println("m2 over");
}
public static void m3() {
System.out.println("m3 begin");
System.out.println("m3 over");
}
}
package com.yonyou;
import java.util.Scanner;
/**
* 方法的返回值类型不是void的时候
* 1、返回值类型不是void的时候：要求方法必须保证百分百的执行“return”值：这样的语句来完成值的返回
* 没有这个语句编译器会报错
* 2、一个方法有返回值的时候，当我们调用这个方法的时候，方法返回了一个值，对于调用者来说，这个返回值可以选择接收，也可以选择不接收。
* 但是大部分情况下我们都是选择接收的
*/
@SuppressWarnings("all")
public class MethodTest08 {
public static void main(String[] args) {
/**
* 获取键盘输入值
*/
System.out.println("--------------------------------------");
Scanner scanner = new Scanner(System.in);
System.out.println("获取键盘输入值：");
System.out.println("请输入起始值:");
int start = scanner.nextInt();
System.out.println("请输入结束值:");
int end = scanner.nextInt();
System.out.println("--------------------------------------");
/**
* 调用方法
* 接受新的
*/
int i = divide(10, 3);
System.out.println(i);
long y = divide(10, 3);
System.out.println(y);
System.out.println(divide(10, 3));
/**
* 这里接收一下方法执行结束之后的返回值
* 采用变量接收
* 变量的数据类型需要和返回值的数据类型相同，或者可以自动类型的转换
*/
System.out.println("--------------------------------------");
}
/**
* 定义一个方法，该方法可以计算两个int类型额商
* 要求将最终的计算结果返回给调用者
*/
/**
// * 编译报错：缺少返回值
// * @param a
// * @param b
// * @return
// */
// public static int divide(int a,int b){
//
// }
// /**
// * 编译错误：缺少返回值
// * @param a
// * @param b
// * @return
// */
// public static int divide(int a,int b){
// return ;
// }
// /**
// * 编译错误：不兼容的类型
// *
// * @param a
// * @param b
// * @return
// */
// public static int divide(int a, int b) {
// return true;
// }
// /**
// * @param a
// * @param b 可以：但是具体的方法体中编写的代码无法满足的当前的需求
// * @return
// */
// public static int divide(int a, int b) {
// return 1;
// }
/**
* @param a
* @param b 可以：但是具体的方法体中编写的代码无法满足的当前的需求
* @return
*/
public static int divide(int a, int b) {
int c = a / b;
return c;
}
}
package com.yonyou;
import java.util.Scanner;
/**
* 深入return语句
* * 带有return关键字的java语句只要执行，所在的方法执行结束
* * 在同一个作用域当中，return语句下面不能编写任何代码。应为这些代码永远都执行不到，所以编译报错
*/
@SuppressWarnings("all")
public class MethodTest09 {
public static void main(String[] args) {
/**
* 获取键盘输入值
*/
System.out.println("--------------------------------------");
Scanner scanner = new Scanner(System.in);
System.out.println("获取键盘输入值：");
System.out.println("请输入起始值:");
int start = scanner.nextInt();
System.out.println("请输入结束值:");
int end = scanner.nextInt();
System.out.println("--------------------------------------");
/**
* int retValue = 0;
* System.out.println(retValue);
*/
System.out.println("--------------------------------------");
}
// /**
// * 编译器不会自主判断是否成立，它只会 a > 3 是一个布尔值
// * 编译报错：缺少返回语句，以下程序编译器认为
// * 无法百分百保证“return 1；”会执行。
// * @return
// */
// public static int m() {
// int a = 10;
// if (a > 3) {
// return 1;
// }
// }
/**
* 以下程序可以保证“return 1；或 return 0 ； ”执行，编译通过
* 可以，和以上方法完全想相同
*
* @return
*/
// public static int m() {
// int a = 10;
// if (a > 3) {
// return 0;
// } else {
// return 0;
// }
// }
public static int m() {
return 10 > 3 ? 1 : 0;
}
}
package com.yonyou;
import java.util.Scanner;
/**
* 在返回值类型是void的方法党章使用“return；”语句
* “return；”语句出现在返回值为void的方法当中主要是为了用来结束当前方法。
*/
@SuppressWarnings("all")
public class MethodTest010 {
public static void main(String[] args) {
/**
* 获取键盘输入值
*/
System.out.println("--------------------------------------");
Scanner scanner = new Scanner(System.in);
System.out.println("获取键盘输入值：");
System.out.println("请输入起始值:");
int start = scanner.nextInt();
System.out.println("请输入结束值:");
int end = scanner.nextInt();
System.out.println("--------------------------------------");
m();
for (int i = start; i < end; i--) {
if (i == 2) {
return;//结束的是main方法
}
System.out.println("data: -->" + i);
}
System.out.println("Excute Here!");
/**
* return 100;
* 编译错误：返回值类型是void，不能返回值
*/
System.out.println("--------------------------------------");
}
// /**
// * 编译报错：对于结果类型为空的方法，无法返回值
// */
// public static void m(){
// return 10;
// }
// public static void m(){
// return;
// }
public static void m() {
for (int i = 0; i < 10; i++) {
if (i == 5) {
// return;//不是终止for循环，终止的是m()方法。
break;//终止的for循环
}
System.out.println("i --> " + i);
}
System.out.println("httpls");
}
}
package com.yonyou;
import java.util.Scanner;
/**
* 方法子啊执行过程当中，在JVM中的内存是如何分配的呢，内存是如何变化的？
* 1、方法只定义，不调用，是不会执行的，并且在JVM中也不会给该方法分配“运行所属”的内存空间
* 只要在调用这个方法的时候，才会动态的给这个方法分配所属的内存空间。
* 2、在JVM内存划分上有三块主要的内存空间(当然除了这三块之外还有其他的内存空间)：
* * 方法区
* * 堆内存
* * 栈内存
* 3、关于栈数据结构：
* * 栈：stack，是一种数据结构
* * 数据结构是独立的学科，不属于任何编程语言的范畴，只不过在大多数变成语言当中要使用数据结构
* * Java有一套庞大的类库文件
* * 常见的数据结构：
* - 数组
* - 队列
* - 栈
* - 链表
* - 二叉树
* - 哈希表/散列表
* 栈：
* 1、栈帧永远指向栈顶元素
* 2、栈顶元素处于活跃状态，其他元素静止
* 3、术语：
* 压栈/入栈/push
* 弹栈/出线/pop
* 4、栈数据结构存储数据的特点是：
* 先进后出
* 后进先出
* 4、方法追星的时候代码片段存在在哪里？方法执行的时候执行过程的内存在哪里分配？
* * 方法代码片段术语.class文件的一部分，字节码文件在类加载的时候，
* 将其放到方法区当中，所以JVM的三块主要的内存空间中方法区内存最先有数据，存放了代码片段
* * 代码片段虽然在方法去内存当中是由一份，但是可以被重复调用。
* * 每一次调用这个方法额时候，需要给该方法分配独立的活动场所，在内存中分配【栈内存中分配方法运行的所属内存空间】
* 5、方法在调用的时候，会给该方法分配独立的内存空间，会在栈中发生压栈动作，方法执行结束之后，给该方法结束之后，会给方法分配的内存空间全部释放，此时发生弹栈动作，
* * 压栈：给方法分配内存
* * 弹栈：释放该方法的内存空间
* 6、局部变量在“方法体”中声明。局部变量运行截端截端内存在栈中分配。
*/
@SuppressWarnings("all")
public class MethodTest011 {
public static void main(String[] args) {
/**
* 获取键盘输入值
*/
System.out.println("--------------------------------------");
Scanner scanner = new Scanner(System.in);
System.out.println("获取键盘输入值：");
System.out.println("请输入起始值:");
int start = scanner.nextInt();
System.out.println("请输入结束值:");
int end = scanner.nextInt();
System.out.println("--------------------------------------");
System.out.println("--------------------------------------");
}
public static void m() {
}
}
这篇关于Java-day-06的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！
您可能喜欢
-
手写消息中间件：从零开始的指南11-26
-
Java语音识别项目资料：新手入门教程11-26
-
JAVA语音识别项目资料：新手入门教程11-26
-
Java语音识别项目资料：入门与实践指南11-26
-
Java云原生资料入门教程11-26
-
Java云原生资料入门教程11-26
-
Java云原生资料：新手入门教程11-26
-
Java创意资料：新手入门的创意学习指南11-25
-
JAVA对接阿里云智能语音服务资料详解：新手入门指南11-25
-
Java对接阿里云智能语音服务资料详解11-25
-
Java对接阿里云智能语音服务资料详解11-25
-
JAVA副业资料：新手入门及初级提升指南11-25
-
Java副业资料：入门到实践的全面指南11-25
-
Springboot应用的多环境打包项目实战11-25
-
SpringBoot应用的生产发布项目实战入门教程11-25
栏目导航
