java系统化基础-day01-基础语法知识

1.学前必看

　　该课程将系统化的讲解java基础,但是该课程并不适合零基础的学员,因为在整个java学习体系中我们是按照实际生产设计,

主体思路是以完成某个业务为主线,用到什么技术就学什么技术,即带着问题去学习某个知识,等到把问题解决完后,在系统化的学习该知识点,这样既能明白学的知识是做什么的,还能做到真正的实战教学,并且大大提高了学习的效率;

那么当前课程是基于我们之前的课程基础上进行系统化深入的讲解,如果你还没有学过之前的课程可以点击如先连接进行学习.

　　该课程的上一个阶段资料:https://www.cnblogs.com/newAndHui/category/1153640.html

　　学习方法:请先认真看浏览博客课件,知道大体要写什么内容,然后根据自己的实际情况,先按照博客上去学习,带着问题在结合视频学习,这样不但能提高自己的学习能力,还能提高学习效率!

2.学前预备知识

　　该课程讲解过程中会提到一些实际生产案例,相对来说内容会偏生,需具备能使用java在web页面上完成基本的CRUD的基础,学起来效果会更好.

3.基本语法　　

　　1.如果一个源文件中什么内容都没有，编译会不会生成 字节码文件？==>不会，编译的本质就是将程序员写的代码转变为计算机能认识的二进制文件，如果连类容都没有就不会编译，也就不会有字节码文件。

　　2.如果一个类中没有主方法，编译运行会怎么样？==>编译可以通过，但运行报错：没有主方法

　　什么是主方法 ：是一个特殊的方法 ，是程序的入口，JVM开始执行的地方

　　

　　3. 我们的代码最小的存在单位是类

　　　　1).类 主方法（方法） 叫结构性的代码 后面是不需要; （分号）

　　　　2).功能执行语句，例如 打印语句 后面必须加上;（分号）

　　　　3).类中不能够写功能执行语句， 例如打印语句

　　　　4).所有的标点符号都必须是英文状态下的

　　　　5).Java代码中是严格区分大小写

　　　　6).字节码文件的名字和类名一致，建议源文件名字和类名一致

　　　　7). 一个Java源文件中可以写多个并列的类，编译完毕之后会生成多个独立的字节码文件
　　　　　　建议 ： 在实际开发中一个java文件中只写一个类

　　　　8). 一个类可以使用public修饰
　　　　　　如果一个类使用public修饰，必须和源文件名字一致，而且我们一般也只会在一个java文件里写一个类，不建议写多个类。

　　　　　　一个源文件中，至多只能有一个类可以被public修饰

　　　　

4.java注释　　

　　1.什么是注释，有什么用
　　　　注释其实可以看成是备注，主要是写给（自己）程序员看的，代码运行的时候是不会管注释内容的，可以增强代码的可读性。
　　2.如何写
　　　　1)// 单行注释，注释一行(是以行终止符为准)
　　　　2)/* */ 多行注释，可以注释多行
　　　　　　每一行前面都加* 只是为了好看
　　　　3)/** */ 文档注释，效果很像多行注释，也可以注释多行，特点 ：可以通过一个命令javadoc 把文档注释中的内容生产文档
　　　　　　注意 ：单行注释 和 多行注释不能 相互嵌套
　　3.什么时候写 在什么地方写
　　　　写代码时候养成写注释的习惯－－》　代码的可读性增强
　　　　1)思路　　流程　
　　　　2)关键代码
　　　　类的整体描述；　字段　　方法　　构造方法前面都会写注释

　　

5.java中的分隔符　

　　分号（;）：语句的分割，表示一句话结束，好比咱们使用的句号。
　　花括号（{}）：表示一个代码块，是一个整体，花括号要成对使用。
　　方括号（[]）：定义数组和访问数组元素时使用。
　　圆括号（()）：使用很广泛，具体用到细讲。
　　圆点（.）：类和对象访问它的成员时使用。
　　空格（ ）：把一整条语句分割成几段，空格的次数不限制。
　　一般单词之间一个空格就可以了
　　注意：必须都是半角下的英文符号。

6.java中关键字、保留字、标识符

　　Java关键字： Java语言设计之初，被赋予特殊意义的单词。

　　通常用来程序控制，错误处理，基本类型，类,方法和变量修饰符……等等

　　共同点：所有的字母全部小写

　　

　　

　　保留字：goto  const   在java中现在还没有赋予它特殊意义，以后可能会用，预留起来

　　标识符：为了增强程序的阅读性而自定义的名称。比如：类名，方法名，变量名等

       标识符的命名规则：

1. 所有的标识符都应该以字母（A-Z或者a-z）,美元符（$）、或者下划线（_），数字（不能以数字开头）开始
2. 关键字不能用作标识符
3. 标识符是大小写敏感的
4. 合法标识符举例：age、$salary、_value
5. 非法标识符举例：123abc、-salary

　　书写建议：

1. 一般来说都是取一些有意义的单词
2. 类名首字母必须大写
3. 方法名，变量名 首字母小写
4. 如果是有多个单词组成，后面每一个单词首字母大写（驼峰法命名）

　　总结：严格按照==》简单明了，驼峰命名法，除了类名首字母大写，其他都采用首字母小写的驼峰命名法

7.java中的数据类型

　　

7.1.基本数据类型（8种）

　　整数类型

　　

　　各个类型之间的取值范围
　　A.byte(8位，-2^8--2^8-1范围是-128到127)
　　B.short（16位，-32768—32767）
　　C.int（32位，-2147483648—2147483647）
　　D.long (64位，-9223372036854775808—9223372036854775807)

　　注意：给long赋值时，因为整数默认是int类型，要转换为long类型的值，后面加上l或L
　　上面的byte short int long 最大长度可以通过jdk文档去找到 具体的范围。

　　同一个整数可以使用不同的进制表示：
　　默认的进制10进制
　　二进制： 是 0b 或者 0B开头
　　八进制： 是0开头
　　十六进制： 0X (0x) 开头

　　浮点型(小数型)

　　

　　A. float(单精度32位) 直接赋值时必须在数字后加上f 或F
　　B. double( 双精度64位)

　　区别：
　　对于单精度浮点数，运行速度相比double更快，占内存更小，但是当数值非常大或者非常小的时候会变得不精确。
　　双精度比单精度表示的位数大 精确的位数多,简单地说, float表示的小数点位数少。
　　默认浮点数的类型是 double

　　表现形式：
　　1.常规 3.14
　　2.科学计数法

　　注意：
　　表示float 类型 必须加上f 或者F

　　float double 不能精确表示一个小数，例如 1.3*1.4

　　例如 double num= 1.0, 是一个无限接近1.0的一个值

　　那怎么更精确的表示浮点数呢？BigDecimal

　　结论：浮点运算很少是精确的，只要是超过精度能表示的范围就会产生误差。

　　往往产生误差不是 因为数的大小，而是因为数的精度。

　　因此，产生的结果接近但不等于想要的结果。尤其在使用 float 和 double 作精确运 算的时候要特别小心。

　

　　字符
　　A:char 16 位[0-65535] (2个字节,16位) 。字符常量使用单引号 ‘’包裹起来。
　　表现形式：
　　1.‘A’最常用，最直观的方式
　　2.使用一个数字表示，对应有一个ASCII码表
　　例如:char c = 65;//表示 ’A’ 这个字符
　　可以当成一个整数来使用，什么是asscii表，就像化学元素周期表

　　3. 16进制表现形式

 　　具体的可以参看表：ASCII表

　　

　　4. 字符与ASCII码的相互转换

 /**
     * ASCII 与字符的相互转换
     */
    @Test
    public void test5() {
        char c = '爱';
        System.out.println("c=" + c);
        //将字符 ==》 ASCII码（十进制的数字）
        int i = (int) c;
        System.out.println(" i=" + i);
        //将一个十进制的数字 ==》 字符
        char c2 = (char) i;
        System.out.println("c2=" + c2);
    }

　　

　　布尔类型
　　值只有两个 true false，不能使用 0 1表示

　   

　　具体的基本类型案例代码如下：

package com.wfd360.com;

import org.junit.Test;

/**
 * <p>
 * 1.数据类型概述
 * 123,3.14
 * 在java中不同类型的数据有不同的数据类型，看看下面的数据类型的分类：
 * 分类：
 * 一、基本数据类型 8 种 java预定义的类型(原生数据类型)
 * 1.整数类型 *4 123
 * byte 1个字节8位
 * short 2字节16位
 * int 4字节32位
 * long 8字节64位
 * <p>
 * 2.小数类型(浮点类型) *2 3.14
 * float 单精度 4字节32位
 * double 双精度 8字节64位
 * 3.字符类型 *1
 * char 2字节16位 ‘A’,’B’
 * 4.布尔类型*1
 * boolean 俩值 true ,false
 */
public class DataType {
    /**
     * 整数类型 4种
     */
    @Test
    public void test1() {
        //byte 1个字节8位
        byte b = 6;
        //short 2字节16位
        short s = 6;
        //int 4字节32位 (经常使用)
        int i = 6;
        //long 8字节64位 （通常在取时间毫秒时使用）
        long l = 6;
        String format = String.format("b=%s,s=%s,i=%s,l=%s", b, s, i, l);
        System.out.println(" format=" + format);
    }

    /**
     * 小数类型 2种
     */
    @Test
    public void test2() {
        // float 单精度 4字节32位,后面必须带f,大写也可以，建议使用小写
        float f = 3.14f; //推荐写法
        float f2 = 3.14F;
        // double 双精度 8字节64位  (经常使用)
        double d = 3.14; //推荐写法  
        double d2 = 3.14d;
        double d3 = 3.14D;
        String format = String.format("f=%s,f2=%s,d=%s,d2=%s,d3=%s", f, f2, d, d2, d3);
        System.out.println(" format=" + format);
    }

    /**
     * 字符类型 1种
     */
    @Test
    public void test3() {
        //char 2字节16位 ,例如：‘A’,’B’，注意使用的是单引号，一般不使用，一般使用String类型代替
        char c = 'A';
        System.out.println("c=" + c);
    }

    /**
     * 布尔类型 1 种
     */
    @Test
    public void test4() {
        // boolean 俩值 true ,false
        boolean b = true;
        boolean b2 = false;
        System.out.println("b=" + b + ",b1=" + b2);
    }
}

　　

7.2.引用数据类型

　　类，数组，接口，枚举……

 /**
     * 　String类：
     * 　String是 java中已经设计好的一个类，表示的值是字符串（Java中设计的类和我们自己设计的类的性质是一样的）
     */
    @Test
    public void test6() {
        String str = "爱老虎油！";
        System.out.println("str=" + str);
    }

7.3.进制（了解）　

　　1) 2进制 （逢2进1）

　　　　其中的符号可以是 0 1   110等于10进制的2    第一位1 ==2*’1‘ 2*2 第二位1==2

　　2) 8进制（逢8进1）

　　　　其中的符号可以是0 1 2 3 4 5 6 7   10等于10进制的8

　　3) 10进制 （逢10进1）

　　　　其中的符号可以是 0 1 2 3 4 5 6 7 8 9    10

　　4) 16进制（逢16进1）

　　　　其中的符号可以是0 1 2 3 4 5 6 7 8 9 A B C D E F  11等于10进制的17

       平时我们在日常生活中使用的是10进制，计算机底层中大都使用的 2进制，每一种进制之间是可以相互转化的 ，

　　具体转化，大家可以参考度娘：进制转化百度百科

9.数据类型转换（非常重要）

　　经常出面试题

　　小数默认为double类型， 整数默认为int类型!
　　在Java中，boolean类型与所有其他7种类型都不能进行转换。
　　下面这7种数据类型，它们之间都可以进行转换，但是可能会存在精度损失或者其他一些变化：
　　byte  --> short ，char  --> int  -->   long -->    float  -->    double

　　如果从小转换到大，（除了byte不能自动转换char ，以及char不能自动转换short）可以自动完成转换。而从大到小，必须强制转换(强制转换前必须知道被转换的值在要转换的类型范围内)。
　　规律：有包含关系的可以由低精度赋值给高精度。
　　为什么float 在long 后面？
　　小数(浮点数) 的存储方式，结构和整数不一样

　　

　　案例代码：

 /**
     * 类型转换：自动转换
     */
    @Test
    public void test7() {
        byte b = 65;
        //byte自动转变为 short
        short bs = b;
        //short 自动转变为 int
        int bsi = bs;
        //int 自动转变 long
        long bsil = bsi;
        //long 自动转变为 float
        float bsilf = bsil;
        //float 自动转变为 double
        double bsilfd = bsilf;
        System.out.println("bsilfd=" + bsilfd);
        //也可以越级 自动转换，比如：byte 自动 转换为 double
        double bd = b;
        System.out.println("bd=" + bd);
    }

    /**
     * 类型转换：强制转换
     */
    @Test
    public void test8() {
        double d = 3.1415926978568412;
        //double 强制转变为 float
        float df = (float) d;
        //float 强制转变为 long
        long dfl = (long) df;
        //long 强制转变为 int
        int dfli = (int) dfl;
        //int 强制转变为 short
        short dflis = (short) dfli;
        //short 强制转变为 byte
        byte dflisb = (byte) dflis;
        System.out.println("dflisb=" + dflisb);
        //也可以越级 强制转换，比如：double 强制 转换为 byte
        byte db = (byte) d;
        System.out.println("db=" + db);
    }

    /**
     * 运算中自动转型：在类型不一致的运算中最终会 得到一个最大的类型
     */
    @Test
    public void test9() {
        int num = 10;
        double b = 10.01;
        double c = num + b;
        // 这样会报错，因为最后运算完成的类型是double，不能自动转变为int
        // int  c2 = num + b;
        System.out.println(c);
    }

    /**
     * byte  --> short ，char  --> int  -->   long -->    float  -->    double
     * <p>
     * char类型向更高长度类型（例如整型）转换时，会转换为对应的ASCII码值，再做其他类型的自动转换
     * <p>
     * char 不能和byte short 相互自动转换,应为取值范围问题，简单的可以这样理解，char是没有负数的，而其是有负数的
     */
    @Test
    public void test10() {
        char c = 'A'; // 65
        int num = 10;
        int a = c + num;
        System.out.println(a);
        //=======================
        byte b = 65;
        //byte不能自动转变为 char
        // char bc=b;
        //但是，byte是可以强制转变为char的
        char bc = (char) b;
        System.out.println(" bc=" + bc);
        //=======================
        char c2 = 'A';// 65
        // char 不能自动转变为 short
        // short c2s=c2;
        //但是，char是可以强制转变为short的
        short c2s = (short) c2;
        System.out.println(" c2s=" + c2s);
    }

    /**
     * 特例
     * byte  b  =  65;//可以自动转换
     * int  k =65;
     * byte b2 =k;//不能转换，报错
     * 我们是把一个常量直接赋值给byte变量，由于编译器能识别100，知道在byte范围之内，所以通过编译。
     * byte b2 =k; 在编译时候，k是int型，但它是一个变量，编译器不能知道变量中值是多少，所以不能隐式转换，提示你可能精度损失。
     */
    @Test
    public void test11() {
        byte b = 65;//可以自动转换
        int k = 65;
        //byte b2 = k;//不能转换，报错
    }

    /**
     * 特例：了解
     * 将一个负数强制转变为 char,在将这个char转变为整数，会是什么情况？
     */
    @Test
    public void test12() {
        int i = -65;
        char c = (char) i;
        System.out.println("c=" + c);

        int i2 = c;
        System.out.println("i2=" + i2);

        char c2 = (char) i2;
        System.out.println("c2=" + c2);

    }

    /**
     * 特例了解
     * System.out.println((int) (char) (byte) -1);
     * 它以int数值-1开始，然后从int转型为byte，之后转型为char，最后转型回int。
     * 第一个转型将数值从32位窄化到了8位，第二个转型将数值从8位拓宽到了16位，最后一个转型又将数值从16位拓宽回了32位。
     * 这个数值最终是回到了起点吗？如果你运行该程序，你就会发现不是。它打印出来的是65535，但是这是为什么呢？
     * <p>
     * 该程序的行为紧密依赖于转型的符号扩展行为。
     * Java使用了基于2的补码的二进制运算，因此int类型的数值-1的所有32位都是置位的。
     * 从int到byte的转型是很简单的，它执行了一个窄化原始类型转化（narrowing primitive conversion），直接将除低8位之外的所有位全部砍掉。
     * 这样做留下的是一个8位都被置位了的byte，它仍旧表示-1。
     * <p>
     * 从byte到char的转型稍微麻烦一点，因为byte是一个有符号类型，而char是一个无符号类型。
     * 在将一个整数类型转换成另一个宽度更宽的整数类型时，通常是可以保持其数值的，但是却不可能将一个负的byte数值表示成一个char。
     * 因此，从byte到char的转换被认为不是一个拓宽原始类型的转换，而是一个拓宽并窄化原始类型的转换（widening and narrowing primitive conversion）：byte被转换成了int，而这个int又被转换成了char。
     * <p>
     * 所有这些听起来有点复杂，幸运的是，有一条很简单的规则能够描述从较窄的整型转换成较宽的整型时的符号扩展行为：
     * 如果最初的数值类型是有符号的，那么就执行符号扩展；如果它是char，那么不管它将要被转换成什么类型，都执行零扩展。
     * 了解这条规则可以使我们很容易地解决这个谜题。
     * <p>
     * 因为byte是一个有符号的类型，所以在将byte数值-1转换成char时，会发生符号扩展。
     * 作为结果的char数值的16个位就都被置位了，因此它等于2*E16-1，即65535。
     * 从char到int的转型也是一个拓宽原始类型转换，所以这条规则告诉我们，它将执行零扩展而不是符号扩展。
     * 作为结果的int数值也就成了65535，这正是程序打印出的结果。
     */
    @Test
    public void test13() {
        //=======了解==============
        System.out.println((int) (char) (byte) -0);
        System.out.println((int) (char) (byte) -1);
        System.out.println((int) (char) (byte) -2);
        System.out.println((int) (char) (byte) -3);
        System.out.println((int) (char) (byte) -4);
        System.out.println((int) (char) (byte) -5);
        System.out.println((int) (char) (byte) -6);
    }

    /**
     * 数据类型过长 和 溢出
     * <p>
     * 生产上大的数据运算一定要注意
     */
    @Test
    public void test14() {
        byte b = 127;
        // byte b1=128;// 错误超出范围  -128 到 127

        //===============================
        //获取当前时间 毫秒
        long time = System.currentTimeMillis();
        System.out.println("time=" + time);
        int i = (int) time;
        System.out.println("i=" + i);

        //==============================
        int a = 129;
        byte b2 = (byte) a;
        System.out.println("b2=" + b2); // 结果为  -127
    }

10.java中的常量

　　Java中的常量，常量就是一个固定不变的量（或者值）。例如 123,45,1.2，false等。
　　常见的分类
　　① 整数常量 例如：123 ，250,666
　　② 小数常量 例如：1.2,3.14
　　③ 字符串常量 例如：”12345”
　　④ 字符常量 例如： ‘2’,‘B’
　　⑤ 布尔常量 例如：true ,false

11.java中的变量　

　　1.变量是什么
　　很好理解，从小我们学的数学，x=2,x就是一个变量

　　2.变量的语法

    /**
     * 语法格式： 数据类型 变量名；
     * 注意： 此处的数据类型可以是Java中支持的所有的数据类型，包括自己定义的类型！
     */
    @Test
    public void test1() {
        //先声明再赋值
        int x;
        x = 2;
        //声明的时候同时赋值
        int y = 2;
        //可以重复赋值
        y = 20;
        //使用变量
        int z = x + y;
        System.out.println("z=" + z);
    }

　　3.变量分类
　　1)成员变量
　　直接声明在类中的变量；

　　2)局部变量
　　直接声明在方法内部,比如main方法的形参 或者 大括号中

　　作用域范围：
　　声明在局部区域，例如方法里面大括号的范围内
　　局部变量 必须放在使用的功能语句前面；

　　3)区别
　　a)局部变量在使用之前必须得有值，试想一下一个空变量盒子你用啥呢？
　　b)成员变量系统会分配默认值（默认值意义不大）
　　c)作用域范围不同

　　4)问题
 　　同一个作用域范围之内能不能够有两个名字一样的变量 ， 为什么？
　　

　　5)案例代码

package com.wfd360.com;


import org.junit.Test;

public class Demo {
    //成员变量
    int age = 20;
    //成员变量系统会分配默认值（默认值意义不大），不赋值也可使用
    int age2;

    @Test
    public void test2() {
        //局部变量
        int age = 28;
        String name = "无忌";
        //==============
        int age3;
        //局部变量在使用之前必须得有值,否则报错
        //System.out.println("age3="+age3);
        // age2 为成员变量不赋值也可以使用
        System.out.println("age2=" + age2);
    }

    /**
     * 练习
     * 交换2个变量里面的数据，例如 变量 a= 3;b=5; 交换后则变成：a=5,b=3;
     */
    @Test
    public void test3() {
        int a = 3;
        int b = 5;
        int c = a;
        a = b;
        b = c;
        System.out.println("a=" + a);
        System.out.println("b=" + b);

    }

    /**
     * 语法格式： 数据类型 变量名；
     * 注意： 此处的数据类型可以是Java中支持的所有的数据类型，包括自己定义的类型！
     */
    @Test
    public void test1() {
        //先声明再赋值
        int x;
        x = 2;
        //声明的时候同时赋值
        int y = 2;
        //可以重复赋值
        y = 20;
        //使用变量
        int z = x + y;
        System.out.println("z=" + z);
    }
}

12.java中的表达式

　　

 /**
     * 表达式：
     * 由一系列的 常量  变量  运算符，括号()组成的一个算式，为了按照一定的运算规则计算出结果值
     * 例如： 3+2-5
     */
    @Test
    public void test4() {
        int a = 3;
        int b = 2;
        int c = 5;
        int d = a + b - c;
        System.out.println("d=" + d);
    }