java基础知识01

作者: 贪挽懒月 | 来源:发表于2018-10-28 16:07 被阅读17次

    前言:

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

    一、概述:

    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、short、int、long、float、double、char、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();//调用内部类的方法。 
        }
    }
    

    匿名内部类就是内部类的简化写法,只调用一次时可以用匿名内部类。

    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基础知识容我日后再整理。

    相关文章

      网友评论

        本文标题:java基础知识01

        本文链接:https://www.haomeiwen.com/subject/hvmdtqtx.html