Java基础语法（自用备忘）

1. 对象和类

对象： 对象是类的一个实例，有状态和行为。例如，一条狗是一个对象，它的状态有：颜色、名字、品种；行为有：摇尾巴、叫、吃等。
类： 类是一个模板，它描述一类对象的行为和状态。
构造方法
在创建一个对象的时候，至少要调用一个构造方法。构造方法的名称必须与类同名，一个类可以有多个构造方法。

public class Puppy{
    public Puppy(){
    }
 
    public Puppy(String name){
        // 这个构造器仅有一个参数：name
    }
}

2. 基本数据类型

八种基本类型

六种数字类型（四个整数型，两个浮点型），一种字符类型，还有一种布尔型。

1. byte 数据类型是8位、有符号的，以二进制补码表示的整数；
2. short 数据类型是 16 位、有符号的以二进制补码表示的整数
3. int数据类型是32位、有符号的以二进制补码表示的整数；
4. long 数据类型是 64 位、有符号的以二进制补码表示的整数；
5. float数据类型是单精度、32位、符合IEEE 754标准的浮点数；
6. double 数据类型是双精度、64 位、符合IEEE754标准的浮点数；
7. boolean数据类型表示一位的信息；
8. char类型是一个单一的 16 位 Unicode 字符；

对于数值类型的基本类型的取值范围，我们无需强制去记忆，因为它们的值都已经以常量的形式定义在对应的包装类中了。

        System.out.println("基本类型：byte 二进制位数：" + Byte.SIZE);  //Byte.SIZE
        System.out.println("包装类：java.lang.Byte");  
        System.out.println("最小值：Byte.MIN_VALUE=" + Byte.MIN_VALUE);  
        //Byte.MIN_VALUE最小值   Byte.MAX_VALUE最大值
        System.out.println("最大值：Byte.MAX_VALUE=" + Byte.MAX_VALUE);  

常量

常量在程序运行时是不能被修改的。
在 Java 中使用 final 关键字来修饰常量，声明方式和变量类似：

final double PI = 3.1415927;

3. Java 变量类型

Java语言支持的变量类型有：

• 类变量（静态变量）：独立于方法之外的变量，用 static 修饰。
• 实例变量：独立于方法之外的变量，不过没有 static 修饰。
• 局部变量：类的方法中的变量。

public class Variable{
    static int allClicks=0;    // 类变量
    String str="hello world";  // 实例变量
    //实例变量具有默认值。数值型变量的默认值是0，布尔型变量的默认值是false，引用类型变量的默认值是null。变量的值可以在声明时指定，也可以在构造方法中指定；
    public void method(){
        int i =0;  // 局部变量
        //局部变量没有默认值，所以局部变量被声明后，必须经过初始化，才可以使用。
    }
}

4. Java修饰符

修饰符用来定义类、方法或者变量，通常放在语句的最前端。主要包括：访问修饰符、非访问修饰符

访问控制修饰符

Java中，可以使用访问控制符来保护对类、变量、方法和构造方法的访问。Java 支持 4 种不同的访问权限。

• default (即默认，什么也不写）: 在同一包内可见，不使用任何修饰符。使用对象：类、接口、变量、方法。
• private : 在同一类内可见。使用对象：变量、方法。 注意：不能修饰类（外部类）
• public : 对所有类可见。使用对象：类、接口、变量、方法
• protected : 对同一包内的类和所有子类可见。使用对象：变量、方法。 注意：不能修饰类（外部类）。

非访问修饰符

为了实现一些其他的功能，Java 也提供了许多非访问修饰符。

• static 修饰符，用来修饰类方法和类变量。
• final 修饰符，用来修饰类、方法和变量，final修饰的类不能够被继承，修饰的方法不能被继承类重新定义，修饰的变量为常量，是不可修改的。
• abstract 修饰符，用来创建抽象类和抽象方法。
• synchronized 和 volatile 修饰符，主要用于线程的编程。

static 修饰符

• 静态变量：
  static 关键字用来声明独立于对象的静态变量，无论一个类实例化多少对象，它的静态变量只有一份拷贝。 静态变量也被称为类变量。局部变量不能被声明为 static 变量。

• 静态方法：
  static 关键字用来声明独立于对象的静态方法。静态方法不能使用类的非静态变量。静态方法从参数列表得到数据，然后计算这些数据。

final 修饰符

• final 变量：
  final 表示"最后的、最终的"含义，变量一旦赋值后，不能被重新赋值。被 final 修饰的实例变量必须显式指定初始值。
  final 修饰符通常和 static 修饰符一起使用来创建类常量
• final 方法：
  父类中的 final 方法可以被子类继承，但是不能被子类重写。
  声明 final 方法的主要目的是防止该方法的内容被修改。
• final 类
  final 类不能被继承，没有类能够继承 final 类的任何特性。

abstract 修饰符

• 抽象类：
  抽象类不能用来实例化对象，声明抽象类的唯一目的是为了将来对该类进行扩充。
  一个类不能同时被 abstract 和 final 修饰。如果一个类包含抽象方法，那么该类一定要声明为抽象类， 否则将出现编译错误。
  抽象类可以包含抽象方法和非抽象方法。

• 抽象方法
  抽象方法是一种没有任何实现的方法，该方法的的具体实现由子类提供。
  抽象方法不能被声明成 final 和 static。
  任何继承抽象类的子类必须实现父类的所有抽象方法，除非该子类也是抽象类。
  如果一个类包含若干个抽象方法，那么该类必须声明为抽象类。抽象类可以不包含抽象方法。
  抽象方法的声明以分号结尾，例如：public abstract sample();。

• synchronized 修饰符
  synchronized 关键字声明的方法同一时间只能被一个线程访问。synchronized 修饰符可以应用于四个访问修饰符。

• transient 修饰符
  序列化的对象包含被 transient 修饰的实例变量时，java 虚拟机(JVM)跳过该特定的变量。
  该修饰符包含在定义变量的语句中，用来预处理类和变量的数据类型。

• volatile 修饰符
  volatile 修饰的成员变量在每次被线程访问时，都强制从共享内存中重新读取该成员变量的值。而且，当成员变量发生变化时，会强制线程将变化值回写到共享内存。这样在任何时刻，两个不同的线程总是看到某个成员变量的同一个值。
  一个 volatile 对象引用可能是 null。

5. Java运算符

• 算术运算符
• 关系运算符
• 位运算符
• 逻辑运算符
• 赋值运算符
• 其他运算符

6. Java Number & Math 类

Java 的 Math 包含了用于执行基本数学运算的属性和方法，如初等指数、对数、平方根和三角函数。
Math 的方法都被定义为 static 形式，通过 Math 类可以在主函数中直接调用。

public class Test {  
    public static void main (String []args)  
    {  
        System.out.println("90 度的正弦值：" + Math.sin(Math.PI/2));  
        System.out.println("0度的余弦值：" + Math.cos(0));  
        System.out.println("60度的正切值：" + Math.tan(Math.PI/3));  
        System.out.println("1的反正切值： " + Math.atan(1));  
        System.out.println("π/2的角度值：" + Math.toDegrees(Math.PI/2));  
        System.out.println(Math.PI);  
    }  
}

Number & Math 类常用的一些方法：

• xxxValue() ：将 Number 对象转换为xxx数据类型的值并返回。
• compareTo(): 将number对象与参数比较。
• equals() ： 判断number对象是否与参数相等。
• valueOf()：返回一个 Number 对象指定的内置数据类型
• toString()：以字符串形式返回值。
• parseInt()：将字符串解析为int类型。
• abs()：返回参数的绝对值。
• ceil()：返回大于等于( >= )给定参数的的最小整数，类型为双精度浮点型。
• floor()：返回小于等于（<=）给定参数的最大整数 。
• rint()：返回与参数最接近的整数。返回类型为double。
• round()：它表示四舍五入，算法为 Math.floor(x+0.5)，即将原来的数字加上 0.5 后再向下取整，所以，Math.round(11.5) 的结果为12，Math.round(-11.5) 的结果为-11。
• min() ：返回两个参数中的最小值。
• max()：返回两个参数中的最大值。
• exp()：返回自然数底数e的参数次方。
• log()：返回参数的自然数底数的对数值。
• pow()： 返回第一个参数的第二个参数次方。
• sqrt()：求参数的算术平方根。
• sin()：求指定double类型参数的正弦值。
• cos()：求指定double类型参数的余弦值。
• tan()：求指定double类型参数的正切值。
• asin()：求指定double类型参数的反正弦值。
• acos()：求指定double类型参数的反余弦值。
• atan()：求指定double类型参数的反正切值。
• atan2()：将笛卡尔坐标转换为极坐标，并返回极坐标的角度值。
• toDegrees()：将参数转化为角度。
• toRadians()：将角度转换为弧度。
• random()：返回一个随机数。

7. Java Character 类

Character类的方法：

8. Java String 类

创建格式化字符串
我们知道输出格式化数字可以使用 printf() 和 format() 方法。
String 类使用静态方法 format() 返回一个String 对象而不是 PrintStream 对象。
String 类的静态方法 format() 能用来创建可复用的格式化字符串，而不仅仅是用于一次打印输出。

System.out.printf("浮点型变量的值为 " +
                  "%f, 整型变量的值为 " +
                  " %d, 字符串变量的值为 " +
                  "is %s", floatVar, intVar, stringVar);

或者

String fs;
fs = String.format("浮点型变量的值为 " +
                   "%f, 整型变量的值为 " +
                   " %d, 字符串变量的值为 " +
                   " %s", floatVar, intVar, stringVar);

String方法

9. Java StringBuffer 和 StringBuilder 类

当对字符串进行修改的时候，需要使用 StringBuffer 和 StringBuilder 类。

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

StringBuffer 类支持的主要方法：

• public StringBuffer append(String s)：将指定的字符串追加到此字符序列。
• public StringBuffer reverse()：将此字符序列用其反转形式取代。
• public delete(int start, int end)：移除此序列的子字符串中的字符。
• public insert(int offset, int i)：将 int 参数的字符串表示形式插入此序列中。
• replace(int start, int end, String str)：使用给定 String 中的字符替换此序列的子字符串中的字符。

下面的列表里的方法和 String 类的方法类似：、

• int capacity()：返回当前容量。
• char charAt(int index)：返回此序列中指定索引处的 char 值。
• void ensureCapacity(int minimumCapacity)：确保容量至少等于指定的最小值。
• void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)：将字符从此序列复制到目标字符数组 dst。
• int indexOf(String str)：返回第一次出现的指定子字符串在该字符串中的索引。
• int indexOf(String str, int fromIndex)：从指定的索引处开始，返回第一次出现的指定子字符串在该字符串中的索引。
• int lastIndexOf(String str)：返回最右边出现的指定子字符串在此字符串中的索引。
• int lastIndexOf(String str, int fromIndex)：返回 String 对象中子字符串最后出现的位置。
• int length()：返回长度（字符数）。
• void setCharAt(int index, char ch)：将给定索引处的字符设置为 ch。
• void setLength(int newLength)：设置字符序列的长度。
• CharSequence subSequence(int start, int end)：返回一个新的字符序列，该字符序列是此序列的子序列。
• String substring(int start)：返回一个新的 String，它包含此字符序列当前所包含的字符子序列。
• String substring(int start, int end)：返回一个新的 String，它包含此序列当前所包含的字符子序列。
• String toString()：返回此序列中数据的字符串表示形式。

10. Java 数组

Arrays 类

java.util.Arrays 类能方便地操作数组，它提供的所有方法都是静态的。

具有以下功能：

• 给数组赋值：通过 fill 方法。
• 对数组排序：通过 sort 方法,按升序。
• 比较数组：通过 equals方法比较数组中元素值是否相等。
• 查找数组元素：通过 binarySearch 方法能对排序好的数组进行二分查找法操作。
  

11. Java 日期时间

java.util 包提供了 Date 类来封装当前的日期和时间。 Date 类提供两个构造函数来实例化 Date 对象。
第一个构造函数使用当前日期和时间来初始化对象。
Date( )
第二个构造函数接收一个参数，该参数是从1970年1月1日起的毫秒数。
Date(long millisec)
Date对象创建以后，可以调用下面的方法。

12. Java 流(Stream)、文件(File)和IO

Java.io 包几乎包含了所有操作输入、输出需要的类。所有这些流类代表了输入源和输出目标。
读取控制台输入
Java 的控制台输入由 System.in 完成。
下面是创建 BufferedReader 的基本语法：

BufferedReader br = new BufferedReader(new 
                      InputStreamReader(System.in));

从控制台读取多字符输入：
从 BufferedReader 对象读取一个字符要使用 read() 方法，它的语法如下：

int read( ) throws IOException

从控制台读取字符串
从标准输入读取一个字符串需要使用 BufferedReader 的 readLine() 方法。

String readLine( ) throws IOException

13. Java Scanner 类

java.util.Scanner 是 Java5 的新特征，我们可以通过 Scanner 类来获取用户的输入。

下面是创建 Scanner 对象的基本语法：

Scanner s = new Scanner(System.in);

next() 与 nextLine() 区别
next():
1、一定要读取到有效字符后才可以结束输入。
2、对输入有效字符之前遇到的空白，next() 方法会自动将其去掉。
3、只有输入有效字符后才将其后面输入的空白作为分隔符或者结束符。
4、next() 不能得到带有空格的字符串。
nextLine()：
1、以Enter为结束符,也就是说 nextLine()方法返回的是输入回车之前的所有字符。
2、可以获得空白。

14. Java异常处理

15. Java正则表达式

导入包：import java.util.regex.Pattern;

参考：https://www.runoob.com/java