前言：

正所谓万丈高楼平地起，有了扎实的基础才能进阶更深奥的课程，才能让你后面的走得更轻松，学Java亦是如此！所以千万不能忽略基础的重要性，下面一起来温习一下那些容易忽略、容易混淆以及比较重要的Java基础。

欢迎大家关注我的公众号 javawebkf，目前正在慢慢地将简书文章搬到公众号，以后简书和公众号文章将同步更新，且简书上的付费文章在公众号上将免费。

一、概述：

1.JDK：Java Development Kit，java的开发和运行环境。
2.JRE：Java Runtime Environment，java程序的运行环境，java运行的所需的类库+JVM(java虚拟机)。
3.javac命令：当执行javac时，会启动java的编译器程序。对指定扩展名的.java文件进行编译。 生成了jvm可以识别的字节码文件。也就是class文件，也就是java的运行程序。
4. java命令：负责运行的部分，会启动jvm，加载运行时所需的类库，并对class文件进行执行。一个文件要被执行，必须要有一个执行的起始点，这个起始点就是main函数。

二、Java基础：

1.数据类型：
(1). 8种基本类型：byte(1字节)、short(2)、int(4)、long(8)、float(4)、double(8)、char(2)、boolean
(2). 3种引用类型： 数组、类、接口。
级别从低到高为：byte,char,short(这三个平级)-->int-->float-->long-->double
自动类型转换：从低级别到高级别，系统自动转的；
强制类型转换：把一个高级别的数赋给一个别该数的级别低的变量就需要强转。

2、运算符：
(1). & 和 &&区别：第一个叫逻辑与，第二个叫短路与。逻辑与是无论左边结果是什么，右边都参与运算；而短路与，如果在左边为false，那么右边就不参与运算了；显然短路与效率更高。| 和 || 的区别亦是如此。

(2). == 和 equals方法的区别：

• 当比较的是基本类型：== 比较值是否相等；equals不能比较基本类型。
• 当比较的是引用类型(除了String)：== 和 equals都是比较地址值是否相同，即是否为同一个对象；
• 当比较的是String时：== 比较的还是地址值，但是由于String类重写了equals方法，所以equals比较的是值是否相等。

(3).++和--：
++和--参与运算时，如果++(--)放在操作数后面，则先运算再自增(减)，如果++(--)放在操作数前面，则先自增(减)，再参与运算。

3、语句：

(1). switch循环：

String s = "牛逼";
switch (s){
    case "牛逼":
         System.out.println("牛逼");
         break;
    case "厉害":
         System.out.println("厉害");
         break;
    default:
         System.out.println("默认");
         break;
}

这就是switch循环的用法了，switch支持的数据类型有byte、short、int、char、String以及Enum类型。

(2). while循环：

int x = 10;
while( x < 20 ) {
    System.out.print("value of x : " + x );
    x++;
}

(3).do while循环：

int x = 10;
do{
    System.out.print("value of x : " + x );
    x++;
}while( x < 20 );

do while和while的区别：do while至少执行一次。

break: 作用于switch ，和循环语句，用于跳出，或者称为结束。break语句单独存在时，下面不要定义其他语句，因为执行不到，编译会失败。当循环嵌套时，break只跳出当前所在循环。要跳出嵌套中的外部循环，只要给循环起名字即可，这个名字称之为标号。
continue: 只作用于循环结构，继续循环用的。结束本次循环，继续下次循环。该语句单独存在时，下面不可以定义语句，执行不到。

4、数组：用于存储同一类型数据的一个容器。
(1). 数组的初始化

int [] i = {1,2,3} //静态初始化
int [] arr = new int[5]; //动态初始化
arr[0] = 10;

(2).二分查找法(前提：数组中的元素必须有序)
二分查找法基本思想:
定义最大索引max，最小索引min，计算中间索引mid=(max+min)/2，拿要查找的数和中间索引处的数比较，如果中间索引处的数大了，就在左边找，这时最小索引min不变，最大索引max=mid-1，如果中间索引处的数小了，就在右边找，这时最大索引不变，最小索引min=mid+1。
代码实现：

public static int getIndex(int[] arr, int value) {
        int min = 0;
        int max = arr.length - 1;
        int mid = (max + min) / 2;
        while (arr[mid] != value) {
            if (arr[mid] > value) {
                max = mid - 1;
            } else if (arr[mid] < value) {
                min = mid + 1;
            }
            if (min > max) {
                return -1;
            }
            mid = (max + min) / 2;
        }
        return mid;
}

(3).数组排序之冒泡排序：
冒泡排序基本思想：
相邻元素两两比较，大的往后放，这样一轮下来，最大值就出现在了最大索引处，如此这般继续，便可得到排好序的数组。每比完一次，下一次比较就可少比较一个元素，总共需要比较数组长度减一次。
代码实现：

for(int x=0; x<arr.length-1; x++){ // 外循环控制比较次数
    for(int y=0; y<arr.length-1-x;y++){ // 内循环控制每一次的比较
        if(arr[y]> arr[y+1]){
             int temp= arr[y];
             arr[y]= arr[y+1];
             arr[y+1]=temp;
        }
    }
}

(4).数组排序之选择排序：
选择排序基本思想：
从0索引处开始，依次和后面的每一个比较，小的往前放，第一次比较完毕，最小值出现在0索引处，如此这般，便可得到排好序的数组。
代码实现：

 for(int x=0; x<arr.length-1; x++){
    for(int y=x+1; y<arr.length; y++){
       if(arr[y]< arr[x]){
           int temp = arr[x]; 
           arr[x] = arr[y];
           arr[y] = temp;
        }
    }
 }

(5).数组逆序：

for(int start =0,  end=arry.length-1;  start <end ; start ++; end --){
    int  temp =arry[start];
    arry[start] = arry[end];
    arry[end] = temp;
}

5、Java内存：java分了5片内存。
1：寄存器。2：本地方法区。3：方法区。4：栈。5：堆。
栈：存储的都是局部变量 ( 函数中定义的变量，函数上的参数，语句中的变量 )；
堆：用于存储数组和对象，new出来的东西就存在堆内存中。

三、面向对象：

1、面向对象特点：

• 将复杂的事情简单化。
• 面向对象将以前的过程中的执行者，变成了指挥者。
• 面向对象这种思想是符合现在人们思考习惯的一种思想。

2、构造函数：
用于给对象进行初始化的函数，在对象创建时，就被调用，而且初始化动作只执行一次。所有对象创建时，都需要初始化才可以使用。
(1). 特点：

• 该函数的名称和所在类的名称相同。
• 不需要定义返回值类型。
• 该函数没有具体的返回值。
• 子类构造函数运行时，先运行了父类的构造函数，这是因为子类的所有构造函数中的第一行，其实都有一条隐身的语句super()；super(): 表示父类的构造函数，并会调用于参数相对应的父类中的构造函数。

3、面向对象特性：
(1).封装: 封装是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。

• 好处：将变化隔离；便于使用；提高重用性；安全性。
• 封装原则：将不需要对外提供的内容都隐藏起来，把属性都隐藏，提供公共方法对其访问。

(2).继承：从已有类得到继承信息创建新类的过程。

• 好处：提高了代码的复用性；让类与类之间产生了关系，提供了另一个特征多态的前提。
• 使用时机：当类与类之间存在着所属关系时，才具备了继承的前提。a是b中的一种。a继承b。狼是动物的一种，狼继承动物。子类与父类是所属关系：" is a "。
• Java支持单继承，多重继承。

(3).多态：允许不同子类型的对象对同一消息做出不同的响应。

• 前提：必须要有继承或者实现关系。
• 体现：父类引用或者接口的引用指向了自己的子类对象：Animal a = new Cat();
• 好处：提高了程序的扩展性。
  关于多态，有个孔子装爹的故事：

class 孔子爹 {
  public int age = 40;
  public void teach() {
    System.out.println("讲解JavaSE");
  }
}

class 孔子 extends 孔子爹 {
    public int age = 20;
    public void teach() {
        System.out.println("讲解论语");
    }
    public void playGame() {
        System.out.println("玩王者荣耀");
    }
}

Java培训特别火,很多人来请孔子爹去讲课。这一天孔子爹被请走了，但是还有人来请，就剩孔子在家，价格还挺高。孔子一想，我是不是可以考虑去呢?然后就穿上爹的衣服，带上爹的眼睛，粘上爹的胡子，就开始装爹，跑到别人家里去讲课：

孔子爹 k爹 = new 孔子(); //向上转型
System.out.println(k爹.age); //40，对外表现的是父类的属性
k爹.teach(); //讲解论语，子类重写了teach方法，所以表现的是子类的，若没重写，则输出“讲解JavaSe”。

讲完了，下班回家了，脱下爹的装备，换上自己的装备，做回了自己：

孔子 k = (孔子) k爹; //向下转型
System.out.println(k.age); //20
k.teach(); //讲解论语
k.playGame(); //英雄联盟

4、抽象类和接口：
(1). 抽象：将一类事物的共同特征或行为抽取出来，而不管是怎么实现的。
(2). 抽象类： 用abstract修饰的类。特点如下：

• 抽象方法只能定义在抽象类中，抽象类和抽象方法必须由abstract关键字修饰（可以描述类和方法，不可以描述变量）。
• 抽象方法只定义方法声明，并不定义方法实现，即没有方法体。
• 抽象类不可以被创建对象(实例化)。
• 只有通过子类继承抽象类并覆盖了抽象类中的所有抽象方法后，该子类才可以实例化。否则，该子类还是一个抽象类。

注意如下几点：

• 抽象类也有构造方法，用于给子类对象进行初始化。
• 抽象类中可以没有抽象方法，但抽象方法一定是定义在抽象类中。
• abstract不可以和final , private , static 共存。

(3). 接口：是用关键字interface定义的。
接口中的成员都有固定的修饰符：

• 成员变量：public static final
• 成员方法：public abstract

抽象类与接口区别：

• 抽象类：一般用于描述一个体系单元，将一组共性内容进行抽取。
• 接口：一般用于定义对象的扩展功能，是在继承之外还需这个对象具备的一些功能。
• 抽象类只能被继承，而且只能单继承。接口需要被实现，而且可以多实现。接口的出现弥补了Java单继承的缺点。
• 抽象类中可以定义非抽象方法，子类可以直接继承使用。接口中都是抽象方法，需要子类去实现。
• 抽象类使用的是 is a 关系；接口使用的 like a 关系。
• 抽象类的成员修饰符可以自定义；接口中的成员修饰符是固定的。全都是public的。

5、内部类：

• 定义：

如果A类需要直接访问B类中的成员，而B类又需要建立A类的对象。这时,为了方便设计和访问，直接将A类定义在B类中就可以了。A类就称为内部类。内部类可以直接访问外部类中的成员。而外部类想要访问内部类，必须要建立内部类的对象。

class Outer{
    int num = 4;    
    class  Inner {
        void show(){
            System.out.println("inner show run "+num);// 直接访问外部类成员          
        }
    }
    public void method(){
        Inner in = new Inner();//创建内部类的对象。
        in.show();//调用内部类的方法。 
    }
}

• 内部类和静态内部类：

看一下静态和非静态内部类创建对象有什么区别。看下面的代码：

public class Outer {
   class Inner{ // 内部类
       void show(){
           System.out.println("内部类");
       }
   }
   static class Inner2{ // 静态内部类
        void show(){
            System.out.println("静态内部类");
        }
    }
   public static void fun1(){
       //new Inner().show(); // 编译报错
       Inner inner = new Outer().new Inner();
       inner.show();
       new Inner2().show();
   }

   public void fun2(){
       new Inner().show();
       new Inner2().show();
   }  
}

这段代码中，有两个内部类，一个内部类Inner，一个静态内部类Inner2。首先看如何创建Inner的对象：在非静态方法fun2中，可以直接new一个Inner的对象，而在静态方法fun1中，不能直接new内部类Inner的对象，编译报错。只能通过Inner inner = new Outer().new Inner()这样的方式来创建对象。这是因为静态只能访问静态，fun1是静态方法，而Inner类不是静态的，所以不能访问。当内部类是静态的时候(Inner2)，那就不管要使用它的方法是不是静态，都可以直接new一个Inner2对象。

• 匿名内部类：实质是一个对象，格式：

new 类名或者接口名(){
     重写方法{};
}

举个栗子：

 public interface inter{
     public void show();
 }
 class outer{
     new inter(){
          public void show(){
                system.out .print ("重写方法")
          }
     }.show();
 }

6、异常：
异常分两种：
(1). 编译时受检异常：只要是Exception及其子类都是编译时被检测的异常。
(2). 其中Exception有一个特殊的子类RuntimeException，以及RuntimeException的子类是运行异常，也就说这个异常是编译时不被检查的异常。
两种异常的区别：

• 编译被检查的异常在函数内被抛出，函数必须要声明，否编译失败。
• 声明的原因：是需要调用者对该异常进行处理。
• 运行时异常如果在函数内被抛出，在函数上不需要声明。
• 不声明的原因：不需要调用者处理，运行时异常发生，已经无法再让程序继续运行，所以，不让调用处理的，直接让程序停止，由调用者对代码进行修正。
• 一般写代码时如果有编译受检异常，ide会有警告；而运行时异常只有当程序运行了才能发现，比如空指针异常。

四、常见关键字：

1、this: 代表对象。就是所在函数所属对象的引用。哪个对象调用了this所在的函数，this就代表哪个对象，就是那个对象的引用。
2、Super： 代表是子类所属的父类中的内存空间引用。
3、static: 是一个修饰符，用于修饰成员(成员变量和成员函数)。

• 想要实现对象中的共性数据的对象共享。可以将这个数据进行静态修饰。
• 被静态修饰的成员，可以直接被类名所调用。也就是说，静态的成员多了一种调用方式。类名.静态方式。
• 静态随着类的加载而加载。而且优先于对象存在。
• 静态方法只能访问静态成员，不可以访问非静态成员。
• 静态方法中不能使用this，super关键字。因为this代表对象，而静态在时，有可能没有对象，所以this无法使用。
  -静态代码块、构造代码块、构造函数同时存在时的执行顺序：静态代码块 --- > 构造代码块 ---> 构造函数；

4、final：

• 这个关键字是一个修饰符，可以修饰类，方法，变量。
• 被final修饰的类是一个最终类，不可以被继承。
• 被final修饰的方法是一个最终方法，不可以被覆盖。
• 被final修饰的变量是一个常量，只能赋值一次。

五、多线程：

1、线程与进程：

• 进程：正在进行中的程序。其实进程就是一个应用程序运行时的内存分配空间。
• 线程：其实就是进程中一个程序执行控制单元，一个进程可能包含多个线程。

2、线程的随机性原理：
因为cpu的快速切换造成，哪个线程抢到了cpu的执行权，哪个线程就执行。

3、线程中常用方法：
(1). 线程启动：使用start方法。调用start方法做了两件事：启动了线程；让jvm调用了run方法。
(2). 线程休眠： Thread.sleep(1000); // 休眠1秒钟。
(3). 线程礼让：Thread.yield(); // 使线程看上去更和谐，但不能保证你一次我一次。
(4). 给线程起名字：my1.setName("线程名")。
(5). 设置与获取线程优先级：my1.setPriority()和my1.getPriority()；优先级默认是5，最大是10，最小是1。
(6). 守护线程：my1.setDaemon(true)；my1设置为守护线程，表示该线程就是守护主线程的，主线程一退出my1也就死了。
(7). 线程中止：my1.interrupt();
(8). 线程加入：my1.join(); my2.start()；// 表示my1走完了才轮到my2
(9). 获取当前线程名称：Thread.currentThread().getName();

4、线程状态：

• 被创建：start()
• 运行：具备执行资格，同时具备执行权；
• 冻结：sleep(time),wait()—notify()唤醒；线程释放了执行权，同时释放执行资格；
• 临时阻塞状态：线程具备cpu的执行资格，没有cpu的执行权；
• 消亡：stop()

5、实现多线程的方式：
三个窗口出售100张电影票，用两种方式实现：
(1). 继承Thread类 ，由子类复写run方法。步骤：

• 定义类继承Thread类；
• 目的是复写run方法，将要让线程运行的代码都存储到run方法中；
• 通过创建Thread类的子类对象，创建线程对象；
• 调用线程的start方法，开启线程。

public class sellTicket extends Thread{
    //票要定义成静态成员，才能让三个线程共享。
    private static int tickets=100;
    public void run(){
       while(true){
          if(tickets>0){
              Thread.sleep(100)   //模拟延迟
              System.out.print(Thread.currentThread().getName()+"正在出售第"+tickets-- +"张票");
           }
        }
    }
    public static void main(String[] args){
        sellTicket s1=new sellTicket();
        sellTicket s2=new sellTicket();
        sellTicket s2=new sellTicket();
        s1.setName("窗口1");
        s2.setName("窗口2");
        s3.setName("窗口3");
        s1.start();
        s2.start();
        s3.start();
    }
}

(2).实现Runnable接口。步骤：

• 定义类实现Runnable接口。
• 覆盖接口中的run方法（用于封装线程要运行的代码）。
• 通过Thread类创建线程对象；
• 将实现了Runnable接口的子类对象作为实际参数传递给Thread类中的构造函数。
• 调用Thread对象的start方法，开启线程。

public class sellTicket implements Runnable {
   private int tickets=100;
   public void run(){
       while(true){
           if(tickets>0){  
               Thread.sleep(100);  //模拟延迟
               System.out.print(Thread.currentThread().getName()+"正在出售第"+tickets-- +"张票");
            }
        }
   }
   public static void main(String[] args){
            sellTicket st=new sellTicket();
            Thread t1=new Thread(st,"窗口1");
            Thread t2=new Thread(st,"窗口2");
            Thread t3=new Thread(st,"窗口3");
            t1.start();
            t2.start();
            t3.start();
   }
}

6、同步：
运行上面两段卖票的程序会发现，票会出现负数或者是同一张票卖了好几次的情况，这就是线程安全问题。
(1).如何判断一个程序是否有线程安全问题？

• 是否是多线程环境
• 是否有共享数据
• 是否有多条语句操作共享数据

满足以上3个条件，程序就有线程安全问题。

(2). 同步代码块：解决了线程安全问题，格式：

synchronized(锁对象){ // 锁对象可以是任意对象
   // 多条语句操作共享数据的代码
}

改进上面的卖票案例：

public class sellTicket implements Runnable {
   private int tickets=100;
   Object obj = new Object();  // 锁对象
   public void run(){
      while(true){
         synchronized(obj){
            if(tickets>0){
               Thread.sleep(100);  //模拟延迟
               System.out.print(Thread.currentThread().getName()+"正在出售第"+tickets-- +"张票");
             }
          }
      }
   }
}

(3).同步方法：其实就是将同步关键字定义在方法上，让方法具备了同步性。同步方法的锁对象是this；静态同步方法的锁对象是当前类的class文件。

(4).死锁：两个或两个以上的线程因争夺资源产生相互等待的现象。

(5).线程间的通信问题：

先看下面的例子(省略了student类)：

设置学生信息的类：

public class SetStudentInfo implements Runnable {
    private Student s;
    public SetStudentInfo(Student s){
            this.s=s;
    }
    public void run(){
        synchronized(s){
            s.setName("林青霞");
            s.setAge(27);
        }
    }
}

获取学生信息的类：

public class GetStudentInfo implements Runnable {
    private Student s;
    public GetStudentInfo (Student s){
            this.s=s;
    }
    public void run(){
       synchronized(s){
          System.out.println(s.getName()+"---"+s.getAge());
       }
    }
}

开启线程：

public class Test{
   public static void  main(String[] args){
      Student s = new Student ();
      SetStudentInfo setStudentInfo = new SetStudentInfo(s);
      GetStudentInfo getStudentInfo = new  GetStudentInfo(s);
      Thread t1 =new Thread(setStudentInfo );
      Thread t2 =new Thread(getStudentInfo );
      t1.start();
      t2.start();
   }
}

多线程就是多条线程在抢cpu的执行权，上面的程序中，如果是t2先抢到执行权，那就有问题了。因为t2是获取学生信息，我都还没设置学生信息就获取，肯定出错。其实这就是生产消费模式。设置学生信息就是生产者，获取学生信息是消费者。正常的执行是这样的：

• 生产者：没有产品就生产，有产品就等待，生产完通知消费者来消费。
• 消费者：有产品就消费，没有产品就等待，消费完通知生产者去生产。

要实现这样的执行过程，Java提供了等待唤醒机制。Object类提供了3个方法：

• wait()：等待
• notify(): 唤醒
• notifyAll()：唤醒所有

因为这三个方法是通过锁对象调用，而锁对象又可以是任意对象，只有Object才可以表示任意对象，所以这三个方法定义在Object中。

使用等待唤醒机制改进上述案例：

student类中添加一个成员变量作为标记：

boolean flag; // true表示已生产，可以消费，false表示无产品可供消费

设置学生信息：

public class SetStudentInfo implements Runnable {
    private Student s;
    public SetStudentInfo (Student s){
            this.s=s;
    }
    public void run(){
        synchronized(s){
             if(s.flag){ //true表示有
                s.wait();//有就等待
             }
             //没有就生产
             s.setName("林青霞");
             s.setAge(27);
             //修改标记并唤醒另一个线程
             s.flag = true ;  //生产了就修改标记为true
             s.notify(); // 同时唤醒另一线程
        }
    }
}

唤醒以后并不是另一个线程就有了执行权，还是要抢，如果还是当前线程抢到，那么没关系，因为标记已经改成true ，当前线程就会等待。
获取学生信息：

public class GetStudentInfo implements Runnable {
    private Student s;
    public GetStudentInfo (Student s){
            this.s=s;
    }
    public void run(){
       synchronized(s){
          if(!s.flag){ // 是false就等待
               s.wait();
          }
          //被SetStudentInfo唤醒后就走到了这里
          System.out.println(s.getName()+"---"+s.getAge());
          s.flag = false(); //经过消费就没有了,修改为false
          s.notify();// 通知生产者生产
       }
    }
}

上述代码就使用了等待唤醒机制。

总结：

为避免篇幅过长，本文先到此为止。本文总结了一些Java基础知识以及一个重点 —— 多线程。剩下的Java基础知识容我日后再整理。