Java学习笔记（持续更新）

非访问修饰符：

static：

用来修饰类方法和类变量。

静态变量：

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

静态方法：

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

final：

用来修饰类、方法和变量。

final 变量：

final 表示"最后的、最终的"含义，变量一旦赋值后，不能被重新赋值。被 final 修饰的实例变量必须显式指定初始值。

final方法：

final 方法可以被子类继承，但是不能被子类重写。

final类：

final 类不能被继承，没有类能够继承 final 类的任何特性。

abstract：

用来创建抽象类和抽象方法。（一个类不能同时被 abstract 和 final 修饰。）

抽象类：

抽象类不能用来实例化对象，声明抽象类的唯一目的是为了将来对该类进行扩充。

抽象类可以包含抽象方法和非抽象方法。

抽象方法：

抽象方法是一种没有任何实现的方法，该方法的具体实现由子类提供。

抽象方法不能被声明成 final 和 static。

任何继承抽象类的子类必须实现父类的所有抽象方法，除非该子类也是抽象类。

如果一个类包含若干个抽象方法，那么该类必须声明为抽象类。抽象类可以不包含抽象方法。

抽象类与抽象方法示例：

public abstract class SuperClass{ //抽象类
    abstract void m(); //抽象方法
}

synchronized：

声明的方法同一时间只能被一个线程访问。

volatile：

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

运算符：

自增、自减运算符：

a++与++a的区别：

public class selfAddMinus{
    public static void main(String[] args){
        int a = 5;//定义一个变量；
        int b = 5;
        int x = 2*++a;
        int y = 2*b++;
        System.out.println("自增运算符前缀运算后a="+a+",x="+x);
        System.out.println("自增运算符后缀运算后b="+b+",y="+y);
    }
}

位运算符：

A = 0011 1100
B = 0000 1101
-----------------
A&B = 0000 1100
A | B = 0011 1101
A ^ B = 0011 0001
~A= 1100 0011

操作符	描述	例子
＆	如果相对应位都是1，则结果为1，否则为0	（A＆B），得到12，即0000 1100
|	如果相对应位都是 0，则结果为 0，否则为 1	（A | B）得到61，即 0011 1101
^	如果相对应位值相同，则结果为0，否则为1	（A ^ B）得到49，即 0011 0001
〜	按位取反运算符翻转操作数的每一位，即0变成1，1变成0。	（〜A）得到-61，即1100 0011
<<	按位左移运算符。左操作数按位左移右操作数指定的位数。	A << 2得到240，即 1111 0000
>>	按位右移运算符。左操作数按位右移右操作数指定的位数。	A >> 2得到15即 1111
>>>	按位右移补零操作符。左操作数的值按右操作数指定的位数右移，移动得到的空位以零填充。	A>>>2得到15即0000 1111

逻辑运算符：

操作符	描述	例子
&&	称为逻辑与运算符。当且仅当两个操作数都为真，条件才为真。	（A && B）为假。
| |	称为逻辑或操作符。如果任何两个操作数任何一个为真，条件为真。	（A | | B）为真。
！	称为逻辑非运算符。用来反转操作数的逻辑状态。如果条件为true，则逻辑非运算符将得到false。	！（A && B）为真。

条件运算符：

variable x = (expression) ? value if true : value if false

instanceof 运算符：

( Object reference variable ) instanceof  (class/interface type)

如果运算符左侧变量所指的对象，是操作符右侧类或接口(class/interface)的一个对象，那么结果为真。

String：

创建字符串：

String str = "Runoob";
String str2=new String("Runoob");

String创建的字符串存储在公共池中，

new 创建的字符串对象在堆上。

求字符串长度：

string.length()

连接字符串：

string1.concat(string2)

string1+string2

返回指定索引出的字符：

string.charAt(num)

转换成字符数组：

string.toCharArray()

从一个较大的字符串中提取一个子串：

string.subString(start, end)

把多个字符串放在一起，且用一个定界符分隔：

String.join(分隔符, string1, string2, ...)

判断两个字符串是否相等：

string1.equals(string2)   （区分大小写）

string1.equalsIgnoreCase(string2)   （不区分大小写）

== 符号 不能检测两个字符串是否相等，只能检测两个字符串是不是在同一位置

Java StringBuffer 和 StringBuilder 类:

当对字符串进行修改的时候，需要使用 StringBuffer 和 StringBuilder 类，和 String 类不同的是，StringBuffer 和 StringBuilder 类的对象能够被多次的修改，并且不产生新的未使用对象。

 StringBuilder 相较于 StringBuffer 有速度优势，所以多数情况下建议使用 StringBuilder 类。

创建一个新的StringBuilder对象：

 StringBuilder sb = new StringBuilder(10);

往字符串中增加字符或字符串：

sb.append("sting")

在指定位置插入字符或字符串：

sb.insert(num,"string")

删除指定位置区域的字符串：

sb.delete(start,end)

返回序列中数据的字符串形式：

sb.toString()

2022年11月9日：

数组：

声明数组变量：

dataType[] arrayRefVar;   // 首选的方法
 
或
 
dataType arrayRefVar[];  // 效果相同，但不是首选方法

创建数组：

arrayRefVar = new dataType[arraySize];

声明+创建数组：

dataType[] arrayRefVar = new dataType[arraySize];

或

dataType[] arrayRefVar = {value0, value1, ..., valuek};

多维数组：

String[][] str = new String[num1][num2];

Java ArrayList：

秋招不如意，发现只会python找不到合适的工作，看到好多秋招的要求上有Java，于是重新拾起Java的学习，现阶段查漏补缺，一边学习新知识，一边找工作投简历，加油！

祝自己秋招顺利！最差也要春招顺利！！

2023年10月1日-10月2日

《Java核心技术》第三章：

输入输出：

读取标准输入流：

import java.util.*

Scanner in = new Scanner(System.in);

String name = in.nextLine();   //读取一行
String name = in.next();       //读取一个单词（以空白符为分隔符）
String name = in.nextInt();    //读取一个整数

输出：

System.out.printf("Hello!")
println
printf

数组：

声明数组：

int[] a;
或
int a[];

创建数组：

//不知道数组元素：
int[] a = new int[100];


//知道数组元素：
smallPrimes = new int[] {17,19,0};
或
int[] anonymous = {17,19,0};
smallPrimes = anonymous;

tips：一旦创建了数组，就不能改变其大小。

for each 循环语句：

for (int element: a)
    System.out.println(element)

拷贝数组：

int[] string1 = Arrays.copyOf(string2,string2.length)

数组排序：

Arrays.sort(string)

用的是快速排序法

二维数组：

//不知道数组元素：
int a[][] = new int[100];


//知道数组元素：
smallPrimes = new int[] {17,19,0};
或
int[] anonymous = {17,19,0};
smallPrimes = anonymous;