1、Java是一种高级计算机语言，是可以编写跨平台应用软件、完全面向对象的程序设计语言。

2、Java划分为三个技术平台：Java SE、Java EE、Java ME

Java SE是桌面应用，Java EE是web应用，平台企业版，Java ME是手机应用，平台微型版

3、Java语言的特点：简单易用、安全可靠、跨平台（通过Java虚拟机实现）、面向对象、支持多线程、自动进行垃圾回收(c语言没有)。

Java引入了虚拟机的概念，通过虚拟机（JVM）可以在不同的操作系统上运行Java程序，从而实现跨平台特性。

4、所有的可执行文件都在bin文件夹下

5、bin目录：该目录用于存放一些可执行程序，如javac.exe(Java编译器)、java.exe(Java运行工具)、jar.exe（打包工具）和 javadoc.exe（文档生成工具）

javac.exe是Java编译器工具，它可以将编写好的Java文件编译成Java字节码文件(可执行的Java程序)。就是将.java文件编译成.class文件。

java.exe是Java运行工具，它会启动一个Java虚拟机(JVM)进程，专门负责运行由Java编译器生成的字节码文件(.class文件)

6、db目录：db目录是一个小型数据库

7、include目录：在启动时引入一些C语言的头文件。

8、jre目录：此目录时Java运行时环境的根目录，它包含Java虚拟机、运行时的类包、Java应用启动器以及一个bin目录，但不包含开发环境中的开发工具。

jre只负责编写，不负责编译(只有java没有javac)

9、lib目录：为Java类库或库文件，是开发工使用的归档包文件

10、src文件夹：放置JDK核心类的源代码。

1、PATH配置bin文件夹的目录

2、PATH环境变量用于存储Java的编译和运行工具所在的路径。

3、因为Hello World.class字节码文件不是二进制的，不能直接执行，所以需要进行解析。

4、解析器使用“java HelloWorld”命令启动Java虚拟机运行程序，Java虚拟机首先将编译好的字节码问价加载到内存，这个过程称为类加载。

5、Java通过虚拟机，一次编译，到处运行。

6、Java程序通过Java虚拟机可以实现跨平台特性，但是Java虚拟机并不是跨平台的。

7、一个Java文件编译后一定生产一个class文件(❌)

一个Java文件可以有很多类，一个类对应一个class文件，有几个类就编译生成几个class文件。

8、一个文件中只能有一个公共类(public 修饰的类)

9、一个Java文件中可以没有公共类，但是一旦有了公共类，那么公共类的名字一定要和文件名保持一致。

1、Java的三大体系是：Java EE、Java SE、Java ME
2、Java程序的运行环境简称：JRE
3、编译Java程序需要使用 javac 命令
4、javac.exe和java.exe两个可执行程序存放在JDK安装的目录下的 bin 目录下。
5、Path环境变量用来存储Java的编译和运行工具所在的路径，而classpath环境变量则用来保存Java虚拟机要运行的“,class”文件路径。
6、Java.util包含Java中大量工具类、集合类，例如：Arrays、List、Set等。
7、JDK工具包括：Java编译器、Java运行工具、Java文档生成工具、Java打包工具。
8、.class文件可以在Java虚拟机中运行。
9、java.exe命令的作用是Java解释器

1、标识符：经常需要在程序中定义一些符号来标记一些名称，如包名、类名、方法名、参数名、变量名等，这些符号被称之为标识符。

标识符可以由任意顺序的大小写字母、数字、下画线(_)和美元符号( $ )组成，但是标识符不能以数字开头，也不能是Java中的关键字，也不能和JDK中的类同名。否则会在编译的时候出错

2、Java中的命名约定：
1⃣️：包名所有的字母一律小写。
2⃣️：类名和接口名每个单词的首字母都要大写，例如：ArrayList。
3⃣️：常量名的所有字母都大写，单词之间用下画线连接，例：DAY_OF_MONTH。
4⃣️：变量名和方法名的第一个单词首字母小写，从第二个单词开始每个单词首字母大写(驼峰命名法)，例：lineNumber
5⃣️：尽量使用有意义英文单词来定义标识符。

3、为一个float类型的变量赋值的时候，所赋值的后面一定要加上F或者f
而在为一个double类型的变量赋值的时候，可以在后面加上D或者d，当然这个double类型的后面可以不加D或者d。

4、Java的字符类型采用的是Unicode编码方案，每个Unicode码占用16个字节。

5、对于char类型的赋值时需要使用一对单引号括起来，而且单引号中必须有且只能有一个字符。

6、Java中不能使用1、0表示真假，只能用true、false表示真假，而c语言用非0表示真，用0表示假，C语言中没有true、false。

范围小的能够自动转换为范围大的。

7、如果对表达式加强制类型转换，那么表达式一定加括号
例：(类型)(表达式)

8、理解几个转换：

public class testA {
	public static void main(String[] args) {
		System.out.println(2+3+'a'); //自动转换成int类型了
		System.out.println(2+3+"a"); //自动转换成String类型的了
		System.out.println("a"+2+3); //自动转换成String类型的了
	}
}

9、常量分为数值常量、符号常量：100，‘a’ ，true

10、整型常量：
1⃣️：二进制：由数字0和1组成，使用二进制面值来表示整数的时候，二进制数前面要以0b或0B开头，目的是为了和十进制进行区分，例：0b01101100

System.out.println(0b01101100);

2⃣️：八进制：以0开头，并且其后由0～7(包括0和7)的整数组成的数字序列，如：0324

System.out.println(0324);

System.out.println(010);

3⃣️：十进制：由数字0～9(包括0和9)的整数组成的数字序列，如198.

4⃣️：十六进制：以0x或者0X开头，并且后面跟随着0~9、A～F组成的字符序列，如0x25AF

System.out.println(0x25AF);

System.out.println(0x10);

1、java常量需要声明定义常量类型、常量名，并且可以对该常量进行初始化赋值，也可以后续赋值，但是Java常量一旦赋值后，值就不允许更改。

2、注意%的使用

public class testA {
	public static void main(String[] args) {
		System.out.println(-20%3);
		System.out.println(20%-3);
	}
}

3、位运算符的使用

& 按位与 只有当&左右的两个数相同的时候才会返回值1

public class testA {
	public static void main(String[] args) {
		System.out.println(0&0);
		System.out.println(0&1);
		System.out.println(1&0);
		System.out.println(1&1);
	}
}

| 按位或 只有当 | 左右都取0的时候才会返回值0

public class testA {
	public static void main(String[] args) {
		System.out.println(0|0);
		System.out.println(0|1);
		System.out.println(1|0);
		System.out.println(1|1);
	}
}

~ 取反

例：
7 ：二进制 00000111
～7: 二进制 11111000
我们看到最高位是1，这表示这个～7得到的是一个负数，负数以补码的形式存储的。是个负数还是比较麻烦的。
先进行减1 ： 11110111
再取反：00001000
得到的这个二进制数的值是8
但因为我们一开始知道～7是一个负数，所以我们要对8加上一个负号，即最终结果为：-8

自己求～-7的值，反正我不知道该怎么办了。

^ 按位异或
只有当^左右的两个数不相同的时候，才会输出值1

public class testA {
	public static void main(String[] args) {
			System.out.println(0^0);
			System.out.println(0^1);
			System.out.println(1^0);
			System.out.println(1^1);
	}
}

<< 逻辑左移，<<就是将操作数所有二进制位向左移动制定的位数。运算时，左边移走的部分舍去，右边的空位补0.

>>逻辑右移，就是将操作数所有的二进制位向右移动制定的位数。运算时，左边的空位根据原数的符号位补0或1(原本是负数就全部补1，原本是整数就全部补0)，右边移走的部分舍去。

>>>无符号右移，就是将所有操作数所有二进制位不考虑正负向右移动指定尾数。运算时，左边的空位全部补0，右边移走的部分舍去。

对于switch语句，支持字符型，整型，字符串，不支持小数(float、double)，也不支持布尔型。

方法的三要素： 方法名、参数、返回值的类型
对于return回去什么类型的值，返回值的类型就是什么。

System.in.read();
用于读取一个字符，返回的是一个整数值，可以通过强制转换转换为字符型，对于输入的是单个字符的时候可以用这种方法。

如果输入的字符很多的时候或者是一个字符串的时候使用：
Scanner sc =new Scanner(System.in);

数组的常用操作：插入、删除、修改、查找、排序、初始化

遍历数组可以使用通过下标使用for循环进行遍历
也可以shying增强for循环来遍历数组

public class testA {
	public static void main(String[] args) {
			int a[] = {1,2,3,4,5,6,7};
			for(int i : a) {
				System.out.print(i+"    ");
			}
	}
}

二维数组是按照行进行存储的：

public class testA {
	public static void main(String[] args) {
		int [][]a;  //正确
		int []b[];  //正确
		int c[][];  //正确
	}
}



public class testA {
	public static void main(String[] args) {
		int [][]a = new int[3][4];  //正确
		int [][]b = new int[3][];  //正确
		int [][]c = new int[][4];  //不正确
	}
}

不规则数组：int [][]b = new int[3][];
此时不能输出b[0][0]
因为没有指定列：
所以可能会出现下面的情况：
a[0] = new int a[3];
a[1] = new int a[2];
a [2 ] = new int a[5]

数组的赋值也可以按照下面的形式：
int [][]a = {{1,2,3},{4,5},{7,8,9}};

java 中的变量分为两种数据类型：基本数据类型、引用数据类型。

Java语言严格区分大小写。

1、面向对象的三大特征：封装、继承、多态

2、子类是不能够继承父类的构造方法的，所以子类不能将父类中所有的东西都继承。

3、类是对某一类事物的抽象的描述，而对象用于表示现实中该类事物的个体。类是对某一类事物的抽象描述的集合。

4、通过构造方法给成员变量赋初始值。

5、一个类中的构造方法是可以相互调用的，但调用的时候必须是构造方法的第一行语句，使用的关键字是this
比如：

public class A{
	int x;
	int y;
	
	A(int x){
		this.x=x;
	}
	
	A(int x,int y){
		this(x);    //调用其他构造方法的时候，必须写在该构造方法的第一行上。
		this.y=y;
	}
}

6、类的封装：
1⃣️：成员变量私有化(private)
2⃣️：提供公开的set、get方法
set方法是void方法，但是需要参数
get方法是有返回值的，但是不需要参数。

7、类是不能够使用private、protected修饰的。
类也不能同时使用abstract和final修饰，只能选择其中一个，是不能共存的。

8、方法的重载：前提是在同一个类中有多个同名的方法，其参数的个数与参数的类型不同，这与返回的类型(方法)无关。

1、静态的方法只能访问静态的方法和静态的成员。

2、什么时候使用static修饰方法
所有的对象的成员变量都是一样的时候使用static修饰。
方法中的内容与对象调用是无关时，用static修饰。
即两个不同的对象同时调用同一个方法，若这两个对象获取的方法的内容相同就可以使用static来修饰方法。

3、在非静态成员方法中，可以使用this访问类的其他非静态成员。

4、类对象(使用static修饰的)在未创建对象之前就已经被加载了。

5、声明构造方法的时候，不能使用private关键字修饰。(default、protected、public都可以修饰构造方法)

6、static关键字不可以修饰类。

7、static关键字不可以修饰所有的变量。因为static不能修饰局部变量。

8、构造方法不能被继承。

1、构造方法不能被继承。

2、super关键字用于访问父类的成员，例如访问父类的成员变量、成员方法、构造方法。

3、方法的重写时方法的三要素必须是一致的。
方法的三要素：方法名、参数、返回值类型

4、方法的重写的时候可以改变方法的权限，但是子类的权限范围要比父类的权限范围大。

5、方法的重写的时候子类不呢个抛出比父类抛出的更多的异常。

6、final关键字用于修饰类、变量、和方法，它有“不可更改”或者“最终”的含义，因此被final修饰的类、变量、和方法有以下特征。
1⃣️：final修饰的类不能被继承
2⃣️：final修饰的方法不能被子类重写
3⃣️：final修饰的变量(成员变量和局部变量)是常量，只能赋值一次，赋值后不再允许改变其值。

7、String类就是被static、final修饰的类。

8、包含抽象方法的类一定是抽象类，抽象类不一定含有抽象方法。— abstract

9、接口是一种特殊的抽象类--------- interface

1、接口中除了抽象方法外，还可以有默认方法和静态方法(类方法)，默认方法使用default修饰，静态方法使用static修饰，并且这两种方法都允许有方法体。

public interface my {
	void aa();   //public修饰的方法是不能有方法体的。
	default void bb() {   //default修饰的方法，是可以有方法体的。
		System.out.println("default修饰的方法在接口中是必须有方法体的");
	}
	
	static void cc() {
		System.out.println("静态方法在接口中是必须有方法体的");
	}
	
	private void dd() {   //private修饰的方法是永远不会被使用的，所以使用private修饰方法是无意义的。
		System.out.println("private修饰的方法是必须加方法体。");
	}

}

2、接口中默认的方法都是使用public abstract进行修饰的。

3、接口中的变量默认都是public static final 进行修饰的。
这里的变量相当于是常量。

4、继承只能是单继承，但是实现接口可以实现多实现。

5、父类对象可以指向子类对象，但是子类对象不能指向父类对象，但是子类对象可以通过强制类型转换可以进行转换为父类对象，但是强转是有条件的，只有当父类的对象就是指向的子类的对象的时候才能够发生强制转换。

6、方法的重写、重载都是一种多态的体现（同一种事物、多种形态）

7、注意：if(a instance of cat) 的使用。

1、异常分为编译时异常和运行时异常，编译时异常是必须要出来的异常。

2、数组下标越界异常时运行时(处理时)异常。

3、Error类称为错误类，错误是我们处理不了的。

4、Throwable常用方法：

5、我们自己定义的方法，将来别人要去调用，所以我们自己定义的方法要消极的处理异常，别人谁调用谁就积极的处理异常。

6、catch后面如果有多个异常，子类要在父类异常前。

7、注意抛出异常的throws和throw关键字。

8、注意自定义异常的使用。

1、String表示的是不可变得字符串
String Buffer表示的是可变的字符串

2、

public class test{
	public static void main(String[] args) {
		String s1 = "abc";
		String s2 = "a" + "b" +"c";
		System.out.println(s1==s2);
	}
}

3、[ int ] capacity; 返回的是当前的容量。

4、String类转换为StringBuffer类：通过StringBuffer的构造方法
StringBuffer类转换为String类：通过使用toString方法。

public class test{
	public static void main(String[] args) {
		String s1 = "abcde";
		StringBuffer sb = new StringBuffer(s1);//将String类转换为StringBuffer类
		sb.reverse();
		String s2 = sb.toString();//将StringBuffer类转换成String类
		System.out.println(s2);
		}
}

5、注意包装类：

6、SimpleDateFormat类是将Date类输出的美式格式的日期转换为自己想要的格式串的形式。

7、SimpleDateFormat 返回的是String字符串

1、Java中操作日期的类有：Date、Calendar、DateFormat

2、Java中专门用于将日期格式化为字符串的类是：DateFormat

3、System类中所提供的属性和方法都是静态的。

4、在进行字符串的比较的运算中，==用于比较地址和值，而equals只用与比较值，是不比较地址的。

5、System类中的currentTimeMillis()方法返回一个long类型的值。

6、Date、Calendar都位于java.util包下，而DateFormat类位于java.text包下。

1、在创建TreeSet对象时，可以传入自定义比较器，自定义比较器需要实现 Comparator接口。

2、使用Iterator遍历集合的时候，首先需要调用的是hasNext()方法判断是否存在下一个元素，若存在下一个元素，则调用next()方法取出该元素。

import java.util.ArrayList;
import java.util.Iterator;

public class test{
	public static void main(String[] args) {
		ArrayList<Integer> list = new ArrayList<Integer>();
		list.add(1);
		list.add(3);
		list.add(23);
		list.add(7);
		list.add(9);
		list.add(13);
		Iterator<Integer> it = list.iterator();
		while(it.hasNext()) {
			System.out.println(it.next());
		}
	}
}

3、List集合中存放的元素是有序的，可重复的（所谓的有序是添加元素到集合的顺序和从集合中取出元素的顺序是一致的。）
Set集合存放的元素无序的，不可重复。

4、List集合的主要实现类有：ArrayList、LinkedList，
Set集合的主要实现类有：HashSet、TreeSet
Map集合的主要实现类有：HashMap、TreeMap

5、在JDK1.8中，根据Lambda表达式特性还增加了一个 forEach(Consumer action) 方法来遍历集合。

6、集合中不能存放基本数据类型，而只能存放引用数据类型。

7、在程序开发时，经常会使用 Properties 类来存储程序中所需的配置

1、编译Java程序需要使用___javac________命令。

2、用户可以根据需要自定义异常，但自定义异常一定要继承__Exception__类。

3、在Java 中，可以使用关键字____new_______来创建类的实例对象。

4、在非静态成员方法中，可以使用关键字_____this______访问类的其他非静态成员。

5、定义一个Java类时，如果前面使用____final_______关键字修饰，那么该类不可以被继承。

6、如果子类想使用父类中的成员，可以通过关键字___super________引用父类的成员

7、接口是一种只含有常量和___抽象方法________的一种特殊的抽象类。

8、JDK中提供了一系列可以存储任意对象的类，统称为_____集合______。

9、在Java语言中，以下throws关键字用于在方法上声明抛出异常

10、System类位于java.lang包中

11、static方法不能访问实例变量，也不能访问实例方法，不能使用this关键字

1、被static修饰的成员变量被称为_类变量_________，它可以被该类所有对象共享。
2、JDK中定义了大量的异常类，这些类都是__Throwable________类的子类或者间接子类。
3、接口中的方法都是__抽象的________，不能实例化对象。
4、一个超类可以有多个子类，但是一个子类不能有多个超类
5、覆盖只有发生在父类与子类之间，而重载可以发生在同一个类中
6、实现一个接口必须实现接口的所有方法
7、父类的引用指向自己子类的对象是多态的一种体现形式。
8、 throws关键字用于对外声明方法可能发生的异常，这样调用者在调用方法时，可以明确知道该方法有异常，并进行相关处理
9、不存在继承关系的情况下，不能实现方法的重写。
10、如果一个方法的参数是接口类型的参数，调用该方法时可以传递任何可以实现该接口的类的实例。

1、Java的封装性是通过访问权限控制实现的
2、Java中的标识符和关键字都是区分大小写的，如果把声明类的class写成Class或者CLASS，编译会出错。
3、一个类的所有对象共享static修饰的类变量。
4、重载方法的参数形式（类型、参数个数或参数顺序）必须不同
5、Java程序的运行环境简称之为___JRE___。
6、Java中的变量可分为两种数据类型，分别是__基本数据类型__和__引用数据类型__。

1、如果子类中的某个方法名、返回值类型和 参数 与父类中的某个方法完全一致，则称子类中的这个方法覆盖了父类的同名方法。
2、在Java程序中，通过类的定义只能实现单重继承，但通过_接口_ 的定义可以实现多重继承关系。
3、类方法在内存中只有一个副本，能被该类的所有实例共享，实例方法则在每个对象中有独立的内存空间
4、类方法允许用实例方式和类名方式调用。被static修饰的方法称为类方法。
5、如果子类的构造函数没有通过super调用父类构造函数，那么子类会先调用父类不含参数的构造函数，再调用子类自己的构造函数
6、main方法一定是static修饰的。
7、一个abstract类不可以被声明为final类。 因为一个类要么是abstract要么是final修饰
8、Java编译器使用文件系统来保存程序包。