java基础语法 复习

在菜鸟教程网站上复习Java基础语法，摘录下自己需要注意的知识点

1. 在 Java 中，接口可理解为对象间相互通信的协议。接口只定义方法，不实现。

2. 类变量，在类中要声明为static

3. 如果没有显示定义类的构造方法，Java编译器会为该类提供一个默认的构造方法。写了自己的构造方法后最好加一个空的构造方法（IDE可自动生成）

4. 创建对象：类名 对象名 = new 类名(构造器的参数);

5. 源文件：以.java为扩展名。一个源文件只能有一个public类，可以有多个非public类。源文件名和public类名要一样

6. 常量：final 大写常量名 = 值;

7. 实例变量和局部变量：
   实例变量（类中声明的变量）默认值：0、0.0、false、null。实例变量可以在声明时赋值。
   局部变量没有默认值，所以局部变量被声明后，必须经过初始化，才可以使用（否则报错）。在栈上分配空间。

8. 自动类型转化：运算时，不同类型数据先转化为同一类型，然后进行运算
   
   不能对boolean类型进行类型转换。不能把对象类型转换成不相关类的对象。在把容量大的类型转换为容量小的类型时必须使用强制类型转换。浮点数到整数的转换是通过舍弃小数得到，而不是四舍五入

9. 强制类型转化：前提是转换的数据类型必须是兼容的。格式：variable = (type)value;

10. 隐含强制类型转换：整数的默认类型是 int。小数默认是 double 类型浮点型，在定义 float 类型时必须在数字后面跟上 F 或者 f。

11. 访问修饰符和非访问修饰符：
    访问控制符用来保护对类、实例变量、方法和构造方法的访问。如：public，private，default（即不写）。访问修饰符能用来修饰实例变量，不能用来修饰局部变量
    非访问修饰符用来实现出来访问外其他的限定功能。如：final、static

12. 静态变量储存在静态存储区。经常被声明为常量，很少单独使用 static 声明变量。

13. 静态变量只有一份拷贝，每次更改后，所有共享它的对象使用的都是最新更改后的拷贝。静态变量值可以在声明的时候指定，也可以在构造方法中指定，可以在方法中更改。

14. 自动装箱、拆箱：Java 语言为每一个内置数据类型提供了对应的包装类。这种由编译器特别支持的包装称为装箱，所以当内置数据类型被当作对象使用的时候，编译器会把内置类型装箱为包装类。相似的，编译器也可以把一个对象拆箱为内置类型。

15. String 创建的（字面值）字符串存储在公共池中，而 new 创建的字符串对象在堆上：
    

16. 注意:String 类是不可改变的，所以你一旦创建了 String 对象，那它的值就无法改变了。如果需要对字符串做很多修改，那么应该选择使用 StringBuffer & StringBuilder 类。

17. 和 String 类不同的是，StringBuffer 和 StringBuilder 类的对象能够被多次的修改，并且不产生新的未使用对象。StringBuilder 类在 Java 5 中被提出，它和 StringBuffer 之间的最大不同在于 StringBuilder 的方法不是线程安全的（不能同步访问）。由于 StringBuilder 相较于 StringBuffer 有速度优势，所以多数情况下建议使用 StringBuilder 类。然而在应用程序要求线程安全的情况下，则必须使用 StringBuffer 类。

18. 数组的声明：dataType[] arrayRefVar = new dataType[arraySize]; 或者dataType[] arrayRefVar = {value0, value1, …, valuek};

19. For-Each 循环能在不使用下标的情况下遍历数组。语法格式如下：

for(type element: array) //elemen相当于i
{
    System.out.println(element);
}

20. sleep()使当前线程进入停滞状态（阻塞当前线程），让出CPU的使用、目的是不让当前线程独自霸占该进程所获的CPU资源，以留一定时间给其他线程执行的机会。

21. Calendar c = Calendar.getInstance(); Calendar是抽象类，抽象类可以通过子类的实例化然后赋值给父类而（看似）实例化。getInstance()是类方法，会返回一个Calendar的子类对象。

22. 正则表达式定义了字符串的匹配模式，可以用来搜索、编辑或处理文本。

23. 正则表达式：
    

    \d  是匹配一个数字(0到9)
    \\d 前面多了第一个\ 是为了转义第二个\    
    \\d+ 就表示多个数字，形如 12、44、6763
    

24. 方法重载：一个类的两个方法拥有相同的名字，但是有不同的参数列表。

25. 方法重写：子类重写从父类继承过来的方法

26. main(String[] args): 有时候你希望运行一个程序时候再传递给它消息。这要靠传递命令行参数给main()函数实现。命令行参数是在执行程序时候紧跟在程序名字后面的信息。
    

1. 默认构造方法的访问修饰符和类的访问修饰符相同
2. 一个方法的声明：public static void printMax( double… numbers) 可以传任意多个double值给这个函数。
3. finalize() 方法：在对象被垃圾收集器析构(回收)之前调用。在finalize() 方法里，你必须指定在对象销毁时候要执行的操作。例如，你可以使用 finalize() 来确保一个对象打开的文件被关闭了。
4. 输入输出流：一个流被定义为一个数据序列。输入流用于从源读取数据，输出流用于向目标写数据。
5. 从控制台输入：
   法一：
   BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
   c = (char)br.read();
   System.out.println©;//读入用户输入的一个字符
   String str = br.readLine();//读入用户输入的一行字符串
   法二：Java5 的新特征，通过 Scanner 类来获取用户的输入
   Scanner s = new Scanner(System.in);
6. finally 代码块出现在 catch 代码块最后，是 try 代码块最后执行的代码块。无论是否发生异常，finally 代码块中的代码总会被执行。在 finally 代码块中，可以运行清理类型等收尾善后性质的语句。在 try/catch 后面添加 finally 块并非强制性要求的。
7. 异常：
   检查性异常：最具代表的检查性异常是用户错误或问题引起的异常，这是程序员无法预见的。例如要打开一个不存在文件时，一个异常就发生了，这些异常在编译时不能被简单地忽略。
   运行时异常： 运行时异常是可能被程序员避免的异常。与检查性异常相反，运行时异常可以在编译时被忽略。
8. 声明自定义的异常。
   所有异常都必须是 Throwable 的子类。
   如果希望写一个检查性异常类，则需要继承 Exception 类。
   如果你想写一个运行时异常类，那么需要继承 RuntimeException 类。

------------------------------------------------2021年10月11日---------------------------------------------------------

9. Java 支持多重继承（C继承B ，B继承A。或者C和B都继承A），不支持多继承（C同时继承B和A）。即Java的继承是单继承

10. 继承可以使用 extends 和 implements 这两个关键字来实现继承，而且所有的类都是继承于 java.lang.Object，当一个类没有继承的两个关键字，则默认继承object（这个类在 java.lang 包中，所以不需要 import）祖先类。

11. implements 关键字可以变相的使java具有多继承的特性，可以implements多个接口

12. super关键字：我们可以通过super关键字来实现对父类成员的访问，用来引用当前对象的父类。

13. this关键字：指向自己的引用。

14. final 关键字声明类可以把类定义为不能继承的，即最终类；或者用于修饰方法，该方法不能被子类重写

15. 被声明为 final 类的方法自动地声明为 final，但是实例变量并不是 final

16. 子类是不继承父类的构造器（构造方法或者构造函数）的，它只是调用（隐式或显式）。如果父类的构造器带有参数，则必须在子类的构造器中显式地通过 super 关键字调用父类的构造器并配以适当的参数列表。如果父类构造器没有参数，则在子类的构造器中不需要使用 super 关键字调用父类构造器，系统会自动调用父类的无参构造器。

17. 重写：子类对父类的允许访问的方法的实现过程进行重新编写, 返回值和形参都不能改变（返回类型与被重写方法的返回类型可以不相同，但是必须是父类返回值的派生类）。即外壳不变，核心重写！

18. 重写方法不能抛出新的检查异常或者比被重写方法申明更加宽泛的异常

19. 构造方法不能被重写

20. 重载(overloading) 是在一个类里面，方法名字相同，而参数不同。返回类型可以相同也可以不同。每个重载的方法（或者构造函数）都必须有一个独一无二的参数类型列表。

21. 方法能够在同一个类中或者在一个子类中被重载。

22. 无法以返回值类型作为重载函数的区分标准。

23. 多态：同一个接口，使用不同的实例而执行不同操作

24. 多态存在的三个必要条件：
    继承
    重写
    父类引用指向子类对象：Parent p = new Child();、

25. 抽象类：该类没有足够的信息能描述具象的对象，所以将之声明为抽象类

26. 抽象类中的方法能有方法体，抽象类中不一定要包含抽象方法

27. 可以在抽象类中将方法声明为抽象方法，该抽象方法必须被非抽象子类重写

28. 构造方法，类方法（用 static 修饰的方法）不能声明为抽象方法。

29. 封装：可以被认为是一个保护屏障，防止该类的代码和数据被外部类定义的代码随机访问。要访问该类的代码和数据，必须通过严格的接口控制。

30. 实现Java封装的步骤：1. 修改属性的可见性来限制对属性的访问（一般限制为private） 2.对每个值属性提供对外的公共方法访问，也就是创建一对赋取值方法，用于对私有属性的访问

31. 接口：一个抽象类型，是抽象方法的集合，接口以interface来声明

32. 在 Java 中，接口类型可用来声明一个变量，他们可以成为一个空指针，或是被绑定在一个以此接口实现的对象。（多态）

33. 接口文件保存在 .java 结尾的文件中，文件名使用接口名。

34. 接口中所有的方法必须是抽象方法，Java 8 之后 接口中可以使用 default 关键字修饰的非抽象方法。接口不能包含成员变量，除了 static 和 final 变量。接口不是被类继承了，而是要被类实现。

35. 接口中每一个方法也是隐式抽象的,接口中的方法会被隐式的指定为 public abstract（只能是 public abstract，其他修饰符都会报错）。
    接口中可以含有变量，但是接口中的变量会被隐式的指定为 public static final 变量（并且只能是 public，用 private 修饰会报编译错误）。

36. 可以将接口理解为特殊的抽象类

37. 抽象类和接口的区别

38. 抽象类中的方法可以有方法体，就是能实现方法的具体功能，但是接口中的方法不行。

39. 抽象类中的成员变量可以是各种类型的，而接口中的成员变量只能是 public static final 类型 的。

40. 接口中不能含有静态代码块以及静态方法(用 static 修饰的方法)，而抽象类是可以有静态代码块和静态方法。

41. 一个类只能继承一个抽象类，而一个类却可以实现多个接口。

42. 接口可以多继承、多实现

43. 类在实现接口的方法时，不能抛出强制性异常，只能在接口中，或者继承接口的抽象类中抛出该强制性异常。

44. 类在重写方法时要保持一致的方法名，并且应该保持相同或者相兼容的返回值类型。

45. 标记接口：没有任何方法和属性的接口。作用：给类打个标（盖个戳），可以作为一组接口的父接口

46. java包：把功能相似或相关的类或接口组织在同一个包中，方便类的查找和使用。

47. 创建包：package 包名;

48. 每个源文件只能有一个包声明（定义）

49. 包声明应放在第一行

50. 如果一个源文件中没有使用包声明，那么其中的类，函数，枚举，注释等将被放在一个无名的包（unnamed package）中。

51. 导入包：import 包名。

52. 导入包的语句在package语句后

53. 通常，一个公司使用它互联网域名的颠倒形式来作为它的包名.例如：互联网域名是 runoob.com，所有的包名都以 com.runoob 开头。包名中的每一个部分（以“.”分隔）对应一个子目录。