Four（java）

Day4

类型转换

• 由于Java是强类型语言，所以要进行有些运算的时候，需要用到类型转换。

低 ------------------------------------------------------------高

byte,short,char -> int ->long -> float ->double

• 运算中，不同种类的数据先转化为同一种类，再进行计算

• 强制类型转换

• 自动类型转换

public class Demo {
    public static void main(String[] args) {
        int i = 128;
        double b = i;

        //强制转换  （类型）变量名 高--低
        //自动转换  低--高

        System.out.println(i);
        System.out.println(b);
        /*
        注意点：
        1.不能对布尔值进行转换
        2.不能把对象类型转换为不相干的类型
        3.再把高容量转换为低容量的时候，强制转换
        4.转换的时候可能存在内存溢出，或者精度问题！！！
         */

        System.out.println("------------------------------------");
        System.out.println((int)23.7);  //23
        System.out.println((int)-45.89f);    //-45

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

变量

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

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

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

public class Demo {
    public static void main(String[] args) {
        //int a,b,c;
        //int a=1,b=2,c=3;
        String name = "王";
        char x = 'X';
        double pi = 3.14;
        System.out.println(name);
        System.out.println(x);
        System.out.println(pi);
    }
}

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

变量作用域

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

public class Cariable{
	static int allClicks = 0;		//类变量
	Sttring str = "hello world";	//实例变量

	public void method(){
        int i = 0;		//局部变量
    }
}

常量

• 常量(Constant)：初始化(initialize)后不能再改变值！不会变动的值
• 所谓常量可以理解成一种特殊的变量，它的值被设定后，在程序运行过程中 不允许被改变

final 常量名=值；
final double Pi = 3.14;

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

public class Demo2 {

        //类变量
        static double salary = 2500;

        //属性：变量

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

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

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

            //变量类型 变量名字 = new Demo2();
            Demo2 demo2 = new Demo2();
            System.out.println(demo2.age);
            System.out.println(demo2.name);

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

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

}

变量的命名规范

1. 所有变量，方法，类名：见名知意
2. 类成员变量：首字母小写与驼峰原则：monthSalary 除了第一个单词以外，后面的单子首字母大写 lastName
3. 局部变量：首字母小写与驼峰原则
4. 常量：大写字母和下划线：MAX_VALUE
5. 类名：首字母大写和驼峰原则：Man，GoodMan
6. 方法名：首字母小写和驼峰原则：run()，runRun()

算数运算符和数学类

注意优先级

• 算数运算符:+, -, *, /, %, ++, –
• 赋值运算符: =
• 关系运算符: >, <, >=, <=, ==, != insttanceof
• 逻辑运算符: &&, ||, !
• 位运算符: &, |, ^, ~, >>, <<, >>>(了解!!!)
• 条件运算符: ?, :
• 拓展赋值运算符: +=, -=, *=, /=

public class Demo {
    public static void main(String[] args) {
        //二目运算符
        //Ctrl + D：复制当前到下一行
        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);
    }
}

层级变化

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

        System.out.println(a+b+c+d);//long
        System.out.println(b+c+d); //int      //有long即为long其他变int
        System.out.println(c+d);//int
    }
}

布尔值 取余-模运算

public class Demo3 {
    public static void main(String[] args) {
        //关系运算符返回的结果：正确，错误  （布尔值）
        //if

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

        //取余即模运算
        System.out.println(c%a);//  c/a  22/10=2.....1

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

自增自减

public class Demo3 {
    public static void main(String[] args) {
        //关系运算符返回的结果：正确，错误  （布尔值）
        //if

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

        //取余即模运算
        System.out.println(c%a);//  c/a  22/10=2.....1

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

与或非 短路运算

public class Demo5 {
    public static void main(String[] args) {
        //与（and)     或(or)    非(取反)
        boolean a = true;
        boolean b = false;

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

        //短路运算
        int c = 5;
        boolean d = (c<4)&&(c++<4);//因为前半部已经得出结果，即后半部分直接不用计算，即c不需要++，所以最终c结果为5
        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 = 0011 1100
        A|B = 0011 1101
        A^B = 0011 0001
        ~B  = 1111 0010

        2*8 = 16    即2*2*2*2
        效率极高
        <<      *2
        >>      /2

        0000 0000       0
        0000 0001       1
        0000 0010       2
        0000 0011       3
        0000 0100       4
        ....
        0000 1000       8
        ....
        0001 0000       16
         */

        System.out.println(2<<3);
    }
}