Java初学习

基本理解

1. 在 Java 中，类的继承是单一继承，也就是说，一个子类只能拥有一个父类，所以 extends 只能继承一个类。

2. super关键字：我们可以通过super关键字来实现对父类成员的访问，用来引用当前对象的父类。当需要在子类中调用父类的被重写方法时，要使用 super 关键字。
   this关键字：指向自己的引用。

3. final 可以用来修饰变量（包括类属性、对象属性、局部变量和形参）、方法（包括类方法和对象方法）和类。
   把类定义定义为最终类，不能被继承，或者用于修饰方法，该方法不能被子类重写。

4. 类的实例化结果就是对象，⽽对⼀类对象的抽象就是类。

5. 方法签名由方法名称和一个参数列表(方法的参数顺序和类型)组成。

6. （1）基本类型存储在栈里，包装类型存储在堆里。因为栈的效率更高，所以保留了基本类型。
   （2）包装类是对象，拥有方法和字段，对象的调用是引用对象的地址。

7. 抽象类表示的是一种继承关系，一个类只能继承一个抽象类，而一个类却可以实现多个接口。

8. 接口：在JAVA编程语言中是一个抽象类型，是抽象方法的集合，接口通常以interface来声明。一个类通过继承接口的方式，从而来继承接口的抽象方法。接口不是类。接口无法被实例化，但是可以被实现。

9. static用例：

   原文链接：https://blog.csdn.net/qq_45671732/article/details/115800465

public class Bianlitry {

    //static学习
    public static String s1="xcx";
    public String s2="xcx2";

    public static void main(String[] args) {

        Bianlitry a=new Bianlitry();
        System.out.println(s1);
        System.out.println(a.s2);
}

函数式接口

原文链接：https://blog.csdn.net/qq_32719221/article/details/102468633

概念

函数式接口在Java中是指：有且仅有一个抽象方法的接口。
函数式接口，即适用于函数式编程场景的接口。而Java中的函数式编程体现就是Lambda，所以函数式接口就是可以适用于Lambda使用的接口。只有确保接口中有且仅有一个抽象方法，Java中的Lambda才能顺利地进行推导。
函数式接口的使用:一般可以作为方法的参数和返回值类型。

常见接口用例子 Supplier接口

仅包含一个无参的方法：T get()。用来获取一个泛型参数指定类型的对象数据。

    public static int getmax(Supplier s){
        return s.get();
    }
    
    public static void main(String [] args){
      List list = Arrays.asList(1,2,30,8,0,9,100);

     //Supplier
    int max=getmax(()
      ->{
          int mi=0;
          for (Integer i:list){
              if(i>mi)
                  mi=i;
              }
          return mi;
      });
        System.out.println(max);
}

consumer接口

Consumer接口中包含抽象方法void accept(T t)，意为消费一个指定泛型的数据。
Consumer接口是一个消费型接口,泛型执行什么类型,就可以使用accept方法
消费什么类型的数据至于具体怎么消费(使用),需要自定义(输出,计算…)

public static void main(String [] args){
      List list =Arrays.asList(1,2,30,8,0,9,100);

     //Consumer
      list.forEach((mm)
                ->{
                int ma=10;
                if(mm>ma){
                    System.out.print("俩数相差");
                    System.out.println(mm-ma+"n原值为"+mm);
                  }
        }
        );
}

Predicate接口

Predicate接口中包含一个抽象方法：
boolean test(T t):用来对指定数据类型数据进行判断的方法
结果:
符合条件,返回true
不符合条件,返回false

 public static boolean judje(String s, Predicate p){
        return p.test(s);
    }
  public static void main(String [] args){  
            //Predicate
        String s="abcdadafaf";
        boolean p=judje(s,(str)->str.length()>5);
        System.out.println(p);
 }

多个判断请看上文链接。

Java流的操作 创建

1. 通过 java.util.Collection.stream() 方法用集合创建流

List list = Arrays.asList("a", "b", "c");
// 创建一个顺序流
Stream stream = list.stream();
// 创建一个并行流
Stream parallelStream = list.parallelStream();

2. 使用 java.util.Arrays.stream(T[]array)方法用数组创建流

int[] array={1,3,5,6,8};
IntStream stream = Arrays.stream(array);

常用方法 Intermediate类型

Filter：过滤元素
Map：把一个类型的数据类型转换为另一个数据类型
Skip：跳过前n个元素
Limit：获取前n个元素
Flatmap：把input Stream的每一个元素，映射成output Stream的另外一个元素
Distinct：把相同的元素过滤
Peek：对每个元素执行操作并返回一个新的stream
Parallel ：实现任务的切分，并行流
Sequential：实现任务的合并，顺序流，连续流
unordered ：消除相遇顺序（以提升并行流的性能）

Terminal类型

Foreach：遍历元素
Count：统计流中的元素个数
Statistics：统计收集器
forEachOrdered：需要先使用sorted方法排序，再使用该方法，该方法可以保证动作是有序应用到流上的
toArray：转化为特定类型的数组
reduce：这个方法的主要作用是把 Stream 元素组合起来。
collect： 流的收集器
min：求出流中的最小值
max：求出流中的最大值
count：统计流中的元素个数
anyMatch：至少匹配一个元素，返回真
allMatch：匹配全部元素，返回真
noneMatch：没有一个元素匹配，返回真
findFirst：返回第一个元素
findAny：返回当前流的任意元素
iterator：流迭代器
Concat：合并两个流，组合成新流

示例

public class Liutry {

    public static void main(String[] args){
        //int []a={1,2,10,9,5,8,12,3,0,7};
        List list =Arrays.asList(1,2,10,9,5,8,12,3,0,7);
        List s=list.stream().
                filter((i)->{
                        return i%2==0;
                }).
                map((i)->{
                    return i*2;
                }).
                sorted().
                collect(Collectors.toList());

        System.out.println(s);

    }
}

Java注解 作用

编写文档：通过代码里标识的元数据生成文档。
代码分析：通过代码里标识的元数据对代码进行分析。
编译检查：通过代码里标识的元数据让编译器能实现基本的编译检查

元注解 基本内置注解 1. @Override :

对覆盖超类中方法的方法进行标记，如果被标记的方法并没有实际覆盖超类中的方法，则编译器会发出错误警告。

public class OverrideDemoTest {
    @Override
    public String tostring() {
        return "测试注解";
    }
}

2. @Deprecated

对不应该再使用的方法添加注解，当编程人员使用这些方法时，将会在编译时显示提示信息。

public class DeprecatedDemoTest {
    public static void main(String[]args) {
        // 使用DeprecatedClass里声明被过时的方法
        DeprecatedClass.DeprecatedMethod();
    }
}
 
class DeprecatedClass {
    @Deprecated
    public static void DeprecatedMethod() {
    }
}

3. @SuppressWarnings

其参数有：
deprecation，使用了过时的类或方法时的警告
unchecked，执行了未检查的转换时的警告
fallthrough，当 switch 程序块直接通往下一种情况而没有 break 时的警告
path，在类路径、源文件路径等中有不存在的路径时的警告
serial，当在可序列化的类上缺少serialVersionUID 定义时的警告
finally ，任何 finally 子句不能正常完成时的警告
all，关于以上所有情况的警告

public class SuppressWarningsDemoTest {
    public static List list = new ArrayList();
    @SuppressWarnings("unchecked")
    public void add(String data) {
        list.add(data);
    }
}

自定义注解

1. 类似于新创建一个接口文件，但为了区分，我们需要将它声明为@interface

public @interface NewAnnotation {
}

2. 使用自定义的注解类型

public class AnnotationTest {
    @NewAnnotation
    public static void main(String[]args) {
    }
}

3. 为自定义注解添加变量

public @interface NewAnnotation {
    String value();
}

public class AnnotationTest {
    @NewAnnotation("mainmethod")
    public static void main(String[]args) {
        saying();
    }
     
    @NewAnnotation(value="saymethod")
    public static void saying() {
    }
}

4. 定义一个枚举类型，然后将参数设置为该枚举类型，并赋予默认值

public @interface Greeting {
    public enum FontColor {
        BLUE,
        RED,
        GREEN
    };
    String name();
    FontColor fontColor() default FontColor.RED;
}

5. 这里有两种选择，其实变数也就是在赋予默认值的参数上，我们可以选择使用该默认值，也可以重新设置一个值来替换默认值

public class AnnotationTest {
    @NewAnnotation("mainmethod")
    public static void main(String[]args) {
        saying();
        sayHelloWithDefaultFontColor();
        sayHelloWithRedFontColor();
    }
 
    @NewAnnotation("saymethod")
    public static void saying() {
    }
     
    // 此时的fontColor为默认的RED
    @Greeting(name="defaultfontcolor")
    public static void sayHelloWithDefaultFontColor() {
    }
 
    // 将fontColor改为BLUE
    @Greeting(name="notdefault", fontColor=Greeting.FontColor.BLUE)
    public static void sayHelloWithRedFontColor() {
    }
}