JavaSE第二章.基础语法

注释

使用的特定的符号标记的内容,对代码功能的解释

// 单行注释

/*
多行注释
*/

/**
文档注释 用于为类,成员变量,方法的功能进行说明,在调用时可以提示
*/

关键字

java中被赋予特定含义的单词、主要用来修饰包、类、变量、方法

标识符

对包、类、变量、方法等进行命名的字符序列 通俗讲自己可以命名的名称

命名需要遵守规则:

语法强制规范:

大小写字母,数字,下划线 $

数字不能开头；不能是关键字；不能有空格；区分大小写

Java变量

程序中基本的存储单元,运行时值可变.

声明变量:

[修饰符] 数据类型 变量名 [=值];

数据类型

基本数据类型：byte、short、int、long、float、double、char、boolean

引用数据类型

基本数据类型转换

基本数据类型之间的转换

除了boolean型,其他7种之间可以进行相互转换

默认转换
byte,short,char–>in–>long–>float–>double
容量小的数据类型 默认自动转为容量大的

容量大的 转为 容量小的
可以强制类型转换
会出现问题：数据溢出、精度损失

public class Demo5 {

    public static void main(String[] args) {
          byte b=127;
          int c= 2147483647;
          long d = c;
          float f = d;

          int x = 258;
          byte y = (byte)x;
        System.out.println(y);

          float m = 10.5F;
          long n = (long)m;
        System.out.println(n);

    }

算术运算符

算术运算符
+ - * / % ++ --
+ 加法  字符串连接
- * / % 只能进行算数运算

int i = 1;
i=i++;
sout(i)=1

public class OperateDemo1 {
    //java程序的入口/主方法/主线程
    public static void main(String[] args) {
             int a = 10;
             int b = 5;
             char c  = 'd';//100
             String d = "100";
             String e = "aa";
        System.out.println(a+b);
        System.out.println(a+c);//整数+char(int)
        System.out.println(a+b+d);// 数值+(连接)字符串==字符串
        System.out.println(d+e);//字符串+字符串=字符串
        System.out.println(a-b);
        System.out.println(a-c);
        //System.out.println(a-d);

        //++  每++一次 在原来的基础上+1 再赋值
        //单独使用时++在前/后没有区别,在混合运算时++在前先自增后运算,反之则先运算后自增
        // --
        int x = 5;
            //x++;//x=x+1  6
            //++x;//x=x+1  7
        //int y = x++;
        int y = ++x;
        System.out.println(x);//6
        System.out.println(y);//6
    }
}

比较运算符

/*
   比较运算符
   ==
   !=  数值,布尔,引用类型
   > < >= <= 适用于数值类(char)
   instanceof 类型检测
 */
public class OperateDemo2 {

    //java程序的入口/主方法/主线程
    public static void main(String[] args) {
        //==
        int a = 10;
        int b = 5;
        boolean c = true;
        boolean d = false;
        String e = "abc";
        String f = "efg";
        System.out.println(a==b);
        System.out.println(c==d);
        System.out.println(e==f);
        //!=
        System.out.println(a!=b);
        System.out.println(c!=d);
        System.out.println(e!=f);

       /* System.out.println(e>f);
        System.out.println(c>e);*/

        Object x = 10;
        //Object类型可以表示任何类型,但是实际表示的是哪种类型呢?
        System.out.println(x instanceof Integer);
    }
}

逻辑运算符

/*
    逻辑运算符
     &       |        !     ^  可以参与逻辑运算还可以参与位运算
     逻辑运算: true & false
     位运算: 二进制bit位运算  6 & 3

     &&(短路与)   ||(短路或)

 */
public class OperateDemo3 {

    //java程序的入口/主方法/主线程
    public static void main(String[] args) {
         int a = 10;
         int b = 5;
         int c = 6;
         int d = 20;

       /* //& 左右都为true 结果为true  遇到第一个false时,后面的表达式继续执行
        System.out.println(a>b&b<c);//true & true = true
        System.out.println(a>b&b>c);//true & false = false
        System.out.println(a<b&b>c);//false & false = false

        //&&左右都为true 结果为true   遇到第一个false时,就发生短路,后面的表达式就不在执行了
        System.out.println(a>b&&b<c);//true && true = true
        System.out.println(a>b&&b>c);//true && false = false
        System.out.println(a<b&&++b>c);//false && false = false
        System.out.println(b);*/

        //| 只要有一为true 结果为true
        System.out.println(a>b|b<c);//true | true = true
        System.out.println(a>b|b>c);//true | false = true
        System.out.println(a<b|b>c);//false | false = false

        //||只要有一为true 结果为true 只要遇到第一个true 后面的表达式就不行了
        System.out.println(a>b||b<c);//true || true = true
        System.out.println(a>b||++b>c);//true || false = true
        System.out.println(a<b||b>c);//false || false = false
        System.out.println(b);

       /* //!
        System.out.println(!(a>b));
        
        //^  异或运算  相同为false  不同为true
        System.out.println(a>b^b<c);//true ^ true = false
        System.out.println(a>b^b>c);//true ^ false = true
        System.out.println(a<b^b>c);//false ^ false = false*/
    }
}

赋值运算

/*
   赋值运算符
   =  注意在赋值时,值的类型与声明的变量类型一致.
      牵扯到数据类型的转换(基本类型之间) 自动转换,强制转换
   扩展赋值运算
   +=
   -=
   *=
   /=
   %=
 */
public class OperateDemo4 {

    //java程序的入口/主方法/主线程
    public static void main(String[] args) {

         byte a = 12;//隐式的将int12 转为 byte
         int b = a;
         short c = (short)b;

         float d = 10.5f;
         int e = (int)(c+b+d);//混合运算时,数据类型默认会转为表达式中最大的类型

       /* int x = 5;
        long y = 10;
            x += y; // x=x+y
        System.out.println(x);*/

        short s = 3;
              //s=s+2; s = short+ int = int
              s+=2;//隐式转换 short + int = short


    }

条件运算符

/*
     条件运算符(3元运算符)
      类型  结果 = (条件表达式)?表达式1:表达式2
       必须返回一个结果,结果的类型与定义结果类型一致

      if(条件){
        ssss
      }else{
        ssss
      }
 */
public class OperateDemo5 {

    //java程序的入口/主方法/主线程
    public static void main(String[] args) {

         int score = 70;

        String res = (score>=60)?"考试及格":"挂科";
        System.out.println(res);

    }
}

位运算

/*
    位运算符, 二进制的bit位的运算
    <<
    >>
    >>>
    &
    |
    ^
    ~
 */
public class OperateDemo6 {

    //java程序的入口/主方法/主线程
    public static void main(String[] args) {
       // <<  010  左移1位  100  乘法
       //int a  = 2;
        //System.out.println(a<<2);

        //带符号
       //>> 0000 0011 右移 1位
       //>> 1000 0011 右移 1位
       //int b = -6;
        //System.out.println(b>>1);

        //>>> 无符号右移 0100 0011 右移 1位  最高位只需要补0
        //System.out.println(b>>>1);

        /*
          & 按位与
            0000 0110
          & 0000 0011
                 0010
         */
        /*int a = 6;
        int b = 3;
        System.out.println(a&b);*/


         /*
          | 按位或
            0000 0110
          | 0000 0011
                 0111
         *//*
        int a = 6;
        int b = 3;
        System.out.println(a|b);*/

        /*
          ^ 按位或
            0000 0110
          ^ 0000 0011
                 0101

           0000 0101
           0000 0110
                0011
         */
        int a = 6;
        int b = 3;

            a=a^b;
            b=a^b;
            a=a^b;
        System.out.println(a);
        System.out.println(b);


        //~  按位取反
    }

表达式的运算顺序

控制台输入

System.out.println("请输入");
Scanner scanner = new Scanner(System.in);
int a =scanner.nextInt();
System.out.println("你输入的数据为:"+a);

条件控制

if

​ if…else

​ if…else if…else

switch

Java5以前switch(expr)中，expr 只能是 byte、short、char、int
从Java 5开始，Java中引入了枚举类型
从Java 7开始，expr还可以是String，但是long在目前所有的版本中都是不可以的。

int i = 5;
        switch (i){
            case 5:
                System.out.println("是个5");
                break;
            case 10:
                System.out.println("是个10");
                break;
            case 4:
                System.out.println("是个4");
                break;
            default:
                System.out.println("默认值");
                break;
        }

循环语句

while

属于前测试循环语句，也就是说，在循环体内的代码被执行之前，就会对出口条件求值。其实就是先与while里面的条件进行判断，成立就走循环体内的代码，不成立就不走循环体内代码。循环体内的代码有可能永远不会执行。

do while

后测试循环语句，即只有在循环体中的代码执行之后，才会测试出口条件。其实就是，代码在刚开始执行的时候，都是要先走一遍do循环体内的代码，然后在与while里面的条件进行判断，成立循环就一直继续下去，不成立就跳出循环。循环体内代码至少被执行一次。

for

for(表达式1,表达式2,表达式3){语句}

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

			public static void main(String[] args) {
                int x = 1;
                for(show('a'); show('b') && x<3; show('c')){
                    show('d');
                    x++;
                }
            }

            public static boolean show(char ch){
                System.out.print(ch);
                return true;
            }

结果:abdcbdcb

break

break 语句用于终止某个语句块的执行。用在循环语句体中，可以强行退出循环；

int stop = 4;
        for (int i = 1; i <=10 ; i++) {  //当i等于stop时跳出循环
            if(i==stop){
                break;
            }
            System.out.print(i);
        }

结果:123

continue

continue 语句用在循环语句体中，用于终止某次循环过程，跳过循环体中continue 语句下面未执行的循环，开始下一次循环过程；

int stop = 4;
        for (int i = 1; i <=10 ; i++) {  //当i等于stop时跳过该次循环
            if(i==stop){
                continue;
            }
            System.out.print(i);
        }

结果:1235678910

java方法

• Java的方法类似于其它语言的函数，方法是解决一类问题的步骤的有序组合, 方法包含于类或对象中.
• 方法在程序中被创建，声明格式：
  [访问权限修饰符 修饰符…] [返回值类型] 方法名(形式参数类型 参数名){
  Java语句；… … …
  [return 返回值;]
  }

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

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

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

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

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

19.return

return语句用于从当前执行的方法中退出, 返回到调用该方法的语句处继续执行。

有两种格式:

return 表达式; //将表达式的值返回

return; //不返回任何值，当方法说明中用void声明无返回值时, 可以使用这种格式，此类return语句有时可省略