1. 编译 javac 文件名.java
运行 java 文件名
2. Public class 和 class 声明类的区别：public 声明的文件名必须和其类名一致；class声明的类文件名可以不与类名一致，但运行时的文件名必须和main()方法所在的类名一致。
3. System.out.println() 和 System.out.print() 有ln的表示输出后换行，没有则不换行。
4. 单行注释：//
多行注释：/*…*/
文档注释：/**…*/ 生成说明文档：javadoc 文件名.java
5. Java的包、类、方法、参数和变量的名字可以由任意顺序的大小写字母、数字、下划线（_）和美元符号（$）组成，但标识符不能以数字开头。（注：标识符最好用字母开头）
6. 数据类型：基本数据类型、引用数据类型
基本数据类型：数值型、字符型（char（2字节））、布尔型（boolean）
数值型：整数类型：byte（1字节）、short（2字节）、int（4字节）、long（8字节）
浮点类型：float（4字节）、double（8字节）【1个字节为8位】
引用数据类型：类（class）、接口（interface）、数组
7. Integer在Java中属于包装类，可以使用MAX_VALUE取得最大值，也可以通过MIN_VALUE取得其最小值，Integer的最大作用在于字符串与整型的转换上，还有自动拆箱和装箱功能。
在区最大值最小值的时候MAX_VALUE和MIN_VALUE必须大写，例如：
用法：int max = Integer MAX_VALUE;
int min = Integer MIN_VALUE;
8. 字符类型（占有2个字节），给字符变量赋值可以使用数值和字符。注意的是，字符要用一对单引号（’ ’）括起。（可用于数值运算和比较）
声明方式：char 对象名 = ‘a’; 或 char 对象名 = 97;
9. 常用的转义字符：换页（\f）、反斜线（\\）、倒退一格（\b）、单引号（\’）、归为（\r）、双引号（\”）、制表符TAB（\t）、换行（\n）。
10. 浮点数类型与双精度浮点数类型声明方式：
float 变量名；可以赋初值，初值后可加F或f，也可不加。
double 变量名；可以赋初值，初值后可加D或d，也可不加。
11. 布尔（boolean）类型的变量只有true（真）和false（假）两种。其声明方式：
boolean 对象名 = 值；
12. 基本数据类型默认值：char默认值（空，”）、boolean默认值（false）其余都为0或0.0
13. 数据类型自动转换：任何一个基本数据类型和double运算都会自动转换为double；也就是说最低的会自动转换成最高的。（注：int和float运算自动转换为float，布尔类型不能转换其他的类型。）
14. 任何类型的数据都会向String类型转换，String属于引用数据类型。两个字符传之间可以使用“+”进行连接。
15. 数据类型的强制转换：float转换int、double转换long
16. 运算符：
赋值运算符：等号（=），例如：num=30；或num=num-20；（把右边的值赋给左边）
一元运算符：正号（+）、负号（-）、NOT否（！）
算数运算符：加（+）、减（-）、乘（*）、除（/）、取余（%），除为整除。
关系运算符：大于（>）、小于（<）、大于等于（>=）、小于等于（<=）、等于（==）、
不等于（!=）
自增自减运算符：自增（++）、自减（--）；先加后用（++a）、先用后加（a++）
先减后用（--a）、先用后减（a--）
逻辑运算符：AND与（&）、短路与（&&）、OR或（|）、短路或（||）
与（有假为假）、或（有真为真）
短路与（第一个条件为false，则后面的不再判断）
短路或（第一个条件为true，则后面的不再判断）
括号运算符：可以提高表达式的优先级，例如：(a+b)*c
位运算符：最后补充此内容（作者尚未学习此内容）
运算符的优先级：( )；[ ]；!、正号（+）、符号（-）；位逻辑运算符（~）；
自增（++）、自减（--）；*、/、%；+、-；
位移左右（<<、>>）；>、>=、<、<=；==、！=；
位逻辑运算符：&；^；|；逻辑运算符：&&；||；三目：?:；
1. 简洁表达式：
+=、-=、*=、/=、%=；例如：a+=b 同 a=a+b；
b++、++b、b--、--b； 例如：a*=b++ 同 a=a*b；b++
a*=++b 同 b++；a=a*b
2. 程序的结构：顺序结构、选择结构、循环结构。
顺序结构：从头到尾依次执行。
选择结构：条件为true执行语句1，条件为false执行语句2
循环结构：只要符合条件一直执行语句1，否则执行语句2
3. 选择结构：if、if…else、switch
if：if(判断条件){语句1；语句2；…语句n}
如果条件为true执行语句体，否则继续执行后面的语句
if…else：if(判断条件){语句主体1}else{语句主体2}
如果条件为true执行语句主体1，否则执行语句主体2，然后继续执行后面的语句
?:：三目运算符：变量 = 条件判断 ？ 表达式1：表达式2
如果条件为true把表达式1的值赋值给变量，否则把表达式2的值赋值给变量
if…else if…else：if(判断条件1){语句主体1}else if(判断条件2){语句主体2}…else{语句主体3}
如果判断条件1为true则执行语句主体1，否则执行判断条件2，如果判断条件2为true则执行语句主体2，否则执行语句主体3
switch：switch(表达式){case 选择值1：语句主体1；
break；
case 选择值2：语句主体2；
break；
……
case 选择值 n：语句主体n；
break；
default：语句主体；
}
表达式的值符合选择值几就执行相应的语句主体，如果都不匹配则执行default所包含的语句主体，之后执行switch循环后面的语句。default可有可无。
如果没有break语句则从符合条件的语句主体开始依次执行知道遇见break语句为止
注意：表达式的值只能为数字、字符或枚举
4. 循环结构：while、do…while、for
while：while(循环条件判断){语句1；语句2；…语句n；循环条件更改；}
如果循环条件为true则依次执行循环体内的语句，否则不执行。
循环条件更改后继续执行循环条件判断，如果为true则继续执行，否则不执行
do…while：do{语句1；语句2；…语句n；循环条件更改}while(循环条件判断);
首先执行do的循环主体，然后执行while循环条件判断，如果条件为true则继续执行do的循环主体，否则终止循环。
注意：do…while循环至少都会执行一次循环主体。
for：for(赋值初值；判断条件；赋值增减量（循环条件改变）){循环主体}
首先执行 赋值初值，继续执行 判断条件，如果判断条件为true则执行循环主体，否则不执行。当判断条件为true时，执行完循环主体之后继续执行赋值增减量，然后继续执行判断条件，如果判断条件为true则继续执行循环主体，否则不执行。以此类推。
5. 循环的嵌套：for循环可以嵌套for循环；先执行外层循环，后执行内层循环，内层循 环执行完毕后继续执行外层循环。
6. 循环中的中断：break语句、continue语句、return语句
break语句：作用是中断循环，可以放在循环主体的任意位置。
Continue语句：作用是跳出本次继续执行下次循环，可以放在循环主体的任意位置。
return语句：作用是结束方法，可以放在循环主体的任意位置，也可以放在方法的最后。
7. 局部变量：在方法中或循环语句中定义的变量属于局部变量，所谓的局部变量是指此变量只能在方法中或循环语句中使用，而在方法或循环语句之外无法使用。
8. 一维数组：要使用Java的数字，必须经过声明数组和分配内存给数组两个步骤。
9. 声明一维数组并分配内存：
数据类型 数组名[] = null；或 数据类型[] 数组名 = null； null是引用数据类型默认值。
数组名 = new 数据类型[长度] ；用new关键字分配内存空间。
例如：int score[] = new int[3]；其元素个数为3，长度为3。
常见的数据类型有整型、浮点型与字符型等。
数组名是用来统一这组相同数据类型的元素的名称，其命名规则和变量相同。
10. 数组中元素的表示方法：score[0]代表第一个元素，数组下标是从0开始的。
11. 数组的静态初始化：数据类型 数组名[] = {初值0，初值1，…，初值n}
例如：int score[] = {1，2，3，4，5，6} 其长度是6 score[3]的值是4
12. 二维数组：二维数组声明的方式和一维数组类似，内存分配也要使用new关键字完成。
格式：数据类型 数组名[][]；
数组名 = new 数据类型[行的个数][列的个数]；
例如：int score[][]；
Score = new int[3][4]； 可保存元素个数3*4=12个，共占内存4*12=48个字节
13. 二维数组静态初始化格式：数据类型 数组名[][]={{第0行初值}，…，{第n行初值}}；
例如：int score[3][4] = {{1，2，3，4}，{2，3，4，5}，{3，4，5，6}}；
int score[3][4] = {{1，2，{2，3，4}，{3}}；
int score[][] = {{1}，{2，3，4}，{3，4，5，6，7}，{2，6}}；
14. 注意：用户不许要定义二维数组的长度，二维数组赋初值时不必全赋值，默认为0
大括号内还有几个大括号，没组大括号内的初值会依次制定给数组的第0，1，…n
15. 数组应用范例：
a) 求出数组中的最大值和最小值
public class Deno1 {
public static void main(String[] args) {
int max = 0;
int min = 0;
int score[]={5,6,11,32,14,1,3,100};
max=min=score[0];
for(int i=0;i<score.length;i++){
if(score[i]>max){
max=score[i];
}
if(score[i]<min){
min=score[i];
}
}
System.out.println(max);
System.out.println(min);
}
}
b) 对整型数组按照由小到达的顺序进行排列
public class Demo2 {
public static void main(String[] args) {
int score[]={5,6,11,32,14,1,3,100};
for(int i=1;i<score.length;i++){
for(int j=0;j<score.length;j++){
if(score[i]<score[j]){
int temp = score[i];
score[i] = score[j];
score[j] = temp;
}
}
}
for(int i=0;i<score.length;i++){
System.out.print(score[i]+"\t");
}
}
}
16. 多维数组：声明方法和二维数组一样
例如：
int score[][][]={{{1，2}，{3，4，5}，{6}}，{{1}，{2，3}，{4}}，{{3}，{2}，{1}}}；
17. 以上是三维数组，几维就写几个[]，4个就是四维数组，N个就是N维数组。
18. 输出数组元素：几维数组就使用几层循环。
- 数组：
- 集合：
- super是父类内存空间的标识
- this代表其所在方法所属对象的引用，谁调用就代表谁
- 重载：方法名相同，参数列表不同，且与返回值无关
- 重写：子父类中，方法名和声明都相同，且与返回值有关
- 成员变量：存储在堆内存中（随着对象的创建而存在，随着对象的消失而消失）
- 局部变量：存储在栈内存中（在方法调用时，或者语句执行时才存在）
- 成员变量：作用与整个类中
- 局部变量：只在某个范围内（一般指方法中，或某个语句中）
- 成员变量：有默认初始值
- 局部变量：没有默认初始值，使用前需赋值
- ==：比较基本类型比较的是值
- equals：比较引用类型默认比较的是对象的地址值（重写该方法后，比较的是这两个对象的值）
- A：有throws的时候可以没有throw。
- B：throws用于方法的声明上，其后跟的是异常类名，后面可以跟多个异常类，之间用逗号隔开
- Start()方法:
- start方法用来启动线程,实现了多线程运行,这时无需等待run方法体代码执行完毕而直接继续执行下面的
- Run()方法:
- (1)这两个方法来自不同的类，sleep()来自Thread类，和wait()来自Object类。
- (2)sleep是Thread的静态类方法，谁调用的谁去睡觉，即使在a线程里调用了b的sleep方法，实际上还是a去睡觉，
- (3)sleep()释放资源不释放锁，而wait()释放资源释放锁；
- (4)使用范围：wait,notify和notifyAll只能在同步控制方法或者同步控制块里面使用,而sleep可以在任何地方使用
- 饿汉式是类一加载进内存就创建好了对象；
- 懒汉式则是类加载进内存的时候，对象还没有存在，只有调用了getInstance()方法时，对象才开始创建。
- 懒汉式是延迟加载，如果多个线程同时操作懒汉式时就有可能出现线程安全问题，解决线程安全问题
- 创建集合对象
- Collection c=new ArrayList();
- ArrayList list=new ArrayList();
- LinkedList link=new LinkedList();
- Vector v=new Vector();
- HashSet hs=new HashSet();
- TreeSet ts=new TreeSet();
- 创建元素对象
- 添加元素
- 遍历使用
| 添加：boolean add(Object obj) | 向集合中添加元素 |
| 删除：boolean remove（Object obj） | 从集合中删除指定元素 |
| 判断：boolean isEmpty（Object obj） boolean contains（Object obj） |
判断是否为空 判断是否包含指定元素 |
| 遍历：Iterator iterator( )(迭代器) | 用来获取集合中每一个元素 |
| 长度：int size() 转换：Object toArray() |
获取集合的长度
把集合转换成数组
|
| Object get(int index) | 返回指定位置索引对应的元素 |
| 添加：void addFirst(Object o) void addLast(Object o) |
在最前面的位置添加元素 在最末位的位置添加元素 |
| 获取：void getFirst(Object o) void getLast(Object o) |
获取最前面的元素 获取最末位的元素 |
| 删除：void removeFirst(Object o) void removeLast(Object o) |
删除最前面的元素 删除最末位的元素 |
- List
- ArrayList
- 底层数据结构是数组，查询快，增删慢
- 线程不安全，效率高
- Vector
- 底层数据结构是数组，查询快，增删慢
- 线程安全，效率低
- LinkedList
- 底层数据结构是链表，查询慢，增删快
- 线程不安全，效率高
- Set
- HashSet
- 底层数据结构是哈希表
- 通过重写HashCode()和equals()方法来保证唯一性
- 线程不安全，效率高
- TreeSet
- 底层是数据结构是二叉树
- 通过判断compareTo或compare返回值是否为0来判断是否重复
- 排序有两种方法：
- 实现comparable接口重写compareTo方法
- 实现comparator接口重写compare方法
- 线程不安全，效率高
- 安全——Vector
- 不安全
- 增删多----LinkedList
- 查询多----ArrayList
- 如果什么都不知道就用ArrayList
- 概述：一种把明确类型的工作放在创建对象或者调用方法时才明确类型的一种预定义类型
- 作用（好处）：
- 解决了黄色警告线的问题
- 把系统运行期间的异常提前到编期
- 优化了程序设计不需要强制转换
- 泛型的定义（类，方法，接口）
- 在类上定义泛型
- public class MyArrayList{}
- 在方法上
- public void show(E e){}
- 在接口中
- 和类中一样
- 说明：,E的名字可以任意
- 格式：
- 好处：方便数组和集合的遍历
- 注意事项：增强for是用来代替Iterator的，所以也同样不能在遍历时对集合本身进行修改（并发修改异常）
1.定义（什么时候使用）
2.修饰哪些内容
3.特点
static（静态）：
1.定义：当某些内容被当前类下所有内容共享时，用static修饰
2.可以修饰成员变量和成员方法
3.特点
1）随着类的加载而加载，优先于对象存在（所以被static修饰的内容不能被this关键字修饰）
2）被当前类下所有对象共享
3）可以通过类名直接调用
final：
1.定义：final是最终的意思
2.可以修饰类、变量和方法
3.特点：
1）被final修饰的成员变量是常量
2）被final修饰的方法不能被重写
1.概念：
当一个类中的方法都是抽象的时候，java提供了另一种表示方式，叫接口。
用interface关键字表示。类与接口关系用implements表示。
2.接口的成员特点
A:成员变量
是常量，默认修饰 public static final
B:成员方法
都是抽象的，默认修饰 public abstract
3.关系
A:类与类的关系
是继承关系。类与类只能单继承，可以多重继承。
B:类和接口的关系
是实现关系。类可以多实现接口。
类在继承一个类的同时，可以实现多个接口。
C:接口和接口的关系
是继承关系。接口可以多继承接口。
4.接口的特点
A:是对外暴露的规则
B:是功能的扩展
C:接口的出现降低耦合性。
耦合(类与类之间的关系)
内聚(类完成功能的能力)
编程规范：低耦合，高内聚。
D:接口可以多实现。如：CPU和主板、笔记本的USB插口、插座
5.接口和抽象类的区别
A：抽象类只能被单继承
接口可以多实现,接口的出现避免了多继承的局限性。
B：抽象类中的数据特点：
成员变量：可以是变量，也可以是常量
成员方法：可以是抽象方法，也可以是非抽象方法
构造方法：有构造方法
接口中的数据特点：
成员变量：是常量。默认修饰 public static final
成员方法：都是抽象方法。都有默认修饰 public abstract
构造方法：没有构造方法
C：抽象类中定义的是继承体系中的共性功能。
接口中定义的是继承体系中的扩展功能。
D：抽象类被继承是"is a"关系:xx是yy的一种
格式为：外部类名.this
B:外部类要想访问内部类的成员，必须创建对象访问。
3.内部类的访问格式：
A:当内部类定义在外部类的成员位置，而且非私有，则可以在其他外部类中直接建立内部类对象
格式：外部类名.内部类名 变量名 = new 外部类对象.内部类对象
如：Outer.Inner in = new Outer().new Inner()
B:当内部类在外部类成员位置，且被static修饰时
外部其他类可直接访问静态内部类的非静态成员
格式：new 外部类名.内部类名().内部类成员
如：new Outer.Inner().function();
外部其他类可直接访问静态内部类的静态成员
格式：new 外部类名.内部类名.内部类成员
如：new Outer.Inner.function();
需要创建A类对象进行访问，这个时候，就可以把A类定义为B类的内部类。
5.内部类的位置
A:成员位置
可以被private修饰
可以被static修饰。
B:局部位置
可以直接访问外部类中的成员，因为还持有外部类的持用
也可以直接访问局部成员，但是局部成员要用final修饰。
new 父类名或者接口名()
{
重写父类方法或者实现接口中的方法。
也可以自定义其他方法。
};
3.什么时候定义匿名内部类？
匿名内部类只是为了简化书写，匿名内部类有局限，通常定义匿名内部类时，该类方法不超过3个
4.匿名内部类的好处和弊端：
好处：简化代码书写
弊端：
不能直接调用自己的特有方法
不能执行强转换动作
进程：正在进行的程序。每一个进程执行都有一个执行顺序，该顺序是一个执行路径，或者叫一个控制单元。
线程：进程内部的一条执行路径或者一个控制单元。
两者的区别：
线程太多会导致效率的降低，因为线程的执行依靠的是CPU的来回切换。
实现多线程可以通过继承Thread类和实现Runnable接口。
(1)继承Thread
定义一个类继承Thread类
复写Thread类中的public void run()方法，将线程的任务代码封装到run方法中
直接创建Thread的子类对象，创建线程
调用start()方法，开启线程(调用线程的任务run方法)
//另外可以通过Thread的getName()获取线程的名称。
(2)实现Runnable接口；
定义一个类，实现Runnable接口；
覆盖接口的public void run()的方法，将线程的任务代码封装到run方法中；
创建Runnable接口的子类对象
将Runnabl接口的子类对象作为参数传递给Thread类的构造函数，创建Thread类对象
（原因：线程的任务都封装在Runnable接口子类对象的run方法中。
所以要在线程对象创建时就必须明确要运行的任务）。
调用start()方法，启动线程。
两种方法区别：
(1)实现Runnable接口避免了单继承的局限性
(2)继承Thread类线程代码存放在Thread子类的run方法中
实现Runnable接口线程代码存放在接口的子类的run方法中；
在定义线程时，建议使用实现Runnable接口，因为几乎所有多线程都可以使用这种方式实现
5、创建线程是为什么要复写run方法？
调用start方法方可启动线程，而run方法只是thread的一个普通方法，调用run方法不能实现多线程；
Start()方法:
start方法用来启动线程,实现了多线程运行,这时无需等待run方法体代码执行完毕而直接继续执行下面的
代码。通过调用Thread类的start()方法来启动一个线程,这时此线程处于就绪(可运行)状态，并没有运行，
一旦得到cpu时间片(执行权),就开始执行run()方法,这里方法run()称为线程体，
它包含了要执行的这个线程的内容，Run方法运行结束,此线程随即终止。
Run()方法:
run()方法只是Thread类的一个普通方法,如果直接调用Run方法,程序中依然只有主线程这一个线程,
其程序执行路径还是只有一条，还是要等待run方法体执行完毕后才可继续执行下面的代码，
(1)这两个方法来自不同的类，sleep()来自Thread类，和wait()来自Object类。
(2)sleep是Thread的静态类方法，谁调用的谁去睡觉，即使在a线程里调用了b的sleep方法，实际上还是a去睡觉，
要让b线程睡觉要在b的代码中调用sleep。而wait()是Object类的非静态方法
(3)sleep()释放资源不释放锁，而wait()释放资源释放锁；
标签：
365 |
|--RuntimeException:运行时异常，这个我们也不需要处理。
其实就是为了让他在运行时出问题，然后我们回来修改代码。
3.异常的分类
异常有两种：
编译时被检测异常：
该异常在编译时，如果没有处理(没有抛也没有try)，编译失败。
该异常被标识，代表这可以被处理。
运行时异常(编译时不检测)
在编译时，不需要处理，编译器不检查。
基本格式：
try
{
可能出现异常的代码
}
catch(异常对象)
{
异常处理代码
}
finally
{
释放资源
}
变形格式：
try...catch
try...catch...catch...
try...catch...catch...finally
它修饰的类不能被继承，它修饰的变量时常量，它修饰的方法不能被重写。
finally:是异常处理里面的关键字。
它其中的代码永远被执行。特殊情况：在执行它之前jvm退出。System.exit(0);
finalize:是Object类中的一个方法。
它是于垃圾回收器调用的方式。
常用的类：HashMap，TreeMap，HashTable
HashMap：
底层是数据结构哈希表，效率高，线程不安全，允许null键和值，是通过Hashcode和equals来保证元素唯一性的
HashTable：
底层数据结构是哈希表，效率低，线程安全，不允许null键和值，是通过Hashcode和equals来保证元素唯一性的
TreeMap：
底层数据结构是二叉树，效率高，线程不安全，是通过重写Comparable方法，或实现Compatator接口来给元素排序的
类名.class