Resource

runoob
Java在线中文手册
\r,\n,\r\n的区别
Oracle Java Documentation
Java SE Documentation - Standard 8

缘起

从一个Java函数说起

// 定义一个公开类
public class HelloWorld {
    
    // 主方法 - Java程序的入口点
    public static void main(String[] args) { // 访问修饰符/静态标识/返回类型/方法名（参数列表）
        // 调用sayHello函数
        sayHello("Java初学者");
    }
    
    /**
     * 一个简单的问候函数
     * @param name 要问候的对象名字
     */
    public static void sayHello(String name) { // 方法参数/局部变量
        // 打印输出到控制台
        System.out.println("你好, " + name + "!");
    }
}

iDea

iDea图标含义

iDea图标

iDea快捷键

iDea shortcut ：iDea > Help > Keyboard Shortcuts PDF
程序当前快捷键定义：File > Settings > Keymap
.var

new object.var // Enter后更新为下一行代码所示
Object object = new Object();

Windows

鼠标悬停在异常虚线上显示可能错误的原因，ctrl+1 suggestions available
Ctrl + D：复制当前行到下一行
Press Ctrl+Shift+V to select the text fragment that you have previously copied to the clipboard

Alt + insert: Generate code 和切换页面冲突，自修改为Alt + Win
Ctrl + Button1：打开父类方法
Ctrl + W : expand code selection
Ctrl + / : for single line comments // ...
Ctrl + Shift + / : for block comments /*...*/
Alt + Enter : fix a highlighted error or warning, improve, or optimiaze a code construct.
Ctrl + Q : open a preview or an action description for intention actions
Alt + 1 : open the Project tool window and switch focus to it
Ctrl+Alt+T：Surround with function
Ctrl+Alt+L：Format
Ctrl+Alt+Left/Right 光标定位到上一个/下一个浏览位置处
Ctrl+Shift+F 全局搜索
Run>ViewBreakPoints>复选框勾选>“-”Remove 去除所有断点
Alt+Windows Generate构造器等基本方法 File-Settings-Keymap-Main menu-Code-Generate 原Alt+Insert
Search Everywhere
Press Shift twice search for files, actions, symbols, UI elements, Git branches and comments across your project. Pressing double Shift again, will extend the search to non-project items.
Use tabs or direct shortcuts Ctrl + N for classes, Ctrl + Shift +N for files, Ctrl + Alt + Shift + N for symbols, and Ctrl + Shift + A for actions to narrow your search results.

Alt + 7 : Quickly locate all occurences of code referencing the symbol at the caret.
Ctrl + W : Expand code selection.
Ctrl + F12 : Show file structure.

MacOS

command+N Generat Constructor Getter Setter

Java基础

Java教程

文件名需与类名一致

public class classname{    
    public static void main(String[] args) {null;}
    }

●public：表示的这个程序的访问权限，表示的是任何的场合可以被引用，这样 Java 虚拟机就可以找到 main() 方法,从而来运行 javac 程序。
● static： 表明方法是静态的，不依赖类的对象的，是属于类的，在类加载的时候 main() 方法也随着加载到内存中去。
● void:main()：方法是不需要返回值的。
● main：约定俗成，规定的。
● String[] args：从控制台接收参数。

Java对象和类

类：是一个模板，它包含类的属性和方法
对象：类的实例

类中的变量

• 类变量（Class Variables）/静态变量：相比成员变量而言，必须声明为static类型。静态变量的值在程序运行期间只有一个副本。
• 成员变量（Instance Variables）/字段（Field）/属性：定义在类中、方法之外的变量。在创建对象的时候实例化，可以被类中的方法访问。
• 局部变量：在方法中定义的变量。变量的声明和初始化都在方法中，方法结束变量即销毁。
• 参数/形参：方法和构造方法声明中的变量
  辨析：局部变量和参数始终被归类为“变量”（而不是“字段”）。
  如果成员变量和局部变量同名，根据就近原则优先使用局部变量，调用成员变量需要使用this. this可能是new的对象名

构造方法

每个类都有构造方法（如果没有显式地为类定义构造方法，Java编译器将会为该类提供一个默认构造方法），一个类可以有多个构造方法，构造方法的名称必须与类同名。
在创建一个对象的时候，至少要调用一个构造方法。

public class Puppy {
	String breed; // 属性
	int size;
	String colour;
	int age;

	public Puppy() { // 构造方法
	}

	public Puppy() {String name) { // 这个构造器仅有一个参数name
		System.out.println("小狗的名字是 :" + name);
	}

	public void setAge(int age) {
		puppyAge = age;
	}

	public int getAge() {
		System.out.println("小狗的年龄为：" + puppyAge); // 可以调用其他方法中的变量？
		return puppyAge;
	}
	
	void eat() {
	}
	
	void run() {
	}

	public static void main(String[] aregs) {
		Puppy myPuppy = new Puppy("tony");//创建对象
		myPuppy.setAge(2); //调用实例方法
		myPuppy.getAge();
		System.out.println("变量值：" + myPuppy.puppyAge); // 访问实例变量
		
	}

创建对象

在Java中，使用关键字‘new来创建对象：
step 1 声明：声明一个对象，包括对象类型和对象名称
step 2 实例化：使用关键字new来创建一个对象。
step 3 初始化：调用构造方法初始化对象。

访问实例变量和方法

// 先实例化对象
myPuppy.age;
myPuppy.eat();

源文件声明规则

一个源文件只能有一个public类，可以有多个非public类。
源文件的名称应该和public类的类名保持一致，如ClassName.java。
如果类定义在包中，那么包package语句应该在源文件的首行。
如果源文件包含import语句，应放在package语句和类定义之间，若无包，则放在头部。

内部类

访问内部类，可以通过创建外部类的对象，然后创建内部类的对象来实现。
（1）非静态内部类：
（1.1） 内部类，具有访问外部类成员的权限
（1.2）私有内部类
可以使用private和protected修饰，如果不希望内部类被外部类访问可以使用private修饰。
若private修饰，InnerClass设置为私有内部类，执行会报错
（2）静态内部类
使用static关键字定义，静态内部类不需要创建外部类来访问，可以直接访问

class OuterClass {
   int x = 10;

   class InnerClass { // （1.1） 可添加private修饰
//  private class InnerClass { // （1.2）可添加private修饰
        public it myInnerMethod() {
            return x; // 内部类访问外部类的属性和方法
        }
//   static class InnerClass { // 可添加static关键字修饰。静态内部类不能放外外部类的成员
      int y = 5;
   }
}

public class MyMainClass {
    public static void main(String[] args) {
        OuterClass myOuter = new OuterClass(); // （1.1）首先实例化外部类
        OuterClass.InnerClass myInner = myOuter.new InnerClass(); //然后创建内部类的对象。  
       // （1.2）若私有内部类，则这行代码会报错error: OuterClass.InnerClass has private access in OuterClass
       // （2）若静态类，则可省略（1.1）首先实例化外部类的步骤，不通过外部类访问，instead直接访问
     System.out.println(myInner.y + myOuter.x);
     System.out.println(myInner.my
     }
 }
 // 15   

问题：一个源文件中可以有多个类？----可以，如公类中嵌套私类

main方法

程序都是从main方法开始执行。如果要运行源文件，源文件类中须包含main方法并创建一个实例对象

javac Puppy.java //编译源文件
java Puppy // 运行程序

Java基本数据类型

8种内置数据类型

八种基本类型：六种数字类型（四个整数型，两个符点型），一种字符型，一种布尔型

DataType	Size(bytes位)	Range(Signed有符)	Range(Unsigned无符)	Note
byte	8	-27~27-1; -128~127	0~ 28-1;0~255
short	16
int	32
long	64			表示整数，如果数字大于int类型的存储极限，需要写尾缀L或l
float单精度	32
double双精度	64
char字符	16
boolean 布尔	1

引用数字类型

引用类型指向一个对象。
如类、接口、对象、数组

String

字符串是对象，使用String类创建并操作字符串
string不可改变

//创建字符串
String str = "string";

//方法
str.length();//获取字符串长度
str1.concat(str2);//连接字符串
str1 = str2 + ""；
str.charAt(int index);//返回制定索引处的char值

StringBuilder & StringBuffer

可以对字符串进行修改
StringBuilder 不是线程安全，有速度优势，优先使用；
StringBuffer 是线程安全的，不能同步访问。

//方法
str_b1.append(str_b2);//追加字符串
str_b.length;//返回长度值int
str_b.toString();//返回序列中数据的String形式

类型转换

混合运算中，不同类型的数据先转化为同一类型进行运算

• 自动类型转换：低位数转换为高位数
• 强制类型转换：(type)value 转换的数据类型必须是兼容的
• 隐含强制类型转换：整数默认int，小数默认double，定义float类型时须在数字后面跟上F或f

Java数组

Arrays

An Array is a container object (容器对象) that holds a fixed number of values of a single type.

• 注意：所有的数组（数据类型array）如int[], string[]都继承自Object，Arrays只是Java的一种标准工具类，可以操作数组类型数据。

// Declaring a Variable to Refer to an Array
dataType[] anArray;
dataType anArray[]; // Convention discourages this form.

// Creating, Initialzing, and Accessing an Array
anArray = new int[10];//Create abd Array of integers with the new operation. Default value is zero.

anArray[0] = 100; // Initialize first element and so forth.
int[] anArray = {100, 200, 300};// using the shortcut syntax to create and initialize an arra.

System.out.println("Element 1 at index 0: " + anArray[0]);//Each array element is accessed by its numerical index

Multidimensional Array

You can also declare an array of arrays (also known as a multidimensional array) by using two or more sets of brackets, such as String[][]. A multidimentionsional array’s rows are allowed to very in length in the Java programming language.

String[][] names = {
	{"Mr. ", "Mrs. ", "Ms. "},
    {"Smith", "Jones"}
};

Array Method

binarySearch

java.util.Arrays.binarySearch(Object[] a, Object key); // Search the specified array for the specified value using binary search algorithm. Returns the index of the key in this array.

copy

String[] copyTo = new String[7];
// System class
System.arraycopy(copyFrom, 2, copyTo, 0, 7);//System.arraycopy(Object src, int srcPos, Object dest, int destPos, int length); The two Object arguments specify the array to copy from and the array to copy to. The three int arguments specify the starting position in the source array, the starting position in the destination array, and the number of array elements to copy.
// java.util.Arrays class
String[] copyTo = java.util.Arrays.copyOfRange(copyFrom, 2, 9); // The difference is that using the copyOfRange method of java.util.Arrays class does not require you to create the destination array before calling the method, because the destination array is returned by the method.

sort

java.util.Arrays.sort(Object[] a);//Sorting an arrays into ascending order.

java.util.Arrays.sort()

Java 修饰符

访问控制修饰符

访问控制符控制类、变量、方法、构造方法的访问
default 默认，什么都不写，不使用任何修饰符。类、接口、变量、方法均可使用
private 同一类内可见。可修饰变量、方法，不可修饰类（外部类）
public 对所有类可见。类、接口、变量、方法均可使用
protected 对同一包内的类和所有子类可见。可修饰变量、方法，不可修饰类（外部类）

非访问控制修饰符

static

• 静态类：属于类本身，不能使用 new 关键字来创建实例。在程序启动时就被初始化，全局只有一份。只能包含静态成员（静态字段、静态方法、静态属性等）。
• • 非静态类：属于实例对象。必须使用 new 关键字创建具体的实例后，才能使用。可以包含静态成员和非静态成员。
• 静态变量/类变量：无论一个类实例化多少对象，它的静态变量只有一份拷贝。局部变量不能被声明为 static 变量。
• 静态方法：静态方法不能使用类的非静态变量。静态方法从参数列表得到数据。

Q：静态类是否可以访问非静态类？

A：可以。静态类必须通过（在静态方法内创建）非静态类的实例对象来访问其非静态成员。可以直接通过非静态类的类名来访问这些静态成员，而无需创建实例。

final

• 修饰类：不能够被继承
• 修饰方法：不能被继承类重新定义
• 修饰变量：常量不可修改

abstract

创建抽象类和抽象方法

synchronized & volatile

• 对象锁：在Java中，每一个对象都有一把内置的锁（也称为监视器锁）。synchronized 关键字就是用来获取这把锁的。
• 作用：用于实现线程同步，保证同一时刻，只有一个线程能执行某个代码块或方法（这个代码块/方法被称为临界区）

sleep() 与 wait()

• sleep()是Thread 类的静态方法，Thread.sleep(1000); 让当前正在执行的线程暂停执行一段指定的时间，不会释放已经持有的任何锁，睡眠时间到期（sleep(milliseconds)），或者被中断（interrupt()）唤醒。
• wait()是Object 类的实例方法，lockObject.wait();让当前线程主动释放对象锁，并进入等待（阻塞）状态。会立即释放当前持有的对象锁。需要由其他线程主动唤醒，通过调用同一个锁对象的 notify() 或 notifyAll() 方法。也可以设置超时时间 wait(milliseconds)。

Java 运算符

算数运算符

a/b 除法-左操作数整除以右操作数
(float)a/b //其中一个是浮点数，结果保留小数

中缀表示法3 + 4对人类很直观，但对计算机来说需要处理运算符优先级和括号。
逆波兰表示法/后缀表示法（Reverse Polish Notation, RPN）3 4 + 因可看作是波兰表示法/前缀表示法+ 3 4的逆序而得名。
RPN消除了对括号和运算符优先级的需要，依赖于数据结构栈。
基本计算过程：从左到右扫描表达式；遇到操作数就将其压入栈中；遇到运算符，就从栈中弹出两个操作数用运算符运算；将计算结果压回栈中；最后栈中剩下的唯一数就是表达式的计算结果。

自增/自减运算符

i++ & ++i 区别

i++ & ++i 区别在于自增的时机和返回表达式的值。
i++ 先返回i的值，再将i加1。

int i = 5;
int a = i++;
System.out.println(a);//输出5
System.out.println(i);//输出6

++i 先将i加1，再返回i的新值。

int i = 5;
int a = ++i;
System.out.println(a);//输出6
System.out.println(i);//输出6

i++ & ++i在循环体中的效果

1. 一般情况下没有区别
   在标准for循环中，i++ & ++i效果相同，因为递增部分是在每次循环体结束后执行的，不直接影响循环条件。

// 均输出0，1，2，3，4
for(int i = 0; i < 5; i++){
	System.out.println(i + "");
}

for(int i = 0; i < 5; ++i){
	System.out.println(i + "");
}

2. 特殊情况下的区别
   当循环条件依赖i的值，i++ & ++i可能效果不同。

int i = 0
while(i++ < 3){
	System.out.println(i + "");
}
//输出：0，1，2

int j = 0
while(++j < 3){
	System.out.println(j + "");
}
//输出：1，2

位运算符

按二进制位运算，应用于整数类型int, long, short, char, 和字节型byte

& // 1&1=1 其余得0
| // 0|0=0 其余得1
^ // x^x=0 相同为0，相异为1
~ // 按位取反
<< // 按位左移，右边自动补0
>> // 按位右移，左边不补0
>>> // 按位右移，左边补0

Java逻辑结构

Java循环结构

while

do…while

for

for (inil; boolean_expression; update) { // i++升序/i--降序
	code_lines;
}
// Java增强for循环--Java5引入
for (声明变量: 数组) { // 降序
	code_lines;
}

Java条件语句

if (boolean_expression) code_line;

if (boolean_expression) {
	code_lines;
} else if {
	code_lines;
} else {
	code_lines;
}

Java switch case

Java Common Class

java.lang

public static int compareTo(Object a)

int x.compareTo(y); // Returns a negative integer, zero, or a positive integer as this object is less than, equal to, or greater than the specified object. 

Interface Comparable

定义对象的自然排序规则。当一个类实现了Comparable接口，就意味着它的实例可以互相比较，并通过Array.sort()或Collections.sort()等方法自动排序。

Java Math Class

Math.min();// Return the minium on between the two parameters.

Java 异常处理

（1）检查性异常：用户错误或问题引起的异常，程序员无法预见。如打开一个不存在的文件。编译时不能被简单地忽略。
（2）运行时异常：可以被程序员避免。可以在编译时被忽略。
（3）错误：错误不是异常。程序员不能控制。在代码中常被忽略。如栈溢出，在编译时检查不到。

Java Number & Math类

round()四舍五入，Math.floor(x+0.5),加0.5后向下取整，返回一个最接近的int、long型值方法返回

long round(double d)
int round(float f)

Java Stream、File、IO

读写文件

字节流

字节流用于处理二进制数据，例如文件、图像、视频等。
ObjectInputStream & ObjectOutputStream

字符流

字符流用于处理文本数据，例如读取和写入字符串或文件。

Java内置异常类

Java语言定义了一些异常在java.lang标准包中。该包默认加载到所有的Java程序。大部分运行时异常都可以直接使用，如以下非检查性异常。
IndexOutOfBoundsException 指示某排序索引（例如对数组、字符串或向量的排序）超出范围时抛出。
又如以下定义在java.lang包中的检查性异常
ClassNotFoundException 应用程序试图加载类时，找不到相应的类，抛出该异常
IllegalArgumentException 向方法传递了一个不合法或不正确的参数。
IllegalStateException 在非法或不适当的时间调用方法时产生的信号。换句话说，即 Java 环境或 Java 应用程序没有处于请求操作所要求的适当状态下。

try-catch被动捕获并处理异常

• 用于处理可能发生异常的代码块，被动等待；try块必须至少有一个catch或finally捕获。
• 程序可以继续运行，除非在catch块中再次抛出（throw）异常或终止程序。

// 基本语法
try {
    // 可能会抛出异常的代码
    int[] arr = new int[5];
    arr[10] = 50; // error1
    int result = 10/0; // error2
} catch (ArrayIndexOutOfBoundsException e1) {
    System.out.println("数组越界: " + e); // 处理 ArrayIndexOutOfBoundsException 类型的异常
} catch (ArithmeticException e2) {
    System.out.println("发生了算术异常: " + e.getMessage()); // 处理 ArithmeticException 类型的异常
} catch (Exception e) {
    System.out.println("其他异常: " + e);
} finally {
    // 无论是否发生异常都会执行的代码（可选），如确保资源被释放
}

throws/throw关键字-主动抛出异常

• throw 关键字用于在当前方法内部抛出一个异常。通常情况下，当代码执行到某个条件下（主动创建）无法继续正常执行时使用，主动抛出一个异常对象。
• 当前方法会立即停止执行，异常会沿着调用栈向上传输，知道被某个try-catch块捕获，或到达main方法仍未处理则程序终止。

public void checkNumber(int num) {
  if (num < 0) {
    throw new IllegalArgumentException("Number must be positive");
  }
}

• throws 关键字用于在方法声明中指定该方法可能抛出的异常。当方法内部抛出指定类型的异常时，该异常会被传递给调用该方法的代码，并在该代码中处理异常。一个方法可以声明抛出多个异常，多个异常之间用逗号隔开。
• 因此，当方法内部没有实际抛出异常，或抛出异常但调用方用try-catch处理时，程序可以继续执行；当抛出异常但调用方不处理，则程序终止运行。
• 例如，下面的代码中，当 readFile 方法内部发生 IOException 异常时，会将该异常传递给调用该方法的代码。在调用该方法的代码中，必须捕获或声明处理 IOException 异常。

public void readFile(String filePath) throws IOException {
  BufferedReader reader = new BufferedReader(new FileReader(filePath));
  String line = reader.readLine();
  while (line != null) {
    System.out.println(line);
    line = reader.readLine();
  }
  reader.close();
}

Class System

public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length) // 将指定源数组从指定位置开始的length长度子序列，复制到目标数组的制定位置