08月31, 2020

JAVA基础语法

总结一下JAVA基础知识如:注释、关键字、标识符、数据类型、变量、数据类型转换等基础语法。初学者可参考看看。

1、程序注释

  1. 单行注释:

    //xxxxxx
  2. 多行注释:

    /* xxxxxx */
  3. 文档注释:

    /** xxxxxx */

2、关键字

关键字:是被Java语言赋予特殊含义,具有专门用途的单词。所有的Java关键词,都是小写。关键词比较多,不用刻意去背,以后用多了自己就记住了。

3、标识符

Java中除了关键字以外基本上都是标识符。我们自己定义的词,比如自己定义的HelloWorld。

标志符命名规则:

标志符组成:字母、数字、下划线、美元符号
字母:a~z、A~Z
数字:0-9 
下划线:_ 
美元符号:$

注意:不能数字开头,不能是关键字,严格区分大小写,不限制长度起名时,尽量达到见名知意。

4、数据类型

数据类型分为基本数据类型和引用数据类型。

A、基本数据类型:4类8种(4类展开后共8种基本类型),基本数据类型是JAVA中内置的类型。

第一类:整型

  1. 字节

    byte   1个字节  二进制位数:8   
    -128~127
  2. 短整型

    short  2个字节  二进制位数:16
    包装类:java.lang.Short 
    最小值:Short.MIN_VALUE=-32768 (-2的15此方)
    最大值:Short.MAX_VALUE=32767  (2的15次方-1)
  3. 整型

    int   4个字节   二进制位数:32
    包装类:java.lang.Integer
    最小值:Integer.MIN_VALUE= -2147483648 (-2的31次方)
    最大值:Integer.MAX_VALUE= 2147483647  (2的31次方-1)
  4. 长整型

    long  8个字节   二进制位数:64
    包装类:java.lang.Long
    最小值:Long.MIN_VALUE=-9223372036854775808 (-2的63次方)
    最大值:Long.MAX_VALUE=9223372036854775807 (2的63次方-1)

第二类:浮点型

  1. 单精度

       float   4个字节  二进制位数:32
       包装类:java.lang.Float
       最小值:Float.MIN_VALUE=1.4E-45 (2的-149次方)
       最大值:Float.MAX_VALUE=3.4028235E38 (2的128次方-1)

    注意:必须已“F”结尾,java才认为是float类型,否则默认认为是double类型。

  2. 双精度

       double  8个字节  二进制位数:64
       包装类:java.lang.Double
       最小值:Double.MIN_VALUE=4.9E-324 (2的-1074次方)
       最大值:Double.MAX_VALUE=1.7976931348623157E308 (2的1024次方-1)

    注意:必须以“D”结尾,java中默认的浮点类型是double类型。

第三类:字符型

char 2个字节  二进制位数:16   表示一个字符,如('a','2','家')

注意:用单引号包裹起来,并且其中只能包含一个字符,必须填写。一个汉字=2个字节=16位,所以一个中文字符刚好可以装下。

第四类:布尔型

boolean 1个字节 只有2个值true与false

只记基本数据类型的字节数,以及byte取值范围127~-128即可,其它不用记,一般开发中使用int、double、char、boolean。

B、引用数据类型:分别是数组、类、接口

引用数据是强大的数据类型,它是基于基本数据类型创建的。JavaSE中提供了一个超级类库,类库中包含了近万种引用数据类型。

5、常量

JAVA中数据量分为常量和变量。常量就是不变的数据量,任何数据量都是有其类型的,常量就是整数类型。

整数表示方式有十进制、二进制、十六进制、八进制,它们之间的转换(自行谷歌/百度)。

整数常量是byte、short、int、long中的哪种类型呢?

整数常量可以根据所在范围来确定类型,java中默认的整数类型是int类型。long类型必须添加“L”后缀,java才知道其类型,不加"L",java会将其当作int类型。默认浮点类型为doule类型。float需要加“F”后缀,double需加“D”后缀。

1267:没有L后缀,为int类型,但是超出int范围,会报错。
12L:为long类型.
3.1:没有后缀,所以为double类型。
2.34D:为double类型。
1.45F:为float类型。

6、变量

Java变量应用最多的。内存数据运行时,临时存储数据的地方。变量就是内存中装载数据的小盒子,只能用来存数据和取数据,数据类型定义了就不能改变了,里面的数据可以变化的。

定义变量格式:

数据类型  变量名  数据值
int       num  =  100;

注意:变量必须要有明确的类型,什么类型的变量装载什么类型的数据,同时也要指定变量能装载多大的数据。数据值不指定,不能使用,编译时不会报错,但是运行时会报错。变量名必须满足标识符规则,才能作为变量来使用。

7、字符串

字符串类型,值用""双引号包裹起来,属于引用数据类型。

String str = "Hello World";

注意:字符串Sring不属于基本数据类型,属于JAVA中的引用类型,但是定义、使用和基本数据类型定义类似。

标记一下,后面详细记录String类型

8、变量使用注意事项

  1. 变量定义后可以不赋值,使用时再赋值。不赋值不能使用。

    错误演示:

    /**
    * 变量使用注意事项演示
    * 错误演示:变量没有赋值
    */
    public class ErrorVariable{
        public static void main(String[] args){
            int i;
            System.out.println(i);
        }
    }

    输出结果:

    ErrorVariable.java:9: 错误: 可能尚未初始化变量i
    System.out.println(i);

    正确演示:

    /**
    * 变量使用注意事项演示
    * 正确演示
    */
    public class CorrectVariable{
        public static void main(String[] args){
            int i;
            i = 100;
            int j = 200;
            System.out.println(i);
            System.out.println(j);
        }
    }

    输出结果:

    100
  2. 变量是有自己的作用范围,变量的有效范围为:定义的一对大括号内.

    错误演示:

    /**
    * 变量使用注意事项演示
    * 错误演示:变量有效范围
    */
    public class ErrorVariable2{
        public static void main(String[] args){
            {
                int i = 100;
            }
            System.out.println(i);
        }
    }

    输出结果:

    ErrorVariable2.java:11: 错误: 找不到符号
                    System.out.println(i);
                                       ^
    符号:   变量 i
    位置: 类 ErrorVariable2
    1 个错误
  3. 变量不能重复定义

    错误演示:

    /**
    * 变量使用注意事项演示
    * 错误演示:变量不能变量重复定义
    */
    public class ErrorVariable2{
        public static void main(String[] args){
            int a = 50;
            int a = 30;
        }
    }

    输出结果:

    ErrorVariable3.java:9: 错误: 已在方法 main(String[])中定义了变量 a
                    int a = 30;
                        ^
    1 个错误

变量使用总结:1、变量没有赋值不能使用 2、变量有效范围 3、变量不能重复定义

9、数据类型代码演示

  1. 定义Java八种基本数据类型变量

    /**
    * 定义Java八种基本数据类型变量。
    * 变量只能存一个值,以最后一个值为准。
    */
    public class DataType{
        public static void main(String[] args){
            //字节类型(127~-128) 1个字节
            byte b = 127;
            //短整型 2个字节
            short s = 128;
            //整型 4个字节
            int i =111111;
            //长整型 8个字节
            long l = 22222222222222L;
            System.out.println(b);
            System.out.println(s);
            System.out.println(i);
            System.out.println(l);
    
            //单精度 4个字节
            float f =1.176F;
            //双精度 8个字节
            double d =1.100D;
            System.out.println(f);
            System.out.println(d);
    
            //字符类型 2个字节
            //注意:必须有值,空字符也可以,必须单引号包裹起来。
            char c ='6';
            //char c2 =''; 这个没有值,会报错。
            char c3 =' ';
            System.out.println(c);
            System.out.println(c3);
    
            //布尔类型 1个字节  只有2个值,true和false
            boolean boo = true;
            boolean boo2 = false;
            System.out.println(boo);
            System.out.println(boo2);
        }
    }

    输出结果:

    127
    128
    111111
    22222222222222
    1.176
    1.1
    6
    
    true
    false
  2. 数据类型

    /**
    * 数据类型演示
    */
    public class DemoOne{
        public static void main(String[] args){
            //输出整数 十进制
            System.out.println(50);
            //输出整数 二进制,数字开头oB
            System.out.println(0B11);
            //输出整数 八进制,数字开头0
            System.out.println(0537);
            //输出整数 十六进制,数组开头0X 0-9 A-F
            System.out.println(0XE);
    
            //输出浮点数
            System.out.println(3.2);
    
            //输出布尔数据,只有2个值,true/false
            System.out.println(true);
            System.out.println(false);
    
            //输出字符常量,单引号包裹,只能写1个字符(无论是汉字、数组、字母),都是一个字符。
            //注意:不写也不行,不写会报错,但可以写一个空字符。
            System.out.println('6');
            System.out.println(' ');
    
            //输出字符串。
            //注意:可以什么都不写,就为一个空字符。
            System.out.println("");
        }
    }

    输出结果:

    50
    3
    351
    14
    3.2
    true
    false
    6
    
    

   注意:最后输出的2个为空。

3. 字符串类型演示

   ```java
   /**
   * 字符串,引用类型
   * 常量:字符串,""双引号包裹起来
   * 注意:字符串Sring不属于基本数据类型,属于JAVA中的引用类型,但是定义、使用和基本数据类型定义类似。
   */
   public class StrVariable{
       public static void main(String[] args){
           String str = "Hello World";
           System.out.println(str);
       }
   }

输出结果:

   Hello World

强烈推荐阿里巴巴JAVA开发手册,程序员必备手册。


10、数据类型转换

数据类型转换分为自动转换和强制转换。不同类型的变量是否可以一起运算?答案是可以的,但是需要先进行数据类型转换,再运算。

数据转换遵循原则:

   范围小的数据类型值,可以直接转换为范围大的数据类型值。

   范围大的数据类型值,不可以直接转换为范围小的数据类型值。

各种数据类型按照数据范围从小到大依次列出:

   byte -> short -> int -> long -> float -> double

A:自动类型转换:表示范围小的数据类型转换成范围大的数据类型,这种方式称为自动类型转换。

自动转换格式:

范围大的数据类型 变量 = 范围小的数据类型值;

   /**
   * 数据类型转换
   * 自动转换:取值范围小的数据值,会自动转换成取值范围大的值。
   * 注意:bolean类型不能参与转换
   */
   public class DataTypeConversion{
       public static void main(String[] args){
           //double类型变量
           double d = 10000;  //出现类型自动转换,int自动转换成double
           System.out.println(d);

           int i =100;
           double d2 = i; //出现类型自动转换,int自动转换成double
           System.out.println(d2);

        byte b =10;
        int j = b; //自动类型转换,byte类型自动转换成int类型
        System.out.println(j);
       }
   }

注意:bolean类型不能参与转换

B:强制转换:把数据类型取值范围大的,转换成数据类型取值范围小的。

数据类型强制转换公式:

被转后的数据类型 变量名 = (被转换后数据类型)要被转的数据;

   /**
   * 强制数据类型转换
   */
   public class DataTypeConversion2{
       public static void main(String[] args){
           //double浮点,转成int
           double d = 3.14; 

           //被转后的数据类型 变量名 = (被转换后数据类型)要被转的数据
           int i = (int)d;

        System.out.println(i);

           //类似大桶中的水倒入小桶,水肯定会丢失(精度丢失)
           byte b = (byte)200;
           System.out.println(b);
       }
   }

输出结果:

   3
   -56

注意:强制类型转换,实际开发中没有要求强制转换时,不转换,不然会丢失精度 ,除非要求转换才做强制转换。


11、运算符

运算符分为:算术运算符、赋值运算符、比较运算符、三元运算符。

  1. 算术运算符

    运算符是用来计算数据的符号。数据可以是常量,也可以是变量。被运算符操作的数我们称为操作数。

    算术运算符最常见的操作是将操作数参与数学计算,如下:

    运算符        运算规则        范列        结果 
    +            正号              +3            3
    +            加               2+3            5
    +          字符串连接         "你"+"好"       你好
    -            负号           int a=3;-a    -3
    -            减号            3-1           2
    *            乘                2*3          6
    /            除                5/2          2
    %            取模               5/2          1
    ++            自增       int a=1;a++/++a   2
    --            自减       int b=3;b--/--b   2

    算术运算符演示:

    /**
    * + 加法,连
    * - 减法
    * * 乘法
    * / 除法
    * % 取模(求余数)
    * ++ 自增
    * -- 自减
    */
    public class Operator{
        public static void main(String[] args){
            // + 连接作用,将一个字符串和其他数据连接起来
            // 遇到字符串,变成连"5+4=54"
            // + 任何类型只要和字符串+,所有的数据都变成了字符串。
            System.out.println("5+4="+5+4);
    
            //除法运算
            //java中,整数除法运算最后只会得到整数
            int i = 100;
            int j = 9;
            System.out.println(i/j);
    
            //取模运算,两数相除,获取的余数
            int k =6;
            int m =4;
            System.out.println(k%m);
    
            //++/-- 自增/自减运算
            int a = 3;
            int b = 3;
    
            a++; //变量a自己增加1
            System.out.println(a);
    
            ++b;
            System.out.println(b);
            //======================================================
            //++:写在变量前面,和写在后面的,区别
            int c = 3;
            int d = 3;
            ++c;
            d++;
            //结论:符号写在前面,还是后面,在变量自己独立计算的时候,没有区别。
            //但是变量,要是参与了其它运算,就有区别了。
            //f = e++,++后算,先将e的值赋予f,然后e再自增1.
            //q = ++h,++先算,先将h自增1,后再赋值给q。
            //======================测试============================
            int e = 5;
            int f = e++;
            System.out.println(e);
            System.out.println(f);
    
            int h = 5;
            int q = ++h;
            System.out.println(h);
            System.out.println(q);
    
        }
    }

    输出结果:

    5+4=54
    11
    2
    4
    4
    6
    5
    6
    6

    ++:写在变量前面,和写在后面的,区别:

    符号写在前面,还是后面,在变量自己独立计算的时候,没有区别。但是变量,要是参与了其它运算,就有区别了。

    f = e++,++后算,先将e的值赋予f,然后e再自增1.
    q = ++h,++先算,先将h自增1,后再赋值给q。

    -- 与++类似,不再做说明。

  2. 赋值运算符

    赋值运算符就是为变量赋值的符号。

    赋值运算符的使用如下:

    运算符        运算规则        范例        结果
    =             赋值           int a=2        2
    +=             加后赋值    int a=2,a+=2    4
    -=             减后赋值    int a=2,a-=2    0
    *=             乘后赋值    int a=2,a*=2    4
    /=             整除后赋值    int a=2,a/=2    1
    %=             取模后赋值    int a=2,a%=2    0

    注意:诸如+=这样形式的赋值运算符,会将结果自动强制转成等号左边的数据类型。

    public class Operator2{
        public static void main(String[] args){
            int a = 1;
            a+=4.8;
            System.out.println(a);
    
            int b = 10;
            b%=3.3;  //会先把10转成double 10.0 然后相除余数0.1,去整数0.
            System.out.println(b);
    
            int h = 10;
            //h=h%3.3;  会报 不兼容的类型: 从double转换到int可能会有损失
            System.out.println(h);
    
            int c = 10;
            double d=3.3;
            System.out.println(c/d);
            System.out.println(c%d);
    
            byte m =1;
            //m = m + 1; //出错,会丢失精度,类似把小桶加大桶的水,放到小桶。
            m=(byte)(m+1);//通过强转就可以。
    
            m+=1;//这种加就包含了上面的强转,因此推荐使用+=这种
            System.out.println(m);
        }
    }

    输出结果:

    5
    0
    10
    3.0303030303030303
    0.10000000000000053
    3

    注意:在运算时,都会往类型占有字节大的转换后再运算,除/余数运算,结果去整数。

  3. 比较运算符

    比较运算符,又叫关系运算符,它是用来判断两个操作数的大小关系及是否相等关系的,结果是布尔值true/false。

    运算符        运算规则        范例        结果
    ==            相等于            4==3        false
    !=            不等于            4!=3        true
    <            小于            4<3            false
    >            大于            4>3            true
    <=            小于等于        4<=3        false
    >=            大于等于        4>=3        true

    注意:赋值运算符的=符号与比较运算符的==符号是有区别的:

    赋值运算符的=符号,是用来将=符号右边的值,赋值给=符号左边的变量。

    比较运算符的==符号,是用来判断==符号左右变量的值是否相等的。

    /**
    * 赋值运算符
    */
    public class Operator3{
        public static void main(String[] args){
            int a = 3;
            int b = 4;
            System.out.println(a=b);
            System.out.println(a==b);
            System.out.println(a==3);
            System.out.println(a!=3);
        }
    }

    输出结果:

    4
    true
    false
    true
  4. 逻辑运算符

    逻辑运算符,是用于布尔值进行运算的,结果为布尔值true或false

    运算符        运算规则        范例        结果
    &             与            false&true        false
    |             或            false|true        true
    ^             异或        true^false        true
    !             非              !true         false
    &&            短路与        false&&true        false
    ||            段落或        false||false    true

    逻辑运算符通常是对两个类型数据之间进行计算,结果也是boolean类型。

    /**
    * 逻辑运算符
    */
    public class Operator4{
        public static void main(String[] args){
            //一边是false,运算结果就是false
            System.out.println(false & false);
            System.out.println(false & true);
            System.out.println(true & true);
    
            //一边是true,结果就是true
            System.out.println(false | false);
            System.out.println(false | true);
            System.out.println(true | true);
    
            ////两相同就是false,不同为true
            System.out.println(false ^ false);
            System.out.println(false ^ true);
            System.out.println(true ^ true);
    
            //取反
            System.out.println(!false);
            System.out.println(!true);
    
            //前边是false,后边不运行,结果为false。比&效率高
            System.out.println(false && false);
            System.out.println(false && true);
            System.out.println(true && true);
    
            //前边是true,后边不运行,结果为true。比|效率高
            System.out.println(false || false);
            System.out.println(false || true);
            System.out.println(true || true);
        }
    }

    输出结果:

    false
    false
    true
    false
    true
    true
    false
    true
    false
    true
    false
    false
    false
    true
    false
    true
    true

    重点:

    &与&&区别: 短路与&&,前面不成立(false),后面就不运算了,结果为不成立(false)。
    
    |与||区别: 短路或||,前面成立,后面就不运算了,结果为成立(true)。
  5. 三目运算符

    之前的均为一元或二元运算符,元就是参与运算的数据。

    例如: 3+5,使用算术运算符将操作数联系起来,这种情况,称为:算符表达式。 3>2,使用比较运算符(条件运算符)将操作数联系起来,称为:条件表达式 其它表达式类似。

三目运算符格式:

   (条件表达式)? 表达式1 : 表达式2

   表达式:几通过使用运算符将操作数联系起来的式子。

三目运算符运算规则:

先判断条件表达式的值,为true,结果则为表达式1,为false,结果为表达式2.

   /**
   * 三目运算符
   */
   public class Operator5{
       public static void main(String[] args){
           int a =2;
           int b=6;
           System.out.println(a>b ? a+b : b-a);
           System.out.println(a<b ? a+b : b-a);

           String c = 9>4 ? "Hello" : "呵呵";
           System.out.println(c);
       }
   }

输出结果:

   4
   8
   Hello

本文链接:https://www.yanxizhu.com/post/JAVA basics.html

-- EOF --

Comments