【Java基础】Java语言基本语法

目录:

• 关键字保留字
• 标识符
• 变量
• 运算符
• 程序流程控制

一、关键字和保留字

      关键字:被Java语言赋予了特殊含义,用于专门用途的字符串(单词).

      特点:关键字中的所有字母都为小写

   

 

      注意：※标识的本质上不算关键字,但可以当做关键字来使用.现阶段只需要记住就可以了.

      保留字:现有的Java版本尚未使用,但以后的版本可能作为关键字来使用,在进行变量命名时,应          避免使用这些保留字.(goto const

二、标识符

     标识符:Java对各种变量、方法、类等要素进行命名时,使用的字符序列称为标识符

     技巧:凡是可以自己起名字的地方都叫做标识符

    

     定义合法标识符的规则(熟记):如果不遵守上面的规则,编译不通过,需要严格遵守!

• 由字母(大小写)、数字(0-9)、下划线或$组成 
• 数字不可以开头   
• 不可以使用关键字和保留字,但可以包含关键字和保留字
• Java中严格区分大小写,长度没有限制
• 标识符不能包含空格

   Java中的名称命名规范:-->如果不遵守如下的规范,编译可以通过！建议遵守
  
  包名：多单词组成时所有字母都小写,xxxyyyzzz
  类名、接口名：多单词组成时,所有单词的首字母大写,XxxYyyZzz(大驼峰)
  常量名、方法名：多单词组成时,第一个单词首字母小写,第二个单词开始每个单词首字母大写，                                   xxxYyyZzz（小驼峰）
  常量名：所有字母都大写,多单词时每个单词用下划线连接,XXX_YYY_ZZZ

代码演示:

public static void main(String[] args) {
		// TODO Auto-generated method stub

		//int myNamber=1001;
		//System.out.println(myNamber);
		int mynamber=1002;
		System.out.println(mynamber);
		
		//int 学号=1003;
		//System.out.println(学号);
	}

注意1：在起名字时,为了提高阅读性,要尽量有意义,“见名知意”.
注意2：Java采用unicode字符集,因此标识符也可以使用汉字声明,但是不建议使用 

三、变量

     变量:

       >内存中的一个存储区域

       >该区域的数据可以在同一类型范围中不断变化

       >变量是程序中最基本的存储单元,包含变量类型 变量名 存储的值

     

    变量的作用:

       >用于在内存中存储数据

   

  使用变量时的注意点:

       > Java中的每个变量都应该先声明再使用

       > 使用变量名来访问这块区域的数据

       >变量的作用域:其定义的一对{}内  

       > 变量只有在作用域内才有效

       >同一个作用域内,不能定义重名的变量

代码演示:

public class VariableTest {

	public static void main(String[] args) {
		// TODO Auto-generated method stub

		//变量的定义
		int myAge=12;
		//变量的使用
		System.out.println(myAge);
		
		//编译错误：使用myNumber之前并未定义过myNumber
		//System.out.println(myNumber);
		
		//变量的声明
		int myNumber;
		
		//编译错误：使用myNumber之前并未赋值过myNumber
	    //System.out.println(myNumber);
		
	    //变量的赋值
	    myNumber=1001;
	    
	    //编译不通过
	    //System.out.println(myClass);
	    
	    //不可以再同一个作用域内定义同名的变量
	    //int myAge=22;
	}

	public void method() {
		int myClass=1;
	}

}

//class VariableTest{} //逆向思维 反证法

反推:为什么不能定义两个同名的变量?

          编译时会生成两个同名的字节码文件,这在任何系统下都是不允许的

Java中定义的数据类型:

       >按照变量的数据类型来分:

             基本数据类型：
                 整型：byte\short\int\long
                 浮点型：float\double
                 字符型:char
                 布尔型:Boolean

            引用数据类型:

                 类(class)
                 接口(interface)
                 数组(array)

    >按照变量在类中声明的位置来分:

           成员变量

           局部变量

代码演示:

  1.整型

        //1.整型：byte(1个字节=8bit)\short(2个字节)\int(4个字节)\long(8个字节)
	    // byte范围:-128~127
		byte b1=12;
		byte b2=-128;
		//b2=128;//编译不通过
		System.out.println(b1);
		System.out.println(b2);


        short s1=128;
		int i1=1234;
		long l1=341453225L;
		System.out.println(l1);

注意:

      1. 一个字节所能表示数的范围是-128~127  b2保存的数值超出了这个范围

      2.定义long型变量时,必须以"l"或"L"结尾

      3.通常定义整型变量时,使用int型

2.浮点型:带小数点的数值    float(4个字节)\double(8个字节)

        double d1=123.3;
		System.out.println(d1+1);
		
		float f1=12.3f;
		System.out.println(f1);
		

 注意:

        1.float表示的数值范围比long还大

        2.定义float类型的变量时,变量要以"f"或"F"结尾

        3.通常定义浮点型变量时,使用double型

3.字符型：char(1个字符=2个字节)

        char c1='a';
		c1='A';
		//编译不通过
		//c1='AB';
		System.out.println(c1);
		
	    char c2='1';
	    char c3='中';
	    char c4='そ';
	    System.out.println(c2);
	    System.out.println(c3);
	    System.out.println(c4);

注意:

       c1='AB'编译不通过的原因是char型变量只能存储1个字符

     

拓展:字符常量的表示方式

        1.声明一个字符

        2.转义字符

        3.直接使用Unicode值来表示字符型常量

        char c5='\n';//换行符
	    c5='\t';//制表符
	    System.out.print("hello"+c5);
	    System.out.println("world");
	    
	    char c6='\u0043';
	    System.out.println(c6);

注意:

       1.需要会使用'\n' ,'\t'

       2.Unicode值不需要记忆,用的时候查相关文档即可

4.布尔型(Boolean)：

        boolean bb1=true;
	    System.out.println(bb1);
	    
	    boolean isMarried=true;
	    if(isMarried) {
	    	System.out.println("你就不能参加\"单身\"party了! \\n很遗憾！");
	    }else {
	    	System.out.println("你可以多谈谈女朋友！");
	    }

注意:

       1.只能取两个值之一: true 、false
       2.常常在条件判断、循环结构中使用

       3.转义字符强化:"单身"在外面嵌套了一对""的情况下是不能输出的,此时需要借助转义字符,通过\把"转义成单纯意义上的''，\\n 不会强制换行,而是输出\n

基本数据类型之间的运算规则:

前提:这里只讨论7种数据类型变量之间的运算,不包含boolean类型.

        1.自动类型提升:

           结论:当容量小的数据类型的变量与容量大的数据类型的变量做运算时,结果自动提升为容量                     大的数据类型

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

          说明：此时的容量大小指的是,表示数的范围的大和小.比如：float容量要大于long的容量

代码演示:

        byte b1=2;
		int i1=12;
		//编译不通过
		//byte b2=b1+i1;
		
		int i2=b1+i1;
		long l1=b1+i1;
		System.out.println(i2);
		
		float f=b1+i1;
		System.out.println(f);
		
		short s1=123;
		double d1=s1;
		System.out.println(d1);//123.0

注意:

        b2=b1+i1编译不通过的原因是等号右边有int型变量,如果强制用一个byte的数据类型接收的             话,可能会造成数据丢失 最少也只能用int型接收.

       d1结果分析:第二步把short类型的变量赋给一个double类型的变量,会进行自动类型提升,提升为double类型.

特殊情况:

        char c1='a';//97
		int i3=10;
		int i4=c1+i3;
		System.out.println(i4);
		
		short s2=10;
		//char s3=s1+s2;//编译不通过
		
		byte b2=10;
		//char c3=c1+b2;//编译不通过
		
		//short s3=b2+s2;//编译不通过
		
		//short s4=b1+b2;//编译不通过

结果分析:

              1).字符在计算机底层存储的是对应的ASCII码值,当和整型数据进行运算时,会转换成对应                     的ASCII码值,然后再进行运算.

              2).特别的: 当byte、char、short三种类型的变量做运算时,结果为int型

     2.强制类型转换:自动类型提升运算的逆运算.

   代码演示:

        double d1=12.9;
		int i1=(int)d1;	//截断操作
		System.out.println(i1);
		
		long l1=123;
		short s2=(short)l1;
		System.out.println(s2);
		
		int i2=128;
		byte b=(byte)i2;
		System.out.println(b);//-128

  结果分析:

                1.当double类型的数据强制转换成int型数据时,会进行截断操作(数据精度丢失),舍去小                      数点后的数字,不会四舍五入.

                2.

String类型变量的使用:

    1 > String属于引用数据类型

    2 > 声明String类型变量时,使用一对""

    3 > String可以和8种基本数据类型做运算,且运算只能是连接运算:+

    4 > 运算的结果仍然是String类型

    

    代码演示:

     

        String s1="Hello world!";
		System.out.println(s1);
		
		String s2="a";
		String s3="";
		
		//char c='';//编译不通过
		
		//**********************
		int number=1001;
		String numberStr="学号: ";
		String info=numberStr+number;// +:连接运算
		boolean b1=true;
		String info1=info+b1;
		System.out.println(info1);

          编译不通过原因分析:声明String类型的变量只能用""

       两个练习:

//练习1：
		char c='a';//97 A:65
		int num=10;
		String str="hello";
		System.out.println(c+num+str);//107hello
		System.out.println(c+str+num);//ahello10
		System.out.println(c+(str+num));//a10hello
		System.out.println((c+num)+str);//107hello
		System.out.println(str+num+c);//hello10a

        //练习2：
		//在控制台上打印* *
		System.out.println("* *");
		System.out.println('*'+'\t'+'*');//93
		System.out.println('*'+"\t"+'*');
		System.out.println('*'+'\t'+"*");//51*
		System.out.println('*'+('\t'+"*"));

  注意:

        1> ‘a’:97  ‘A’:65

        2> 当"+"两端为数字时,进行相加运算

             但"+"有一端为字符串时,进行字符串拼接运算. 

        3> '*'的ASCII码值为42  '\t'的ASCII码值为9  单个字符不会进行拼接运算

        4> 括号的优先级高于括号外的"+",故括号里面的"+"进行字符串拼接运算,得到新的字符串

      //String str1=123;//编译不通过
		String str1=123+"";
		System.out.println(str1);//"123"
		
		//int num1=str1;
		//int num1=(int)str1;
		
		//int num1=Integer.parseInt(str1);
		System.out.println(num1);//123

   注意:字符串类型的变量转换为数字型变量时,需使用Integer类包下的parseXxx方法

【扩展】计算机中不同进制的说明

  对于整数,有四种表示方式:
   1> 二进制(binary):0,1 满2进1,以0b或0B开头
   2> 十进制(decimal):0-9,满10进1.
   3> 八进制(octal):0-7,满8进1,以数字0开头表示
  4> 十六进制(hex):0-9及A-F,满16进1,以0x或0X开头表示,此处的A-F不区分大小写

        int num1=0b110;
		int num2=110;
		int num3=0127;
		int num4=0x110A;
		System.out.println("num1 = "+num1);
		System.out.println("num2 = "+num2);
		System.out.println("num3 = "+num3);
		System.out.println("num4 = "+num4);

四、运算符

    1) 算术运算符

         + - *  / % (前)++ (后)++ (前)-- (后)-- 

下面通过代码方式进行详细介绍:

        //除号:除法运算

		int num1=12;
		int num2=5;
		int result1=num1/num2;
		System.out.println(result1);//2
		
	    int result2=num1/num2*num2;
        System.out.println(result2);//10
        
        double result3=num1/num2;
        System.out.println(result3);//2.0
        
        double result4=num1/num2+0.0;//2.0
        double result5=num1/(num2+0.0);//2.4
        double result6=(double)num1/num2;//2.4
        System.out.println(result5);
        System.out.println(result6);

简要分析:

  1> 很多不熟悉运算符优先级的同学,会误认为result2的结果为12,其实和数学中的加减乘除运算相         似,先乘除后加减，从左到右依次运算,有括号先算括号里面的

  2> result4为什么输出为2.0?

       首先先进行 num1 / num2 运算，得到2

       再和0.0进行加法运算,得到2.0

  3> result5为什么输出为2.4？

       首先先进行括号内的加法运算 ，加号右边是浮点数，相加会进行自动类型提升，得到2.0

       再和num1进行除法运算,得到2.4

       输出2.4的其他方法:把num1和num2相除的结果强转为双精度浮点数即可

// %: 取余运算
        //结果的符号和被模数的符号相同
        //开发中,经常使用%来判断能否被除尽的情况.
        int m1=12;
        int n1=5;
        System.out.println("m1%n1= "+m1%n1);//2
        
        int m2=-12;
        int n2=5;
        System.out.println("m2%n2= "+m2%n2);//-2
        
        int m3=12;
        int n3=-5;
        System.out.println("m3%n3= "+m3%n3);//2
        
        int m4=-12;
        int n4=-5;
        System.out.println("m4%n4= "+m4%n4);//-2
        

        //(前)++:先自增1,后运算
        //(后)++:先运算,后自增1

        int a1=10;
        int b1=++a1;
        System.out.println("a1="+a1+" b1="+b1);
        
        int a2=10;
        int b2=a2++;
        System.out.println("a2="+a2+" b2="+b2);
        
        int a3=10;
        ++a3;//a3++;
        int b3=a3;
        System.out.println("a3="+a3+" b3="+b3);
        
        //注意点:
        short s1=10;
        //s1=s1+1; //编译失败
        //s1=(short)(s1+1);//正确的
        s1++;//自增1不会改变本身变量的数据类型
        System.out.println(s1);
        

        //(前)--:先自减1,后运算
        //(后)--:先运算,后自减1
        
        int a4=10;
        int b5=a4--;//int b5=--a4;
        System.out.println("a3="+a3+" b5="+b5);

码云地址:https://gitee.com/zsm_123