JDK 1.8 新特性_Lambda表达式(一)

• 1.JDK1.8新内容
  • 接口有变化
  • lambda表达式
  • 流编程:Stream
• 2.介绍
  • 2.1接口
  • 方法五要素:
    • 修饰符
    • 返回值
    • 方法名
    • 参数
    • 方法体
  • 什么是抽象方法:抽象方法是一个特殊的方法;
    • 没有方法体
    • 被abstract修饰
  • 什么是类
    • 属性
    • 方法
  • 什么是抽象类:抽象类是一个特殊的类
    • 对属性没有要求
    • 至少有0个抽象方法
    • 如果此类有一个方法时抽象的,此类必须是抽象类
    • 类被abstract修饰
    • 不能new
  • 什么是接口:接口是一个特殊的抽象类
    • 接口里面的方法全部是抽象的
    • 属性全部是:public static final;
    • 标准
  • 三流的公司卖服务,二流的公司写实现,一流的公司写接口
  • 标准
    • 属性可以是不变,是标准
    • 所有实现类的方法也是一样的
  • 新特性
    • 接口里面的方法可以有方法体:就不再是抽象的方法
    • 如何调用普通的方法呢?
      • new 对象,对象.方法();
      • static 修饰的,直接使用类名.方法名();
  • 2.2 Lambda 表达式–λ
    • 完全是被js,scala,python 给逼出来的
    • 没有lambda表达式,是如何做的;匿名类;
    • java 的开发
      • 创建一个类
      • 继承父类和接口
      • 定义属性和方法
      • new对象
      • 调用属性和方法
    • 方法的参数类型,有两大类,十一小类;(基本数据类型和引用类型)
      • 疑问:为啥方法的参数不能是方法呢 ?
      • 参数的方法要执行,方法的本身也要执行;
    • lambda:

      • 方法的参数得是接口;调用接口中方法

      • 接口的注解;@必须是:@FunctionalInterface; #(注解!=注释)

      • 接口中方法只能有一个是抽象的

      • 方法的五要素,方法的参数是方法

        /* 方法的定义 */
        Public void aa(IAnimal a)
        {
           Asdflka sflkda sjlfdk askdfj afd
        }
        

        /* 方法的调用 
        参数是接口,目的也是执行接口中的方法,默认执行抽象的方法
        (只能有一个)
        */
        对象名/类名.aa((接口中抽象方法的实参列表--A) ->
        {
           /* 方法体 */
           Return 返回值的值(类型要匹配啊
        });
        

      • 注意

        • 如果A的参数列表只有一个,类型可以省略,(自动推断)
        • 如果方法体只有一行,大括号可以省略;
        • 返回值,return 也可以省略;(new)
        • new Thread(() -> System.out.println("===lambda测试====")).start();

      • 接口的类型分类

        • 所有分类的lambda都在java.util.function

接口名	方法	说明
Supplier	get	返回值和类型定义时的泛型一样
Consumer	accept	接收类定义时的泛型;处理,不需要返回值
Function	apply	定义中接收第一个泛型,返回第二个泛型
Predicate	test	判断一个(断言)接口定义时泛型是否符合要求

• 3.实例

  • 3.1接口

  • 动物接口:

    import java.util.function.Supplier;
    
    /**
     * 接口
     * 动物
     * @author Administrator
     */
    public interface IAnimal
    {
    	/* public static final */
    	/*public static final int headNum = 1 ; */
    	int headNum = 1;
    	
    	/**
    	 * 跑方法
    	 */
    	void run();
    	
    	/**
    	 * 可以写方法体,
    	 * 普通的方法
    	 * default:修饰符,依然是public,
    	 */
    	default void def_eat()
    	{
    		System.out.println("IAnimal-def_eat-用嘴吃---");
    	}
    	
    	/**
    	 * 可以写方法体,
    	 * 静态的方法
    	 * default:修饰符,依然是public,
    	 */
    	static String static_eat()
    	{
    		System.out.println("IAnimal-static_eat-用嘴吃---");
    		return "--hwhw--";
    	}
    	
    	/**
    	 * 创建了一个对象
    	 * 调用者
    	 * @return
    	 */
    	static IAnimal createObj(Supplier supplier)
    	{
    		/* 返回此对象 */
    		return supplier.get(); 
    	}
    }
    

    

    • 人实现类

    /**
     * 人
     * @author Administrator
     */
    public class Person implements IAnimal
    {
    	@Override
    	public void run()
    	{
    		System.out.println("=Person==run==");
    	}
    	
    	@Override
    	public void def_eat()
    	{
    		System.out.println("=Person==def_eat==");
    	}
    }
    

    • 狗实现类

     * ~实现;孝子
     * ~不实现;不孝子
     * @author Administrator
     *
     */
    public class Dog implements IAnimal
    {
    
    	@Override
    	public void run()
    	{
    		System.out.println("===Dog=run===");
    	}
    }
    

    • 测试类

    /**
     * 测试类
     * 
     * ~标准的多态;
     * 		动物的接口
     * 		人和狗的实现类
     * 		写了一个多态;父类引用指向子类对象
     * ~jdk1.8里面的方法可以写方法体
     * 		普通的方法;在方法返回值的左边加上default
     * 		静态的方法;在方法返回值的左边加上static
     * 
     * ~如何重写
     * 		普通方法和静态方法有方法体,但是不报错;所有的实现类,不用重写default和static方法
     * 		普通方法可以被实现类重写;
     * 		静态的方法不能被重写
     * 
     * ~Supplier:提供者
     * 		使用::new调用new方法;
     * 		::调用某一个方法;返回值必须是function Interface;
     * @author Administrator
     */
    public class ClientMain
    {
    	public static void main(String[] args)
    	{
    		System.out.println("====");
    		/* 父类引用指向子类对象 */
    		IAnimal animal = new Person();
    		/* 调用属性 */
    		System.out.println("=对象.属性===>" + animal.headNum);
    		System.out.println("--类名(接口).属性名---" + IAnimal.headNum);
    		/* 调用方法 */
    		animal.run();
    		/* 调用普通的方法
    		 * 对象名.方法
    		 *  */
    		animal.def_eat();
    		/* 静态的方法 */
    		IAnimal.static_eat();
    		
    		/* new一个Dog */
    		Dog dog = new Dog();
    		/*
    		 * 当调用一个方法或者属性的时候,如何当前类里面有此方法或者属性,就执行;
    		 * 如果当前类里面木有此类或者方法,往上找;
    		 * */
    		dog.def_eat();
    		
    		/*IAnimal animal2 = new Dog();*/
    		/* 提供了一个新特性
    		 * 此写法和上面的写法一样,
    		 * 下面的更装逼
    		 * 调用了new方法 */
    		IAnimal animal2 = IAnimal.createObj(Dog::new);
    		System.out.println("---->" + animal2);
    		
    		/* 返回值必须是@FunctionalInterface */
    		//String result = IAnimal::static_eat;
    	}
    }
    

  • 3.2 Lambda

    • 3.2.1 匿名类
    • 多线程实现

    import java.util.Date;
    
    /**
     * 实现多线程的一种方式;
     * ~多线程只要一启动,就会走一遍run方法
     * @author Administrator
     */
    public class MyRunnable implements Runnable
    {
    	@Override
    	public void run()
    	{
    		for (int i = 0; i < 10; i++)
    		{
    			System.out.println(new Date().toLocaleString() + 
    					"===" + i +"==>" + Thread.currentThread());
    		}
    	}
    }
    

    • 测试类

    import java.util.Date;
    
    /**
     * ~多线程,写了一个类,实现了runnable接口
     * ~匿名类
     * 		缺点:只使用一次;(代码只调用一次)
     * 		优点:在哪使用,在哪定义;方便
     * ~多个人同时开发;
     * @author Administrator
     */
    public class AnnoMain
    {
    	public static void main(String[] args)
    	{
    		/* 多线程;Runnable; */
    		/* 启动一个多线程;
    		 * 不是调用MyRunnable中的main方法 */
    		Runnable myRunnable = new MyRunnable() ; 
    		Thread t = new Thread(myRunnable);
    		/* 启动多线程 */
    		t.start();
    		/* -------匿名类----- 
    		 * new后面直接跟上接口名,只有在接口名后面直接写上类体才可以
    		 * 类体:包含属性和方法
    		 * public class 省略 implements Runnable
    		 * {
    		 * }
    		 * */
    		Thread t1 = new Thread(new Runnable()
    		{
    			/**
    			 * 匿名类里面的代码只能在此处使用一次
    			 */
    			@Override
    			public void run()
    			{
    				for (int i = 0; i < 10; i++)
    				{
    					System.out.println(new Date().toLocaleString() + 
    							"=lambdaMain==" + i +"==>" + Thread.currentThread());
    				}
    			}
    		});
    		t1.start();
    	}
    }
    

    • 3.2.2 lambda表达式

    import java.util.Arrays;
    import java.util.Date;
    import java.util.List;
    import java.util.function.Consumer;
    
    import com.jinghangzz.news.inter.IAnimal;
    import com.jinghangzz.news.inter.Person;
    
    /**
     * ~初识lambda
     * 	方法的参数得是接口;调用接口中的方法
    	接口的注解;(注解!=注释);@必须是;@FunctionalInterface
    	接口中的方法只能有一个是抽象的
    	方法的五要素;方法的参数是方法
     * @author Administrator
     */
    public class LambdaMain
    {
    	public static void main(String[] args)
    	{
    		/* 多线程
    		 * 参数是:runnable;是接口
    		 * 目的是想调用runnable中的run方法(抽象方法,只有一个)
    		 * lambda语法就是诊对run来定义的
    		 *  */
    		Thread t = new Thread( () -> 
    		{
    			/* ():run方法的参数
    			 * 方法体指的是run方法的方法体
    			 * 返回值: */
    			/* 方法体 */
    			for (int i = 0; i < 10; i++)
    			{
    				System.out.println(new Date().toLocaleString() + 
    						"==lambda=" + i +"==>" + Thread.currentThread());
    			}
    		});
    		t.start(); 
    		
    		/* 简写为一行 */
    		new Thread(() -> System.out.println("===lambda测试====")).start();
    		
    		/* lambda */
    		List list = Arrays.asList("test1","test2","aaa","test4");
    		System.out.println("-asList-->" + list);
    		/* 循环List */
    		list.forEach(new Consumer()
    		{
    			@Override
    			public void accept(String t)
    			{
    				System.out.println("==接口_low==>" + t);
    			}
    		});
    		
    		/* 高大尚 */
    		list.forEach(e -> System.out.println("==lambda==" + e));
    		/* 全版:木有简写 */
    		list.forEach((String e) -> 
    		{
    			System.out.println("==lambda=全版=" + e);
    		});
    		
    		/* Person::new */
    		/*IAnimal ani = new Person();*/
    		Person person = (Person) IAnimal.createObj(Person::new);
    		/* 创建了 List */
    		List aniList = Arrays.asList(person);
    		/* 循环:参数是Consumer;它的注解就是funtionInterface */
    		aniList.forEach(Person::def_eat);
    	}
    }
    

• 就这么多,理解错了就多多包涵<(￣3￣)>
• 未完待续…