Java自学 | 在实践中完善知识结构

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

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 obect (容器对象) that holds a fixed number of values of a single type.

// 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.

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

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.
java.util.Arrays.sort(Object[] a);//Sorting an arrays into ascending order.

java.util.Arrays.sort()

Java 修饰符

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

运算符

算数运算符

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

自增/自减运算符

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

Java Common Class

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内置异常类

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

捕获异常

throw 关键字用于在当前方法中抛出一个异常

throws 关键字用于在方法声明中指定该方法可能抛出的异常。

throws/throw关键字

throw 关键字用于在当前方法中抛出一个异常。
通常情况下，当代码执行到某个条件下无法继续正常执行时，可以使用 throw 关键字抛出异常，以告知调用者当前代码的执行状态。

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

throws 关键字用于在方法声明中指定该方法可能抛出的异常。当方法内部抛出指定类型的异常时，该异常会被传递给调用该方法的代码，并在该代码中处理异常。一个方法可以声明抛出多个异常，多个异常之间用逗号隔开。
例如，下面的代码中，当 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长度子序列，复制到目标数组的制定位置

Java面向对象

Java继承

继承：子类继承父类的特征/实例域和行为/方法。

class 父类 {}
class 子类 extends 父类 {}

Java支持多重继承（C继承B，B继承A）；不支持多继承
extends 只能继承一个类
implements 可以继承多个接口，用","隔开
super 实现对父类成员的访问
this 指向自己的引用
finel 终态，类不能被继承，方法不能被改写

重写Override与重载Overload

重写：子类对父类允许访问的方法的实现过程进行重新编写，返回值和形参都不能改变
编译时检查参数的引用类型，父类中需有对应的方法，运行时运行实例对象的方法。
通过super调用父类被重写之前的方法。
标记@Override可以避免一些基本的错误。

重载：在一个类中，方法名相同，参数不同，返回类型可同可不同。最常用的地方是构造器的重载。

Java高级

Java HashMap

HashMap存储健值对，无序。

//初始化赋值
Map<Integer, String> map = Map.of(key1, value1,...,keyn, valuen);// 元素是对象，基本元素可使用对应包装类
//创建HashMap对象
HashMap<Integer, String> map = new HashMap<Integer, String>();

//方法
map.put(keyi, valuei);//添加元素
map.get(keyi);// 获取valuei

Java常见报错

1 Project JDK is not defined

Setup SDK > +Add SDK > JDK: Java Path (高级设置 > 环境变量)

2 List item

error: duplicate class: Main
程序只需要一个入口，即只有一个类包含main方法，其他类都是用于被main方法直接或间接调用的。

3 error: non-static method ‘xxx’ cannot be referenced from a static context

描述：在静态上下文中无法引用非静态方法
解决：Make the method static.

4 error: cannot find symbol

描述：无法找到符号

5 找不到或无法加载主类

java.lang.ClassNotFoundException
原因：查看该类是否有被编译成class文件

6 cannot be resolved 无法解析

cannot be resolved a type 无法解析为类型
原因：jar包缺失
解决：import导入对应包

7 MAVEN

Project build error: Non-parseable POM D:\xxx\xxx\pom.xml: expected START_TAG or END_TAG not TEXT (position: xxx)
原因：代码格式（空格）问题
解决：自动格式化 Ctrl+Shift+F

8 未设置系统全局属性 system property

Exception in thread "main" java.lang.IllegalStateException: The path to the driver executable must be set b the webdriver.chrome.driver system property:
解决方案：系统设置Chrome驱动文件的路径
将驱动放置对应目录下，并添加代码
System.setProperty("webdriver.chrome.driver", "xxx");

Exception in thread "main" java.lang.IllegalStateException: The driver executable does not exist

9 无法在静态方法中引入非静态成员

cannot make a static reference to non-static field
原因：在静态方法中，不能直接访问非静态成员（方法/变量）。因为，非静态变量依赖于对象存在，对象必须实例化后，变量才会在内存中存在。
解决方案：1）将变量改为静态的；2）先实例化对象，然后使用对象名.变量名调用

10 不兼容的类型 incompatible types

public Map<Character, Integer> getFrequencyMap(List lst) {
	for (String elem : lst) {
	......
	}
}

java: incompatible types: java.lang.Object cannot be converted to java.lang.String
原因：List默认返回Object类
解决方案：
（1）将Object转换为String

String str = String.valueOf(obj);
String str = (String)(obj);

（2）使用String类

import ...

public class NaiveLetterFreqGuesser implements Guesser { // Java代码须在class类中

	private final List<String> words; // 声明属性words，是一个String组成的List
	public NaiveLetterFreqGuesser(String dictionaryFile) { words = FileUtils.readWords(dictionaryFile); } // 变量words读取文件
	
	public Map<Character, Integer> getFrequencyMap() { // 构造方法
		for (String elem : words) { // 使用全局属性words
		......
		}
	}
	
	public static void main(String[] args) { // run main 以执行代码
		NaiveLetterFreqGuesser nlfg = NaiveLetterFreqGuesser(dictionary: "data/example.txt") // 定义类
		System.out.println（"list of words: " + nlfg.words); // 调用类的属性words
		System.out.println("frequency map: " + nlfg.getFrequencyMap()); // 调用方法
	}
}

11 类1不能强制转换为类2

class java.lang.Character cannot be cast to class java.lang.Integer

12 并发修改异常

for (int i = 0; i < guesses.size(); i ++) {
                if (!(pattern.indexOf(guesses.get(i)) != -1)) {
                    for (String elem: lst) {
                        if (elem.indexOf(guesses.get(i)) != -1) {
                            lst.remove(elem);
                        }
                    }
                }
            }

报错：ConcurrentModificationException
分析：迭代的时候不允许迭代体的长度发生变化

13 java: 错误: 不支持发行版本 20

问题：设置的项目SDK与本地下载的java版本不符
解决：“File -> Project Structure”