JAVA基础一

朱言蹊
2021-06-21 / 0 评论 / 74 阅读 / 正在检测是否收录...
温馨提示:
本文最后更新于2021年06月21日,已超过168天没有更新,若内容或图片失效,请留言反馈。

总结一下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类型。

  1. 双精度

    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
  1. 变量是有自己的作用范围,变量的有效范围为:定义的一对大括号内.

错误演示:

/**
* 变量使用注意事项演示
* 错误演示:变量有效范围
*/
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 个错误
  1. 变量不能重复定义

错误演示:

/**
* 变量使用注意事项演示
* 错误演示:变量不能变量重复定义
*/
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
  1. 数据类型

    /**
    * 数据类型演示
    */
    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个为空。

  1. 字符串类型演示

    /**
    * 字符串,引用类型
    * 常量:字符串,""双引号包裹起来
    * 注意:字符串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。

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

  1. 赋值运算符

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

赋值运算符的使用如下:

运算符        运算规则        范例        结果
=             赋值           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

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

  1. 比较运算符

比较运算符,又叫关系运算符,它是用来判断两个操作数的大小关系及是否相等关系的,结果是布尔值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
  1. 逻辑运算符

逻辑运算符,是用于布尔值进行运算的,结果为布尔值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)。
  1. 三目运算符

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

例如:
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
1

评论 (0)

取消