Java基础（9）-基础语法-摩杜云开发者社区

1、注释

Java中注释由三种：单行注释、多行注释、文档注释
单行注释以 // 开头，多行注释以 /* 开头，以*/ 结尾，文档注释以 /** 开头，以 */ 结尾，如下：

public class HelloWorld {
     
       
    public static void main(String[] args) {
     
       
        // 这是单行注释：下面打印 Hello World

        /* 这是多行注释 这是多行注释 这是多行注释 这是多行注释 */

        /** * 这是文档注释 * @Description Hello world * @author redrose2100 */
        System.out.println("Hello Word!");
    }
}

2、标识符、关键字

关键字，如下：
标识符：
- 所有的标识符以字母、美元符（$），下划线（_）开头
- 首字符之后可以是字母、数字、美元符、下划线
- 不能使用关键字所为变量名或者方法名
- 标识符是大小写敏感
- 可以使用中文命名，但是一般不建议这么做，也不建议使用汉语拼音
  如：

public class HelloWorld {
     
       
    public static void main(String[] args) {
     
       
        String Hello="Hello";
        String hello="hello";
        String  $hello="hello";
        String _hello="_hello";
        // String 3hello="hello"; 不能以数字开头

        String Man="Man";
        String man="man";
        String 学校="哈尔滨工业大学"; // 中文变量语法上是可以的，但是强烈不推荐
        System.out.println(学校);
    }
}

3、数据类型

强类型语言：要求变量的使用要严格符合规定，所有的变量必须先定义后才能使用
弱类型语言：变量的使用不需要符合严格规定，变量不需要定义，可以直接赋值
Java基本数据类型分为：基本类型和引用类型
基本类型如下：

Java基础（9）-基础语法
如：

public class Demo02 {
     
       
    public static void main(String[] args) {
     
       
        // 整数
        int num1=10;
        byte num2=20;
        short num3=30;
        long num4=30L;

        // 浮点数
        float num5=50.1f;
        double num6=3.141592653589793238462643;

        // 字符
        char name='A';

        // 布尔值
        boolean flag=true;
    }
}

引用类型主要包含：类、接口、数组

数据类型拓展：

public class Demo03 {
     
       
    public static void main(String[] args) {
     
       
        // 整数拓展：二进制 八进制 十进制 十六进制
        int i0=0b10;
        int i1=10;
        int i2=010;
        int i3=0x10;

        System.out.println(i0);
        System.out.println(i1);
        System.out.println(i2);
        System.out.println(i3);

        // 浮点数拓展：浮点数存在舎入误差的问题，在实际开发中，尽量避免使用浮点数去比较，银行业务中绝对不能使用浮点数类型

        float f=0.1f;
        double d=1.0/10;
        System.out.println(f==d);
        System.out.println(f);
        System.out.println(d);

        float d1=2323232323232323f;
        float d2=d1+1;
        System.out.println(d1==d2);

        // 字符拓展:所有字符本质上还是数字
        char c1='a';
        char c2='中';
        System.out.println(c1);
        System.out.println((int)c1);
        System.out.println(c2);
        System.out.println((int)c2);

        char c3='\u0061';
        System.out.println(c3);

        // 转义字符：\t： tab \n： 换行
        System.out.println("Hello\tWorld!");

        // 字符串拓展：
        String sa=new String("hello world");
        String sb=new String("hello world");
        System.out.println(sa==sb);

        String sc="hello world";
        String sd="hello world";
        System.out.println(sc==sd);

        boolean flag=true;
        if (flag==true){
     
       
            System.out.println(flag);
        }
        if (flag){
     
       
            System.out.println(flag);
        }
    }
}

执行结果如下：

2
10
8
16
false
0.1
0.1
true
a
97
中
20013
a
Hello	World!
false
true
true
true

4、类型转换

运算中，不同类型的数据先转化为同一类型，然后进行计算
类型低到高：byte，short,char->int->long->flaot->double
自动类型转换：从低到高，可以自动转换
强制类型转换：从高到低时，不能自动转换，如果要转换，必须强制类型转换
如：

public class Demo05 {
     
       
    public static void main(String[] args) {
     
       
        int i=128;
        // 强制类型转换
        byte b=(byte)i;
        System.out.println(i);
        System.out.println(b);

        System.out.println((int)23.7);
        System.out.println((int)-45.89f);

        char c='a';
        int d=c+1;
        System.out.println(d);
        System.out.println((char)d);
    }
}

执行结果为：

注意点：
- 不能对布尔值进行转换
- 不能把对象转换为不相干的类型
- 在把高容量转换到低容量的时候，需要使用强制类型转换
- 转换的时候可能存在内存溢出，或者精度问题

类型转换举例：

public class Demo06 {
     
       
    public static void main(String[] args) {
     
       
        int money=10_0000_0000;
        int years=20;
        int total=money*years;
        long total2=money*years;
        System.out.println(total);
        System.out.println(total2);
        
        long total3=money*(long)years;
        System.out.println(total3);
    }
}

执行结果如下：

-1474836480
-1474836480
20000000000

5、变量

变量：就是可以变化的量
Java是一种强类型语言，每个变量都必须声明其类型
Java变量是程序中最基本的存储单元，其要素包含变量名，变量类型，作用域
每个变量都有类型，类型可以是基本类型，也可以是引用类型
变量名必须是合法的标识符
变量声明是一条完整的语句，因此每个声明都必须以分号结束

变量的定义：

public class Demo07 {
     
       
    public static void main(String[] args) {
     
       
        // int a=1,b=2,c=3; // 不推荐，推荐使用如下方式
        int a=1;
        int b=2;
        int c=3;
        String name="张三";
        char x='A';
        double pi=3.14;
    }
}

变量的作用域：类变量、实例变量、局部变量

public class Demo08 {
     
       
    // 属性：变量，static 声明的就是类变量
    static double salary=10000;

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

    // 其他方法

    // main方法
    public static void main(String[] args) {
     
       
        // 局部变量：必须声明和初始化值
        int i=10;
        System.out.println(i);

        Demo08 demo=new Demo08();
        System.out.println(demo.name);
        System.out.println(demo.age);
        System.out.println(salary);
    }
}

执行结果如下：

10
null
0
10000.0

6、常量

常量：初始化之后不能再改变的值，不会变动的值
常量可以理解成一种特殊的变量，它的值被设定后，在程序运行过程中不允许被改变
常量名一般使用大写字符

public class Demo09 {
     
       

    // 修饰符，不存在先后顺序
    // 变量类型前面的都是修饰符
    final static  double PI=3.14;
    static final   double PI2=3.14;

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

执行的结果如下：

3.14
3.14

变量的命名规范：
- 所有的变量、方法、类型要做大见名知意
- 类成员变量，首字符小写和驼峰原则
- 局部变量：首字母小写和驼峰原则
- 常量：大写字母和下划线
- 类型：首字母大写和驼峰原则
- 方法名：首字母小谢和驼峰原则

7、运算符

Java 支持的运算符

加减乘除

package operator;

public class Demo01 {
     
       
    public static void main(String[] args) {
     
       
        // 二元运算符
        int a=10;
        int b=20;
        int c=25;
        int d=25;

        System.out.println(a+b);
        System.out.println(a-b);
        System.out.println(a*b);
        System.out.println(a/(double)b);

    }
}

运算中如果有long类型，则都转换为long类型计算得到long类型，否则不管有没有int类型，则都转换为int类型，计算得到int类型

package operator;

public class Demo02 {
     
       
    public static void main(String[] args) {
     
       
        long a=121212125452121L;
        int b=123;
        short c=10;
        byte d=8;

        // 如果有long类型，则结果为long类型
        // 如果没有long类型，不管有没有int类型，都会转换为int类型，然后计算得到int类型
        System.out.println(a+b+c+d);
        System.out.println(b+c+d);
        System.out.println(c+d);
    }
}

计算结果为：

121212125452262
141
18

关系运算符

package operator;

public class Demo03 {
     
       
    public static void main(String[] args) {
     
       
        // 关系运算符返回结果为true或者false
        int a=10;
        int b=20;
        int c=21;

        // 取余，模运算
        System.out.println(c%a);

        System.out.println(a>b);
        System.out.println(a<b);
        System.out.println(a==b);
        System.out.println(a!=b);
    }
}

执行结果如下：

1
false
true
false
true

自增和自减（++/–）

package operator;

public class Demo04 {
     
       
    public static void main(String[] args) {
     
       
        // 自增 ++ 自减 --
        // 一元运算符

        int a=3;
        int b=a++;
        int c=++a;
        System.out.println(a);
        System.out.println(b);
        System.out.println(c);
    }
}

执行结果如下：

package operator;

public class Demo04 {
     
       
    public static void main(String[] args) {
     
       
        // 自增 ++ 自减 --
        // 一元运算符

        int a=3;
        int b=a++;     // 先将a的值赋给b，然后a自增1
        int c=++a;     // a先自增1，然后将值赋值给c
        System.out.println(a);
        System.out.println(b);
        System.out.println(c);
    }
}

Math类简介

package operator;

public class Demo05 {
     
       
    public static void main(String[] args) {
     
       
        // 幂运算
        System.out.println(Math.pow(2,3));
        System.out.println(Math.pow(3,2));
    }
}

执行结果如下：

8.0
9.0

逻辑运算

package operator;

public class Demo06 {
     
       
    public static void main(String[] args) {
     
       
        // 逻辑运算符
        boolean a = true;
        boolean b = false;

        System.out.println("a && b:"+(a&&b));
        System.out.println("a || b:"+(a||b));
        System.out.println("!(a && b):"+(!(a&&b)));

        int c=5;
        boolean d=(c<4) && (c++<4);
        System.out.println(d);
        System.out.println(c);
    }
}

执行结果如下：短路&& 运算当第一个条件为假时，第二个条件则不再执行

a && b:false
a || b:true
!(a && b):true
false
5

位运算：

package operator;

public class Demo07 {
     
       
    public static void main(String[] args) {
     
       
        /* A = 0011 1100 B = 0000 1101 A & B = 0000 1100 A | B = 0011 1101 A ^ B = 0011 0001 ~B = 1111 0010 << 左移 >> 右移 2*8=16 如何计算的最快？ */
        System.out.println(2<<3);
    }
}

执行结果为：

扩展的赋值运算符

package operator;

public class Demo08 {
     
       
    public static void main(String[] args) {
     
       
        int a=10;
        int b=20;
        a+=b;
        System.out.println(a);

        // 字符串连接符
        System.out.println(a+b);
        System.out.println(""+a+b);
        System.out.println(a+b+"");
        System.out.println(""+(a+b));
    }
}

执行结果如下：

三元运算符：

package operator;


public class Demo09 {
     
       
    public static void main(String[] args) {
     
       
        // 三元运算符 x ? y:z 如果x为真，则y，否则z
        int score=80;
        String type=score<60?"不及格":"及格";
        System.out.println(type);
    }
}

8、包机制

为了更好的组织类，java提供了包机制，用于区别类名的命名空间
一般利用公司域名倒置作为报名
如：www.baidu.com则包名为com.baidu.www
导入包使用import