java上课笔记

@TOP(上课笔记)
1.授课内容
接口有变化
lambda表达式;λ
流编程:Stream;
2.Why
2.1.Jdk1.8
新功能
3.介绍
3.1.接口
方法五要素:
修饰符,
返回值
方法名
参数
方法体
啥是抽象方法:抽象方法是一个特殊的方法;
木有方法体
被abstract修饰
啥是类
属性
方法
啥是抽象类:抽象是一个特殊的类
对属性木有要求
至少有0个抽象方法;
如果此类有一个方法是抽象的,此类必须抽象类
类被abstract修饰
不能new
啥是接口;接口是一个特殊的抽象类
接口里面的方法全部是抽象的,
属性全部是:public static final;
标准
三流的公司卖服务,二流的公司写实现,一流的公司写接口
标准:
属性可以是不变,是标准,
所有实现类的方法也是一样的
新特性:
接口里面的方法可以有方法体:就不再是抽象的方法;
如何调用普通方法呢?
New对象,对象.方法();
Static修饰的,直接使用类名.方法名();
3.2.Lambda表达式–λ
完全是被,js,scala,python给逼出来的;
木有lambda表达式,是如何做的;匿名类;
Java的开发
创建一个类
继承父类和接口
定义属性和方法
New对象
调用属性和方法
方法的参数类型;有两大类,11小类;(基本数据类型和引用类型)
疑问:为啥方法的参数不能是方法呢?
参数的方法要执行,方法本身也要执行;
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.数据流–stream
懒:能往后拖就往后拖;
如果数据源要是静止不变的,懒与不懒木有区别
如果数据源是经常发年变化的,先攒一攒;
攒到一定程度再一块执行;
2秒,1秒;
spark中的stream;
方法分为两类
返回值是它自已Stream;transformation算子;(懒)
返回值是非Stream;action算子(如果碰到了action算子,必须执行)
4.实战
4.1.接口

动物接口
package com.jinghangzz.news.inter;

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();
    }
    }

人实现类
package com.jinghangzz.news.inter;

/**

• 人

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

  @Override
  public void def_eat()
  {
  System.out.println("=Persondef_eat");
  }
  }

狗实现类
package com.jinghangzz.news.inter;

/**

• ~实现;孝子
• ~不实现;不孝子
• @author Administrator

*/
public class Dog implements IAnimal
{

@Override
public void run()
{
	System.out.println("===Dog=run===");
}

}

测试类
package com.jinghangzz.news.inter;

/**

• 测试类

• ~标准的多态;

•  动物的接口
  

•  人和狗的实现类
  

•  写了一个多态;父类引用指向子类对象
  

• ~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;
  

  }
  }
  4.2.Lambda
  4.2.1.匿名类
  多线程实现类
  package com.jinghangzz.news.lambda;

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());
  }
  }
  }
  测试类
  package com.jinghangzz.news.lambda;

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();
  }
  }
  4.2.2.lambda表达式
  package com.jinghangzz.news.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<String> list = Arrays.asList("test1","test2","aaa","test4");
   System.out.println("-asList-->" + list);
   /* 循环List */
   list.forEach(new Consumer<String>()
   {
   	@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<Person> aniList = Arrays.asList(person);
   /* 循环:参数是Consumer;它的注解就是funtionInterface */
   aniList.forEach(Person::def_eat);
  

  }
  }

5.总结