d4 方法

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为整型。自动转换顺序为 char byte short 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函数参数表可以用...（三个点）表示数组，但该变量必须放在参数表最后。

例子：
 

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将自动产生每一项。

例子：遍历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