JAVASE知识点4:方法（包括一些常用类的方法），break，for循环及其变体，foreach，及练习
public class B {
public static void f(int a,char c)
{
System.out.println(a+" "+c);
}
public static void main(String[] args) {
f(1,97);//报错，97为整型。自动转换顺序为 byte short char int long float double
}
}
package day3_1;
public class B {
public static void main(String[] args) {
char a=97;
System.out.println(a);
}
}
输出：a一方法：
1类中方法的格式：
访问权限修饰符 其他修饰符 返回值类型 函数名称 （参数列表）
{
方法体；
}
2一个完整的函数包含声明部分和实现部分
3作用域：
访问权限修饰符（这里只说两个）：public,default[如果没有添加任何的访问权限修饰符，那么它就是默认权限default,注：default不需要显示的写出来]
public 修饰的变量、方法、类，可以在任何地方被调用
默认权限 修饰的变量、方法、类、只能在同包下被调用
静态方法 能 直接调用 静态方法 和静态变量
静态方法 不能 直接调用 非静态方法 和 非静态变量
非静态方法 能 直接调用 静态方法 和 静态变量
非静态方法 能 直接调用 非静态方法 和 非静态变量
静态方法或变量在同一内存空间
4可以在一个函数中调用一个函数，但不能在一个函数中声明一个函数。
5 int x=1,y=2;//实参
for(int a,int b); //形参
f(x,y);//调用函数，实参给形参赋值
6返回值为void的函数中可以写return; 用于结束整个方法。
return每次只能返回一个值给函数
7如果一个自定义的函数中有返回值，并且在方法中遇到了分支结构，则需要在每一个分支后面都需要出现一个return
出现的问题：在使用单分支的时候，分支内部有return，这时编译还是不通过
//解决办法：在单分支的外面再添加一个返回值，返回值随意，只要类型和返回值类型匹配就ok
//单分支
if(num1 > num2) {
return num1;
}
//没有实际意义，作用只是为了匹配语法
return 0; 8函数参数表可以用...（三个点）表示数组，但该变量必须放在参数表最后。
...作为参数和普通数组作为参数的区别
//总的来说在使用int...a作为参数的方法中可以直接将a当做数组使用
//但是在调用方法时，赋值方式有所区别
//注意：一个方法中只能使用一次...作为参数，且这个参数必须在方法的最后
public class Test {
//使用int...作为参数表
static void f(int a,int... b)
{
System.out.println(a);
for(int i:b)//可以把b直接当做整型数组使用
{
System.out.print(i+" ");
}
System.out.println();
System.out.println(b.length);//可以把b直接当做整型数组使用
System.out.println();
}
//使用int[]作为参数
static void g(int a,int[] b)
{
System.out.println(a);
for(int i:b)
{
System.out.print(i+" ");
}
System.out.println();
System.out.println(b.length);
System.out.println();
}
public static void main(String[] args) {
f(0,1,2,3,4,5,6,7,8,9,10);//当时用int...时可以直接把数组内容写在参数表里，且这个数组是动态的(任意个数)
int[] b=new int[] {0,2,3,4,5,6,7,8,9,10};
g(10,b);//当使用int[]作为参数时，要声明一个数组并赋值(非动态的,数组个数已经确定)
}
}
例子：
package day3_1;
public class A {
static void f(char a,int...b)
{
for(int i:b)
{
System.out.print(i+" ");
}
System.out.println();
System.out.print(b.length);
}
public static void main(String[] args) {
f('a',2,3,4,5,6,7);
}
}输出：
2 3 4 5 6 7
6
package day3_1;
public class A {
static void f(char a,String...b)
{
for(String i:b)
{
System.out.print(i+" ");
}
System.out.println();
System.out.println(b.length);
System.out.println(b[0].length());
}
public static void main(String[] args) {
f('a',"Hello ","World");
}
}输出：
Hello World
2
6
9对于public static void main(String[] args){}
首先程序会自动调用main()方法，但是为什么是public和static?
public表示谁都可以调用，static表示main()在共享区，程序首先会在共享区找该方法，找到就会运行。
10方法的重载
方法的重载与方法的修饰符和返回值没有任何关系
对于重载函数而言，具体调用的是哪个函数，取决于所传的参数
在同一个类中，如果满足以下的条件，则称为这几个方法之间彼此重载
a.方法名相同
b.参数不同【数量不同或者类型不同或者顺序不同】
c.访问权限修饰符和返回值类型没有影响
class TextDemo04
{
public static void main(String[] args)
{
//对于重载函数而言，具体调用的是哪个函数，取决于所传的参数
Check.show("10");
Check.show("10",10);
}
}
//实体类
/*
在同一个类中，如果满足以下的条件，则称为这几个方法之间彼此重载
a.方法名相同
b.参数不同【数量不同或者类型不同】
c.访问权限修饰符和返回值类型没有影响
*/
class Check
{
public static void show() {
System.out.println("无参无返回值的show");
}
//1.改变参数
public static void show(int a) {
System.out.println("int的show");
}
public static void show(String a) {
System.out.println("String的show");
}
public static void show(String a,int b) {
System.out.println("String int的show");
}
//2.改变返回值:返回值对方法的重载没有任何影响
//只改变返回值类型，其他都不改变，则对于编译器而言，则认为是同一个方法
/*
public static String show() {
System.out.println("String返回值的show");
return "abc";
}
*/
//3.访问权限修饰符
//只改变访问权限修饰符，其他都不改变，则对于编译器而言，则认为是同一个方法
/*
static void show() {
System.out.println("show");
}
*/
}11递归算法
在一个方法的方法体内调用该函数本身，称为函数的递归
方法递归包含了一种隐式的循环，会重复执行某段代码，但是这种重复不需要使用循环语句来进行控制
class DiGuiUsageDemo01
{
public static void main(String[] args)
{
/*
斐波那契数列
1,2,3,4,5,6, 7, 8, 9,10,11,.....
1,1,2,3,5,8,13,21,34,55,89....
分析：
1.第一个位置和第二个位置上的数是固定的，都是1
2.第n个位置上的数 = 第n - 1个位置上的数 + 第n - 2个位置上的数
fun(1) = 1
fun(2) = 1
fun(3) = fun(2) + fun(1) = 1 + 1
fun(4) = fun(3) + fun(2) = fun(2) + fun(1) +fun(2)
fun(5) = fun(4) + fun(3) = fun(3) + fun(2) + fun(2) + fun(1) = fun(2) + fun(1) + fun(2) + fun(2) + fun(1)
....
fun(n) = fun(n - 1) + fun(n -2)
*/
int result1 = fun(10);
System.out.println(result1);
}
//需求：报个数，获取在斐波那契数列中对应的数
public static int fun(int n) {
if(n == 1 || n == 2)
return 1;
else
return fun(n - 1)+fun(n -2);
}
}
}Thinking in JAVA:
import java.util.*;//Date位于java.util包中
public class A {
public static void main(String[] args)
{
System.out.println(new Date());//创建一个Date类的对象，它可以自动转化成字符串
}
}
输出：
Sun Jul 22 10:33:58 CST 2018
2.Math.round()//四舍五入
3Character类中的static isLowerCase(char或int)方法用于判断是否为小写字母，例子：
public static void main(String[] args)
{
for(int i=0;i<=128;i++)
{
if(Character.isLowerCase(i))
{
System.out.println((char)i);
}
}
}
}输出：
a
b
c
d
e
f
g
h
i
j
k
l
m
n
o
p
q
r
s
t
u
v
w
x
y
z
4foreach语法：一种新的更加简洁的for语法用于数组和容器，不必创建int变量去计数，foreach将自动产生每一项。
foreach也成为增强for
例子：遍历float数组
import java.util.*;
public class Test {
public static void main(String[] args) {
Random rand=new Random(47);
float[] f=new float[10];
for(int i=0;i<=9;i++)
f[i]=rand.nextFloat();
for(float x:f)
System.out.println(x);
}
}输出：
0.72711575
0.39982635
0.5309454
0.0534122
0.16020656
0.57799757
0.18847865
0.4170137
0.51660204
0.73734957
任何返回一个数组的方法都可以使用foreach，例如，String类有一个方法toCharArray()，它返回一个char数组，因此可以很容易地像下面这样迭代在字符串里面的所有字符。
public class Test {
public static void main(String[] args) {
for(char c:"An African Snallow".toCharArray())
{
System.out.print(c);
}
System.out.println();
}
}输出：
An African Snallow
break，continue
break语句
作用：
跳出所在的循环体
书写位置：
必须出现在循环或选择结构内
for(int i=0; i<10; i++) {
if(i>5) {
break;
}
System.out.println(“我爱Java”+i);
}continue语句
-
a: 作用
-
提前结束本次循环，继续进行下次循环
-
-
b: 使用方式
-
无法单独使用，必须将continue关键字置于循环语句中
-
-
c：运行规律
-
不需要判断任何条件，只要遇到continue便直接跳出本轮循环进行下次循环
-
-
d：案例代码
-
public class ContinueDemo{ public static void main(String[] args){ for(int i = 0 ; i < 10 ; i++) { if(i%2==0){ continue; } System.out.println(i); } } }//会把0-9之间所有的奇数打印到控制台上
for(表达式1;表达式2;表达式3)
{
表达式4
}
一执行顺序：
第一次：表达式1，表达式2，表达式4，表达式3
以后为：表达式2，表达式4，表达式3
二变体（注意自己写代码时要按正规方式写，这里变体只是了解：）
1.根据执行顺序可以变为
for(表达式1;表达式2;)
{
表达式4
表达式3
}
2.根据执行顺序可以变为
for(表达式1;;)
{
if(表达式2){
表达式4
表达式3
}
else
break;
}
3可以放在一行
for(表达式1;表达式2;表达式3,表达式4)；//即：如果表达式4逻辑比较少时可以放在表达式3中，和其一起运算，注意是用逗号隔开的。
4.for(int i=1,j=1,w=2;i<10;i++,j++,w++) //表达式一可以是多个相同类型的变量，表达式2只能是一个判断语句，表达式3可以是个表达式
{
}
public class A {
public static void main(String[] args) {
for(int i=1;i<=10;i++,System.out.println(i));
}
}
输出：
2
3
4
5
6
7
8
9
10
11
package day3_1;
//打印0-9之间所有奇数
public class A {
public static void main(String[] args) {
for(int i=1;i<=10;i++)
{
System.out.print(i+" ");
}
System.out.println("");
for(int j=1;j<=10;)
{
System.out.print(j+" ");
j++;
}
System.out.println("");
for(int k=1;;)
{
if(k<=10) {
System.out.print(k+" ");
k++;
}
else
break;
}
System.out.println("");
for(int w=1;w<=10;w++,System.out.print(w+" "));
System.out.println("");
for(int r=1;r<=10;System.out.print(r+" "),r++);
System.out.println("");
}
}
输出：
1 2 3 4 5 6 7 8 9 10
1 2 3 4 5 6 7 8 9 10
1 2 3 4 5 6 7 8 9 10
2 3 4 5 6 7 8 9 10 11
1 2 3 4 5 6 7 8 9 10
写一个方法，分别计算出一个字符串中字母，数字，下划线，空格和其他字符的个数
/*1.设计一个方法，分别计算出一个字符串中字母，数字，下划线，空格和其他字符的个数*/
/* Character.isLetter();//判断为字母
Character.isWhitespace();//判断空格
Character.isDigit();//判断数字*/
public class A {
public static void main(String[] args) {
String s="abcd AB CD EF ..!@#$%^&*()_+=-1235346457680980{}[]\\\';/.,<>? ";
int digit=0,letter=0,space=0,special=0;
for(int i=0;i<=s.length()-1;i++)
{
char c=s.charAt(i);
if(Character.isLetter(c))//判断为字母
letter++;
else if(Character.isDigit(c))//判断为数字
digit++;
else if(Character.isWhitespace(c))
space++;
else
special++;
}
System.out.println("字母出现"+letter+"次");
System.out.println("数字出现"+digit+"次");
System.out.println("空格出现"+space+"次");
System.out.println("特殊字符出现"+special+"次");
}
}
输出：
字母出现10次
数字出现16次
空格出现6次
特殊字符出现29次
求最大公倍数和最小公约数
这个是算法题没错...但是算法什么的都已经还给老师了，只记得：两个数的最小公倍数*这两个数的最大公约数=这两个数的乘积，先用最笨的方法做一下：
package day3_1;
import java.util.*;
/4.输入两个正整数m和n，求其最大公约数和最小公倍数/
public class B {
public static void main(String[] args) {
System.out.print("请输入两个正整数");
Scanner sc=new Scanner(System.in);
int a=sc.nextInt();
int b=sc.nextInt();
int gb,gy;
if(a>b)//把小的给a
{
int tmp =a;
a=b;
b=tmp;
}
for(int i=a;i>=1;i--)
{
if(a%i==0 && b%i==0)
{
gy=i;
gb=a*b/gy;
System.out.println("最大公约数为"+gy+"最小公倍数为"+gb);
break;
}
}
}
}
辗转相除法：
//还是写的很笨...哎= =
package day3_1;
import java.util.*;
/4.输入两个正整数m和n，求其最大公约数和最小公倍数/
public class B {
public static void main(String[] args) {
System.out.print("请输入两个正整数");
Scanner sc=new Scanner(System.in);
int a1=sc.nextInt();
int b1=sc.nextInt();
int r=1;
int a=a1,b=b1;
if(a