一、HelloWorld

注意事项：

• 拼写，第一行第三个单词必须和文件名一模一样；第二行的String[]的S必须大写；第三行的分号必须是英文分号

//第一行的第三个单词必须和所在的文件名称完全一样，大小写也一样
//public class后面代表定义一个类的名称，类是java当中所有源代码的基本组织单位
public class HelloWorld {
    //第二行的内容是万年不变的固定写法，代表main写法
    //这一行代表程序执行的起点
    public static void main(String[] args){
        //第三行代表打印输出语句
        System.out.println("Hello World");
    }
}

1、注释

单行注释：//（Ctrl+/） （python：#）
多行（区块）注释：/* */ （python：''' '''，单引号）

2、常量（程序运行期间固定不变的量）

字符串常量：" "双引号，里面不限数量；
字符常量：' '单引号，里面只有一个字符；
空常量：null。代表没有任何数据；
布尔常量：true，flase
字符常量，即单引号之间必须有且只能有一个字符；空常量无法打印；布尔常量可以

3、基本数据类型

整数型：byte short int(默认)
浮点型：float double(默认) float
字符型：char
布尔型：boolean
引用数据类型
字符串、数组、类、接口、Lambda

注意事项：

• 字符串不是基本类型，是引用类型
• 浮点型可能只是一个近似值，不是一个精确值
• 数据类型与字节数不一定相关，例如float数据范围比long更广，但是float是4字节，long是8字节
• 浮点数默认类型是double，如果一定要使用float类型，需要在数字后加上后缀F，推荐大写；如果是整数，默认是int，要使用long类型，需要加上后缀L

4、变量

变量：程序运行过程中，内容可以发生改变的量
格式一：
数据类型 变量名称；
变量名称 = 数据值
格式二：
数据类型 变量名称 = 数据值

public class HelloWorld{
    public static void main(String[] args){
        int num1;
        num1 = 10;
        System.out.println(num1);

        int num2 = 20;
        System.out.println(num2);
    }
}

基本使用

public class HelloWorld{
    public static void main(String[] args){
        int num1;
        num1 = 10;
        System.out.println(num1);

        num1 = 20;
        System.out.println(num1);//变量的重新赋值

        //byte num2 = 128;//右侧数值不能超过左侧数据类型的范围
        byte num3 = 127;
        System.out.println(num3);

        boolean var1 = true;
        System.out.println(var1);

        boolean var2 = var1;
        System.out.println(var2);//将一个变量的数据内容赋值给另一个变量
    }
}

注意事项：

• 如果创建多个变量，那么变量名不能重复
• 对于float和long类型来说，字母后缀F和L不要丢掉
• 对于使用byte和short的变量，右侧是数据值不能超过左侧数据类型的范围
• 变量如果没有赋值就不能使用（比如打印）
• 变量使用不能超过作用域的范围；
  作用域：从定义变量的那一行开始，一直到直接所属的大括号结束为止

public class HelloWorld{
    public static void main(String[] args){
        int num1 = 10;
        System.out.println(num1);

        //int num1 = 20;//变量名不能重复

        //byte num2
        //System.out.println(num2);//没有赋值不能使用

        //System.out.println(num3);//创建变量之前，不能使用这个变量

        int num3 = 100;
        System.out.println(num3);
        {
            int num4 = 10;
            System.out.println(num4);
        }
        //System.out.println(num4);//已经超出了作用域，重新声明这个变量之前不能使用

        long num4 = 10;
        System.out.println(num4);//在外面的大括号作用域里，重新声明可以使用
    }
}

5、数据类型转换

当数据类型不一样时，将会发生数据类型转换
自动类型转换（隐式）：
（1）特点：代码不需要进行特殊处理，自动完成；
（2）规则：数据范围从小到大
强制类型转换（显式）
（1）特点：代码需要进行特殊的格式处理，不能自动完成
（2）格式：范围小的类型 范围小的变量名 = （范围小的类型） 原本范围大的数据

public class HelloWorld{
    public static void main(String[] args){
        System.out.println(1024);//整数类型，默认int
        System.out.println(1.11);//浮点数类型，默认double

        //左边long类型，右边是默认的int类型，int-->long,符合数据范围从小到大的规则
        //自动转换数据类型
        long num1 = 100;
        System.out.println(num1);//100

        //左边double,右边float,float-->double,符合从小到大规则
        //自动转换
        double num2 = 1.1F;
        System.out.println(num2);//1.100000023841858

        //左边float,右边long,float范围更大，符合规则
        //自动转换
        float num3 = 100L;
        System.out.println(num3);//100.0

        //long-->int不是从小到大，不能自动转换
        //int num4 = 100L;
        int num5 = (int) 100L;
        System.out.println(num5);
    }
}

注意事项：

• 强制类型转换一般不推荐使用，因为有可能发生精度损失，数据溢出
• byte/short/char都可以发生数学运算
• byte/short/char这三种类型在运算的时候，都会被首先提升为int类型，然后再计算
• boolean不能发生数据类型转换

public class HelloWorld{
    public static void main(String[] args){

        //long-->int
        int num1 = (int) 20000000000L;
        System.out.println(num1);//-1474836480  int类型装不下这么大的值，所以发生数据溢出

        //double-->int
        int num2 = (int) 4.99F;
        System.out.println(num2);//4  不会四舍五入，所有的小数位全部被舍弃

        char zifu = 'A';
        System.out.println(zifu);//A
        System.out.println(zifu+1);//66  大写字母A被提升为int65，然后进行了计算

        byte num3 = 40;
        byte num4 = 50;
        //byte result1 = num3+num4; //因为num3和num4都被提升为int，所以会报错
        int result1 = num3+num4;
        System.out.println(result1);

        short num6 = 60;
        short result2 = (short) (num3+num6);// 如果符合左边的数据类型范围，即逻辑的真实大小，那么可以使用强制转换来实现
        System.out.println(result2);
    }
}

6、算术运算

加：+；减：-；乘：*；除：/；模：%；

注意事项：

• 运算中有不同的数据类型，结果按范围大的数据类型显示

public class HelloWorld{
    public static void main(String[] args){
        //常量运算
        System.out.println(20+30);//50

        //变量运算
        int a =10;
        int b= 3;
        System.out.println(a+b);//13

        //变量常量混合
        System.out.println(a*20);//200

        //除，取商
        System.out.println(a/b);//3

        //除，取模（余数）
        System.out.println(a%b);//1

        //数据类型不同，结果取范围大的数据类型
        //int+double --> double+double --> double
        double result = a + 2.5;
        System.out.println(result);//12.5
    }
}

加号的多种用法

• 对于数值来说，就是加法
• 对于字符char类型来说，会先将char提升为int，然后进行运算
• 对于字符串String（首字母大写，不是关键字），表示拼接操作，任何数据类型和字符串进行连接的时候，结果都会变成字符串
• 优先级，小括号优先

public class HelloWorld{
    public static void main(String[] args){
        String str1 = "nihao";
        System.out.println(str1);//nihao

        System.out.println(str1+"hello");//nihaohello

        //String + int --> String
        System.out.println(str1+20);//nihao20
        System.out.println(str1+20+30);//nihao2030
        System.out.println(str1+(20+30));//nihao50
    }
}

自增自减
含义：让一个变量加一个数字1或者降一个数字1
格式：写在变量名称之前或之后。例：a++,++a
区别：（1） 单独使用的时候，无区别；（2）混合时，如果是++a，数值立马加1，并使用+1之后的值；a++，先使用原本的值，然后+1

public class HelloWorld{
    public static void main(String[] args){
        //单独使用
        int num = 10;
        System.out.println(num);
        num++;
        System.out.println(num);//11
        ++num;
        System.out.println(num);//12

        //混合使用,比如放到打印中
        //后++
        int num2 = 10;
        System.out.println(num2++);//10
        System.out.println(num2);//11

        //前++
        int num3 = 10;
        System.out.println(++num3);//11
    }
}

注意事项：

• 只有变量可以使用自增自减

7、赋值运算符

注意事项：

• 只有变量才能使用赋值运算符，常量不能进行赋值
• 复合赋值运算符其中隐含了一个强制类型转换

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

        int b = 10;
        b -= 5;
        System.out.println(b);

        int c = 10;
        System.out.println(c*=5);

        int d = 10;
        System.out.println(d/=5);

        int e = 10;
        System.out.println(e%=3);

        byte f = 10;
        //f = f+5
        //f = byte + int
        //f = int + int
        //f = int
        //f = (byte)int
        f += 5;
        System.out.println(f);
    }
}

8、比较运算符

==、<、>、<=、>=、!=

注意事项：

• 比较运算符的结果一定是一个boolean值，成立就是true，不成立就是false
• 多次判断不能连着写，比如1 < x <3

public class HelloWorld{
    public static void main(String[] args){
        System.out.println(10 == 20);//false

        int a = 10;
        int b = 20;
        System.out.println(a == b);//false

        System.out.println(a<b);//true
        System.out.println(a!=b);//true
        System.out.println(b<=20);//true
    }
}

9、逻辑运算符

与（并且）  &&    全部是true，才是true；否则就是false
或（或者）  ||   至少一个是true，就是true，否则就是false
非（取反） ! 本来是true，变成false；本来是false，变成true

注意事项：

• 与（&&），或（||），具有短路效果，即如果左边已经可以判断得到最终结果，那么右边的代码将不再执行，节省一定的性能
• 逻辑运算符只能用于boolean值
• 与、或需要左右各有一个boolean值，但取反只需要唯一的一个boolean值即可
• 与、或两种运算符，如果有多个条件，可以连续写，比如：条件A && 条件B && 条件C

public class HelloWorld{
    public static void main(String[] args){
        System.out.println(true && false);//false
        System.out.println(true && true);//true
        System.out.println(3<4 && 3>4);//false
        System.out.println(3<4 && 3>2);//true

        System.out.println(true || false);//true
        System.out.println(false || false);//false
        System.out.println(3>2 || 3<2);//true
        System.out.println(3<2 || 3<1);//false

        System.out.println(!true);//false
        System.out.println(!(3<4));//false

        int a = 10;
        int b = 20;
        System.out.println(3<2 && ++a<100);//与，第一个是false，所以阻断后面的代码执行
        System.out.println(3>2 || ++b<100);//或，第一个是true，阻断后面代码执行
        System.out.println(a);//10
        System.out.println(b);//20
    }
}

10、三元运算符

格式：数据类型 变量名称 = 条件判断 ？ 表达式A：表达式B
流程：
首先判断条件是否成立：
  如果成立为true，那么将表达式A的值赋值给左侧的变量；
  如果不成立为false，那么将表达式B的值赋值给左侧的变量

注意事项：

• 必须同时保证表达式A和表达式B都符合左侧数据类型的要求
• 三元运算符的结果必须被使用，比如打印

public class HelloWorld{
    public static void main(String[] args){
        int a = 10;
        int b = 20;

        //数据类型 变量名称 = 条件判断？表达式A：表达式B
        //判断a大于b是否成立，如果成立，将a赋值给max，如果不成立，将b赋值给max
        int max = a > b ? a : b;
        System.out.println(max);

        //int num = 3 > 4 ? 2.5 : 3;//冒号左右两边必须同时满足左侧的数据类型，这是错误写法
        //a > b ? a : b;
        System.out.println(a > b ? a : b);
    }
}