Java基础知识点总结

• 1.java标识符

  • 命名规则

    • 标识符只能由数字、字母、下划线以及美元符号组成，不能以数字开头。

    • java中严格区分大小写，理论上没有长度限制。

    • 不能使用关键字和保留字，但是能包含关键字和保留字。

    • 标识符不能包含空格。

  • 命名规范

    • 类名、接口名首字母大写，后面的每个词开头也必须大写开头

    • 方法名、函数名、变量首字母小写，后面的每个词开头以大写开头

    • 常量名全部大写，单词之间使用_衔接

  • 盘符切换注意事项

    • 如果我们要切换盘符的目录，正确的用法是在cd和路径中间增加一个“/d”，如cd/dd:

    • 当我们要切换盘符时，可以不用cd指令，直接用输入盘符：，如执行e：可以切换到E盘。

• 2.数据类型

  • 基本数据类型

    • 整数型：byte、short、int、long =》 1 2 4 8

    • 浮点型：float、double =》 4 8 声明float变量需要后面加上F

    • 布尔型：boolean ==》1

    • 字符型：char ==》 2 （一个中文占用2个字节，因此字符变量可以储存一个中文汉字）

  • 数据类型转换

    • 小的数据类型可以自动向大的数据类型转换

    • 多种数据类型混合运算，系统将所有数据转换成容量大的那种数据类型，然后再进行计算。

    • 大容量的数据类型转换成小容量的，需要进行强制类型转换，编写时需添加“强制类型转换符”。

    • byte、short、char之间不会相互转换，计算时先转换为int类型

    • 整数型字面量没有超出byte、short、char的取值范围，可以直接将其赋值为byte，short，char类型的变量

    • 字符串不能转换为基本类型；布尔类型也不能转其它数据类型。

    • 例子： byte a=3,b=4; byte f = a+4; //报错，因为在执行a+4语句时，后面为int类型，而前者为byte类型，需要强制转换

• 3.运算符

  • ++和–的区别

    • a++ 是先赋值后计算，++a是先计算后赋值；–道理是一样的
    • 包括使用其它运算符进行计算时，也是遵循上述的方式

  • 赋值运算符

    • += 、-=、*=、/=、%=

    • x -= 1 ===> x = x + 1

  • 逻辑运算符

    • “&”和“&&”的区别

      • “&”，左边无论真假，右边都会进行运算

      • “&&”，如果左边为真，右边参与计算，如果左边为假，右边则不参与运算。

  • 条件运算符

    • 表达式：（条件表达式）？表达式1：表达式2

    • 如果条件为true，运算结果为表达式1；否则为表达式2。

  • [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-y2O2k2Bn-1691477848231)(C:\Users\PC\AppData\Roaming\Typora\typora-user-images\image-20230808132454706.png)]

• 4.控制语句

  • 选择语句

    • switch()语句

      switch(int/String 数据类型){
          case int/String 数据类型:
      ​               java语句;
                     break;
      ……
          default:
      ​              java语句;
      ​ }
      

      • switch表达式中的返回值必须是下述几种类型之一：int byte char short 枚举 字符串

      • case子句中的变量值必须是常量

  • 循环语句

    • do while和while循环的区别

      • do while 是肯定执行一次，且while语句后需要加上分号符

      • do while循环体执行次数为N-1次，而while循环体的执行次数为N次

    • continue和break

      • continue终止当前本次循环，break则是终止循环的执行

• 5.方法

  • 方法重载

    • 重载满足条件：

      • 在同一个类中；方法名相同；参数列表不同（个数、顺序、类型）

      • 不能通过参数名去区分两个方法

      • 不能通过返回值的类型来区分两个方法

      • Java的重载是可以包括父类和子类的，即子类可以重载父类的同名不同参数的方法 ￥￥￥

• 6.面向对象

  • 构造器

    • 格式：<修饰符> <类名>（[<参数表>]）{ [< 语句 >] }

    • 作用：利用构造器参数初始化对象的属性。

    • 具有与类相同的名称，没有返回值

    • 功能：创建类的实例时，初始化实例的一组指令。

    • Java语言每个类至少含有一个构造方法，系统一般默认提供一个无参构造方法

    • 构造方法可以被重载。

    • 默认构造器的修饰符只跟当前类的修饰符有关，如果当前类的修饰符是public，则构造器的修饰符也是public

  • 封装

    • Java中通过将数据声明为私有的（private），再提供公开的（public）方法：getXXX和setXXX实现对该属性的操作，以达到下述目的：

      • 隐藏一个类的实现细节

      • 使用者只能通过事先定制好的方法来访问数据，可以方便地加入控制逻辑，限制对属性的不合理操作；

      • 便于修改，增强代码的可维护性；

  • this关键字

    • this不能使用在static的方法中，可以使用在实例方法中，代表当前对象

    • 多数情况下this关键字可以省略，但是在区分局部变量和实例变量时不能省略

    • this关键字只能出现在构造方法内的第一行，可以实现代码的复用，用关键字省去this.name=name等步骤

      • 用法：this(参数) 上述的就可表示为this(name)

    • 每个成员方法内部，都有一个this引用变量，指向调用这个方法的对象。

    • this（）调用本类中的无参构造方法

  • static关键字

    • 用于修饰类的成员（成员变量、属性、方法、内部类、代码块）

    • static修饰的成员为类成员，为类中的所有实例所共享。

    • static修饰的方法称为类方法。

    • 静态变量存储在方法区中（在类加载时被初始化），实例变量存储在堆内存中

    • 在访问权限允许的前提下，static修饰的成员可以通过“类名.”的方式去访问（无需创建对象，当然也可以通过对象的方式访问）

    • static方法内部只能访问类的static属性，不能访问非static属性；反之，非static方法可以访问类的static成员

    • 静态方法中不能以任何方式引用this和super关键字

    • 静态代码块（一般都是最先开始执行的）经常用来进行类属性的初始化，遵循自上而下的执行顺序。

    • 静态代码块在 类加载时执行，并且在main方法执行之前执行。

    • static不能修饰方法体内的局部变量

    • 单态设计模式

      • 保证在整个软件系统中，对某个类只能存在一个对象实例

        • 1、在外部不能通过new 构造器的方式创建实例，因此需要把构造器隐藏起来，及构造器私有化

        • 2、因为在类的外部不能创建类的实例，只能在类的内部创建

        • 3、为了让类的外部可以直接使用该实例，使用static修饰

        • 4、不能在类的外部修改该属性：私有化该属性，同时提供共有的get方法访问

  • 继承（extends）

    • java中的继承只支持单继承，不支持多继承（可以间接继承）。

    • 继承中除去构造方法和被private修饰的数据无法被继承外，剩下的都可被继承

  • 方法覆盖(Override)

    • 覆盖满足条件

      • 1）方法覆盖发生在具有继承关系的父子类之间

      • 2）覆盖后的方法和原方法具有相同的返回值类型、方法名以及形式参数列表

    • 注意事项：

      • 私有方法和构造方法无法被继承，所以不能覆盖

      • 覆盖后的方法不能比原方法有更低的访问权限，可以更高

  • 多态

    • 多态：同样类型的变量，调用同样的方法，却产生完全不同的行为（父类型引用指向子类型对象）

    • 1.当父类类型的变量指向一个子类的对象，调用父类中已经被重写的方法

    • 2.在多态的情况下（当父类类型的变量指向一个子类的对象）：不能调用子类添加的方法。

    • 3.在多态的情况下，可以对对象进行强制的类型转换。

      • 3.1 父类的对象可以转为任何子类的类型，但有可能会发生：java.lang.ClassCastException

      • 3.2 只有在有父子关系的情况下，才能进行强制的类型转换。

    • instanceof操作符

      • x instanceof A: 检验x是否为类A的对象，返回值为boolean型。

      • 要求x所属的类和类A必须是子类和父类的关系，否则编译出错

      • 如果x属于类A的子类B，x instanceof A值也为true。

    • 多态存在的三个必要条件：

      • 继承、方法覆盖、父类型引用指向子类型引用

    • 类型转换

      • 向上转型：通过子类对象（小范围）转化为父类对象（大范围），这种转换是自动完成的，不用强制。

      • 向下转型：通过父类对象（大范围）实例化子类对象（小范围），这种转换不是自动完成的，需要强制指定。

  • super关键字

    • super只是代表当前对象中那部分父类型特征

    • 用法：

      • 1、在子类对象的方法中引用父类对象的成员。

      • 2、在子类的构造器中调用父类的构造器。

        • 2.1 可以在子类中通过super(参数列表)的方式类调用父类的构造器

        • 2.2 默认情况下子类的构造器调用父类的无参数的构造器

      • 3、若父类定义了带参数的构造器，则系统将不再为父类提供无参数的构造器，而子类的构造器中必须调用父类的一个构造器。

        • 3.1 父类显式定义个无参数的构造器

        • 3.2 在子类 的构造器中显式的调用父类带参数的构造器 super(name, age);

      • 访问父类中定义的属性、调用父类中定义的成员方法

      • 实例：在方法覆盖中使用super

        • return super.getInfo()+“school:”+school;

      • 注意：super无法在static静态方法中使用

    • super 在什么情况下不能省略了吗？

      • 当父类中有该实例变量，子类中又重新定义了同名的实例变量，如果想在子类中访问父类的实例变量， super 不能省略

    • super(实际参数列表)和this(实际参数列表)都是只允许出现在构造方法第一行

    • 与this类似，super(参数列表)必须放在构造器第一行，说明这两者不能同时存在

  • final关键字

    • 可以修饰类、属性、方法，表示最终的

    • final修饰的属性，是最终的属性-属性值不能被修改，即常量

      • 必须在声明时被初始化，或在非静态代码块，或在构造器中初始化

    • final 修饰的方法，是最终的方法-该方法不能被修改–同样也无法被重写

    • final修饰的类，是最终的类-该类不能被扩展-该类不能被继承

    • 构造方法不能被final修饰

    • final修饰的引用，这个引用只能指向一个对象，也就是说对象不能再次赋值（不能 new），但被指向的对象是可以修改的。

  • 抽象类（abstract）

    • 抽象方法只需在抽象类中，提供声明，不需要具体实现过程。

    • 一个类中含有抽象方法，这个类必须定义为抽象类。

    • 这个类是抽象的，那这个类被子类继承时，抽象方法必须要进行重写（强制约束作用），如果子类中的方法不重写，必须将该子类再次声明为抽象类

    • 抽象类不能实例化，只能被继承，抽象类中可以有构造方法，（构造函数也是可以有的，用于初始化其子类）

    • 抽象方法不能被final修饰，因为抽象方法就是被子类实现的

    • 抽象方法不能被声明为静态(抽象方法一般都是需要被实例化的)

    • abstract关键字只能修饰类和对象，不能修饰字段

    • 抽象类的抽象方法不能实现。

    • 注意事项：

      • 1.有抽象方法的类一定是抽象类，但抽象类中可以没有抽象方法

      • 2.不能用abstract修饰私有方法，构造方法，静态方法

  • 接口(interface)

    • 接口中的方法默认都是 public abstract的，不能更改

    • 接口中的变量默认都是public static final类型的，不能更改，必须显示初始化

    • 接口不能被实例化，接口中没有构造函数

    • 接口之间可以继承，但是接口之间不能实现

    • 接口中的方法只能通过类来实现，即通过implements关键字

    • 如果一个类实现了接口，那么接口中所有的方法必须实现

    • 一个类可以实现多个接口，接口之间使用逗号隔开

    • 若 一个类继承父类，同时又实现一个接口，则extends必须在implements前

    • 接口只能使用两种访问修饰符：public、default。

    • 接口中没有构造函数

  • Object 类及其主要方法

    • ==操作符与equals方法

      • 1.==：

        • ==比较两个对象在内存里是不是同一个对象，就是说在内存里的存储位置一致

        • 1.1 引用类型比较引用（是否指向同一个对象）

        • 1.2 用“==”进行比较时，符号两边的数据类型必须可兼容，否则编译出错

      • 2. equals():

        • 对于字符串变量来说,equal比较的两边对象的内容，所以内容相同返回的是true

        • 对于非字符串变量，equals比较的内存的首地址，这时候和==是一样的，即比较两边指向的是不是同一个对象

        • 2.1 只比较引用类型，其作用与“==”相同，比较是否指向同一个对象

        • 2.2 当用equals()方法进行比较时，对类File、String、Date及封装类（Wrapper Class）来说，是比较类型及内容而不考虑引用的是否是同一个对象，因为在这些类中覆盖了equals()方法

    • toString()

      • 返回对象的字符串表示，返回一个“以文本方式表示”此对象的字符串

    • 访问控制权限

    • 常见方法：

      • clone方法、getClass方法、toString方法、finalize方法、hashCode方法、wait方法

  • 内部类

    • 和外部类不同，Inner class可以声明为private或protected

    • 非static的内部类中的成员不能声明为static的，只有在顶层类或者static的内部类中可声明static成员。

    • 实例内部类

      • 实例内部类会有外部类的引用

      • 实例内部类不能定义static成员，只能定义实例成员

    • 静态内部类

      • 静态内部类可以访问内部的静态变量，如果访问外部类的成员变量必须通过外部类的实例访问

      • 静态内部类不会含有外部的类的引用，创建时可以不用创建外部类

      • 不能直接引用外部类的实例变量

    • 匿名内部类

      • 在类的内部直接创建一个接口的实现类对象，该对象称为匿名内部类对象。

    • 创建非静态的内部类的对象：

      • 外部类 外部类对象名=new 外部类构造器;

      • 外部类.内部类 内部类对象名=new 外部类对象名.new 内部类构造器;

    • 创建的是一个静态内部类的对象:

      • 外部类.内部类 内部类对象名=new 外部类名.内部类构造器;

  • 初始化顺序

    • 静态属性：static开头的属性

    • 静态方法块：static{} 包起来的代码块

    • 普通属性：非static定义的属性

    • 普通方法块：{}包起来的代码块

    • 构造函数：类名相同的方法

    • 方法：普通方法

    • 父类静态变量-》父类静态代码块-》子类静态变量-》子类静态代码块-》父类非静态变量-》父类非静态代码块-》父类构造方法-》子类非静态变量-》子类非静态代码块-》子类构造方法

    • 注：静态变量和静态代码块是按代码的顺序执行

  • 构造函数调用顺序：

    • 子类没有显示调用父类构造函数，不管子类构造函数是否带参数都会默认调用父类的无参构造函数。

• 异常

  • Java提供的是异常处理的抓抛模型

  • Exception类是所有异常类的父类，Error类是所有错误类的父类，这两个类都是Throwable类的子类。

  • NollPointerException 空指针异常，如果去调用其属性和方法就会报异常

  • 异常处理机制

    • 采用try-catch-finally语句实现

    • try{……}语句块选定捕获异常的范围，将可能出现异常的代码块放在try语句块中

    • catch语句块是对异常对象进行处理的代码，每个try语句块可以伴随着一个或多个catch语句，用于处理可能产生的不同类型的异常对象

    • 可以将异常的父类当作catch的参数，但是不能是与异常类无关的异常，否则，catch中的语句将不会执行。

  • 捕获异常的有关信息

    • getMessage()方法，用来得到有关异常事件的信息

    • printStackTrace()用来追踪异常事件发生时执行堆栈的内容

  • finally

    • 捕获异常的最后一步是通过该语句为异常处理提供一个统一的出口

    • 不论try、catch代码块中是否发生了异常事件，finally块中的语句都会被执行。

    • finally语句是可选的

    • finally 必须和 try 一块使用

    • finally无论如何也会执行,在那之前catch或者正常 代码中如果有其它的return或者throw exception,会被暂存起来等待finally执行完后在执行;而finally中有return则前面的throw和return会被忽略 （还需再看看）

  • 注意：异常类的父类要放在异常类的子类的后面，否则出错

  • 声明抛出异常

    • 用法：在方法参数列表的后面使用throws关键字声明抛出异常

      • 1.异常在当前方法内部不处理，而抛给当前方法的方法

      • 2.可以声明抛出多个异常，多个异常使用，进行分割，多个异常没有顺序

      • 3.可以声明抛出出现的异常类的父类。

      • 重写方法不能抛出比重写方法范围更大的异常类型（均指非运行时异常）

  • 人工抛出异常

    • 首先生成异常类对象，然后通过throw语句实现抛出操作

    • 可以抛出的异常必须是Throwable或其子类的实例。

  • 自定义异常（抛出异常后一定要捕获异常才可）

    • 自己定义的异常类,通常情况下继承RuntimeException

    • 基本实现

      public class UserNotFoundException extends RuntimeException {
      private static final long serialVersionUID = 1L;    public UserNotFoundException() {
          }
      public UserNotFoundException(String msg) {
      super(msg);    }
      }
      

    • 自定义异常的作用:看见异常类的名字,就知道出现了什么问题

    • 自定义异常通常都需要使用throw关键字进行抛出

  • 注意:

    • Integer.parseInt(args[0]);上述方法将字符串类型转换成对应的int值

  • 编译时异常，必须显示异常throw

• 集合

  • 集合区分：

    • List是一个有序集合，可存放重复的数据

    • Set是一个无需集合，不允许放重复的数据

    • Map是一个无序集合，键对象不允许重复，值对象可以重复。

  • collection接口

    • collection接口是List、Set和Queue接口的父接口，该接口里定义的方法即可用于操作Set集合，也可以用于操作List和Queue集合

    • 常见方法

      • add(Object obj)：添加一个元素到集合中

      • addAll(Collection collection)：添加一组元素到集合中

      • 在Collection中无法获取指定的元素，但可以遍历所有的元素

        • 1. 使用增强的for循环

             for(Object obj: 集合)
             

        • 2. 使用Iterator迭代器

          • 2.1 获取迭代器对象：调用Collection中的iterator()方法，获取Inerator接口的对象*

          • 2.2 调用Iterator接口的方法进行迭代*

          • Iterator iterator = set.iterator();
              while(iterator.hasNext()){
                 System.out.println(iterator.next());
              }
            

      • clear()：清空集合

      • remove(obj)：移除指定的元素，通过equals()方法在集合* 中查找指定的元素，若存在，则移除

      • removeAll(Collection collection) 移除中有的元素

      • remainAll(Collection collection) 保存collection中的元素

      • contains(Object o)：利用equals()比较，查看集合中有没有指定的元素

      • containsAll(Collection<?> c)：查看集合中没有指定元素的集合

      • isEmpty()：检验集合是否为空集合

      • toArray()：把集合中元素转换为Object 对象的数组

  • Set 集合

    • Set集合不允许包含相同的元素

    • Set判断两个对象是否相同不是使用==运算符，而是根据equals方法

    • HashSet和TreeSet都继承自AbstractSet

    • HashSet

      • HashSet是Set接口的典型实现

      • HashSet按Hash算法来存储集合中的元素

      • 以下特点：

        • 不能保证元素的排列顺序

        • HashSet不是线程安全的

        • 集合元素可以是null

    • LinkedHashSet

      • LinkedHashSet集合根据元素的hashCode值来决定元素的存储位置

      • 元素的是按插入顺序保存的

      • 不允许集合元素重复

      • LinkedHashSet也是不安全的

      • 其插入性能略低于Hashset

    • TreeSet

      • 默认情况下TreeSet要求集合中的元素必须实现Comparable接口

      • Comparable接口中只有一个方法：

        • public int compareTo(T o)：若是返回0代表两个元素相等，若返回整数，代表当前元素大，若返回负数，代表当前元素小。

        •     public int compareTo(Object o) {
                  if(o instanceof Person){
                      Person person = (Person)o;
                      return this.name.compareTo(person.name);
                  }else {
                      throw new ClassCastException("不能转为Person对象");
                  }
              }
          

      • TreeSet会调用每个元素的compareTo()方法去和集合中的每个已经有的元素去比较，进而决定当前元素在集合中的位置。

      • 当把一个对象放入TreeSet中，重写该对象对应的equals()方法时，应保证该方法与compareTo(Object obj)方法有一致的结果。

    • 定制排序

      • 创建TreeSet集合对象时，提供一个Comparator接口的实现类对象。

        Comparator comparator = new Comparator(){
        
                   @Override
                   public int compare(Object o1, Object o2) {
                       if(o1 instanceof Person1 && o2 instanceof Person){
                           Person1 person1 = (Person1) o1;
                           Person1 person11 = (Person1) o2;
                           return person1.getAge() - person11.getAge();
                       }else {
                           throw new ClassCastException("不能转换为Person1类型");
                       }
                   }
               };
        //创建TreeSet对象，传入Comparator接口的实现类对象
        TreeSet set = new TreeSet(comparator);
        

    • 常见的一些方法

      • SortedSet tailSet(fromElement) 该方法需要重写对象中的equals方法
      • Object first()

  List 特点：

  • List代表一个元素有序、且可重复的集合，集合中的每个元素都有其对应的顺序索引

  • List允许使用重复元素，可以通过索引来访问指定位置的集合元素

  • List默认按元素的添加顺序设置元素的索引

  • List集合里添加了一些根据索引来操作集合元素的方法

    void add(int index, Object ele)  // 根据索引添加元素
    boolean addAll(int index, Collection eles) // 根据索引添加一组元素
    Object get(int index) // 
    int indexOf(Object obj) // 获取指定元素的索引值，若元素不存在返回-1
    注：indexOf方法需要重写equals方法
    int lastIndexOf(Object obj) // List中可以存放重复的元素，获取重复元素的最后一个索引
    Object remove(int index) // 移除指定元素的索引值
    Object set(int index, Object ele) // 设置index位置的元素为ele，原来的元素被替代
    List subList(int fromIndex, int toIndex) // 
    

  • list遍历方式

    //list独有的遍历方式
            for(int i = 0;i < list.size(); i++){
                Object object = list.get(i);
                System.out.println(object);
            }
    

  • ArrayList

    • ArrayList.asList() 方法返回的List集合既不是ArrayList实例也不是Vector实例。
    • 其返回值是一个固定长度的List集合。
    • ArrayList 是线程不安全的，而 Vector 是线程安全的。

• Map

  • Map集合里保存着两组值，一组值用于保存Map里的key，另一组则是Map的Value

  • Map中的Key不允许重复，即同一个Map对象的任何两个Key通过equals方法比较中返回false

  • key和value之间存在单向一对一关系

  • Map的遍历

     //对Map进行遍历
            //1.遍历键的集合：keySet()
            //2.遍历值的集合：values()
            //3.得到键值对的组合
             Set keySet = map.keySet();
            Iterator it = keySet.iterator();
            while(it.hasNext()){
                Object key = it.next();
                Object val = map.get(key);
                System.out.println(val);
            }
    

  • HashMap和Hashtable

    • Hashtable是一个线程安全的Map实现，但是HashMap是线程不安全的
    • Hashtble不允许使用null作为key和value，而HashMap的键值对可以为Null

  • Properties

    • Hashtable的子类，该对象用于处理属性文件

    • properties里的key和value都是字符串类型的

      public void testProperties() throws IOException {
              //读取jdbc.properties
      
              //1.创建Properties对象
              Properties properties = new Properties();
              //2.调用Properties的load()方法加载属性文件对应的输入流
              InputStream inStream = PropertiesTest.class.getClassLoader().getResourceAsStream("jdbc.properties");
              properties.load(inStream);
              //3.调用getProperty(String key)方法获取属性值
              String user = properties.getProperty("user");
              System.out.println(user);
          }
      

  • Collections（工具类）

    • 排序操作
      • reverse(List)：反转List中元素的顺序
      • shuffle(List)：对List集合元素进行随机排序
      • sort(List)：根据元素的自然顺序对指定的List集合按升序排序
      • sort(List, Comparator)：根据指定的Comparator产生的顺序对List集合元素进行排序

  • 泛型

    • 泛型使用<>括起来，例如List 代表集合中的类型是Integer
    • 把list集合中的内容限制为一个特定的数据类型
    • 使用集合中泛型会使类型更安全，不再需要强制的类型转换
    • 1、定义泛型方法：
      • 在类（不一定是泛型类）中使用泛型方法
      • 在方法的返回值前使用 <>声明泛型类型，则在方法的返回值、参数、方法体中可以使用该类型
    • 2、通配符
      • 如果Foo是Bar的一个子类型（子类或子接口），而G是某种泛型声明，那么G是G的子类型并不成立！：Person是Object的子类，但List却不是List的子类！
        • printPersons(List persons)；该方法的参数只能是Person类型的List，而不能是Person任何子类的List
      • Collection<?> 就是一个集合，它的元素类型可以匹配任何类型，称为通配符
      • 将任意元素加入到其中不是类型安全的，null除外！因为null可以是任何类型的。
      • 有限制的通配符
      • public void drawAll(List<? extends Shape> shapes) { //…}

• 数组

  • 一维数组

    • 声明： 数组元素的类型[] 变量名称 数组元素的类型 变量名称[]

    • 初始化：int[] data = {1,2,3}

    • 动态初始化：int[] arr = new int[4]

  • 二维数组

    • 声明： 数组元素的类型[][] 变量名称 数组元素的类型 变量名称[][]

    • 静态初始化：int[][] data = {{1,2,3},{1,2,3,4}}

    • 动态初始化：int[][] datea= new int

• 、补充：

  • 1、Java中所有定义的基本类型或对象都必须初始化才能输出值（方法中的局部变量一定要手动初始化，而全局变量会自动初始化）

  • 2、在java里没有引用传递,只有值传递（对于对象、基本类型还是数组，在函数中都不能改变其实际地址，但能改变其中的内容）

  • 3、在编译程序时，所能指定的环境变量不包括class path；javac一次可同时编译数个java源文件；javac.exe能指定编译结果要置于directory；环境变量⼀般都是先配置好再编译源⽂件。

  • 4、const和goto是java中的关键字，Integer不是Java关键字

  • 5、Java程序经编译后会产生byte code

  • 6、在类方法中不可以使用this关键字来调用本类的类方法。 静态方法是属于类的而不是属于某一个对象，没有this指针。 所以在类方法中调用本类的类方法时，可以直接调用，而不需要使用this关键字

  • 7、数据类型区分大小写

  • 8、javac.exe是Java编译器，将Java源代码转换成字节代码

  • 9、Java.exe是java解释器，直接从类文件执行Java应用程序代码

  • 10、HashSet继承自AbstractSet

  • 11、Java只存在值传递！！！

  • 12、注意final关键字修饰的量，在定义时必须初始化赋值操作。

  • 13、静态变量和实例变量都属于类的成员变量。

  • 14、HashMap、Hashtable、HashSet都是不排序的

  • 15、接口中只允许出现常量和抽象方法- ### 1.java标识符

  • 命名规则

    • 标识符只能由数字、字母、下划线以及美元符号组成，不能以数字开头。

    • java中严格区分大小写，理论上没有长度限制。

    • 不能使用关键字和保留字，但是能包含关键字和保留字。

    • 标识符不能包含空格。

  • 命名规范

    • 类名、接口名首字母大写，后面的每个词开头也必须大写开头

    • 方法名、函数名、变量首字母小写，后面的每个词开头以大写开头

    • 常量名全部大写，单词之间使用_衔接

  • 盘符切换注意事项

    • 如果我们要切换盘符的目录，正确的用法是在cd和路径中间增加一个“/d”，如cd/dd:

    • 当我们要切换盘符时，可以不用cd指令，直接用输入盘符：，如执行e：可以切换到E盘。

• 2.数据类型

  • 基本数据类型

    • 整数型：byte、short、int、long =》 1 2 4 8

    • 浮点型：float、double =》 4 8 声明float变量需要后面加上F

    • 布尔型：boolean ==》1

    • 字符型：char ==》 2 （一个中文占用2个字节，因此字符变量可以储存一个中文汉字）

  • 数据类型转换

    • 小的数据类型可以自动向大的数据类型转换

    • 多种数据类型混合运算，系统将所有数据转换成容量大的那种数据类型，然后再进行计算。

    • 大容量的数据类型转换成小容量的，需要进行强制类型转换，编写时需添加“强制类型转换符”。

    • byte、short、char之间不会相互转换，计算时先转换为int类型

    • 整数型字面量没有超出byte、short、char的取值范围，可以直接将其赋值为byte，short，char类型的变量

    • 字符串不能转换为基本类型；布尔类型也不能转其它数据类型。

    • 例子： byte a=3,b=4; byte f = a+4; //报错，因为在执行a+4语句时，后面为int类型，而前者为byte类型，需要强制转换

• 3.运算符

  • ++和–的区别

    • a++ 是先赋值后计算，++a是先计算后赋值；–道理是一样的
    • 包括使用其它运算符进行计算时，也是遵循上述的方式

  • 赋值运算符

    • += 、-=、*=、/=、%=

    • x -= 1 ===> x = x + 1

  • 逻辑运算符

    • “&”和“&&”的区别

      • “&”，左边无论真假，右边都会进行运算

      • “&&”，如果左边为真，右边参与计算，如果左边为假，右边则不参与运算。

  • 条件运算符

    • 表达式：（条件表达式）？表达式1：表达式2

    • 如果条件为true，运算结果为表达式1；否则为表达式2。

  • [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-aadOJJ7L-1691477849710)(C:\Users\PC\AppData\Roaming\Typora\typora-user-images\image-20230808132454706.png)]

• 4.控制语句

  • 选择语句

    • switch()语句

      switch(int/String 数据类型){
          case int/String 数据类型:
      ​               java语句;
                     break;
      ……
          default:
      ​              java语句;
      ​ }
      

      • switch表达式中的返回值必须是下述几种类型之一：int byte char short 枚举 字符串

      • case子句中的变量值必须是常量

  • 循环语句

    • do while和while循环的区别

      • do while 是肯定执行一次，且while语句后需要加上分号符

      • do while循环体执行次数为N-1次，而while循环体的执行次数为N次

    • continue和break

      • continue终止当前本次循环，break则是终止循环的执行

• 5.方法

  • 方法重载

    • 重载满足条件：

      • 在同一个类中；方法名相同；参数列表不同（个数、顺序、类型）

      • 不能通过参数名去区分两个方法

      • 不能通过返回值的类型来区分两个方法

      • Java的重载是可以包括父类和子类的，即子类可以重载父类的同名不同参数的方法 ￥￥￥

• 6.面向对象

  • 构造器

    • 格式：<修饰符> <类名>（[<参数表>]）{ [< 语句 >] }

    • 作用：利用构造器参数初始化对象的属性。

    • 具有与类相同的名称，没有返回值

    • 功能：创建类的实例时，初始化实例的一组指令。

    • Java语言每个类至少含有一个构造方法，系统一般默认提供一个无参构造方法

    • 构造方法可以被重载。

    • 默认构造器的修饰符只跟当前类的修饰符有关，如果当前类的修饰符是public，则构造器的修饰符也是public

  • 封装

    • Java中通过将数据声明为私有的（private），再提供公开的（public）方法：getXXX和setXXX实现对该属性的操作，以达到下述目的：

      • 隐藏一个类的实现细节

      • 使用者只能通过事先定制好的方法来访问数据，可以方便地加入控制逻辑，限制对属性的不合理操作；

      • 便于修改，增强代码的可维护性；

  • this关键字

    • this不能使用在static的方法中，可以使用在实例方法中，代表当前对象

    • 多数情况下this关键字可以省略，但是在区分局部变量和实例变量时不能省略

    • this关键字只能出现在构造方法内的第一行，可以实现代码的复用，用关键字省去this.name=name等步骤

      • 用法：this(参数) 上述的就可表示为this(name)

    • 每个成员方法内部，都有一个this引用变量，指向调用这个方法的对象。

    • this（）调用本类中的无参构造方法

  • static关键字

    • 用于修饰类的成员（成员变量、属性、方法、内部类、代码块）

    • static修饰的成员为类成员，为类中的所有实例所共享。

    • static修饰的方法称为类方法。

    • 静态变量存储在方法区中（在类加载时被初始化），实例变量存储在堆内存中

    • 在访问权限允许的前提下，static修饰的成员可以通过“类名.”的方式去访问（无需创建对象，当然也可以通过对象的方式访问）

    • static方法内部只能访问类的static属性，不能访问非static属性；反之，非static方法可以访问类的static成员

    • 静态方法中不能以任何方式引用this和super关键字

    • 静态代码块（一般都是最先开始执行的）经常用来进行类属性的初始化，遵循自上而下的执行顺序。

    • 静态代码块在 类加载时执行，并且在main方法执行之前执行。

    • static不能修饰方法体内的局部变量

    • 单态设计模式

      • 保证在整个软件系统中，对某个类只能存在一个对象实例

        • 1、在外部不能通过new 构造器的方式创建实例，因此需要把构造器隐藏起来，及构造器私有化

        • 2、因为在类的外部不能创建类的实例，只能在类的内部创建

        • 3、为了让类的外部可以直接使用该实例，使用static修饰

        • 4、不能在类的外部修改该属性：私有化该属性，同时提供共有的get方法访问

  • 继承（extends）

    • java中的继承只支持单继承，不支持多继承（可以间接继承）。

    • 继承中除去构造方法和被private修饰的数据无法被继承外，剩下的都可被继承

  • 方法覆盖(Override)

    • 覆盖满足条件

      • 1）方法覆盖发生在具有继承关系的父子类之间

      • 2）覆盖后的方法和原方法具有相同的返回值类型、方法名以及形式参数列表

    • 注意事项：

      • 私有方法和构造方法无法被继承，所以不能覆盖

      • 覆盖后的方法不能比原方法有更低的访问权限，可以更高

  • 多态

    • 多态：同样类型的变量，调用同样的方法，却产生完全不同的行为（父类型引用指向子类型对象）

    • 1.当父类类型的变量指向一个子类的对象，调用父类中已经被重写的方法

    • 2.在多态的情况下（当父类类型的变量指向一个子类的对象）：不能调用子类添加的方法。

    • 3.在多态的情况下，可以对对象进行强制的类型转换。

      • 3.1 父类的对象可以转为任何子类的类型，但有可能会发生：java.lang.ClassCastException

      • 3.2 只有在有父子关系的情况下，才能进行强制的类型转换。

    • instanceof操作符

      • x instanceof A: 检验x是否为类A的对象，返回值为boolean型。

      • 要求x所属的类和类A必须是子类和父类的关系，否则编译出错

      • 如果x属于类A的子类B，x instanceof A值也为true。

    • 多态存在的三个必要条件：

      • 继承、方法覆盖、父类型引用指向子类型引用

    • 类型转换

      • 向上转型：通过子类对象（小范围）转化为父类对象（大范围），这种转换是自动完成的，不用强制。

      • 向下转型：通过父类对象（大范围）实例化子类对象（小范围），这种转换不是自动完成的，需要强制指定。

  • super关键字

    • super只是代表当前对象中那部分父类型特征

    • 用法：

      • 1、在子类对象的方法中引用父类对象的成员。

      • 2、在子类的构造器中调用父类的构造器。

        • 2.1 可以在子类中通过super(参数列表)的方式类调用父类的构造器

        • 2.2 默认情况下子类的构造器调用父类的无参数的构造器

      • 3、若父类定义了带参数的构造器，则系统将不再为父类提供无参数的构造器，而子类的构造器中必须调用父类的一个构造器。

        • 3.1 父类显式定义个无参数的构造器

        • 3.2 在子类 的构造器中显式的调用父类带参数的构造器 super(name, age);

      • 访问父类中定义的属性、调用父类中定义的成员方法

      • 实例：在方法覆盖中使用super

        • return super.getInfo()+“school:”+school;

      • 注意：super无法在static静态方法中使用

    • super 在什么情况下不能省略了吗？

      • 当父类中有该实例变量，子类中又重新定义了同名的实例变量，如果想在子类中访问父类的实例变量， super 不能省略

    • super(实际参数列表)和this(实际参数列表)都是只允许出现在构造方法第一行

    • 与this类似，super(参数列表)必须放在构造器第一行，说明这两者不能同时存在

  • final关键字

    • 可以修饰类、属性、方法，表示最终的

    • final修饰的属性，是最终的属性-属性值不能被修改，即常量

      • 必须在声明时被初始化，或在非静态代码块，或在构造器中初始化

    • final 修饰的方法，是最终的方法-该方法不能被修改–同样也无法被重写

    • final修饰的类，是最终的类-该类不能被扩展-该类不能被继承

    • 构造方法不能被final修饰

    • final修饰的引用，这个引用只能指向一个对象，也就是说对象不能再次赋值（不能 new），但被指向的对象是可以修改的。

  • 抽象类（abstract）

    • 抽象方法只需在抽象类中，提供声明，不需要具体实现过程。

    • 一个类中含有抽象方法，这个类必须定义为抽象类。

    • 这个类是抽象的，那这个类被子类继承时，抽象方法必须要进行重写（强制约束作用），如果子类中的方法不重写，必须将该子类再次声明为抽象类

    • 抽象类不能实例化，只能被继承，抽象类中可以有构造方法，（构造函数也是可以有的，用于初始化其子类）

    • 抽象方法不能被final修饰，因为抽象方法就是被子类实现的

    • 抽象方法不能被声明为静态(抽象方法一般都是需要被实例化的)

    • abstract关键字只能修饰类和对象，不能修饰字段

    • 抽象类的抽象方法不能实现。

    • 注意事项：

      • 1.有抽象方法的类一定是抽象类，但抽象类中可以没有抽象方法

      • 2.不能用abstract修饰私有方法，构造方法，静态方法

  • 接口(interface)

    • 接口中的方法默认都是 public abstract的，不能更改

    • 接口中的变量默认都是public static final类型的，不能更改，必须显示初始化

    • 接口不能被实例化，接口中没有构造函数

    • 接口之间可以继承，但是接口之间不能实现

    • 接口中的方法只能通过类来实现，即通过implements关键字

    • 如果一个类实现了接口，那么接口中所有的方法必须实现

    • 一个类可以实现多个接口，接口之间使用逗号隔开

    • 若 一个类继承父类，同时又实现一个接口，则extends必须在implements前

    • 接口只能使用两种访问修饰符：public、default。

    • 接口中没有构造函数

  • Object 类及其主要方法

    • ==操作符与equals方法

      • 1.==：

        • ==比较两个对象在内存里是不是同一个对象，就是说在内存里的存储位置一致

        • 1.1 引用类型比较引用（是否指向同一个对象）

        • 1.2 用“==”进行比较时，符号两边的数据类型必须可兼容，否则编译出错

      • 2. equals():

        • 对于字符串变量来说,equal比较的两边对象的内容，所以内容相同返回的是true

        • 对于非字符串变量，equals比较的内存的首地址，这时候和==是一样的，即比较两边指向的是不是同一个对象

        • 2.1 只比较引用类型，其作用与“==”相同，比较是否指向同一个对象

        • 2.2 当用equals()方法进行比较时，对类File、String、Date及封装类（Wrapper Class）来说，是比较类型及内容而不考虑引用的是否是同一个对象，因为在这些类中覆盖了equals()方法

    • toString()

      • 返回对象的字符串表示，返回一个“以文本方式表示”此对象的字符串

    • 访问控制权限

    • 常见方法：

      • clone方法、getClass方法、toString方法、finalize方法、hashCode方法、wait方法

  • 内部类

    • 和外部类不同，Inner class可以声明为private或protected

    • 非static的内部类中的成员不能声明为static的，只有在顶层类或者static的内部类中可声明static成员。

    • 实例内部类

      • 实例内部类会有外部类的引用

      • 实例内部类不能定义static成员，只能定义实例成员

    • 静态内部类

      • 静态内部类可以访问内部的静态变量，如果访问外部类的成员变量必须通过外部类的实例访问

      • 静态内部类不会含有外部的类的引用，创建时可以不用创建外部类

      • 不能直接引用外部类的实例变量

    • 匿名内部类

      • 在类的内部直接创建一个接口的实现类对象，该对象称为匿名内部类对象。

    • 创建非静态的内部类的对象：

      • 外部类 外部类对象名=new 外部类构造器;

      • 外部类.内部类 内部类对象名=new 外部类对象名.new 内部类构造器;

    • 创建的是一个静态内部类的对象:

      • 外部类.内部类 内部类对象名=new 外部类名.内部类构造器;

  • 初始化顺序

    • 静态属性：static开头的属性

    • 静态方法块：static{} 包起来的代码块

    • 普通属性：非static定义的属性

    • 普通方法块：{}包起来的代码块

    • 构造函数：类名相同的方法

    • 方法：普通方法

    • 父类静态变量-》父类静态代码块-》子类静态变量-》子类静态代码块-》父类非静态变量-》父类非静态代码块-》父类构造方法-》子类非静态变量-》子类非静态代码块-》子类构造方法

    • 注：静态变量和静态代码块是按代码的顺序执行

  • 构造函数调用顺序：

    • 子类没有显示调用父类构造函数，不管子类构造函数是否带参数都会默认调用父类的无参构造函数。

• 异常

  • Java提供的是异常处理的抓抛模型

  • Exception类是所有异常类的父类，Error类是所有错误类的父类，这两个类都是Throwable类的子类。

  • NollPointerException 空指针异常，如果去调用其属性和方法就会报异常

  • 异常处理机制

    • 采用try-catch-finally语句实现

    • try{……}语句块选定捕获异常的范围，将可能出现异常的代码块放在try语句块中

    • catch语句块是对异常对象进行处理的代码，每个try语句块可以伴随着一个或多个catch语句，用于处理可能产生的不同类型的异常对象

    • 可以将异常的父类当作catch的参数，但是不能是与异常类无关的异常，否则，catch中的语句将不会执行。

  • 捕获异常的有关信息

    • getMessage()方法，用来得到有关异常事件的信息

    • printStackTrace()用来追踪异常事件发生时执行堆栈的内容

  • finally

    • 捕获异常的最后一步是通过该语句为异常处理提供一个统一的出口

    • 不论try、catch代码块中是否发生了异常事件，finally块中的语句都会被执行。

    • finally语句是可选的

    • finally 必须和 try 一块使用

    • finally无论如何也会执行,在那之前catch或者正常 代码中如果有其它的return或者throw exception,会被暂存起来等待finally执行完后在执行;而finally中有return则前面的throw和return会被忽略 （还需再看看）

  • 注意：异常类的父类要放在异常类的子类的后面，否则出错

  • 声明抛出异常

    • 用法：在方法参数列表的后面使用throws关键字声明抛出异常

      • 1.异常在当前方法内部不处理，而抛给当前方法的方法

      • 2.可以声明抛出多个异常，多个异常使用，进行分割，多个异常没有顺序

      • 3.可以声明抛出出现的异常类的父类。

      • 重写方法不能抛出比重写方法范围更大的异常类型（均指非运行时异常）

  • 人工抛出异常

    • 首先生成异常类对象，然后通过throw语句实现抛出操作

    • 可以抛出的异常必须是Throwable或其子类的实例。

  • 自定义异常（抛出异常后一定要捕获异常才可）

    • 自己定义的异常类,通常情况下继承RuntimeException

    • 基本实现

      public class UserNotFoundException extends RuntimeException {
      private static final long serialVersionUID = 1L;    public UserNotFoundException() {
          }
      public UserNotFoundException(String msg) {
      super(msg);    }
      }
      

    • 自定义异常的作用:看见异常类的名字,就知道出现了什么问题

    • 自定义异常通常都需要使用throw关键字进行抛出

  • 注意:

    • Integer.parseInt(args[0]);上述方法将字符串类型转换成对应的int值

  • 编译时异常，必须显示异常throw

• 集合

  • 集合区分：

    • List是一个有序集合，可存放重复的数据

    • Set是一个无需集合，不允许放重复的数据

    • Map是一个无序集合，键对象不允许重复，值对象可以重复。

  • collection接口

    • collection接口是List、Set和Queue接口的父接口，该接口里定义的方法即可用于操作Set集合，也可以用于操作List和Queue集合

    • 常见方法

      • add(Object obj)：添加一个元素到集合中

      • addAll(Collection collection)：添加一组元素到集合中

      • 在Collection中无法获取指定的元素，但可以遍历所有的元素

        • 1. 使用增强的for循环

             for(Object obj: 集合)
             

        • 2. 使用Iterator迭代器

          • 2.1 获取迭代器对象：调用Collection中的iterator()方法，获取Inerator接口的对象*

          • 2.2 调用Iterator接口的方法进行迭代*

          • Iterator iterator = set.iterator();
              while(iterator.hasNext()){
                 System.out.println(iterator.next());
              }
            

      • clear()：清空集合

      • remove(obj)：移除指定的元素，通过equals()方法在集合* 中查找指定的元素，若存在，则移除

      • removeAll(Collection collection) 移除中有的元素

      • remainAll(Collection collection) 保存collection中的元素

      • contains(Object o)：利用equals()比较，查看集合中有没有指定的元素

      • containsAll(Collection<?> c)：查看集合中没有指定元素的集合

      • isEmpty()：检验集合是否为空集合

      • toArray()：把集合中元素转换为Object 对象的数组

  • Set 集合

    • Set集合不允许包含相同的元素

    • Set判断两个对象是否相同不是使用==运算符，而是根据equals方法

    • HashSet和TreeSet都继承自AbstractSet

    • HashSet

      • HashSet是Set接口的典型实现

      • HashSet按Hash算法来存储集合中的元素

      • 以下特点：

        • 不能保证元素的排列顺序

        • HashSet不是线程安全的

        • 集合元素可以是null

    • LinkedHashSet

      • LinkedHashSet集合根据元素的hashCode值来决定元素的存储位置

      • 元素的是按插入顺序保存的

      • 不允许集合元素重复

      • LinkedHashSet也是不安全的

      • 其插入性能略低于Hashset

    • TreeSet

      • 默认情况下TreeSet要求集合中的元素必须实现Comparable接口

      • Comparable接口中只有一个方法：

        • public int compareTo(T o)：若是返回0代表两个元素相等，若返回整数，代表当前元素大，若返回负数，代表当前元素小。

        •     public int compareTo(Object o) {
                  if(o instanceof Person){
                      Person person = (Person)o;
                      return this.name.compareTo(person.name);
                  }else {
                      throw new ClassCastException("不能转为Person对象");
                  }
              }
          

      • TreeSet会调用每个元素的compareTo()方法去和集合中的每个已经有的元素去比较，进而决定当前元素在集合中的位置。

      • 当把一个对象放入TreeSet中，重写该对象对应的equals()方法时，应保证该方法与compareTo(Object obj)方法有一致的结果。

    • 定制排序

      • 创建TreeSet集合对象时，提供一个Comparator接口的实现类对象。

        Comparator comparator = new Comparator(){
        
                   @Override
                   public int compare(Object o1, Object o2) {
                       if(o1 instanceof Person1 && o2 instanceof Person){
                           Person1 person1 = (Person1) o1;
                           Person1 person11 = (Person1) o2;
                           return person1.getAge() - person11.getAge();
                       }else {
                           throw new ClassCastException("不能转换为Person1类型");
                       }
                   }
               };
        //创建TreeSet对象，传入Comparator接口的实现类对象
        TreeSet set = new TreeSet(comparator);
        

    • 常见的一些方法

      • SortedSet tailSet(fromElement) 该方法需要重写对象中的equals方法
      • Object first()

  List 特点：

  • List代表一个元素有序、且可重复的集合，集合中的每个元素都有其对应的顺序索引

  • List允许使用重复元素，可以通过索引来访问指定位置的集合元素

  • List默认按元素的添加顺序设置元素的索引

  • List集合里添加了一些根据索引来操作集合元素的方法

    void add(int index, Object ele)  // 根据索引添加元素
    boolean addAll(int index, Collection eles) // 根据索引添加一组元素
    Object get(int index) // 
    int indexOf(Object obj) // 获取指定元素的索引值，若元素不存在返回-1
    注：indexOf方法需要重写equals方法
    int lastIndexOf(Object obj) // List中可以存放重复的元素，获取重复元素的最后一个索引
    Object remove(int index) // 移除指定元素的索引值
    Object set(int index, Object ele) // 设置index位置的元素为ele，原来的元素被替代
    List subList(int fromIndex, int toIndex) // 
    

  • list遍历方式

    //list独有的遍历方式
            for(int i = 0;i < list.size(); i++){
                Object object = list.get(i);
                System.out.println(object);
            }
    

  • ArrayList

    • ArrayList.asList() 方法返回的List集合既不是ArrayList实例也不是Vector实例。
    • 其返回值是一个固定长度的List集合。
    • ArrayList 是线程不安全的，而 Vector 是线程安全的。

• Map

  • Map集合里保存着两组值，一组值用于保存Map里的key，另一组则是Map的Value

  • Map中的Key不允许重复，即同一个Map对象的任何两个Key通过equals方法比较中返回false

  • key和value之间存在单向一对一关系

  • Map的遍历

     //对Map进行遍历
            //1.遍历键的集合：keySet()
            //2.遍历值的集合：values()
            //3.得到键值对的组合
             Set keySet = map.keySet();
            Iterator it = keySet.iterator();
            while(it.hasNext()){
                Object key = it.next();
                Object val = map.get(key);
                System.out.println(val);
            }
    

  • HashMap和Hashtable

    • Hashtable是一个线程安全的Map实现，但是HashMap是线程不安全的
    • Hashtble不允许使用null作为key和value，而HashMap的键值对可以为Null

  • Properties

    • Hashtable的子类，该对象用于处理属性文件

    • properties里的key和value都是字符串类型的

      public void testProperties() throws IOException {
              //读取jdbc.properties
      
              //1.创建Properties对象
              Properties properties = new Properties();
              //2.调用Properties的load()方法加载属性文件对应的输入流
              InputStream inStream = PropertiesTest.class.getClassLoader().getResourceAsStream("jdbc.properties");
              properties.load(inStream);
              //3.调用getProperty(String key)方法获取属性值
              String user = properties.getProperty("user");
              System.out.println(user);
          }
      

  • Collections（工具类）

    • 排序操作
      • reverse(List)：反转List中元素的顺序
      • shuffle(List)：对List集合元素进行随机排序
      • sort(List)：根据元素的自然顺序对指定的List集合按升序排序
      • sort(List, Comparator)：根据指定的Comparator产生的顺序对List集合元素进行排序

  • 泛型

    • 泛型使用<>括起来，例如List 代表集合中的类型是Integer
    • 把list集合中的内容限制为一个特定的数据类型
    • 使用集合中泛型会使类型更安全，不再需要强制的类型转换
    • 1、定义泛型方法：
      • 在类（不一定是泛型类）中使用泛型方法
      • 在方法的返回值前使用 <>声明泛型类型，则在方法的返回值、参数、方法体中可以使用该类型
    • 2、通配符
      • 如果Foo是Bar的一个子类型（子类或子接口），而G是某种泛型声明，那么G是G的子类型并不成立！：Person是Object的子类，但List却不是List的子类！
        • printPersons(List persons)；该方法的参数只能是Person类型的List，而不能是Person任何子类的List
      • Collection<?> 就是一个集合，它的元素类型可以匹配任何类型，称为通配符
      • 将任意元素加入到其中不是类型安全的，null除外！因为null可以是任何类型的。
      • 有限制的通配符
      • public void drawAll(List<? extends Shape> shapes) { //…}

• 数组

  • 一维数组

    • 声明： 数组元素的类型[] 变量名称 数组元素的类型 变量名称[]

    • 初始化：int[] data = {1,2,3}

    • 动态初始化：int[] arr = new int[4]

  • 二维数组

    • 声明： 数组元素的类型[][] 变量名称 数组元素的类型 变量名称[][]

    • 静态初始化：int[][] data = {{1,2,3},{1,2,3,4}}

    • 动态初始化：int[][] datea= new int

• 、补充：

  • 1、Java中所有定义的基本类型或对象都必须初始化才能输出值（方法中的局部变量一定要手动初始化，而全局变量会自动初始化）

  • 2、在java里没有引用传递,只有值传递（对于对象、基本类型还是数组，在函数中都不能改变其实际地址，但能改变其中的内容）

  • 3、在编译程序时，所能指定的环境变量不包括class path；javac一次可同时编译数个java源文件；javac.exe能指定编译结果要置于directory；环境变量⼀般都是先配置好再编译源⽂件。

  • 4、const和goto是java中的关键字，Integer不是Java关键字

  • 5、Java程序经编译后会产生byte code

  • 6、在类方法中不可以使用this关键字来调用本类的类方法。 静态方法是属于类的而不是属于某一个对象，没有this指针。 所以在类方法中调用本类的类方法时，可以直接调用，而不需要使用this关键字

  • 7、数据类型区分大小写

  • 8、javac.exe是Java编译器，将Java源代码转换成字节代码

  • 9、Java.exe是java解释器，直接从类文件执行Java应用程序代码

  • 10、HashSet继承自AbstractSet

  • 11、Java只存在值传递！！！

  • 12、注意final关键字修饰的量，在定义时必须初始化赋值操作。

  • 13、静态变量和实例变量都属于类的成员变量。

  • 14、HashMap、Hashtable、HashSet都是不排序的

  • 15、接口中只允许出现常量和抽象方法