环境变量

  1. 在Oracle官网下载安装jdk
  2. 配置环境变量JAVA_HOME和PATH

  3. 常用命令：java 、javac、javadoc

    标识符

    合法标识符

  4. 由26英文字母的大小写，_，0-9或$组成

  5. 数字不可以开头
  6. 标识符中不能包含空格

  7. 不能包含关键字和保留字

    标识符规范

  8. 包名：都小写

  9. 类名，接口名：多单词组成时，所有单词的首字母大写
  10. 变量名，方法名：多单词组成时，除第一个单词外的其他单词首字母大写

  11. 常量名：全大写

    基本数据类型（8）

  12. byte：1个字节

  13. short：2个字节
  14. int：4个字节
  15. long：8个字节，定义以L或l结尾
  16. float：4个字节，定义以F或f结尾
  17. double：8个字节
  18. char：2个字节
  19. boolean：1个字节

注意：byte、short、char三者之间做运算结果类型为int

运算符

算数运算符

赋值运算符

  1. =
  2. +=
  3. -=
  4. *=
  5. /=

注意：2~5不会改变变量的数据类型

  1. byte b1=1;
  2. b1 *= 0.1 //结果为0

比较运算符

  1. =
  2. !=
  3. >
  4. <

  5. =

  6. <=

  7. instanceof

    逻辑运算符

  8. &：无论左边是true还是false，都会执行运算符两边的判断

  9. &&：当该符号左边为false时，不再执行右边的判断
  10. |：无论左边是true还是false，都会执行运算符两边的判断
  11. ||：当该符号左边为true时，不再执行右边的判断
  12. ！

  13. ^

    位运算符

  14. <<（左移）

  15. （右移）

  16. （无符号右移）

  17. &（与）
  18. |（或）
  19. ^（异或）
  20. ~（取反）

    三元运算符

    1. // 条件表达式? result1:result2;
    2. a>b? a:b;

    程序控制结构

    顺序结构

    分支结构

    if … else
    if … else if … else
    switch case

    循环结构

    for
    while
    while … do
    do … while

    static

    static修饰变量
    static修饰方法

    代码块

    ```java /* 静态代码块

随着类的加载而执行，只执行一次 初始化类信息 如果一个类中定义了多个静态代码块，则按先后顺序执行 */

static{

}

/* 非静态代码块

随着对象的创建而执行，每创建一次对象就执行一次 初始化对象信息 如果一个类中定义了多个非静态代码块，则按先后顺序执行 */ { System.out.println(“代码块”); }

  1. <a name="3O7yZ"></a>
  2. # final
  3. final修饰类表示此类不能被继承<br />final修饰类中的方法，子类不能重写此方法<br />final修饰一个属性，则此属性不能再被赋值：显示初始化，代码块中初始化，构造器中初始化<br />final修饰局部变量，则不可被更改<br />final修饰形参，则在方法体中，此形参也不可再被更改
  4. <a name="6jWLc"></a>
  5. # 抽象类 abstract
  6. abstract修饰类<br />abstract修饰方法：父类有抽象方法，子类需重写此抽象方法，否则子类只能是抽象类<br />abstract不能修饰私有方法
  7. <a name="Tg5yq"></a>
  8. # 接口
  9. 接口中只能定义全局常量和抽象方法<br />全局常量：public、static、final的<br />抽象方法：public、abstract的
  10. <a name="FWtQB"></a>
  11. # 异常
  12. <a name="DwJnb"></a>
  13. ## 自定义异常
  14. ```java
  15. public class MyException extends Exception {
  17.     public MyException(){
  18.     }
  20.     public MyException(String msg){
  21.         super.message(msg);
  22.     }
  23. }

多线程

继承Thread方式

常用方法：
start()
run()
currentThread()
getName()
setName()
yield()：释放当前线程的CPU执行权
join()：线程调用此方法获得CPU执行权
stop()：结束线程
sleep()：睡眠
setPriority(int p)：设置优先级
getPriority()：获得优先级

以下三个方法必须由同步代码块或同步方法中的监视器调用
Object中的方法
wait()
notify()
notifyAll()

  1. class MyThread extends Thread {
  3.     @Overried
  4.     public void run(){
  5.         for(int i=1; i<100; i++) {
  6.             System.out.println(Thread.currentThread.getName() + ":" +i);
  7.         }
  8.     }
  9. }
  11. public class ThreadTest{
  13.     public static void main(String [] args) {
  14.         MyThread t1 = new MyThread();
  15.         t1.start();
  16.     }
  18. }

实现Runnable方式

  1. /*
  2. 1. 实现Runnable接口
  3. 2. 使实现Runnable接口的类实现run方法
  4. 3. 创建实现Runnable接口的类
  5. 4. 创建Thread类，构造器中写刚刚实现Runnable接口的类
  6. 5. 调用Thread的start方法
  7. */
  9. class Window implements Runnable {
  10.     @Overried
  11.     public void run(){
  13.     }
  14. }
  16. public MyThread {
  17.     public static void main(String [] args){
  18.         Window w = new Window();
  19.         Thread t1 = new Thread(w);
  20.         t1.start();
  22.         Thread t2 = new Thread(w);
  23.         t2.start();
  24.     }
  25. }

线程的生命周期

  1. 新建
  2. 就绪
  3. 运行
  4. 阻塞
  5. 死亡

线程.png

线程锁

同步代码块

  1. /*
  2. synchronized关键字
  3. */
  5. class Window implements Runnable {
  6.     private Object obj = new Object();
  8.     @Overried
  9.     public void run(){
  10.         //多个线程锁必须是同一把，可使用当前对象this
  11.         synchronized(obj){
  12.             for(int i=1; i<=100; i++){
  13.                 System.out.println(Thread.currentThread().getName() +":"+i);
  14.             }
  15.         }
  16.     }
  17. }
  21. //使用类当锁
  22. class MyThread extends Thread {
  24.     @Overried
  25.     public void run(){
  26.         synchronized(Window.class){
  27.             for(int i=1; i<100; i++) {
  28.                 System.out.println(Thread.currentThread.getName() + ":" +i);
  29.             }
  30.         }
  31.     }
  32. }

同步方法

  2. class Window implements Runnable {
  3.     private Object obj = new Object();
  5.     @Overried
  6.     public void run(){
  7.         show();
  8.     }
  10.     private synchronized void show(){    //此时的锁为this
  11.         for(int i=1; i<=100; i++){
  12.             System.out.println(Thread.currentThread().getName() +":"+i);
  13.         }
  14.     }
  15. }
  19. //使用类当锁
  20. class MyThread extends Thread {
  22.     @Overried
  23.     public void run(){    
  24.         show();
  25.     }
  27.     //需要修饰为静态方法
  28.     private static synchronized void show(){    //此时的锁为MyThread.class
  29.         for(int i=1; i<100; i++) {
  30.             System.out.println(Thread.currentThread.getName() + ":" +i);
  31.         }
  32.     }
  33. }

Lock锁

  1. class Window implements Runnable {    
  2.     private ReentrantLock lock = new ReentrantLock();
  4.     @Overried
  5.     public void run(){
  6.         lock.lock();
  7.         for(int i=1; i<=100; i++){
  8.             System.out.println(Thread.currentThread().getName() +":"+i);
  9.         }
  10.         lock.unLock();
  11.     }
  12. }

sleep()和wait()的异同

相同：都会使线程进入阻塞
不同：

  1. 声明的位置不同：sleep在Thread中声明，wait()在Object中声明
  2. 调用的场景不同：wait只能在同步代码块或同步方法中调用
  3. sleep不会释放锁，wait会释放同步锁

    Callable接口

    ```java /*
  4. 写一个类实现Callable接口
  5. 让Callable接口的实现类实现call方法 call方法有返回值 可以填写泛型
  6. 创建Callable接口的实现类对象
  7. 创建FutureTask对象，同时将Callable接口的实现类对象作为参数传入FutureTask的构造器 FutureTask对象有一个get方法可以获得Callable接口实现类中call方法的返回值 FutureTask也有泛型
  8. new一个Thread对象将FutureTask对象传入其构造器中，并执行start方法 */

class MyThread implements Callable {

  1. @Overried
  2. public Integer call() throws Exception {
  4. }

}

public class CallableTest { public static void main(String [] args){ MyThread t = new MyThread(); FutureTask ft = new FutureTask(t); new Thread(ft).start; } }

  1. <a name="wBaSZ"></a>
  2. ## 线程池
  3. ```java
  4. class RunnableThread implements Runnable{
  5.     @Overried
  6.     public void run(){
  7.         //具体要执行的内容
  8.     }
  9. }
  11. class CallableThread implements Callable<Integer>{
  12.     @Overried
  13.     public Integer call() throws Exception{
  14.         //具体要执行的内容
  15.     }
  16. }
  19. public class ThreadPool {
  20.     public static void main(String [] args){
  22.         //使用ThreadPoolExecutor接收service可以设置线程池的属性
  23.         ExecutorService service = Executors.newFixedThreadPool(10);
  25.         //service.execute(new RunnableThread()); 此方法适用于Runnable接口
  26.         service.submit(new CallableThread());    //此方法适用于Callable接口
  28.         //关闭连接池
  29.         service.shutdown();
  30.     }
  31. }

IO流

IO流体系

字节输入流 字节输出流 字符输入流 字符输出流
抽象基类 InputStream OutputStream InputReader OutputWriter
访问文件 FileInputStream FileOutputStream FileReader FileWriter
访问数组 ByteArrayInputStream ByteArrayOutputStream ByteArrayReader ByteArrayWriter
访问管道 PipedInputStream PipedOutputStream PipedReader PipedWriter
访问字符串 StringReader StringWriter
缓冲流 BufferedInputStream BufferedOutputStream BufferedReader BufferedWriter
转换流 InputStreamReader OuputStreamWriter
对象流 ObjectInputStream ObjectOutputStream
打印流 PrintStream PrintWriter
推回输出流 PushbackInputStream PushbackReader
特殊流 DataInputStream DataOutputStream

FileInputStream

FileOutputStream

FileReader

FileWriter

BufferedInputStream

BufferedOutputStream

InputStreamReader

OutputStreamWriter

PrintStream

PrintWriter

网络编程

TCP（Socket和ServerSocket）

UDP（DatagramSocket）

反射

获取类的四种方式

  1. 通过对象的getClass方法
  2. 通过类名点class
  3. 通过Class.forName（）

  4. 通过类加载器

    三种类加载器

  5. 引导类加载器：加载java核心类库，无法获得

  6. 扩展类加载器：加载系统类加载器，可通过getParent()方法获得
  7. 系统类加载器：加载自定义类，可通过getClassLoader获得，String.class.getClassLoader()