Java基本语法--数据类型、运算符表达式、基本控制语句、数组使用以及练习

java基本语法

1、基本数据类型

1) int:整型，4个字节，-21个多亿到21个多亿

• 1.1) 整数直接量默认为int型，但不能超范围，超范围则编译错误
• 1.2) 两个整数相除，结果还是整数，小数位无条件舍弃
• 1.3) 运算时超范围，则发生溢出，溢出是需要避免的

2) long:长整型，8个字节，很大很大很大

• 2.1) 长整型直接量，需在数字后加l和L
• 2.2) 运算时若有可能溢出，建议在第1个数字后加L
• 2.3) System.currentTimeMillis()用于获取自1970.1.1零时到此时此刻的毫秒数

3) double:浮点型，8个字节

• 3.1) 浮点数直接量默认为double型，表示float需在数字后加f或F
• 3.2) double在运算时，有可能会出现舍入误差，所以精确运算场合不建议使用

4) boolean:布尔型，1个字节

• 4.1) 只能存储true和false

5) char:字符型，2个字节

• 5.1) 采用unicode编码格式，每个字符char对应一个码int表现的形式是char字符，但实质上是int码(0到65535之间)ASCII码(‘a’–97 ‘A’–65 ‘0’–48)
• 5.2) 字符必须放在单引号中，只能有一个
• 5.3) 特殊符号需通过\来转义

1.2 使用

1) int整型

package day02;//声明包名
public class Demo01 {//声明类
    //主方法，为程序的入口 
    //程序的执行从main开始，main结束则程序结束
    public static void main(String[] args) {//主函数
        //1.int:整型，4个字节，-21个多亿到21个多亿
        int a = 250; //250为整数直接量，默认为int型
        //int b = 10000000000; //编译错误，100亿默认为int型，但超出int范围了

        //int型相关运算
        System.out.println(5/2); //控制台输出2
        System.out.println(8/2); //控制台输出4
        System.out.println(2/8); //控制台输出0
        System.out.println(5/2.0); //控制台输出2.5

        int c = 2147483647;//定义int型变量，并赋值
        c = c+1;//运算+1
        System.out.println(c); //-2147483648，溢出了，溢出是需要避免的
    }
}

2) long长整型

package day02;//声明包day02
public class Demo02 {//声明类Demo02
    //主方法，为程序的入口 
    //程序的执行从main开始，main结束则程序结束
    public static void main(String[] args) {//主函数
        //2.long:长整型，8个字节，很大很大很大
        //long a = 10000000000; //编译错误，100亿默认为int型，但超出int范围了
        long b = 10000000000L; //100亿L为长整型的直接量

        //若有可能溢出，建议在第1个数字后加L
        long c = 1000000000*2*10L;
        System.out.println(c); //200亿
        long d = 1000000000*3*10L;
        System.out.println(d); //溢出了
        long e = 1000000000L*3*10;
        System.out.println(e); //300亿

        long f = System.currentTimeMillis();//输出当前系统毫秒
        System.out.println(f); //
    }
}

3) double浮点型

package day02;//声明包名
public class Demo03 {//声明类
    //主方法，为程序的入口 
    //程序的执行从main开始，main结束则程序结束
    public static void main(String[] args) {    
        //3.double:浮点型，8个字节，很大很大很大
        double pi = 3.14; //3.14为浮点数直接量，默认为double型
        float f = 3.14F; //表示float，需在数字后加F或f

        double a=3.0,b=2.9;
        System.out.println(a-b); //0.10000000000000009，舍入误差了，精确场不能使用
    }

}

4) boolean布尔型

package day02;//声明包名
public class Demo04 {//声明类
    //主方法，为程序的入口 
    //程序的执行从main开始，main结束则程序结束
    public static void main(String[] args) {
        //4.boolean:布尔型，1个字节
        boolean b1 = true; //true为布尔型的直接量
        boolean b2 = false; //false为布尔型的直接量
        //boolean b3 = 250; //编译错误，只能取值为true和false
    }
}

5) char字符型

package day02;//声明包day02
public class Demo05 {//声明类Demo02
    //主方法，为程序的入口 
    //程序的执行从main开始，main结束则程序结束
    public static void main(String[] args) {
        //5.char:字符型，2个字节
        char c1 = '女'; //声明字符型变量c1并赋值为字符女
        char c2 = 'f';
        char c3 = '6'; //声明字符型变量c3并赋值为字符6
        char c4 = ' '; //声明字符型变量c4并赋值为空格符
        //char c5 = 女; //编译错误，字符必须放在单引号中
        //char c6 = ''; //编译错误，必须有字符
        //char c7 = '女性'; //编译错误，只能有一个字符

        char c8 = 65; //0到65535之间
        System.out.println(c8); //A

        char c9 = '\'';//转义
        System.out.println(c9); //'
    }

}

6) 变量之间的转换

package day02;//声明包day02
public class Demo06 {//声明类Demo02
    //主方法，为程序的入口 
    //程序的执行从main开始，main结束则程序结束
    public static void main(String[] args) {
        int a = 5; //定义int型变量，并赋值
        long b = a; //自动类型转换
        int c = (int)b; //强制类型转换

        long d = 250; //自动类型转换
        double e = 250; //自动类型转换

        long f = 10000000000L;//定义long型变量，并赋值
        int g = (int)f;//强制类型转换 
        System.out.println(g); //溢出，强转有可能会发生溢出

        double h = 25.98765;//定义double型变量，并赋值
        int i = (int)h;//强制类型转换
        System.out.println(i); //25，强转有可能会丢失精度

        byte b1 = 5;
        byte b2 = 6;
        byte b3 = (byte)(b1+b2);
        System.out.println(b3);//11

        System.out.println(2+2);     //4
        System.out.println(2+'2');   //52，2加上'2'的码50
        System.out.println('2'+'2'); //100
    }

}

2、基本运算符和表达式的使用

1) 求余运算符(%)

package day03;
public class Demo01 {
    public static void main(String[] args) {
        //求余运算符%
        System.out.println(5%2); //1，商2余1
        System.out.println(8%2); //0，商4余0--整除
        System.out.println(2%8); //2，商0余2
        System.out.println(8.5678%2); //0.5678
    }

}

2) 自加自减(++,–)

package day03;
public class Demo02 {
    public static void main(String[] args) {
        //自加自减（++,--）
        int a=5,b=5;//定义int类型变量a,b,并赋值
        a++; //相当于a=a+1
        ++b; //相当于b=b+1
        System.out.println(a); //6
        System.out.println(b); //6

        int c=5,d=5;//定义int类型变量c,d,并赋值
        //1)将c++的值5赋值给e
        //2)c自增1变为6
        int e = c++;
        //1)将++d的值6赋值给f
        //2)d自增1变为6
        int f = ++d;
        System.out.println(c); //6
        System.out.println(d); //6
        System.out.println(e); //5
        System.out.println(f); //6

        int g=5,h=5;//定义int类型变量g,h,并赋值
        //1)输出g--的值5
        //2)g自减1变为4
        System.out.println(g--); //5
        System.out.println(g);   //4
        //1)输出--h的值4
        //2)h自减1变为4
        System.out.println(--h); //4
        System.out.println(h);   //4
    }

}

3) 关系运算符(<,<=,>,>=,==<,!==)

package day03;
    /*
     * 2.关系运算符:
     *   1)>(大于),<(小于)
     *     >=(大于或等于),<=(小于或等于)
     *     ==(等于),!=(不等于)
     *   2)关系运算的结果为boolean型，
     *     关系成立则为true，关系不成立则为false
     */
    public class Demo03 {
        public static void main(String[] args) {
            int a=5,b=10,c=5;//定义int变量a,b,c,并赋值
            boolean b1 = a>b;//boolean类型
            System.out.println(b1);   //false
            System.out.println(c<b);  //true
            System.out.println(a>=c); //true
            System.out.println(b>=a); //true
            System.out.println(a==c); //true
            System.out.println(a!=c); //false
        }

    }

4) 逻辑运算符(&&,||,!)

package day03;
/*
 * 3.逻辑运算符:
 *   1)&&:短路与(并且)，两边都为真则为真，见false则false
 *        ---第一个数为false时，则发生短路(后面的不执行了)
 *     ||:短路或(或者)，有一边为真则为真，见true则true
 *        ---第一个数为true时，则发生短路(后面的不执行了)
 *      !:逻辑非(取反)，非真则假，非假则真
 *   2)逻辑运算是建立在关系运算的基础之上的
 *     逻辑运算的结果也是boolean型
 */
public class Demo04 {
    public static void main(String[] args) {
        int a=5,b=10,c=5;//定义int变量a,b,c,并赋值
        boolean b1 = a>=b && c<b;
        System.out.println(b1);          //false&&true=false
        System.out.println(c<=b && a>b); //true&&false=false
        System.out.println(a==b && c>b); //false&&false=false
        System.out.println(a!=b && a<b); //true&&true=true

        System.out.println(a>=b || c<b); //false||true=true
        System.out.println(c<=b || a>b); //true||false=true
        System.out.println(a!=b || a<b); //true||true=true
        System.out.println(a==b || c>b); //false||false=false

        boolean b2 = !(a>b);
        System.out.println(b2);     //!false=true
        System.out.println(!(a<b)); //!true=false

        boolean b3 = a>b && c++>2;
        System.out.println(b3); //false
        System.out.println(c);  //5，发生短路了

        boolean b4 = a<b || c++>2;
        System.out.println(b4); //true
        System.out.println(c);  //5，发生短路了
    }

}

5) 赋值运算符(=,+=,-=,*=,/=,%=)

package day03;
/*
 * 4.赋值运算符:
 *   1)简单赋值运算符:=
 *   2)扩展赋值运算符:+=,-=,*=,/=,%=
 */
public class Demo05 {
    public static void main(String[] args) {
        int a=2,b=3; //定义int型变量a,b并赋值
        b += a;//+=相当于 b = b+a;
        System.out.println(b);//输出5

        b -= a;//此时b=5,a=2,相当于b = b-a;
        System.out.println(b);//3

        b *= a;//此时b=3,a=2,相当于b = b*a;
        System.out.println(b);//6

        b %= a;//此时b=6,a=2,相当于b = b%a;
        System.out.println(b);//0

    }

}

6) 字符串连接运算符(+)

package day03;
/*
 * 5.字符串连接运算符:
 *   1)+:
 *     1.1)若两边都是数字，则做加法运算
 *     1.2)若两边出现字符串，则做字符串连接
 */
public class Demo06 {
    public static void main(String[] args) {
        System.out.println(10+20+""+30); //"3030"
        System.out.println(10+20+30+""); //"60"
        System.out.println(""+10+20+30); //"102030"

        int age = 37;
        System.out.println("age="); //age=
        System.out.println(age);    //37
        System.out.println("age="+age); //age=37
        System.out.println("我的年龄是:"+age);//我的年龄是:37
        System.out.println("我今年"+age+"岁了");//我今年37岁了
    }
}

7) 三目/条件运算符(boolean?数1:数2)

package day03;
/*
 * 6.三目/条件运算符:
 *   1)语法:
 *       boolean?数1:数2
 *   2)执行过程:
 *       计算boolean的值:
 *         若为true，则整个表达式的结果为数1的值
 *         若为false，则整个表达式的结果为数2的值
 */
public class Demo07 {
    public static void main(String[] args) {
        int a=8,b=55;//定义int变量a,b 并赋值
        int max = a>b?a:b;//boolean?数1:数2
        System.out.println("max="+max);//max=55
    }
}

3、基本控制语句：判断、分支、循环等语句的使用

1) if语句/if..else语句

package day04;
/*
 * if语句/if..else语句
 * if(){}
 * if(){}else{}
 */
public class Demo01 {
    public static void main(String[] args) {
        //if语句
        int a=5,b=6;
        if(a>b) {//判断a是否大于b，若a>b为true，则进入函数体，否则退出if语句
            System.out.println("a大于b");
        }
        System.out.println("退出if语句");

        //if...else语句
        if(a>b) {//判断a是否大于b，若a>b为true，则进入函数体，否则进入else
            System.out.println("a大于b");
        }else {
            System.out.println("a小于b");
        }

        //嵌套使用
        int c=5,d=4,e=7;
        if(c>d) {
            if(c>e) {//判断c是否大于e，若c>e为true，则进入函数体,输出c>d>e
                System.out.println("c>d>e");
            }else {//否则输出d<c<e
                System.out.println("d<c<e");
            }
        }
    }
}

2) switch…case的语句

package day04;
//switch...case的语句
public class Demo02 {
    public static void main(String[] args) {
        int num = 4;//定义变量num，并赋值为4
        switch(num){ //byte,short,int,char
        case 1: //if(num==1)
            System.out.println(111);
            break;
        case 2: //以此为入口
            System.out.println(222);
            break; //跳出switch
        case 3:
            System.out.println(333);
            break;
        default: //所有case都未匹配时执行
            System.out.println(666);
       }
    }
}

3) while语句

package day04;
//while语句
public class Demo03 {

    public static void main(String[] args) {
        int times = 0;   //1.循环变量的初始化
        while(times<10){ //2.循环的条件
            System.out.println("行动是成功的阶梯");
            times++;     //3.循环变量的改变
        }
        System.out.println("over");
    }

}

4) for循环

package day04;
//for循环
public class Demo06 {
    public static void main(String[] args) {
        int sum = 0; //定义临时变量
        for(int i=1;i<=100;i++){//for循环，i逐增1，直到100
            sum = sum+i;//计算和
        }
        System.out.println("sum="+sum);//输出结果
    }

}

5) 成绩等级判断案例

package day04;
//成绩等级判断
import java.util.Scanner;//导包
public class Demo04 {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);//键盘录入
        System.out.println("请输入成绩:");//控制台输出---请输入成绩:
        int score = scan.nextInt();//记录输入的成绩变量

        if(score<0 || score>100){//判断成绩是否合理
            System.out.println("成绩不合法");
        }else if(score>=90){ //score>=0 && score<=100
            System.out.println("A-优秀");//score>=90控制台输出A-优秀
        }else if(score>=80){
            System.out.println("B-良好");//score>=80控制台输出B-良好
        }else if(score>=60){
            System.out.println("C-中等");//score>=60控制台输出C-中等
        }else{
            System.out.println("D-不及格");//其他 控制台输出D-不及格
        }
    }
}

4、 数组的使用

package day04;
//数组的使用
public class Demo05 {
    public static void main(String[] args) {
        //int[] arr = new int[10];
        //数组的定义
        int[] arr1 = new int[4]; //0,0,0,0
        int[] arr2 = {1,4,5,6}; //1,4,5,6
        int[] arr3 = new int[]{1,4,5,6}; //1,4,5,6
        int[] arr4;
        //arr4 = {1,4,5,6}; //编译错误，此方式只能声明同时初始化
        arr4 = new int[]{1,4,5,6}; //正确

        int[] arr = new int[3];
        System.out.println(arr.length);//控制台输出数组的长度（调用.length）
        arr[0] = 100;//给数组中的第一个元素赋值为100
        arr[1] = 200;//给数组中的第二个元素赋值为200
        arr[2] = 300;//给数组中的第三个元素赋值为300
        //arr[3] = 400; //数组下标越界异常
        System.out.println(arr[arr.length-1]);//输出数组中的最后一个元素

        for(int i=0;i<arr.length;i++){
            arr[i] = (int)(Math.random()*100);//生成0-100的随机数并赋值给数组下标为i的元素
            System.out.println(arr[i]);//输出数组中下标为i的元素
        }
    }

}

练习

1. 编制一个java application应用程序，把数组中已知的10个数字由小到大排序后输出

package day04;

import java.util.Arrays;

//编制一个java application应用程序
//把数组中已知的10个数字由小到大排序后输出
public class Demo07 {
    public static void main(String[] args) {
        int[] arr = new int[10];//定义一个10个元素的空数组
        for(int i=0;i<arr.length;i++) {//for循环,遍历数组
            int num =(int)(Math.random()*100);//随机生成0-100的整数
            arr[i] = num;//并赋值给数组下标为i的元素
            System.out.print(arr[i]+" ");//控制台输出，并加上空格
        }
        System.out.println();//转行
//      Arrays.sort(arr);
        rank(arr);//调用rank()函数排序
        for(int i=0;i<arr.length;i++) {//for循环,遍历数组
            System.out.print(arr[i]+" ");//输出每个元素
        }
    }
    //数组排序（由小到大）
    public static int[] rank(int[] arr) {
        for(int i=0;i<arr.length-1;i++) {//控制轮
            for(int j=0;j<arr.length-1-i;j++) {//控制次数
                if(arr[j]>arr[j+1]){ //和它下一个元素比
                    int t = arr[j];//记录一个元素
                    arr[j] = arr[j+1];//交换
                    arr[j+1] = t;//记录的赋给下一个元素
                }
            }
        }
        return arr;//返回排序后的数组
    }

}

还可调用Arrays.sort(arr);

2.编制一个java application应用程序，求3X2+4X-1=0的根

package day04;//包名
import java.util.Scanner;//导包
//编制一个java application应用程序，求3X2+4X-1=0的根
//记ax2+bx+c=0
//由公式可求根：若b*b-4*a*c<0则无实根;>0则有两个实根;=0则有两个相同的实根
public class Demo08 {//类名
    public static void main(String[] args) {//主函数
        Scanner scan = new Scanner(System.in);//键盘录入
        System.out.println("请输入二次方前的系数a:");//控制台输出
        double a = scan.nextDouble();//记录键盘录入的数
        System.out.println("请输入一次方前的系数b:");//控制台输出
        double b = scan.nextDouble();//记录键盘录入的数
        System.out.println("请输入系数c:");//控制台输出
        double c = scan.nextDouble();//记录键盘录入的数
        if((b*b-4*a*c)<0) {//判断(b*b-4*a*c)<0是否成立
            System.out.println("方程无实根");//控制台输出
        }else if((b*b-4*a*c)==0){//判断(b*b-4*a*c)==0是否成立
            System.out.println("方程有一个实根");
            double x1 = ((-b)/(2*a));//计算根并赋值给变量x1
            System.out.println("根为:"+x1);//控制台输出"根为:"+x1
        }else {
            System.out.println("方程有两个实根");
            double x2 = ((-b-Math.sqrt(b*b-4*a*c))/(2*a));//计算根并赋值给变量x2
            double x3 = ((-b+Math.sqrt(b*b-4*a*c))/(2*a));//计算根并赋值给变量x3
            System.out.println("根为:"+x2+"和"+x3);//控制台输出结果
        }
    }
}