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. 输出数组元素：几维数组就使用几层循环。
1.数组和集合区别
数组的存储长度是固定的
数组既可以存储引用类型，又可以存储基本类型
数组只能存储同一类型的数据
集合的存储的长度是不固定
集合只能存储引用类型
集合可以存储不同的数据类型
2.this和super区别
3.重写override和重载overload的区别
4.成员变量和局部变量的区别
1）存储位置：
2）作用范围：
3）初始值：
5.==和equals区别
比较引用类型比较的地址值
6.throws和throw的区别
有throw的时候，如果throw抛的异常是Exception体系，那么必须有throws在方法上声明。
throw用于方法体中，其后跟的是一个异常对象名
7.start()和run方法有什么区别？
调用start方法方可启动线程，而run方法只是thread的一个普通方法，调用run方法不能实现多线程；
代码。通过调用Thread类的start()方法来启动一个线程,这时此线程处于就绪(可运行)状态，并没有运行，
一旦得到cpu时间片(执行权),就开始执行run()方法,这里方法run()称为线程体，它包含了要执行的这个线程的内容，
Run方法运行结束,此线程随即终止。
run()方法只是Thread类的一个普通方法,如果直接调用Run方法,程序中依然只有主线程这一个线程,
其程序执行路径还是只有一条，还是要等待run方法体执行完毕后才可继续执行下面的代码，这样就没有达到多线程的目的。
8.sleep()和wait()的区别：
要让b线程睡觉要在b的代码中调用sleep。而wait()是Object类的非静态方法
9.饿汉式和懒汉式的区别：
可以加同步来解决。但是加了同步之后，每一次都要比较锁，效率就变慢了，
所以可以加双重判断来提高程序效率。
http://blog.sina.com.cn/s/blog_a70405a10102vs6o.html
一、集合
1.集合的由来：
由于我们使用的面向对象，而很多时候我们需要存储很多对象，这时候如果我们还是用数组，数组的特点是长度是固定不变的，所以就不适合存储变化的数据，所以就有了集合
2.集合的特点：
(1)长度可变
(2)真能存储引用类型的数据
(3)可以存储不同类型的数据
数组的特点：
(1)长度不可变
(2)可以存储基本数据类型和引用数据类型
(3)只能存储同一类型的数据
3.集合的结构:
Collection(集合)
|---List(接口) 元素有序，可以重复
|---Arraylist(集合)
|---Linkedlist(集合)
|---Vector(集合)
|---Set(接口) 元素无序，唯一
|---HsahSet(集合)
|---TreeSet(集合)
4.如何创建集合：
5.Collection常用成员方法（常用）
| 添加：boolean add(Object obj) | 向集合中添加元素 |
| 删除：boolean remove（Object obj） | 从集合中删除指定元素 |
| 判断：boolean isEmpty（Object obj） boolean contains（Object obj） |
判断是否为空 判断是否包含指定元素 |
| 遍历：Iterator iterator( )(迭代器) | 用来获取集合中每一个元素 |
| 长度：int size() 转换：Object toArray() |
获取集合的长度
把集合转换成数组 |
List常用成员方法
| Object get(int index) | 返回指定位置索引对应的元素 |
LinkedList常用成员方法
| 添加：void addFirst(Object o) void addLast(Object o) |
在最前面的位置添加元素 在最末位的位置添加元素 |
| 获取：void getFirst(Object o) void getLast(Object o) |
获取最前面的元素 获取最末位的元素 |
| 删除：void removeFirst(Object o) void removeLast(Object o) |
删除最前面的元素 删除最末位的元素 |
5.迭代器（接口）
原理：由于多种集合数据结构不同，所以存储方式也不同， 这个时候我们就把元素的获取和判断定义在一个接口中，这样无论在遍历哪种集合的时候，只要实现这个接口即可。
迭代器是一种内部类。
6.List接口（三个子类）和Set子类（两个接口）的特点
总结：
7.泛型：
8.增强for循环
for(数组或collection子类的元素类型 变量名：数组或collection子类)｛
//使用变量
｝
9.CurrentModificationException（类型转换异常）
(2015-10-21 20:44:46)
主要从三方面总结：
1.定义（什么时候使用）
2.修饰哪些内容
3.特点
static（静态）：
1.定义：当某些内容被当前类下所有内容共享时，用static修饰
2.可以修饰成员变量和成员方法
3.特点
1）随着类的加载而加载，优先于对象存在（所以被static修饰的内容不能被this关键字修饰）
2）被当前类下所有对象共享
3）可以通过类名直接调用
final：
1.定义：final是最终的意思
2.可以修饰类、变量和方法
3.特点：
1）被final修饰的成员变量是常量
2）被final修饰的方法不能被重写
3）被final修饰的类不被被继承
(2015-10-21 20:55:36)
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的一种
接口被实现是"like a"关系:xx像yy的一种
(2015-10-21 21:00:02)
一 内部类
1.把一个类定义在某个类中的，这个类就被称为内部类，内置类，嵌套类。
2.访问特点：
A:内部类可以直接访问外部类中的成员，因为内部类持有外部类的引用，
格式为：外部类名.this
B:外部类要想访问内部类的成员，必须创建对象访问。
3.内部类的访问格式：
A:当内部类定义在外部类的成员位置，而且非私有，则可以在其他外部类中直接建立内部类对象
格式：外部类名.内部类名 变量名 = new 外部类对象.内部类对象
如：Outer.Inner in = new Outer().new Inner()
B:当内部类在外部类成员位置，且被static修饰时
外部其他类可直接访问静态内部类的非静态成员
格式：new 外部类名.内部类名().内部类成员
如：new Outer.Inner().function();
外部其他类可直接访问静态内部类的静态成员
格式：new 外部类名.内部类名.内部类成员
如：new Outer.Inner.function();
4.什么使用时候内部类？
假如有A类和B类，A类想直接访问B类的成员，B类访问A类成员的时候，
需要创建A类对象进行访问，这个时候，就可以把A类定义为B类的内部类。
5.内部类的位置
A:成员位置
可以被private修饰
可以被static修饰。
B:局部位置
可以直接访问外部类中的成员，因为还持有外部类的持用
也可以直接访问局部成员，但是局部成员要用final修饰。
注意：局部内部类不能用private和static修饰
6.通过class文件我们就可以区分是否带有内部类，以及内部类的位置
Outer$Inner:成员内部类
Outer$1Inner:局部内部类
二 匿名内部类
1.前提：继承一个类或者实现一个接口
2.格式：
new 父类名或者接口名()
{
重写父类方法或者实现接口中的方法。
也可以自定义其他方法。
};
3.什么时候定义匿名内部类？
匿名内部类只是为了简化书写，匿名内部类有局限，通常定义匿名内部类时，该类方法不超过3个
4.匿名内部类的好处和弊端：
好处：简化代码书写
弊端：
不能直接调用自己的特有方法
不能执行强转换动作
如果该类里面方法较多，不允许使用匿名内部类
(2015-10-21 21:13:21)
1、进程和线程：
进程：正在进行的程序。每一个进程执行都有一个执行顺序，该顺序是一个执行路径，或者叫一个控制单元。
线程：进程内部的一条执行路径或者一个控制单元。
两者的区别：
一个进程至少有一个线程
进程在执行过程中拥有独立的内存单元，而多个线程共享内存
2、多线程的优势：
解决了多部分同时运行的问题，提高效率
3、线程的弊端：
线程太多会导致效率的降低，因为线程的执行依靠的是CPU的来回切换。
4、实现多线程的方法：
实现多线程可以通过继承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方法？
Thread类用于描述线程。Thread类定义了一个功能，用于存储线程要运行的代码，该存储功能就是run方法。
6、start()和run方法有什么区别？
调用start方法方可启动线程，而run方法只是thread的一个普通方法，调用run方法不能实现多线程；
Start()方法:
start方法用来启动线程,实现了多线程运行,这时无需等待run方法体代码执行完毕而直接继续执行下面的
代码。通过调用Thread类的start()方法来启动一个线程,这时此线程处于就绪(可运行)状态，并没有运行，
一旦得到cpu时间片(执行权),就开始执行run()方法,这里方法run()称为线程体，
它包含了要执行的这个线程的内容，Run方法运行结束,此线程随即终止。
Run()方法:
run()方法只是Thread类的一个普通方法,如果直接调用Run方法,程序中依然只有主线程这一个线程,
其程序执行路径还是只有一条，还是要等待run方法体执行完毕后才可继续执行下面的代码，
这样就没有达到多线程的目的。
7、线程的几种状态：
新建 就绪 运行 阻塞 死亡
8、sleep()和wait()的区别：
(1)这两个方法来自不同的类，sleep()来自Thread类，和wait()来自Object类。
(2)sleep是Thread的静态类方法，谁调用的谁去睡觉，即使在a线程里调用了b的sleep方法，实际上还是a去睡觉，
要让b线程睡觉要在b的代码中调用sleep。而wait()是Object类的非静态方法
(3)sleep()释放资源不释放锁，而wait()释放资源释放锁；
(4)使用范围：wait,notify和notifyAll只能在同步控制方法或者同步控制块里面使用,而sleep可以在任何地方使用
(2015-10-21 21:21:54)
1.概念：
程序运行过程中的不正常现象就叫异常。
2.导致程序运行不正常的现象有很多
Throwable：
|--Error:不需要编写代码处理。比如说内存溢出。
|--Exception:一般性的错误，是需要我们编写代码进行处理的。
|--RuntimeException:运行时异常，这个我们也不需要处理。
其实就是为了让他在运行时出问题，然后我们回来修改代码。
3.异常的分类
异常有两种：
编译时被检测异常：
该异常在编译时，如果没有处理(没有抛也没有try)，编译失败。
该异常被标识，代表这可以被处理。
运行时异常(编译时不检测)
在编译时，不需要处理，编译器不检查。
该异常的发生，建议不处理，让程序停止。需要对代码进行修正。
4.异常的处理
A:try...catch...finally
基本格式：
try
{
可能出现异常的代码
}
catch(异常对象)
{
异常处理代码
}
finally
{
释放资源
}
变形格式：
try...catch
try...catch...catch...
try...catch...catch...finally
finally:永远被执行，除非退出jvm。System.exit(0);
5.final,finally,finalize区别。
final是最终的意思。它可以用于修饰类，成员变量，成员方法。
它修饰的类不能被继承，它修饰的变量时常量，它修饰的方法不能被重写。
finally:是异常处理里面的关键字。
它其中的代码永远被执行。特殊情况：在执行它之前jvm退出。System.exit(0);
finalize:是Object类中的一个方法。
它是于垃圾回收器调用的方式。
6.假如catch中有return语句， finally里中的代码会执行吗？
是在return前，还是在return后呢？
会，在return前执行finally里面的代码。
7.Exception和RuntimeException的区别
A:Exception:一般性的错误，是需要我们编写代码进行处理的。
B:RuntimeException:运行时异常，这个我们也不需要处理。
8.throws和throw的区别
A：有throws的时候可以没有throw。
有throw的时候，如果throw抛的异常是Exception体系，那么必须有throws在方法上声明。
B：throws用于方法的声明上，其后跟的是异常类名，后面可以跟多个异常类，之间用逗号隔开
throw用于方法体中，其后跟的是一个异常对象名
此内容由惯性聚合(RSS阅读器)自动聚合整理，仅供阅读参考。 原文来自 — 版权归原作者所有。