java_day03

Java基础

变量

• 变量是什么：就是可以变化的量
• Java是一种强类型语言，每个变量都必须声明其类型
• Java变量是程序中最基本的存储单元，其要素包括变量名，变量类型和作用域

type varName [=value] [{,varName[=value]}]

//数据类型 变量名 = 值；可以用逗号隔开来声明多个同类型变量

• 注意事项
  • 每个变量都必须有类型，类型可以是基本类型或引用类型
  • 变量名必须是合法的标识符
  • 变量的声明是一条完整的语句，因此每一个声明都必须以分号结束

变量作用域

• 类变量
• 实例变量
• 局部变量

public class Demo7 {

    //属性：变量

    //类变量 变量前加上static
    static double salary = 9500;


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


    //main方法
    public static void main(String[] args) {
        //局部变量：在方法中声明且生命周期只在此方法中 必须声明和初始化值
        int i = 10;

        //变量类型
        Demo7 demo = new Demo7();
        System.out.println(demo.age);
        System.out.println(demo.name);

        //类变量
        System.out.println(salary);


    }

常量

• 初始化之后不能再更改值！是不会变动的值
• 常量是一种特殊的变量，初始化后，再程序的运行过程中不允许被改变

​ final 常量名=值；

​ final double PI=3.14

• 常量名一般使用大写字母

变量的命名规范

• 所有变量、方法、类型：见名知意
• 类成员变量：首字母小写和驼峰原则：monthSalary 除了第一个单词之外，后面的单词首字母大写 lastName
• 局部变量：首字母小写和驼峰原则
• 常量：大写字母和下划线：MAX_VALUE
• 类名：首字母大写和驼峰原则：Man，GoodMan
• 方法名：首字母小写和u驼峰原则:run()、runMan()

运算符

Java语言支持如下运算符

• 算式运算符：+，-，/，%，++，--

• 赋值运算符：=

• 关系运算符：>，<，>=，<=，==，!=，instanceof

• 逻辑运算符：&&

• 位运算符：&，|，^，~，>>，<<，>>>

• 条件运算符：?，:

• 拓展赋值运算符：+=，-=，*=，/=

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

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

    }
}

public class Demo2 {
    public static void main(String[] args) {
        long a = 234234234234234L;
        int b = 23423;
        short c = 123;
        byte d = 12;

        //这里有个知识点 基本类型低容量类型遇到高容量运算 会自动向上转化
        System.out.println(a+b+c+d);//Long 类型
        System.out.println(b+c+d);//int类型
        System.out.println(c+d);//short类型

    }
}

public class Demo3 {
    public static void main(String[] args) {
        //关系运算符返回的结果：false、true
        //一般与if配合使用

        int a = 10;
        int b = 20;
        int c = 21;

        System.out.println(a>b);
        System.out.println(a<b);
        System.out.println(a==b);
        System.out.println(a!=b);
        //取余 也叫模运算
        System.out.println(c%a);


    }
}

一元运算符 --、++

​ a++与++a 结果都是a=a+1,但是会在执行顺序上有一些区别，

a++ 是先执行再自增，++a则相反 先自增再执行

--同理

public class Demo4 {
    public static void main(String[] args) {
        /*
        ++自增；--自减 一元运算符
         */
        int a = 3;

        int b = a++; //执行完这行代码后，先给b赋值，再自增
        //相当于此处隐藏了 a = a + 1;
        System.out.println(a);

        //a = a + 1;
        int c = ++a; //执行完这行代码前，先自增，再给b赋值

        System.out.println(a);
        System.out.println(b);
        System.out.println(c);

    }
}

//逻辑运算符
public class Demo5 {
    public static void main(String[] args) {
        //与 &&、或||、非!
        boolean a = true;
        boolean b = false;

        System.out.println("a && b:"+(a && b));//逻辑与运算，两个变量都为真，结果才返回true
        System.out.println("a || b:"+(a || b));//逻辑或运算，两个变量有一个为真，结果就返回true
        System.out.println("!(a && b):"+!(a && b));//逻辑非运算，如果为真，则返回假，反之 假则返回真

        //短路运算 比如 b&&a 由与b是false 下面的a就不需要在判断了  直接结果为false
        int c = 5;
        boolean d = (c<4) && (c++<4);
        System.out.println(d);
        System.out.println(c);

    }

逻辑运算符

//逻辑运算符
public class Demo5 {
    public static void main(String[] args) {
        //与 &&、或||、非!
        boolean a = true;
        boolean b = false;

        System.out.println("a && b:"+(a && b));//逻辑与运算，两个变量都为真，结果才返回true
        System.out.println("a || b:"+(a || b));//逻辑或运算，两个变量有一个为真，结果就返回true
        System.out.println("!(a && b):"+!(a && b));//逻辑非运算，如果为真，则返回假，反之 假则返回真

        //短路运算 比如 b&&a 由与b是false 下面的a就不需要在判断了  直接结果为false
        int c = 5;
        boolean d = (c<4) && (c++<4);
        System.out.println(d);
        System.out.println(c);

    }

位运算

public class Demo6 {
    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
        ~A = 1100 0011

        ================================

        2*8 = 16 那么如何运算会赠右效率呢？ 答案是使用位运算
        <<  *2
        >>  /2
          二进制       十进制
        0000 0000       0
        0000 0010       2
        0000 0100       4
        0000 1000       8
        0001 0000       16

         */
        System.out.println(4>>1);
        System.out.println(4<<1);
    }
}

+=、-=

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

        a+=b;
        System.out.println(a);
        a-=b;
        System.out.println(a);

        //字符串连接符 + ，String
        System.out.println(""+a+b); //字符串在前会把后面也转换为字符串
        System.out.println(a+b+""); //先计算后转换
    }
}

三元运算符

//三元运算符
public class Demo8 {
    public static void main(String[] args) {
        //x ? y : z  如果x为真，返回y；反之返回z
        //也可用if处理

        int score = 50;
        String res = score<60?"不及格":"及格";
        System.out.println(res);

    }
}

其实运算符有个一优先级的问题（Java优先级是优先级与结合性的综合），但是不用特意去记忆，谨记()最优先足矣