1.jdk1.5
1.1 Static import:
Importing static methods is easy to use, loading first
1.2 Variable parameters
Format: data type...—variable parameters (only the corresponding type of data
can be received ) can receive any number of parameters (0, 1, multiple) The
bottom layer is implemented according to the array, and each parameter value received is assigned to Array elements
can only appear on the far right of the parameter list and there can be at most one
1.3 Enumeration
Enumerate the values one by one (enum constants)
enum constants in the first line
Define properties and methods
Construct method privatization
Define abstract method
switch-case expressions support enumeration types from jdk1.5
package cn.tedu.jdkx.jdk5;
public class EnumDemo {
public static void main(String[] args) {
Season spring = Season.spring;
//switch表达式支持枚举类型
switch (spring){
case spring:
System.out.println("春游！！！");
break;
case summer:
System.out.println("游泳");
break;
case autumn:
System.out.println("爬山");
break;
case winter:
System.out.println("打雪仗");
break;
}
}
}
//枚举类
enum Season{
//将值一一列举
//spring--等效--public final static Season spring=new Season();
//列举的是枚举常量(要在首行)
spring{
@Override
public void n() {
}
},summer{
@Override
public void n() {
}
},autumn{
@Override
public void n() {
}
},winter{
@Override
public void n() {
}
};
//属性
int age;
//方法
public void m(){
}
//私有化构造方法
private Season(){
}
//定义抽象方法
//保证每个枚举常量都通过匿名内部类重写抽象方法
public abstract void n();
}
//定义类---代表季节的类，创建的对象就是具体季节
//一年四季，类只能创建四个对象
/*class Season{
//私有化的构造方法
private Season(){}
//创建四个对象---四个季节
public final static Season spring=new Season();
public final static Season summer=new Season();
public final static Season autumn=new Season();
public final static Season winter=new Season();
}*/
2.jdk1.8
Interface can define entity methods (1. Default method (default) 2. Static method (static))
Lambda expressions can implement interface override abstract methods (provided that the interface must be a functional interface to be used)
package cn.tedu.jdkx.jdk8;
public class LambdaDemo1 {
public static void main(String[] args) {
/* //创建接口实现类对象调用接口的默认的实体方法
System.out.println(new CalcImpl().cj(1,2));
//创建匿名内部类对象调用接口里实体方法
System.out.println(new Calc(){}.cj(1,2));*/
//接口直接调用实体方法（静态方法）
// System.out.println(Calc.sum(1,2));
//Lambda表达式---实现接口重写抽象方法
//前提：接口里只有一个抽象方法
//(参数列表)->{重写方法的方法体}
//Calc c=(int x,int y)->{return x>y?x:y;};
//由前推导出参数类型，可以省略参数类型不写
//如果重写方法的方法体只有一句话可以省略{}和return不写
Calc c=(x,y)->x>y?x:y;
System.out.println(c.max(1,2));
}
}
//接口---计算器
//接口里只有一个抽象---函数式接口---函数式编程
@FunctionalInterface
interface Calc{
//求大小---抽象方法
int max(int x,int y);
//求乘积---体方法（默认方法）
public default int cj(int x,int y){
return x*y;
}
//求和---实体方法（静态方法）
public static int sum(int x,int y){
return x+y;
}
}
//接口的实现类
/*class CalcImpl implements Calc{
}*/
Stream (streaming structure of operation collection)
Provides a large number of functional interfaces that can use Lambda expressions to manipulate collection element objects
package cn.tedu.jdkx.jdk8;
import java.util.ArrayList;
import java.util.Collection;
import java.util.function.Consumer;
import java.util.function.Predicate;
import java.util.stream.Stream;
public class StreamDemo {
public static void main(String[] args) {
//创建集合对象
Collection<String> c=new ArrayList<>();
//添加元素
c.add("JAVA");
c.add("C");
c.add("Python");
c.add("PHP");
c.add("C#");
c.add("C++");
c.add("GO");
//筛选出以C开头的元素
/*for(String s:c){
//判断每个元素对象内容是否以C开头
if(s.startsWith("C")){
System.out.println(s);
}
}*/
//调用方法返回流式结构
Stream<String> stream = c.stream();
//过滤指定元素
/*stream.filter(new Predicate<String>() {
//重写方法指定过滤规则
//重写方法可以接收每个元素对象
@Override
public boolean test(String s) {
return s.startsWith("C");
}
}).forEach(new Consumer<String>() {
//输出过滤之后的元素对象内容
@Override
public void accept(String s) {
System.out.println(s);
}
});*/
//Lambda表达式改写
stream.filter(s->s.startsWith("C")).sorted
((s1,s2)->s2.compareTo(s1))
.forEach(str-> System.out.println(str));
}
}