基础篇
- final 修饰符——修饰的类不能够被继承，修饰的方法不能被继承类重新定义，修饰的变量为常量，是不可修改的。
- long 类型数据 需在数值后加L
- 变量区分
类变量（静态变量）：static 修饰，独立于方法之外（静态存储区）
实例变量：无static 修饰，独立于方法之外
局部变量：类方法变量（在栈上分配）
public class Variable{
static int allClicks=0; // 类变量
String str="hello world"; // 实例变量
public void method(){
int i =0; // 局部变量
}
}
- 变量生命周期
类变量(静态变量)：程序启动是创建，程序销毁时销毁；
实例变量(全局变量)：类创建时创建，类销毁时销毁；
局部变量：方法调用时创建，方法结束时销毁。 - 访问控制
| 修饰符 | 当前类 | 同一包内 | 子孙类 | 其他包 |
|---|---|---|---|---|
| public | Y | Y | Y | Y |
| protected | Y | Y | Y | N |
| default | Y | Y | N | N |
| private | Y | N | N | N |
- abstract 修饰符
抽象方法是一种没有任何实现的方法，该方法的的具体实现由子类提供。
任何继承抽象类的子类必须实现父类的所有抽象方法，除非该子类也是抽象类。
public abstract class SuperClass{
abstract void m(); //抽象方法
}
class SubClass extends SuperClass{
//实现抽象方法
void m(){
.........
}
}
- volatile 修饰符
volatile 修饰的成员变量在每次被线程访问时，都强制从共享内存中重新读取该成员变量的值。而且，当成员变量发生变化时，会强制线程将变化值回写到共享内存。这样在任何时刻，两个不同的线程总是看到某个成员变量的同一个值。
一个 volatile 对象引用可能是 null。
public class MyRunnable implements Runnable
{
private volatile boolean active;
public void run()
{
active = true;
while (active) // 第一行
{
// 代码
}
}
public void stop()
{
active = false; // 第二行
}
}
通常情况下，在一个线程调用 run() 方法（在 Runnable 开启的线程），在另一个线程调用 stop() 方法。 如果 第一行 中缓冲区的 active 值被使用，那么在 第二行 的 active 值为 false 时循环不会停止。
但是以上代码中我们使用了 volatile 修饰 active，所以该循环会停止。
- String、StringBuffer和StringBuilder区别
String 长度大小不可变
StringBuffer 和 StringBuilder 长度可变
StringBuilder是非线程安全的（不能同步访问）
StringBuilder相对于StringBuffer 有速度优势，所以多数情况下建议使用 StringBuilder 类。然而在应用程序要求线程安全的情况下，则必须使用 StringBuffer 类。 - 可变参数
JDK 1.5 开始，Java支持传递同类型的可变参数给一个方法。
在方法声明中，在指定参数类型后加一个省略号(...) 。
一个方法中只能指定一个可变参数，它必须是方法的最后一个参数。任何普通的参数必须在它之前声明。
public class VarargsDemo {
public static void main(String args[]) {
// 调用可变参数的方法
printMax(34, 3, 3, 2, 56.5);
printMax(new double[]{1, 2, 3});
}
public static void printMax( double... numbers) {
if (numbers.length == 0) {
System.out.println("No argument passed");
return;
}
double result = numbers[0];
for (int i = 1; i < numbers.length; i++){
if (numbers[i] > result) {
result = numbers[i];
}
}
System.out.println("The max value is " + result);
}
}
- finalize()方法
在对象被垃圾收集器析构(回收)之前调用，用来清除回收对象。 - 输入输出流
iostream.png
- Scannerl类
获取用户输入，通过 Scanner 类的 next() 与 nextLine() 方法获取输入的字符串，在读取前我们一般需要 使用 hasNext 与 hasNextLine 判断是否还有输入的数据。
12.1 使用 next 方法
import java.util.Scanner;
public class ScannerDemo {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
// 从键盘接收数据
//next方式接收字符串
System.out.println("next方式接收：");
// 判断是否还有输入
if(scan.hasNext()){
String str1 = scan.next();
System.out.println("输入的数据为："+str1);
}
}
}
12.2 使用 nextLine 方法
import java.util.Scanner;
public class ScannerDemo {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
// 从键盘接收数据
//nextLine方式接收字符串
System.out.println("nextLine方式接收：");
// 判断是否还有输入
if(scan.hasNextLine()){
String str2 = scan.nextLine();
System.out.println("输入的数据为："+str2);
}
}
}
12.3 next()和nextLine()区别
next()
(1) 一定要读取到有效字符后才可以结束输入。
(2) 对输入有效字符之前遇到的空白，next() 方法会自动将其去掉。
(3) 只有输入有效字符后才将其后面输入的空白作为分隔符或者结束符。
(4) next() 不能得到带有空格的字符串。
nextLine()：
(1) 以Enter为结束符,也就是说 nextLine()方法返回的是输入回车之前的所有字符。
(2) 可以获得空白。
-
异常处理
Exception.jpg
Exception2.png
所有异常都必须是 Throwable 的子类。
如果希望写一个检查性异常类，则需要继承 Exception 类。
如果你想写一个运行时异常类，那么需要继承 RuntimeException 类。 -
Java内置异常类
14.1 非检查性异常（不处理编译可以通过，如果有抛出直接抛到控制台）
非检查性异常.png
14.2 检查性异常（不处理编译不能通过）
检查性异常.png - finally关键字
无论是否发生异常，finally 代码块中的代码总会被执行。
在 finally 代码块中，可以运行清理类型等收尾善后性质的语句。 - throw跟throws的区别
public void test thorws Exception(){
throw new Exception();
}
throws表示一个方法声明可能抛出一个异常，throw表示此处抛出一个已定义的异常（可以是自定义需继承Exception，也可以是java自己给出的异常类）。
- 继承
子类拥有父类非private的属性，方法。
Java的继承是单继承，但是可以多重继承，单继承就是一个子类只能继承一个父类，多重继承就是，例如A类继承B类，B类继承C类，所以按照关系就是C类是B类的父类，B类是A类的父类，这是java继承区别于C++继承的一个特性。
提高了类之间的耦合性（继承的缺点，耦合度高就会造成代码之间的联系）。 - 继承关键字
extends和implements关键字
18.1 extends关键字
在 Java 中，类的继承是单一继承，也就是说，一个子类只能拥有一个父类，所以 extends 只能继承一个类。
public class Animal {
private String name;
private int id;
public Animal(String myName, String myid) {
//初始化属性值
}
public void eat() { //吃东西方法的具体实现 }
public void sleep() { //睡觉方法的具体实现 }
}
public class Penguin extends Animal{
}
18.2 implements关键字
使用 implements 关键字可以变相的使java具有多继承的特性，使用范围为类继承接口的情况，可以同时继承多个接口（接口跟接口之间采用逗号分隔）。
public interface A {
public void eat();
public void sleep();
}
public interface B {
public void show();
}
public class C implements A,B {
}
- super 与 this 关键字
super关键字：我们可以通过super关键字来实现对父类成员的访问，用来引用当前对象的父类。
this关键字：指向自己的引用。
class Animal {
void eat() {
System.out.println("animal : eat");
}
}
class Dog extends Animal {
void eat() {
System.out.println("dog : eat");
}
void eatTest() {
this.eat(); // this 调用自己的方法
super.eat(); // super 调用父类方法
}
}
public class Test {
public static void main(String[] args) {
Animal a = new Animal();
a.eat();
Dog d = new Dog();
d.eatTest();
}
}
- 继承之构造器
子类不能继承父类的构造器（构造方法或者构造函数），但是父类的构造器带有参数的，则必须在子类的构造器中显式地通过super关键字调用父类的构造器并配以适当的参数列表。
如果父类有无参构造器，则在子类的构造器中用super调用父类构造器不是必须的，如果没有使用super关键字，系统会调用 super()，即自动调用父类的无参构造器。
class SuperClass {
private int n;
SuperClass(){
System.out.println("SuperClass()");
}
SuperClass(int n) {
System.out.println("SuperClass(int n)");
this.n = n;
}
}
class SubClass extends SuperClass{
private int n;
SubClass(){
super(300);
System.out.println("SubClass");
}
public SubClass(int n){
System.out.println("SubClass(int n):"+n);
this.n = n;
}
}
public class TestSuperSub{
public static void main (String args[]){
SubClass sc = new SubClass();
SubClass sc2 = new SubClass(200);
}
}
输出结果为：
SuperClass(int n)
SubClass
SuperClass()
SubClass(int n):200
- 重写(Override)与重载(Overload)
21.1 重写
重写是子类对父类的允许访问的方法的实现过程进行重新编写, 返回值和形参都不能改变。即外壳不变，核心重写！
重写的好处在于子类可以根据需要，定义特定于自己的行为。 也就是说子类能够根据需要实现父类的方法。
21.1.1 重写规则
（1）声明为final的方法不能被重写。
（2）声明为static的方法不能被重写，但是能够被再次声明。
（3）子类和父类在同一个包中，那么子类可以重写父类所有方法，除了声明为private和final的方法。
（4）子类和父类不在同一个包中，那么子类只能够重写父类的声明为public和protected的非final方法。
（5）构造方法不能被重写。
（6）如果不能继承一个方法，则不能重写这个方法。
21.2 重载
重载是在一个类里面，方法名字相同，而参数不同。返回类型可以相同也可以不同。
最常用的地方就是构造器的重载。
21.2.1 重载规则
（1）被重载的方法必须改变参数列表(参数个数或类型或顺序不一样)；
（2）被重载的方法可以改变返回类型；
（3）被重载的方法可以改变访问修饰符；
（4）被重载的方法可以声明新的或更广的检查异常；
（5）方法能够在同一个类中或者在一个子类中被重载。
（6）无法以返回值类型作为重载函数的区分标准。
21.3 重写与重载之间的区别
overriding and overloading .png
方法的重写(Overriding)和重载(Overloading)是java多态性的不同表现，重写是父类与子类之间多态性的一种表现，重载可以理解成多态的具体表现形式。
- 多态实现方式
重写、接口、抽象类和抽象方法 - 抽象类和抽象方法
由于抽象类不能实例化对象，所以抽象类必须被继承，才能被使用。
抽象类表示的是一种继承关系，一个类只能继承一个抽象类，而一个类却可以实现多个接口。
声明抽象方法会造成以下两个结果：
（1）如果一个类包含抽象方法，那么该类必须是抽象类。
（2）任何子类必须重写父类的抽象方法，或者声明自身为抽象类。 - 接口
接口并不是类，编写接口的方式和类很相似，但是它们属于不同的概念。类描述对象的属性和方法。接口则包含类要实现的方法。
除非实现接口的类是抽象类，否则该类要定义接口中的所有方法。 - 抽象类和接口的区别
（1）抽象类中的方法可以有方法体，就是能实现方法的具体功能，但是接口中的方法不行。
（2）抽象类中的成员变量可以是各种类型的，而接口中的成员变量只能是 public static final 类型的。
（3）接口中不能含有静态代码块以及静态方法(用 static 修饰的方法)，而抽象类是可以有静态代码块和静态方法。
（4）一个类只能继承一个抽象类，而一个类却可以实现多个接口。 - 集合框架体系
collection.png
- 泛型
<? extends T>表示该通配符所代表的类型是T类型的子类。
<? super T>表示该通配符所代表的类型是T类型的父类。
public class GenericTest {
public static void main(String[] args) {
List<String> name = new ArrayList<String>();
List<Integer> age = new ArrayList<Integer>();
List<Number> number = new ArrayList<Number>();
name.add("icon");
age.add(18);
number.add(314);
//getUperNumber(name);//1
getUperNumber(age);//2
getUperNumber(number);//3
}
public static void getData(List<?> data) {
System.out.println("data :" + data.get(0));
}
public static void getUperNumber(List<? extends Number> data) {
System.out.println("data :" + data.get(0));
}
}
在(//1)处会出现错误，因为getUperNumber()方法中的参数已经限定了参数泛型上限为Number，所以泛型为String是不在这个范围之内，所以会报错。
28 多线程
一个线程的生命周期
java-thread.jpg
新建状态:
使用 new 关键字和 Thread 类或其子类建立一个线程对象后，该线程对象就处于新建状态。它保持这个状态直到程序 start() 这个线程。
就绪状态:
当线程对象调用了start()方法之后，该线程就进入就绪状态。就绪状态的线程处于就绪队列中，要等待JVM里线程调度器的调度。
运行状态:
如果就绪状态的线程获取 CPU 资源，就可以执行 run()，此时线程便处于运行状态。处于运行状态的线程最为复杂，它可以变为阻塞状态、就绪状态和死亡状态。
阻塞状态:
如果一个线程执行了sleep（睡眠）、suspend（挂起）等方法，失去所占用资源之后，该线程就从运行状态进入阻塞状态。在睡眠时间已到或获得设备资源后可以重新进入就绪状态。可以分为三种：
等待阻塞：运行状态中的线程执行 wait() 方法，使线程进入到等待阻塞状态。
同步阻塞：线程在获取 synchronized 同步锁失败(因为同步锁被其他线程占用)。
其他阻塞：通过调用线程的 sleep() 或 join() 发出了 I/O 请求时，线程就会进入到阻塞状态。当sleep() 状态超时，join() 等待线程终止或超时，或者 I/O 处理完毕，线程重新转入就绪状态。
死亡状态:
一个运行状态的线程完成任务或者其他终止条件发生时，该线程就切换到终止状态。
- 线程创建
（1）实现Runnable接口
（2）继承Thread类
（3）通过Callable和Future创建线程
创建线程的三种方式的对比：
（1）采用实现 Runnable、Callable 接口的方式创见多线程时，线程类只是实现了 Runnable 接口或 Callable 接口，还可以继承其他类。
（2）使用继承 Thread 类的方式创建多线程时，编写简单，如果需要访问当前线程，则无需使用 Thread.currentThread() 方法，直接使用 this 即可获得当前线程。
