Java02基础语法

注释

创建空项目

注释

/**
 * 此为文档注释
 * @Description HelloWorld
 * @Author mingmao
 */
public class HelloWorld {
    public static void main(String[] args) {
        //单行注释
        //输出一个Hello World!
        System.out.println("Hello World!");

        /*
        这是多行注释
        此为Hello World程序
        */
    }
}

有趣的代码注释

 /*
                           _ooOoo_
                          o8888888o
                          88" . "88
                          (| -_- |)
                          O\  =  /O
                       ____/`---'\____
                     .'  \\|     |//  `.
                    /  \\|||  :  |||//  \
                   /  _||||| -:- |||||-  \
                   |   | \\\  -  /// |   |
                   | \_|  ''\---/''  |   |
                   \  .-\__  `-`  ___/-. /
                 ___`. .'  /--.--\  `. . __
              ."" '<  `.___\_<|>_/___.'  >'"".
             | | :  `- \`.;`\ _ /`;.`/ - ` : | |
             \  \ `-.   \_ __\ /__ _/   .-` /  /
        ======`-.____`-.___\_____/___.-`____.-'======
                           `=---='
        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
                 佛祖保佑       永无BUG
        */

标识符和关键字

标识符（identifier）是指用来标识某个实体的一个符号，在不同的应用环境下有不同的含义。在计算机编程语言中，标识符是用户编程时使用的名字，用于给变量、常量、函数、语句块等命名，以建立起名称与使用之间的关系。标识符通常由字母和数字以及其它字符构成。

Java关键字是电脑语言里事先定义的，有特别意义的标识符，有时又叫保留字，还有特别意义的变量。Java的关键字对Java的编译器有特殊的意义，他们用来表示一种数据类型，或者表示程序的结构等，关键字不能用作变量名、方法名、类名、包名和参数。

数据类型

八大基本数据类型的定义与赋值：

public class DateType {
    public static void main(String[] args) {
        //八大基本数据类型

        //整数
        int num1=10; //最常用,默认
        byte num2=20;
        short num3=30;
        long num4=40L;  //long类型要在数字后面加L

        //浮点数
        float num5=10.2F; //float类型要在后面加F或f
        double num6=23.45; //最常用，默认

        //字符
        char cha='A';  //char类型只能有一个字符,必须是单引号
        char cha2='中';
        //字符串--引用数据类型,不是关键字，是一个类
        String str="中国";  //可以有多个字符，必须是双引号

        //布尔类型
        boolean flag=true; //只有两个值，true或false
        boolean flag1=false;

        

    }
}

基本数据类型拓展知识：


public class DateType {
    public static void main(String[] args) {
        //拓展内容
        //整数拓展 进制 二进制0b 八进制0 十进制 十六进制0x
        int i1=0b10; //二进制
        int i2=10; //十进制
        int i3=010; //八进制
        int i4=0x10; //十六进制

        System.out.println(i1);  //2
        System.out.println(i2);  //10
        System.out.println(i3); //8
        System.out.println(i4); //16

        //浮点数拓展：
        //float 有限的 离散的 有舍入误差
        /*
        因此不要使用浮点数进行比较，使用BigDecimal类进行浮点数的比较
        不要使用浮点数进行比较，使用BigDecimal类进行浮点数的比较
        不要使用浮点数进行比较，使用BigDecimal类进行浮点数的比较
         */
        float f=0.1f;
        double d=1.0/10;

        System.out.println(f==d);  //false  ?????
        System.out.println("f="+f); //f=0.1
        System.out.println("d="+d); //d=0.1

        float f2=233456677890890f;
        float f3=f2+1;

        System.out.println(f2==f3); //true  ?????

        //字符拓展
        char c1='a';
        char c2='中';

        System.out.println(c1); //a
        System.out.println((int)c1); // 97  int 强制类型转换
        System.out.println(c2); //中
        System.out.println((int)c2); // 20013  int强制类型转换

        //所有字符皆是数字，Unicode编码，2字节，16bit,0-65536

    }
}

转义字符


public class DateType {
    public static void main(String[] args) {
       //转义字符
        //  \t 制表符（Tab）
        System.out.println("Hello\tWorld!");
        // \n 换行
        System.out.println("Hello World!\n你好，世界！");
    }
}

数据类型转换

public class DateTypeConversion {
    public static void main(String[] args) {
        //强制类型转换 （类型）变量名 高--低
        //自动类型转换  低--高
        //例1
        int i=128;
        byte b=(byte)i; //强制类型转换
        double d=i; //自动类型转换

        System.out.println(i); //128
        System.out.println(b); //-128 内存溢出
        System.out.println(d); //128.0

        //例2
        System.out.println((int)23.7); //23 精度丢失
        System.out.println((int)-45.36f); //-45 精度丢失

        //例3
        char c='a';
        int i1=c+1;
        System.out.println(i1); //98
        System.out.println((char)i1);//b

        //例4
        //计算较大的数，要注意溢出问题
        //JDK7新特性，较大的数可以用下滑线分割，下划线不会输出
        int money=10_0000_0000;
        int year=20;
        int total=year*money;
        long total2=year*money;
        long total3=year*(long)money;

        System.out.println(total);//-1474836480，溢出
        System.out.println(total2);//-1474836480，溢出，先运算后转换类型
        System.out.println(total3);//20000000000，正确
    }
}

变量常量作用域

public class Variable {
    //属性：变量

    //类变量，加关键字static
    static double d=56.7;

    //实例变量：从属于对象；如果不自行初始化，这个类型的默认值 0 0.0
    //布尔类型默认值：false
    //除了基本数据类型，其他类型的默认值：null
    String name;
    int age;


    //main方法
    public static void main(String[] args) {

        //局部变量:必须声明和初始化
        int i=10;
        System.out.println(i);

        //实例变量
        //变量类型 变量名字=new Variable（）
        Variable v=new Variable();
        System.out.println(v.name);
        System.out.println(v.age);

        //类变量，加关键字static,类变量可直接输出
        System.out.println(d);
    }

    //其他方法
    public void add(){

    }
}

public class Constant {
    //修饰符不区分先后顺序
    static final double PI=3.14;

    public static void main(String[] args) {
        System.out.println(PI);
    }
}

运算符

public class Operator {

    public static void main(String[] args) {
        //+ - * / %
        int a=10;
        int b=20;
        System.out.println(a+b);
        System.out.println(a-b);
        System.out.println(a*b);
        System.out.println(a/b); //0  输出为整数除法的商，余数舍掉
        System.out.println(a%b); //10 输出为整数除法的余数,取余，模运算

        //运算后的数据类型
        //整数类型只要有long，自动转为long，否则都是int
        //整数浮点数混合运算，有double一定为double
        long l=1897654;
        int i=10;
        short s=56;
        byte b1=8;

        System.out.println(l+i+s+b1);//long
        System.out.println(i+s+b1);//int
        System.out.println(s+b1);//int

        //关系运算符运算结果：true,false
        int i2=10;
        int i3=20;

        System.out.println(i2==i3);//false
        System.out.println(i2!=i3);//true
        System.out.println(i2>i3);//false
        System.out.println(i2<i3);//true


        //++ 自增 --自减 一元运算符
        int i4=3;
        int i5=i4++;  //i4=3,i5=i4=3, i4=i4+1=4 先赋值后自增
        int i6=++i4; //i4=4,i4=i4+1=5,i6=i4=5 先自增后赋值

        System.out.println(i4);//5
        System.out.println(i5);//3
        System.out.println(i6);//5

        //幂运算，java中没有，借助工具类Math.pow(2,3),2^3
        System.out.println(Math.pow(2,3));

        //逻辑运算符 and && or || not !
        boolean b3=true;
        boolean b4=false;

        System.out.println("b3 && b4:"+(b3 && b4)); //false 都真则真，否则为假 短路运算
        System.out.println("b3 || b4:"+(b3 || b4));//true 都假为假，否则为真 短路运算
        System.out.println("!b3:"+(!b3));//false 真变假， 假变真

        System.out.println("b3 & b4:"+(b3 & b4)); //false 都真则真，否则为假 非短路运算
        System.out.println("b3 | b4:"+(b3 | b4));//true 都假为假，否则为真 非短路运算

        //位运算 效率极高
        /*
        & 同1则1，否则为0  与
         | 同0则0，否则为1  或
        ~ 1变0,0变1  非
         ^ 同为0，不同为1 异或
         << 左移 *2
         >> 右移 /2
        */

        //扩展运算符+= -+ *= /=
        int i7=10;
        int i8=20;
        System.out.println(i7+=i8);//i7=i7+i8
        System.out.println( i7*=i8);//i7=i7*i8

        //字符串拼接 +
        int i9=10;
        int i10=20;
        System.out.println(""+a+b);//1020 字符串拼接
        System.out.println(a+b+"");//30 先运算再拼接

        //三元运算符 ? :
        //x?y:z
        //如果x为true,结果为y,否则为z
        int score=80;
        String type=(score>60)?"及格":"不及格";

        System.out.println(type);

        //运算符的优先级：最好多使用括号

    }
}