JavaSE基础(15) Java方法（函数）
Posted 逆轮回
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了JavaSE基础(15) Java方法（函数）相关的知识，希望对你有一定的参考价值。
概念
概念：也叫函数，其实就是具有一定特殊功能的一段代码，将需要在多个位置重复使用的一组代码，定义在方法内部。
意义：1.避免了重复的代码。2.增强了程序的扩展性。
定义方法
用法：
step1：方法的定义(声明)
public static void main(String[] args) 语法格式：
[修饰符1,修饰符2...] 返回值/void 方法名(参数列表)
.....
return
示例：
//求1-10的和
public static void getSum()
//方法体
int sum =0;
for(int i=1;i<=10;i++)
sum +=i;
System.out.println("sum:"+sum);
修饰符：public，static
返回值：一个方法执行之后，返回给调用处的结果。可能有，也可能没有。
有：在方法定义的时候，写清楚方法要返回的数据的类型。
没有：void，表示这个方法执行结束之后，没有返回值给调用处。
方法名：也是一种标识符。首字母小写，驼峰式命名。
()：方法的标志。括号里：参数列表
：方法体
参数列表：方法在运算过程中的未知数据，调用者调用方法时传递
return ：将方法执行后的结果带给调用者，方法执行到 return ，整体方法运行结束
调用方法
step2：方法的调用(如果一个方法只有定义，那么方法中代码并没有被执行，只有被调用了才会执行方法中的代码)
通过方法的名字进行调用。
static的方法：静态方法
类名.方法名()，本类中类名可以省略。
非static的方法：非静态方法
创建该类的对象，通过对象调用方法。
类名 对象名 = new 类名();
对象.方法名();示例：
//调用一个方法,如果是类的方法，可以用类名直接调用
//倘若是在本类中，那么类名可以省略
//1,static方法的调用
getSum();//方法的调用
//2，非static方法的调用
/*
创建该类的对象，通过对象调用方法。
类名 对象名 = new 类名();
对象.方法名();
*/
Demo1 demo1 = new Demo1();
demo1.test();//非static方法的调用方法返回值
如果一个方法调用之后，需要返回给调用处结果，那么表示这个方法有返回值，在方法中需要使用return语句把结果返回给调用处。
//方法定义
public static 返回值类型 方法名()
//.....
return 结果;
//方法的调用处
变量 = 方法名(); //变量 = 结果如果一个方法，没有返回值，那么写void即可。
return语句：
A：把方法中的返回值，返回给方法的调用处。
B：同时结束了这个方法的执行。
//求1-10的和，并且把方法中计算的结果，返回给调用处，放大10倍再打印
public static void getSum()
int sum = 0;
for (int i = 1; i <=10; i++)
sum += i;
System.out.println("1-10之间的和：" + sum);
//System.out.println("sum:"+sum);
//方法调用处拿到的值和return相关，和方法体无关，
return sum;
注意点：
1.如果一个方法声明了有返回值(非void)，那么方法中一定要使用return语句返回结果。
2.定义方法的时候，声明的返回值类型，一定得和return后实际上返回的数值类型一致。
3.如果一个方法声明了有返回值，如果方法中有分支语句或者循环语句，那么要保证无论执行哪个分支，都要有return可以被执行到。
4.如果一个方法声明没有返回值(void)，那么方法中也可以使用return语句，用于强制结束方法的执行。
/**
* return要注意的点
*/
public class Demo2_return_2
public static int test1()
// return "hehe";
byte i = 20;
double d = 2.3;
return (int)d;//byte----->int，发生了隐式类型转换
public static int test2()
int age =10;
if(age>10)
return 0;
else
return age;
public static int test3()
for(int i=1;i<=10;i++)
// if(i==1)
// return 0;//强制结束方法，，就是说方法后面的代码都不再执行了
//
System.out.println(i);
System.out.println("hello,world");
return 0;
public static void test4()
int age = 12;
if(age>0)
return;//用于结束方法的执行，即使在没有返回值的时候，也可以用return
System.out.println("wowowo,hello,");
public static void main(String[] args)
test3();
方法相互调用
public class Demo2_2
public static void test1()
System.out.println("test1.......");
public static void test2()
test1();
System.out.println("test2......");
public static void test3()
test2();
System.out.println("test3.....");
// Demo2_2 demo22 = new Demo2_2();
// demo22.test4();
public void test4()
Demo2_2.test3();//本类中就直接调用，如果是其他类就，用上类名
System.out.println("test4()......");
public static void main(String[] args)
test3();
方法参数
一个方法中，有些数据的数值不确定，我们定义为参数，由调用处调用方法的时候，传入具体的数据。
形式参数：形参
定义方式，声明的参数，用于接收调用处传来的数据。
实际参数：实参
调用方法的收，实际赋值给形参的数据。
/**
* 方法的参数
*/
public class Demo
public static int getSum(int n)
int sum = 0;
for(int i=1;i<=n;i++)
sum +=i;
return sum;
public static int getSum2(int a,int b)
return a+b;
// public static int getSum2()
// int sum = 0;
// for(int i=1;i<=20;i++)
//
// sum +=i;
//
//
//
// return sum;
//
public static void main(String[] args)
//求1-10的和；
int result1 = getSum(10);
//求1-20的和；
//int result2 = getSum2();
int result2 = getSum(20);
//求1-100的和；
//求两个数的和
int result3 = getSum2(1,2);
实参一定严格匹配形参：一一对应，包括顺序，个数，类型。
方法分类
有返回值：
有参数有返回值：public static 返回值类型 方法名(形参列表)
无参数有返回值：public static 返回值类型 方法名()
无返回值：
有参数无返回值：public static void 方法名(形参列表)
无参数无返回值：public static void 方法名()
方法重载
概念：一个方法的多种形式。
同一个类中
方法名相同
参数列表必须不同(顺序，个数，类型)
与static，返回值，其他的修饰符。。。这些无关
示例：
public class Demo_overload
public static void test1()
public static void test2()
public void test3()
public static int getSum(int a,int b)
return a+b;
public static double getSum(double a,double b)
return a+b;
public void getSum(int c)
public static void main(String[] args)
int result = getSum(1,2);
double result2 = getSum(2.3,4);
递归
方法中调用方法本身，就叫做递归方法。
递归方法一定有出口的，逐层的向出口靠近。
示例：
public class Demo_recursion
// 无返回值的递归方法
public static void test1(int n)
System.out.println("test1()......");
if(n==1)
return;//方法的出口
test1(n-1);//递归，自己调用自己,递归一定要有出口
//test1(4)
//test1(3)
//test1(2)
//test1(1)
//有返回值的递归方法
public static int getSum(int n)
// int sum = 0;
// for (int i = 0; i <= 5; i++)
// sum +=i;
//
// return sum;
if(n==1)
return 1;
return getSum(n-1)+n;
public static void main(String[] args)
test1(5);
//用递归的方式来求1-5之间的和
// getSum(5)---->getSum(4)+5;
// getSum(4)---->getSum(3)+4;
//
// getSum(3)---->getSum(2)+3;
// getSum(2)---->getSum(1)+2;
// getSum(1)----->return 1;
System.out.println("------------------------");
int sum = getSum(5);
System.out.println("sum:"+sum);
JavaSE基础入门_019_Java8特性
Java8概述
-
Java8（又称 JDK 1.8）是 Java 语言开发的一个主要版本。Oracle 公司于 2014.03.18 发布 Java 8
-
支持 Lambda 表达式
-
函数式接口
-
新的 Stream API
-
新的日期 API
-
其他特性
-
Lambda表达式
-
Lambda 表达式：特殊的匿名内部类，语法更简洁。
-
Lambda表达式允许把函数作为一个方法的参数（函数作为方法参数传递），将代码像数据一样传递。
-
// 匿名内部类
Runnable runnable = new Runnable() {
-
// 匿名内部类实现比较器
Comparator<String> com = new Comparator<String>() {
?
-
基本语法：
-
<函数式接口><变量名> = (参数1, 参数2...) -> {
//方法体
}
-
-
Lambda 引入了新的操作符：->(箭头操作符)，->将表达式分成两部分
-
左侧：(参数1，参数2...)表示参数列表
-
右侧：{}内部是方法体
-
-
注意事项
-
形参列表的数据类型会自动推断
-
如果形参列表为空，只需保留()
-
如果形参只有1个，()可以省略，只需要参数的名称即可
-
如果执行语句只有一句，且无返回值，{}可以省略，若有返回值，则若想省去{}，则必须同时省略return，且执行语句也保证只有一句
-
Lambda 不会生成一个单独的内部类文件
-
函数式接口
-
如果一个接口只有一个抽象方法，则该接口称之为函数式接口，函数式接口可以使用Lambda表达式，Lambda表达式会被匹配到这个抽象方法上。
-
@FunctionnalInterface 注解检测是接口是否符合函数式接口
常见函数式接口
| 函数式接口 | 参数类型 | 返回类型 | 方法说明 |
|---|---|---|---|
| Consumer<T>消费型接口 | T | void | void accept(T t); 对类型为T的对象应用操作 |
| Supplier<T>供给型接口 | 无 | T | T get(); 返回类型为T的对象 |
| Function<T，R>函数型接口 | T | R | R apply(T t); 对类型为T的对象应用操作，并返回类型为R类型的对象。 |
| Predicate<T>断言型接口 | T | boolean | boolean test(T t); 确定类型为T的对象是否满足条件，并返回boolean类型。 |
方法引用
-
方法引用是 Lambda 表达式的一种简写形式。如果 Lambda 表达式方法体中只是调用一个特定的已经存在的方法，则可以使用方法引用。
-
常见形式：
-
对象 ：：实例方法
-
类 ：：静态方法
-
类 ：：实例方法
-
类 ：：new
-
Stream API
什么是Stream
-
流（Stream）中保存对集合或数组数据的操作。和集合类似，但集合中保存的是数据。
Stream特点
-
Stream 自己不会存储元素。
-
Stream 不会改变源对象。相反，他们会返回一个持有结果的新 Stream。
-
Stream 操作是延迟执行的。这意味着他们会等到需要结果的时候才执行。
Stream使用步骤
-
创建
-
新建一个流
-
-
中间操作
-
在一个或多个步骤中，将初始Stream转化到另一个Stream的中间操作
-
-
终止操作
-
使用一个终止操作来产生一个结果。该操作会强制它之前的延迟操作立即执行。在这之后，该Stream就不能使用了。
-
创建Stream
-
通过 Collection 对象的 stream() 【串行流，单线程的】 或 parallelStream() 【并行流，多线程】方法
-
通过 Arrays 类的 stream() 方法
-
通过 Stream 接口的 of()、iterate()、generate() 方法
-
通过 IntStream、LongStream、DoubleStream 接口中的 of、range、rangeClosed 方法
-
// 1.- 通过 Collection 对象的 stream() 【串行流，单线程的】 或 parallelStream() 【并行流，多线程】方法
ArrayList<String> arrayList = new ArrayList<String>();
arrayList.add("Apple");
arrayList.add("Xiaomi");
arrayList.add("Huawei");
Stream<String> stream = arrayList.stream();
//Stream<String> stream2 = arrayList.parallelStream();
// 遍历
//stream.forEach(s->System.out.println(s));
stream.forEach(System.out::println);
System.out.println("--------------------------");
//stream2.forEach(System.out::println);
//2. 通过 Arrays 类的 stream() 方法
String[] arr = {"aaa","bbb","ccc","ddd"};
Stream<String> stream2 = Arrays.stream(arr);
stream2.forEach(System.out::println);
System.out.println("--------------------------");
//3. 通过 Stream 接口的 of()、iterate()、generate() 方法
Stream<Integer> stream3 = Stream.of(10,20,30,40,50);
stream3.forEach(System.out::println);
// 迭代流
System.out.println("---------迭代流----------");
Stream<Integer> iterate = Stream.iterate(0, x -> x + 2);
iterate.limit(10).forEach(System.out::println);
//生成流
System.out.println("---------生成流----------");
Stream<Integer> generate = Stream.generate(()->new Random().nextInt(100));
generate.limit(10).forEach(System.out::println);
System.out.println("--------------------------");