Java SE基础语法

目标

IDE的使用


● IDE(Integrated Development Environment )集成开发环境,是用于 提 供程序开发环境的应用程序,一般包括代码编辑器、编译器、调试器 和图 形用户界面等工具。

● 常用的java开发工具有:

● IntelliJ IDEA

● Eclipse

注释


● 注释对程序功能的说明,以某种特定符号作为标记,程序在运行过程中不会执行注释.

● Java语言有三种注释方式:

// 用于单行注释, 快捷键ctrl+/

/**/ 用于多行注释,快捷键ctrl+shift+/ ctrl+shift+\ 取消注释

/*** */ 文档注释,用于为类,方法(函数),属性 功能进行说明,可在调用时提示.

    /**
     * eat()  吃饭
     */
    public static void eat(){
​
    }
​
    //main是java程序的启动入口    ctrl+/  生成单行注释
    public  static void main(String [] args){
        /*
        *  1111
        *  2222
        *   crel+shfit+/  生成多行注释
        */
        System.out.print("1111");
    }
​

关键字


● 关键字的定义和特点

● 定义:被Java语言赋予了特殊含义,用做专门用途的字符串(单词)

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

  • 用于定义数据类型的关键字:

    class interface enum byte short

    int long float double char

    void boolean

  • 用于定义数据类型值的关键字:

    true false null

  • 用于定义流程控制的关键字:

    if else switch case default

    while do for break continue

    return

  • 用于定义访问权限修饰符的关键字:

    private protected public

  • 用于定义类,函数,变量修饰符的关键字:

    abstract final static synchronized

  • 用于定义类与类之间关系的关键字:

    extends implements

  • 用于定义建立实例及引用实例,判断实例的关键字:

    new this super innstanceof

  • 用于异常处理的关键字:

    try catch finally throw throws

  • 用于包的关键字:

    package import

  • 其他修饰符关键字:

    native strictfp trransient volatile assert

标识符


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

●定义合法标识符规则(语法强制要求):

  • 由26个英文字母大小写,0-9 ,_或 $ 组成 数字不可以开头。

  • 不可以使用关键字和保留字,但能包含关键字和保留字。

  • Java中严格区分大小写,长度无限制。

  • 标识符不能包含空格。

  • 注意:在起名字时,为了提高阅读性,要尽量有意义,“见名知意”。

●Java中的名称命名规范(约定):

  • 包名:多单词组成时所有字母都小写:xxxyyyzzz

  • 类名、接口名:多单词组成时,所有单词的首字母大写: XxxYyyZzz

  • 变量名、方法名:多单词组成时,第一个单词首字母小写,第二 个单词开始每个单词首字母大写:xxxYyyZzz

  • 常量名:所有字母都大写。多单词时每个单词用下划线连接: XXX_YYY_ZZZ

Java变量


●变量是程序中最基本的存储单元,程序执行中数值是可变的.

●本质上,变量其实是内存中的一小块区域,使用变量名来访问这块区域,因此,每一个 变量使用前必须要先申请(声明),然后必须进行赋值(填充内容),才能使用.

●变量是通过使用变量名来访问这块区域的.

● 其要素包括变量名,变量类型。

● Java程序中每一个变量都属于特定的数据类型,在使用前必须对其声明,声明格式为:

[修饰符] type varName =value……];Java 基本数据类型 ;

public  static  void  main(String[] args){      
    int a = 10;      
    int b = 5;          
    a = 15;      
    System.out.print(a+b);      
    int c;      
    //int x,y,z;      
    int x=10,y=5,z=20;
}

Java基本数据类型


● 程序中对于每一种数据都定义了明确的具体数据类型,在内存中分配了不同大小的内存空间。

Java SE基础语法_第1张图片

●整数类型

●Java 各整数类型有固定的表数范围和字段长度,其不受具体操作系统的影响,以 保证Java程序的可移植性。

Java SE基础语法_第2张图片

● Java语言的整型常量默认为int型,声明long型常量可以后加‘ l ’或‘ L ’ .

//int x = 0b11;  0b表示二进制
//int x = 0x11;  0x表示16进制
//int x = 011;   0开头整数  8进制

●浮点类型

●与整数类型类似,Java浮点类型有固定的表数范围和字段长度,不受平台 影响。 Java 浮点类型有两种表示形式

  • 十进制形式,例如:3.14 314.0

  • 科学计数法形式,如:3.14e2 3.14E2

  • Java SE基础语法_第3张图片

Java 浮点型常量默认为 double 型(双精度),如要声明一个常量为 float 型(单精度),则需在数字后面加 f 或 F

*/
float f=10.1234567891f;
System.out.println(f);
/*

●逻辑型boolean(布尔)

●boolean 类型适于逻辑运算,一般用于程序流程控制 。

● java语言中boolean 类型数据只允许取值 true 或 false 。

● 注意:不可以0或非 0 的整数替代false和true,这点和C语言不同。

/*   
    boolean 逻辑值   只能用true  false两个关键字表示
*/
boolean t = true;
boolean t1 = false;
boolean t2 = f

●字符型char char 型数据用来表示一个单个字符.

'a' 单引号表示

" " 双引号表示字符串 字符串也是由一个一个字符组成

● char占2字节.

●用单引号括起来

●例如: char c1 = 'a'; ●char c2 ='中';

●可以涵盖世界上所有书面语的字符。

●char运算 char类型是可以运算的因为char在字符编码表中有对应的数值。

计算机之所以能够显示字符,底层会有一个对照表(编码表)

字符 a --- 97 --- 二进制

●在JAVA中,对char类型字符运行时,直接当做对应编码表的整数来对待。char c=‘a’+1; 先将’a’提升为int,计算结果98,对应的字符是b。

char c = 'a';
//String s = "abcd";// 'a' 'b' 'c' 'd' 
System.out.println(c+0);//字符型可以参与算数运算
char z = '中';
System.out.println(z+0);//20013

基本数据类型转换

●java中可以从任意基本类型转型到另外的基本类型

●例外 : boolean 类型不可以转换为其他的数据类型。 ●转换分为默认转换和强制转换

●默认转换 :整形,字符型,浮点型的数据在混合运算中相互转换,转换时遵循以下原则: 容量小的类型默认转换为容量大的数据类型;数据类型按容量大小排序为: byte,shor t,char->int->long->float->double byte,short,char之间不会互相转换,他们三者在计算时首先会转换为int类型 强制转换

●容量小 ----> 容量大 默认会自动转换 byte,short,char-->int

●容量大 ----> 容量小 默认不能进行转换 可以强制类型转换: 可能会出现问题: 数据溢出,精度降低

●有多种类型的数据混合运算时,系统首先自动的将所有数据转换成容量最大的那一 种数据类型,然后再进行计算。

byte  a = 127;
short b = a;
short c  = 258;
byte  d = (byte)c;
System.out.println(d);

●long类型与float类型的大小

●float在内存中占用的是4个字节的空间,而long型占用的是8个字节的空间。可是为什么4个字节的float型的最大值会大于long型的最大值呢?

● long整型数,在内存中占用8个字节共64位,它表示的数值有2的64次方,平分正负,数值范围是负2的63次方到正2的63次方-1。

● 而float在内存中占4个字节,共32位,但是浮点数在内存中是这样的:

● V=(-1)^s * M * 2^E

●浮点数的32位不是简单的直接表示大小,而是按照一定的标准分配的。

● 其中第1位,符号位,即S。

● 接下来的8位,指数域,即E。

● 剩下的23位,小数域,即M。

● 也就是说,浮点数在内存中的二进制值不是直接转换为十进制数值的,而是按照上述公式计算而来,通过这个公式,虽然只用到了4个字节,但是浮点数却比长整型的最大值要大。

long e  = 10; //8 64  
float f = e;  //4  32  由于小数二进制底层存储结构与整数不同  4字节float表示的范围大于8字节long  
float g = 10.5f;  
long  h = (long)g;  System.out.println(h);
//  long x = d+g;  在混合运算时,自动将容量小的转为容量大的

运算符


Java语言支持如下运算符

算术运算符

  • 算数运算符:+,-,*,/,%,++,--

  • 字符串连接运算符:+

Java SE基础语法_第4张图片

   

 int a = 10;
         int b = 5;
        System.out.println(a+b);//15
        System.out.println(a+'a');//107   数值+字符(十进制编码)
        System.out.println(a+"abc");//10abc 
        System.out.println(a-'a');//-87  'a'---97
        
          int x=5;
          x++;//x=x+1
          ++x;//x=+1
          System.out.println(x);//7
​
        int y = x++ + 1;  //在混合运算时,++在后 先运算 后++
        System.out.println(y);//6  
        System.out.println(x);//6     
        int y = ++x + 1; //++在前面  先++, 后运算
        System.out.println(y);// 7
        System.out.println(x);// 6

关系(比较)运算符

  • 关系(比较)运算符: >,<,>=,<=,==,!=

  • 比较运算符的结果都是boolean型,也就是要么是true,要么是false。

注意:比较运算符“==”不能误写成“=”。

Java SE基础语法_第5张图片

int  a = 10;
int  b = 5;
System.out.println(a>b);//true
System.out.println(a>'a');//false 数值 与 数值   数值与字符
boolean c   = true;
boolean d = false;
System.out.println(c==d);//false
System.out.println(c!=d);//true
String s = "abc";
String s1 = "abc";
System.out.println(s==s1);//true
System.out.println(s!=s1);//false

逻辑运算符

  • 逻辑运算符: !,& , | , &&,||   ^

  • Java SE基础语法_第6张图片

  • “&”和“&&”的区别:

  • 单&时,左边无论真假,右边都进行运算;

  • 双&时,如果左边为真,右边参与运算,如果左边为假,那么右边不参与运算

  • “|”和“||”的区别同理,||表示:当左边为真,右边不参与运算。

    int a = 10;   
    int b = 5;   
    int c = 7;  
    // false &  后面的表达式需要继续执行  
    System.out.println(a>b & bb & b>c);//true & false = false  
    System.out.println(ac);//false & false = false  
    System.out.println(b); 
    //  false &&(短路) 后面其他表达式就不执行 
    System.out.println(a>b && bb && b>c);//true && false = false 
    System.out.println(ac);//false && false = false
    System.out.println(b);
    // true | 后面的其他表达式仍需要执行
    // true ||(短路) 后面的其他表达式不需要执行   true
    //! 取反
    //System.out.println(!(a>b));
    //^   相同为false    不同为true
    System.out.println(a>b ^ bb ^ b>c);//true ^ false = true
    System.out.println(ac);//false ^ false = false

赋值运算符

  • 赋值运算符: = ,+ =,- =,* =,/ =

    • 符号:=

    • 当“=”两侧数据类型不一致时,可以使用自动类型转换或使用强制类型转换原则进行处理

    • 扩展赋值运算符: +=, -=, *=, /=, %=

int  a  = 10; 
byte b  = (byte)a;     
     a += b; //a=a+b  
System.out.println(a);
​
short s = 3;     
      //s=s+2;  // s= s(short类型) + 2(int)      
      s += 2; // 隐式转换

Java SE基础语法_第7张图片

条件运算符

  • 语法:

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

  • 条件表达式结果为true,运算后的结果是表达式1; 为false,运算后的结果是表达式2;

/*  条件运算运算符     结果 = (条件表达式)?成立执行:不成立执行 */
int score = 70;
String res=(score>=60)?"及格":"不及格";
System.out.println(res);

位运算符

  • 日常开发中位运算使用相对较少,但是巧妙的使用位运算可以大量减少运行开销, 优化算法.

  • Java SE基础语法_第8张图片

public class Practise {    
public static void main(String[] args) {
    /*
    移位
    */
 int a = 4;                              
// 0000 0100  4        
// 0000 1000  8               
System.out.println(a<<1); //左移       
int b = -6;       
System.out.println(b>>1);//3  -3   有符号的移动  符号不变的        
System.out.println(b>>>1);//3 2147483645   无符号右移  注意负数 移位后,高位补0  
/* 
&             
0000 0011             
0000 0100             
0000 0000 0        
*/           
    int x = 3;           
    int y = 4;        
System.out.println(x&y);        
/*            
0000 0100  任意一个数  &  1            0000 0001            
0000 0000  结果为0 是偶数,不为0为奇数       */        
System.out.println((x&1)==0);//判断奇偶数
    /*
    |            
    0000 0011 3            
    0000 0100 4            
    0000 0111 7         
    */        
 System.out.println(x|y);//7        
    /*           
    ^            
    0000 0011 3            
    0000 0100 4            
    0000 0111 7         
    */          
    System.out.println(x^y);//7          
    //两个变量交换值            
    x = x^y;  //7            
    y = x^y;  // 3 = 7^4            
    x = x^y;  // 4 = 7^3        
    System.out.println(x);                   
System.out.println(y);        
    /*            
    ~ 取反              
    0000 0011 3  y             
    1111 1100 -4 ~y        
    */        
    System.out.println(~y);//-4    
}
}

表达式的运算顺序

Java SE基础语法_第9张图片

控制台输入

  • 使用标准输入串System.in 使用Scanner取得一个字符串或一组数字 在新增一个Scanner对象时需要一个System.in对象,因为实际上还是 System.in在取得用户输入。

  • Scanner的next()方法用以 取得用户输入的字符串; nextInt()将取得的输入字符串转换为整数类型;

  • 同样,nextFloat()转换成浮点型; nextBoolean()转 换成布尔型。

  • Scanner s = new Scanner(System.in);  
    System.out.println("请输入学号");  
    int num =  s.nextInt();//输入一个整数,程序执行到nextInt()时,进入阻塞状态,按回车键表示输入完成  
    System.out.println("请输入姓名");  
    String name = s.next();  
    System.out.println(num);  
    System.out.println(name);

条件语句


  • 条件语句 - 根据不同条件,执行不同语句。

  • if

    • if .. else

    • if .. else if

    • if .. else if .. else if .. else

      int num = 2; 
      if(num>3) {     
          System.out.println("num>3");  
      }  
      if(num>3)     
          //有效作用范围只有紧挨着的一行     
          // 不是if的作用范围了
              
      if(num>3&num<6)   
          System.out.println("num>3"); else   
          System.out.println("11111");

  • switch

    switch语句:多分支选择语句,根据表达式的值,来执行多个操作中的一个。

    switch (表达式){

    case value1: 语句序列1;

    [break]; ………… case valueN: 语句序列N;[break];

    [default : 缺省语句;]

    }

    表达式可以是byte、short、int、char、枚举类型。JDK 7以后,可以使用String类型;

    case语句后面只能使用常量表达式;

    case后的值不能重复;

    某个case分支如果没有提供break语句,则继续执行下一个case后的语句;

    当表达式的值与任一case子句中的值都不匹配时,将执行default后面的语句;

    如果没有default子句,则程序直接跳出switch语句。

    int w = 2;switch(w){    
        case 1://case 后面只能是字面量,不能重复的        
     System.out.println("星期一");        
    break; //添加break 终止,  是否添加break,根据实际需要而定    
        case 2:        
    System.out.println("星期二");        
    break;    
        case 3:        
    System.out.println("星期三");        
    break;    
        case 4:        
    System.out.println("星期四");        
    break;    
        default://所有选项都不匹配时,执行default,  否则跳出        
            System.out.println("无效日期");
    }

循环


  • 循环语句功能

    • 在某些条件满足的情况下,反复执行特定代码的功能

  • 循环语句的四个组成部分

    • 循环变量的初始化

    • 循环条件部分

    • 循环体部分

    • 循环变量的更新

  • 循环语句 – 重复执行某些动作

    • while 循环

      进入循环之前进行判断,条件成立才会进入循环体,不成立,不会进入循环体

      while(条件表达式){

      条件成立执行

      }

      int i=0;
      while(i<5){    
          System.out.println(i);
          i++;
      }
      System.out.println("i="+i);

    • do .. while 循环

      先执行循环体,后判断条件是否成立,成立继续执行,不成立就不再进入循环体

      do{

      循环体

      }while(条件表达式);

      int age = 0;
      do {    
          System.out.println("请输入年龄");    
          Scanner scanner = new Scanner(System.in);       
          age = scanner.nextInt();
      }while (age>18);

    • for 循环

      • for 语句为如下形式:

        • for(表达式1; 表达式2; 表达式3){ 语句; … ; }

      • 执行过程

        • 首先计算表达式1,接着执行表达式2,若表达式2的值 = true,则执行循环语句, 接着计算表达式3,再判断表达式2的值;依此重复下去,直到表达式2的值=false.

        •         int i=0;
                  for(i=0;i<5;i+=2){
                      System.out.println(i);
                  }
                  int i=0;
                  for(;i<5;i++){    
                      System.out.println(i);
                  }
          int i=0;
          for(;i<5;){    
              System.out.println(i);    
              i++;
          }
          for(;;){    
              System.out.println("aaa");
          }

  • break & continue

    • break

      • 在switch,循环中使用,表示结束当前的switch,循环

        break 循环标记 结束指定的循环

        for (int i=0;i<10;i++){     
            if(i==5){          
                break;     
            }     
            System.out.println(i); 
        }
        out:for (int i=0;i<10;i++){
            for(int j=0;j<10;j++){
                if(j==5){
                    break out;//只能结束当前所在的循环         
                }    
          System.out.println("j="+j);//01234 01234     
            }     
          System.out.println("i="+i);//0 1 
        }

    • continue

      • 在循环中使用

        表示跳过本次循环

        for (int i = 0; i <10 ; i++) {
            if(i==5){
                continue;           
            }     
            System.out.println(i); 
        }

  • 嵌套循环

    • 将一个循环放在另一个循环体内,就形成了嵌套循环。其中,for ,while ,do…while均可以作为外层循环和内层循环。

    • 实质上,嵌套循环就是把内层循环当成外层循环的循环体。当只有内层循环的循环条件为false时,才会完全跳出内层循环,才可结束外层的当次循环,开始下一次的循环。

    • 结束外层循环

    • 如果需要从多层循环跳出,则需要使用标签,定义一个标签,如label,然后在需要跳出的地方,用break label就行了.

    //乘法口诀表
    public class Practise2 {    
        public static void main(String[] args) {        
            int i=1,j=1;        
            for(i=1;i<10;i++){
                for(j=1;j<=i;j++){
                    System.out.print(i+"*"+j+"="+i*j+" ");            
                }            
                System.out.println();        
            }    
        }
    }

Java SE基础语法_第10张图片

Java中的方法


  • Java的方法类似于其它语言的函数,方法是解决一类问题的步骤的有序组合,方法包含于类或对象中.

  • 方法在程序中被创建,声明格式:

    [访问权限修饰符 修饰符…] [返回值类型] 方法名(形式参数类型 参数名){

    Java语句;… … …

    [return 返回值;]

    }

  • 修饰符:这是可选的,告诉编译器如何调用该方法。定义了该方法的访问类型。

  • 形式参数:在方法被调用时用于接收外界输入的数据。

  • 实参:调用方法时实际传给方法的数据。

  • 返回值:方法在执行完毕后返还给调用它的环境的数据。

  • 返回值类型:事先约定的返回值的数据类型,如无返回值,必须给出返回值类型void。

  • Java SE基础语法_第11张图片

  • Java语言中使用下述形式调用方法:对象名.方法名(实参列表)

  • 实参的数目、数据类型和次序必须和所调用方法声明的形参列表匹配

  • return 语句终止方法的运行并指定要返回的据。

    import java.util.Scanner;
    public class Practise1 {    
        public static void main(String[] args) {        
            Practise1.print();//方法调用 类名.方法名        
            System.out.println("---------------");        
            Practise1.print();        
            Scanner s = new Scanner(System.in);        
            int m = s.nextInt();        
            int n = s.nextInt();        
            int r= Practise1.max(m,n);        
            System.out.println(r);    
        }    
        public static void print(){        
            int i=1,j=1;        
            for(i=1;i<10;i++){            
                for(j=1;j<=i;j++){                
                  System.out.print(i+"*"+j+"="+i*j+" ");            
                }            
                System.out.println();    
            }
        }    
        public static int max(int a,int b){        
            return a>b?a:b;    
        }
    }

    运行结果:

  • Java SE基础语法_第12张图片

你可能感兴趣的:(java,intellij-idea)