java基础知识01

前言:

正所谓万丈高楼平地起,有了扎实的基础才能进阶更深奥的课程,才能让你后面的走得更轻松,学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[0];
    arry[0] = 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基础知识容我日后再整理。

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏java一日一条

JVM 进行线程同步背后的原理

所有的 Java 程序都会被翻译为包含字节码的 class 文件,字节码是 JVM 的机器语言。这篇文章将阐述 JVM 是如何处理线程同步以及相关的字节码。

711
来自专栏程序员互动联盟

【专业技术】介绍Java中的内存泄漏

Java语言的一个关键的优势就是它的内存管理机制。你只管创建对象,Java的垃圾回收器帮你分配以及回收内存。然而,实际的情况并没有那么简单,因为内存泄漏在Jav...

3278
来自专栏linux驱动个人学习

inline函数不能在for循环中使用的原因

inline函数的作用继承了宏定义的优点,没有了参数压栈,代码生成等一部分操作,并且摒弃了没有检查编译规则的缺点; 另外要注意,内联函数一般只会用在函数内容非常...

2954
来自专栏青玉伏案

窥探Swift编程之错误处理与异常抛出

在Swift 2.0版本中,Swift语言对其错误处理进行了新的设计,当然了,重新设计后的结果使得该错误处理系统用起来更爽。今天博客的主题就是系统的搞一下Swi...

1945
来自专栏Jackson0714

【.Net底层剖析】3.用IL来理解属性

3317
来自专栏spring源码深度学习

java基础thread——java5之后的多线程(浅尝辄止)

虽然我们可以理解同步代码块和同步方法的锁对象问题,但是我们并没有直接看到在哪里加上了锁,在哪里释放了锁,为了更清晰的表达如何加锁和释放锁,JDK5以后提供了一个...

911
来自专栏青玉伏案

算法与数据结构(二) 栈与队列的线性和链式表示(Swift版)

数据结构中的栈与队列还是经常使用的,栈与队列其实就是线性表的一种应用。因为线性队列分为顺序存储和链式存储,所以栈可以分为链栈和顺序栈,队列也可分为顺序队列和链队...

18610
来自专栏Python小屋

Python正则表达式案例一则:单词非两端字符改为小写

问题描述:给定一段英文,要求把其中所有单词除两端字符之外的其他字母都改为小写。 技术要点: 1)re模块的sub()函数用法; 2)match对象的group(...

2876
来自专栏liulun

Nim教程【十一】

引用类型和指针类型 不同的引用可以只想和修改相同的内存单元 在nim中有两种引用方式,一种是追踪引用,另一种是非追踪引用 非追踪引用也就是指针,指向手动在内存中...

2096
来自专栏微信公众号:Java团长

理解Java虚拟机体系结构

  众所周知,Java支持平台无关性、安全性和网络移动性。而Java平台由Java虚拟机和Java核心类所构成,它为纯Java程序提供了统一的编程接口,而不管下...

1286

扫码关注云+社区