JAVA基础语法（二）

一、类型转换

由于java为强类型语言，运算时需要用到类型转换

低----------------------------------------------->高

byte short char int long float double

​ 小数优先级大于整数※

运算中，不同类型转换为同一类型，在进行运算

1 类型转换

1.1 强制转换

​ 强制转换 （类型）变量名 —— (int)a

​ 高 ---> 低

int i = 128;
//byte b = i;   错误    byte范围-128~127
byte b = (byte)i;// 内存溢出   int--->byte  高--->低
System.out.println(i);//128
System.out.println(b);//-128
/*       正数 补码=原码
         负数 补码=原码符号位+反码
         补码=反码+1
         最高位是符号位，1表示负号，参与运算			 	 
         int  0000 0000 1000 0000    2^7    128
	 byte           1000 0000		
                        	
                       	=1000 0000-0000 0001	补码-1
                        =1111 1111		取反
                        =-128			原码	 
 */

二进制补码原理

1.2 自动转换

​ 低 ---> 高

int i = 128;
double b = i；;// 内存溢出	 强制转换 （类型）变量名	int--->double   低--->高

System.out.println(i);//128
System.out.println(b);//128.0

1.3 注意点

  • 不能对布尔值进行转换
  • 不能把对象类型转换为不相干的类型
  • 在高容量转换到低容量时，强制转换
  • 转换的时候可能存在内存溢出，或者精度问题
System.out.println((int)23.7);//23
System.out.println((int)45.89f);//45   float--->int    高---低    强制转换    
								//     高转低 精度丢失

char c = 'a';//97
int d = c+1;
   
System.out.println(c);//a	c是char 将结果转换为char输出
System.out.println(d);//98	d是int 将结果转换为int输出
System.out.println((char)d);//b	将int结果98强制转换为char输出

操作较大数时，要注意溢出问题

//JDK7新特性 数字可用下划线分割
int money = 10_0000_0000;
int years = 20;
int total = money*years;

System.out.println(total);//-1474836480 因为200_0000_0000溢出了
long total2 =  money*years;//两个int的运算结果也是int
System.out.println(total2);//-1474836480    输出的int转换为long时int已经溢出了
long total3 = money *((long)years);//先把一个数转换为long，输出就是lang
System.out.println(total3);//20000000000

二、变量

Java是一种强类型语言，每个变量必须声明类型

变量时程序中最基本的储存单元 包括 变量名+变量类型+作用域

注意：

  • 每个变量都有类型，可以是基本类型，也可以时引用类型
  • 变量名必须是合法标识符
  • 声明是一条完整的语句，因此每个声明都以“；”结束

1 变量名

public class demo07 {
    public static void main(String[] args) {
        //int a,b,c 变量需要初始化，注意程序可读性不建议写在一行 
        int a = 1;
        String name = "qinjiang";
        char x = 'x';
        double pi = 3.14;
    }
}

2 变量作用域

2.1 类变量

加关键词static

public class Demo08 {
    //类变量 前面加static
    static double salary = 2500;//高-->低 自动转换

    public static void main(String[] args) {
        //变量类型 变量名字 = new Demo08()
        System.out.println(salary);//2500
    }
}

2.2 实例变量

public class Demo08 {
    //实例变量:从属于对象,如果不初始化会变成默认值
    //布尔值：默认是fasle
    //除了基本类型，其余默认值都是null
    String name;//可以不初始化
    int age;

    public static void main(String[] args) {

        //变量类型 变量名字 = new Demo08()
        Demo08 demo08 = new Demo08();
        System.out.println(demo08.age);//0
        System.out.println(demo08.name);//null

    }
}

2.3 局部变量

public class demo08 { 
    //main 方法   定义一些属性 = 变量
    public static void main(String[] args) {
        int i = ;//局部变量，必须声明和初始化
        System.out.println(i);
    }
    // 其他方法
    public void add(){
        System.out.println(i);//局部变量i，无法输出main中的i
    }
}

3 常量

3.1 常量表示方法

初始化后不能再改变的值，可以理解为特殊的变量，设定后，在程序中不允许改变

 final 常量名 =  值；
 final double PI = 3.13;

常量名一般使用大写字符

public class Demo09 {
    final static double PI = 3.14;//类变量static修饰符不存在先后顺序

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

4 变量的命名规范

  1. 所有变量、方法、类名：见名知意

  2. 驼峰原则：除了第一个单词后面的单词首字母大写

  • 首字母小写和驼峰原则
    • 类成员变量 monthSalary、lastName
    • 局部变量
    • 方法名 run()，runRun()
  • 首字母大写和驼峰原则
    • 类名 Demo01、Man、GoodMan
  • 大写字母和下划线
    • 常量 MAX_VALUE
  • 小写+单数形式
    • 包名 scr

三、运算符

  • 算数运算符：+ - * / % ++ --
  • 赋值运算符：=
  • 关系运算符：> < >= <= == != instanceof
  • 逻辑运算符：&& || ！
  • 位运算符： & | ^ ~ >> << >>>
  • 条件运算符：？：
  • 扩展赋值运算符： += -= *= /=

1 算数运算符

+ - * /

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);//30    输出int
        System.out.println(a-b);//-10   输出int
        System.out.println(a*b);//200   输出int
        System.out.println(a/b);//0     两个整型相除结果为0.5浮点数 强制转换为整形输出，丢失精度
        System.out.println(a/(double)b);//0.5
    }
}

    public class Demo02 {
      	public static void main(String[] args) {
       		long a = 123123123123123L;
        	int b = 123;
      		short c = 10;
        	byte d =8;
        	char e = 'w';
        	float f = 14.4F;

        	System.out.println(a+b+c+d);//23123123123264 long
        	System.out.println(b+c+d);//141 int
        	System.out.println(c+d);//18    int
        	//有一个数为long等，结果就为long，double，float同理
        	//int short char byte混合运算，结果默认为int
        	//System.out.println((String)(c+d));默认int无法强制转换为字符串
       	 	//System.out.println(e+d);//127
        	//System.out.println(String(e+d));默认int无法强制转换为字符串
        	System.out.println(f+d);
    }
}

		System.out.println((String)(c+d));//short+char输出结果默认int无法强制转换为字符串

报错

		int b = 123;
		boolean g = true;
		System.out.println(b+g);   //布尔型不能参与运算

报错

%

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

System.out.println(c%a);//c/a=21/10...余1

++ --

public class Demo04 {

    public static void main(String[] args) {
        int a = 3;
        int b = a++;//执行完这行代码后++，即先给b赋值，a再自增
       /*等价于  int b = a;
                a = a+1;
        */
        System.out.println(a);//4       执行了 a=3；b=3；a=a+1； 最后a=4

        int c = ++a;//先++,再执行这条代码，即a先自增在给c赋值
       /*等价于  a = a+1;
                int c = a;
        */
        System.out.println(a);//5       
        System.out.println(b);//3 不是6   
        System.out.println(c);//5 不是7   过程：a=3; b=a=3; a=a+1=4; a=a+1=5; c=a=5
    }
}

2 关系运算符：

< >= <= == != instanceof

public class Demo03 {
    public static void main(String[] args) {
        //关系运算符的返回结果 true false 布尔值

        int a = 10;
        int b = 20;

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

很多运算会使用工具来操作

//幂运算2^3    2*2*2 =8在java中没有
double pow =  Math.pow(2,3);
System.out.println(pow);//8.0

3 逻辑运算符

&& || ！

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

        System.out.println("a && b"+(a && b));//a && bfalse
        System.out.println("a || b"+(a || b));//a || btrue
        System.out.println("!(a && b)"+!(a && b));//!(a && b)true
        System.out.println("***************************");
        //短路运算
        int c = 5;
        boolean d = (c<4)&&(c++<4);//    &&=x   ||=+
        System.out.println(d);//false
        System.out.println(c);//5

    }
}

4 位运算符

异或^

相同为0 不同为1 本质就是找出两者不同点

具体就是半加器（二进制数不带进位的加法）

0 + 0 = 0
0 + 1 = 1
1 + 0 = 1
1 + 1 = 0

与&

有0出0，全1才出1 本质就是找出两者都有的东西

0 x 0 = 0
0 x 1 = 0
1 x 0 = 0
1 x 1 = 1

或|

有1出1，全0才出0 本质就是找出两者都能满足的东西

0 + 0 = 0
0 + 1 = 1
1 + 0 = 1
1 + 1 = 1

位运算速度快

public class Demo06 {
    public static void main(String[] args) {
        /*
         A = 0011 1100
         B = 0000 1101

         A&B = 0000 1100        1+1=1   1+0=0   0+1=1   0+0=0
         A|B = 0011 1101        1*1=1   1*0=0   1*0=0   0*0=0
         A^B = 1100 1110        相同为1    不同为0
         ~B  = 1111 0010

         2*8=16 怎么运算最快  2*2*2*2

         位运算效率高
            <<  *2
            >>  /2
         0000 0000      0
         0000 0001      1   2^0
         0000 0010      2   2^1
         0000 0011      3
         0000 0100      4   2^2
         0000 0110      6
         0000 1000      8   2^3
         0000 1100      12
         0001 0000      16  2^4

         */

        System.out.println(2<<3);//16   0000 0010--->0001 0000
        System.out.println(3<<2);//12   0000 0110--->0000 1100
        System.out.println(7<<4);//112  0000 0111--->0111 0000   2^4+2^5+2^6=112
    }
}

5 条件运算符

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

        a+=b;//a = a+b
        a-=b;//a = a-b

        System.out.println(a);//10

        //字符串连接符 "+"
        System.out.println(a+b);//30
        System.out.println(""+a+b);//1020  连接符“+”的两侧有一个String就会都转换为string输出
        System.out.println(a+b+"");//30    连接符"+"前的运算依旧会处理完
    }
}

6 三元运算符

public class Demo08 {
    public static void main(String[] args) {
        // X ? Y ：z
        //如果x=true，则结果为y，否则结果为z

        int score = 80;
        String type = score <60?"及格":"不及格";  //可以用于精简if
        System.out.println(type);
    }
}

运算符有优先级 但一般用括号()

posted @ 2020-08-27 23:44  球球z  阅读(114)  评论(0)    收藏  举报