挖新坑—Java

只记录Java最入门的内容，模块并不完整，更深入的知识在Java基础、Java提高、JavaWeb模块

一、基础（略）

1、注释同C、关键字字母全部小写、常量略、变量命名规范同C，定义long时在整数后加L，定义float时在最后加F

2、标识符命名规范同C，另外小驼峰用来定义变量，大驼峰用来定义类

3、数据类型及类型转换如图，强转同C

4、算术运算符同C，整数除法注意*1.0、字符的“+”操作使用时，若包含多个数据类型，整个表达式类型自动进行提升，优先级如下，字符串操作相当于字符串拼接（特例是1+1+'字符串'为先做加法）。

5、赋值运算符中注意+=运算底层隐含了强制类型转换，自增自减同C

6、关系运算符同C，结果为true或false，逻辑运算符同C用来连接关系表达式、&&短路与 ||短路或

7、三元运算符同C condition?true：false

8、使用引用类型：

• 导包 import 包路径名;
• 创建 数据类型 变量名称 = new 数据类型();
• 使用 变量名称.方法名

以Scanner为例

• import java.util.Scanner
• Scanner sc = new Scanner(System.in);
• int num = sc.nextInt(); String str = sc.next();

9、流程if、while、for、break、continue同C，略

10、数组

• 创建
  • 数据类型[] 数组名 = new 数据类型[]; 或者 数据类型 数组名[] = new 数据类型[];
• 初始化
  • 动态初始化
    • 例：int[] arr = new int[3]，创建含有3个元素的int型数组
  • 静态初始化
    • 例1： int[] arr = new int[] {10,20,30}
    • 例2： int[] arr = {10,20,30}
• 获取长度
• 数组越界
• for each用法
• 可以用Arrays.toString(数组名)打印数组元素
• 数组拷贝 数组类型[] 新数组名 = Arrays.copyOf(旧数组名，新数组长度)

11、Java内存分配

• 栈（Stack）：主要用来存放局部变量
• 堆（Heap）：凡是new出来的都在其中
  • 如果为证书，默认是0
  • 浮点数，默认是0.0
  • 字符，默认是'\u0000'（Unicode写法）
  • 布尔，默认为false
  • 引用类型（包含字符串），默认为null（空常量）
• 方法区（Method Area）：存放与.class相关的信息
• 本地方法区（Native Method Area）：与操作系统相关
• 寄存器（pc Register）：与CPU相关，性能极高

12、方法（相当于C的函数）

• 定义： 修饰符 返回值类型 方法名称(参数类型 参数名称,参数类型 参数名称){方法体;return 返回值;}
• 调用方式：
  • 单独调用：方法名称(参数值)
  • 打印调用：System.out.println(方法名称(参数值))
  • 赋值调用：数据类型 变量名 = 方法名称(参数值) ，数据类型必须与方法返回值一致
• 命名问题（以下两个“可以”的意思是不报错，而不是命名规范）
  • 变量名可以跟方法的名一样
  • 两个方法中可以有同名变量
• 重载（方法名称相同，但参数个数或类型不同）
  • 参数个数不同
  • 参数类型不同
  • 参数的多类型顺序不同
  • 不能根据返回值类型进行重载
• 参数传递
  • 形式参数：在定义的时候，写在小括号之内的参数
  • 实际参数：在调用方法的时候，传入方法里面的数据，叫做实际参数
  • 规则
    • ※基本类型，形参操作不影响实参。
    • ※引用类型，形参操作影响实参。因为引用类型的参数传递的是堆地址，实参形参共用一个地址，形参改变之后，实参也会改变。

13、==：基本类型是比较数据内容，引用类型是比较地址值

二、面向对象编程

2.1 类与对象

• 类的定义
  • 成员变量：将变量位置直接定义在类中，在方法外，为成员变量
  • 成员方法：将普通的方法去掉static
• 局部变量和成员变量的区别
  • 定义的位置不同
    • 局部：定义在方法内部
    • 成员：定义在类中，方法外部
  • 内存中的位置不同
    • 局部：在栈内存中
    • 成员：在堆内存中
  • 生命周期不同
    • 局部：随着方法进栈出现，随着方法出栈消失
    • 成员：随着对象被创建出现，随着对象被JVM回收消失
  • 默认值不同
    • 局部：无默认值
    • 成员：有默认值
• private关键字与getter()和setter()方法
• this关键字 通过谁调用的方法，谁就是this
• 构造方法：通过new创建对象时，就是在调用构造方法
  • 格式：public 构造方法名(参数类型 参数名称){方法体;return;}
  • 注意
    • 构造方法不能写返回值类型
    • 构造方法的名称必须与所在的类名称完全一样（包括大小写）
  • 重载
  • 构造方法如果没有定义就默认生成一个，如果自定义了就不再生成默认的。
• 定义一个标准的类
  • 所有的成员变量都使用private私有化
  • 为每一个成员编写getter和setter方法。对于boolean类型，是get和is
  • 编写一个无参数的构造方法、一个全参数的构造方法
• String类
  • 所有的类都需要导包使用，除了两种情况
    • 和当前类位于同一个包下
    • 要使用的目标类，位于java.lang包下，但是不包含子包内容
  • println可以直接打印String类的内容，一般的对象都是使用“类型信息+@+地址值”作为字符串内容
  • 截取字符串substring
  • 字符串池
    • 位于堆内存，用于保存若干个字符串的地址值
    • 不会出现重复的字符串，因此相同的字符串对应的是同一个地址
    • 凡是双引号创建的字符串都在池中，new出来的字符串默认不在池中
  • 字符串内容不可改变
  • 字符串比较使用equals方法
  • 字符串比较
  • 字符串替换（敏感词）
    • str.replace(oldStr,newStr);
  • 字符串切割split
    • String[] arr = str.split("分割点")
    • 如果分割点是英文的点，需要使用"//."

2.2 集合 ArrayList

• 注意
  • 集合的长度可以改变
• 构造方法
  • 泛型只能写引用类型，不能写基本类型
• 常用方法
  • add()：返回值为boolean
  • get()：索引从0开始
  • size()：长度
• 如何在集合中存储基础类型
  • byte :Byte
  • short :Short
  • int :Integer
  • long :Long
  • float :Float
  • double :Double
  • char :Character
  • boolean:Boolean
• 自定义泛型

三、IO流

3.1 概述与分类

• 输入流与输出流
  • 输入，读，从硬盘到内存
  • 输出，写，从内存到硬盘
• 字节流和字符流
  • 字节流：可以处理任何一种文件数据
  • 字符流只能处理纯文本文件
• IO分类
  • 字节输入流
  • 字节输出流
  • 字符输入流：读纯文本文件
  • 字符输出流：写纯文本文件
• FileWriter写文件：字符输入流
  • 创建：FileWrite fw = new FileWrite("file.txt")
  • 使用
    • 写数据：public void write(String str)
    • 关闭流：public void close();
    • 追加写入：new FileWriter("file.txt",true)
  • 换行符
    • Windows：\r\n
    • macOS：\n
    • Linux：\n
  • 重载
    • public coid write(int ch)：ASCII或Unicode码表
    • public coid write(String str) :写一个完整的字符串
    • public coid write(String str, int offset,int count) :写入截取后的字符串
    • public coid write(char[] array) :写入完整的字符数组
    • public coid write(char[] array,int offset,int count) :写入截取后的字符数组
• FileReader读文件
  • 创建：FileReader fr = new FileReader("file.txt")
  • 使用
    • public int read()：一次只读取一个字符，返回值为ASCII或Unicode码，直到-1为止
    • public int read(char[] buf):一次读取整个字符数组的数据，返回值代表数组当中读取到的有效个数。
    • public void close()：

//读取字符串的标准代码
FileReader fr = new FileReader("File06.txt");
char[] buf = new char[2];
int len;
while ((len = fr.read(buf)) != -1) {
	String str = new String(buf, 0, len);
	System.out.print(str);
}
fr.close();

• BufferedWriter():肚子里有一个长度为8192的char[]字符数组，当做缓冲区使用。缓冲数组满了之后，写到硬盘的文件中。若没有写满，等待下一次写入。关闭流时，将剩余有效部分写到硬盘文件中。
  • 使用
    • 先new一个FileWriter，见下面代码
  • 换行 public void newLine();

基本使用
FileWriter fw = new FileWriter("File06.txt");
BufferedWriter buffer = new BufferedWriter(fw);
buffer.write("Hello!");
buffer.close();

• BufferedReader()：跟BufferedWriter差不多
  • 使用
    • 先new一个Filereader,见下面代码
  • 读取一整行public String readLine()

public static void main(String[] args) throws IOException {
	FileReader fr = new FileReader("File06.txt");
	BufferedReader buffer = new BufferedReader(fr);
	// 读取单个字符
	int read;
	while ((read = buffer.read()) != -1) {
		System.out.print((char) read);
	}
	// 读取字符数组
	char[] buf = new char[2];
	int len;
	while ((len = buffer.read(buf)) != -1) {
		String str = new String(buf,0,len);
		System.out.print(str);
	}
	buffer.close();
}
/**readLine的用法*/
public static void main(String[] args) throws IOException {
	FileReader fr = new FileReader("File06.txt");
	BufferedReader buffer = new BufferedReader(fr);
	String line = null;
	while ((line = buffer.readLine())!=null) {
		System.out.println(line);
	}
	buffer.close();
}

3.2 例： 定义一个集合用于存储多个字符串，向其中添加一些字符串， 然后将集合的所有字符串内容写到文件中。要求每个字符串独占一行。

public static void main(String[] args) throws IOException {
	//创建集合
	ArrayList<String> list = new ArrayList<>();
	list.add("小强1号");
	list.add("小强2号");
	list.add("小强3号");
	list.add("小强4号");
	//写文件
	BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter("test01.txt"));
	//遍历集合
	for (int i = 0; i < list.size(); i++) {
		String str = list.get(i);
		bufferedWriter.write(str);
		if (i==list.size()-1) {
			break;
		}
		bufferedWriter.newLine();
	}
	bufferedWriter.close();
}

3.3 例：与3.2相反，将文件中的字符串文本读取到集合当中，并且每一行文本作为集合中的一个字符串元素。

public static void main(String[] args) throws IOException {
	//新建字符串
	ArrayList<String> list = new ArrayList<String>();
	//读取
	BufferedReader bufferedReader = new BufferedReader(new FileReader("test01.txt"));
	String str = null;
	while ((str = bufferedReader.readLine())!=null) {
		list.add(str);
	}
	bufferedReader.close();
	System.out.println(list.toString());
}

3.4 例：将txt文件每一行倒序输入至另一个文件

public static void main(String[] args) throws IOException {
	BufferedReader bufferedReader = new BufferedReader(new FileReader("Test03.txt"));
	ArrayList<String> list = new ArrayList<String>();
	String str = null;
	while ((str = bufferedReader.readLine())!=null) {
		list.add(str);
	}
	System.out.println(list.toString());
	bufferedReader.close();
	//逆向读取
	BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter("Test04.txt"));
	
	for (int i = list.size()-1; i >= 0; i--) {
		System.out.println(list.get(i));
		bufferedWriter.write(list.get(i));
		if (i==0) {
			break;
		}
		bufferedWriter.newLine();
	}
	bufferedWriter.close();
}

四、方法与接口

4.1 方法的参数类型

• 基本类型
• 数组
• 字符串
• 自定义的类

4.2 方法的返回值类型

同上

4.3 接口的定义格式

public interface 接口名称{}

接口当中可以包含的组成部分有抽象方法、常量、默认方法（Java 8）、静态方法（Java 8） 、私有方法（Java 9）

• 抽象方法
  • 声明
    • public abstract 返回值类型 方法名称 (参数类型 参数名称)
  • 注意
    • 修饰必须是public abstract，可以省略
    • 只有方法头，不能有方法体
  • 实现
    • public class 实现类名称 implements 接口名称 {}
    • 覆盖重写抽象方法Override，去掉abstract关键字，写上大括号方法体
  • 使用
    • 创建：接口名称 引用名 = new 实现类名称();
    • 调用：引用名.抽象方法名(参数)；
  • 注意
    • 左边是接口类型，则只能调用接口中声明的内容，不能调用右侧实现类中特有的内容（接口隔离）。

4.4 λ表达式

有且仅有一个抽象方法的接口，叫做函数式接口。使用Lambda表达式的前提是必须有函数式接口。

检测当前接口是否为函数式接口：@FunctionalInterface

接口：

@FunctionalInterface
public interface Calculator {
	public abstract int sum(int a,int b);
}

使用：

public static void main(String[] args) {
	method((int a,int b) -> { return a+b;} );
}
public static void method(Calculator calculator) {
	int result = calculator.sum(10, 20);
	System.out.println(result);
}

Lamda表达式的参数类型可以省略，如果参数值有一个那么小括号可以省略，如果语句只有一个那么大括号和return也可以省略。

五、方法引用（Java 8）

5.1 静态方法与成员方法

• 定义方法的时候，有无static有什么区别
  • 有static 的时候：静态方法
  • 无static 的时候：成员方法
• 静态方法
  • 定义：public static 方法名（参数类型 参数名称）
  • 调用：类名称.方法名（参数值）
• 成员方法（也叫实例方法，Instance Method）
  • 定义：public static 方法名（参数类型 参数名称）
  • 调用：先创建对象，对象名.成员方法名（参数值）
• 注意
  • 不创建对象，只能调用静态方法
  • 创建了对象，可以调用成员方法
  • 创建了对象，也能调用静态方法，但是不推荐

5.2 方法引用

可以用来简化Lambda表达式，例如()->{}写成类名称::方法名

• 通过类名称引用静态方法 类名称::方法名

接口：

@FunctionalInterface
public interface Calculator {
	int getAbs(int num);
}

使用：

public static void main(String[] args) {
	//Lambda表达式
	method(num -> num >= 0 ? num : -num);
	//引用
	method(Math::abs);
}
public static void method(Calculator cal) {
	int abs = cal.getAbs(-25);
	System.out.println("结果是" + abs);
}

• 通过对象名引用成员方法 ，先new对象，对象名::成员方法名

类定义：

public void makeFood(String food) {
	System.out.println(food);
}

接口定义：

public interface Sitter {
    void work(String food);
}

使用：

public static void main(String[] args) {
	Cook cook = new Cook();
	method( cook::makeFood );
}
public static void method(Sitter  sitter) {
	sitter.work("土豆");
}

六、Stream流（Java 8）

七、模块化（Java 9）