密封类：
sealed 被继承类 permits可以被继承的类
public sealed class Animal permits Dog , Cat{
//定义一个 密封类 Animal, 只允许 Dog, Cat 继承
允许某个类的可以被 特定的类继承 ，子类必须是final或密封类（一般都用final），且 必须定义需要继承的子类
abstract 修饰（抽象）
抽象类
1.抽象类用 abstract 修饰，此类不能实例化 2.抽象类不能创建对象、但必须定义定义构造器，便于子类实例化是调用（子类对象实例化的过程） 3.抽象类使用前提：继承性
抽象方法
1.方法为抽象方法，此时该方法不能实现（不能实例化），具体实现由子类完成。 2.包含抽象方法的类，一定是一个抽象类。但是，抽象类中可以没有抽象方法的 3.子类 重写父类中的 所有抽象方法后，此子类才可以实例化（涉及到接口知识点，接口可以看成是特殊的抽象类） 4.若子类没重写父类中的所有的抽象方法，则此子类也是一个抽象类， 需要使用abstract修饰。
注意：
1.abstract不能用来修饰:属性、构造器等结构 2.abstract不能用来修饰私有方法、静态方法、final方法、final的类
public abstract class TuXing {
public abstract double zhouchang();
public double mianji(){
return 0;
}
}
关键字是有冲突的：
abstract与static 或者 final同时使用。
abstract 和 static 同时修饰类（内部类） ——可以。 static 和 final 同时 修饰 类，属性，方法 ——可以。 剩下的一律不可以同时修饰
abstract class Template{
//计算某段代码执行所需要花费的时间
public void spendTime(){
long start = System. currentTimeMillis();
this.code();//不确定的部分、易变的部分
long end = System. currentTimeMillis();
System.out.println("花费的时间为: " + (end-start));
}
public abstract void code();
}
class SubTemplate extends Template{
@Override
public void code() {
for(int i = 2;i <= 1000;i++){
boolean isFlag = true;
for(int j = 2;j <= Math. sqrt(i);j++){
if(i%j==0){
isFlag = false;
break;
}
}
if(isFlag){
System. out.println(i);
}
}
}
}
匿名内部类
new 类名(参数) implements 接口() { // 匿名内部类的类体部分 }
匿名内部类必须 且只能 继承一个父类，或实现一个接口。 规则： 匿名内部类不能是抽象类。 匿名内部类不能定义构造器。由于匿名内部类没有类名，所以无法定义构造器，但匿名内部类可以初始化块，可以通过初始化块来完成构造器需要完成的工作。
举例说明： 先创建一个接口
public interface Product{
double getPrice();
double getName();
定义一个 实体类，实体类 定义一个方法，方法的 参数 为上述的 接口的对象，到时候会传入一个匿名类对象，这个匿名类实现了上述创建的接口。
public class Anony{ public void test(Product product){ System.out.println("购买了一个"+product.getName()+"，花掉了"+product.getPrice()); } }
测试运行：
pubic class Test{
public static void main(String[] args){
Anony anony=new anony();
// 注意，此处要传入一个匿名类对象
anony.test(new Product(){
@Override
public double getPrice(){
return 2000.0;
}
@Override
public String getName(){
return "联想笔记本";
}
}
);
}
}
接口
接口很重要
接口的定义：
一个接口只有方法的特征没有方法的实现，因此这些方法可以在不同的地方被不同的类实现，而这些实现类可以具有不同的功能
请牢记：接口中不能定义构造器
接口的概念：
用关键字 interface 定义一个接口 用 implements 来实现接口 接口是为了 指定 标准、规则 提高可扩展性 实现低耦合，高内聚 接口与接口之间采用 多继承 接口与类之间采用 多实现 （多个类实现同一个接口）
接口的特点：
接口是特殊的抽象类 接口定义的 方法 必须是 抽象方法
（抽象方法只能存在与 抽象类 和 接口中 但抽象类里允许存在 非抽象方法 接口中必须全部都是抽象方法） 接口中的 属性 都是 public static final（公开静态常量）修饰的 接口中没有构造方法 接口中允许定义 default 成员方法 接口中 允许 定义 私有 成员方法 接口中 允许定义公开/私有 静态方法 ps：一个类实现这个接口 必须实现这个接口中定义的所有的抽象方法。
lambda表达式
接口中有且只有一个抽象方法 这样的接口可以称为函数式接口 @FunctionalInterface 用在接口 作用和@Override类似，用来检测该接口是否符合函数式接口的标准
函数式接口
数组补充 补充工具类方法 注意： 1.这三种方法需要用 流 来调用 2.区分 调用方法的参数列表 3.过滤，映射的返回值是数组的流（也可toArray成数组） 聚合的返回值是单个值 int流 （用getAsInt转成int类型）
过滤filter
Arrays.stream(arr).filter(s -> 判断语句) //返回值是流，有需要可用soArray转回数组 举例：
int[] arr = {1,2,3};
int [] ints = Arrays.stream(arr).filter(s -> s%2==0).toArray();
System.out.println(Arrays.toString(ints));
映射map
//map
int[] arr = {1, 2, 3};
int[] arr2 = Arrays.stream(arr).map(s -> s * 3).toArray();
System.out.println(Arrays.toString(arr2));
聚合reduce
//reduce 聚合
int[] arr = {1, 2, 3};
int arr2 = Arrays.stream(arr).reduce((max,a)->max > a?max:a).getAsInt();
System.out.println(arr2);
