类型转换、变量、常量、运算符及其相应代码

类型转换

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

低--->高

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

public class Demo03类型转换 {
    public static void main(String[] args) {
        int i = 128;
        byte b = (byte)i;   //内存溢出
        // 强制转换 （类型）变量名   高-->底
        //自动转换   底--高

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

    }
}

注意事项

public class Demo04注意事项 {
    public static void main(String[] args) {
        //操作比较大的数的时候，注意溢出问题
        //JDK7新特性，数字之间可以用下划线分割
        int money = 10_0000_0000;
        int years =20;
        int total = money*years;  //-1474836480 计算的时候溢出了
        System.out.println(total);
        long total2 = money*years; //默认是int，转换之前已经存在问题了
        long total3=money*((long)years);  //先把一个数转换为long
        System.out.println(total3);

    }
}

变量

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

注意事项

每个变量都有类型，类型可以是基本类型，也可以是引用类型。
变量名必须是合法的标识符。

变量声明是一条完整的语句，因此每一个声明都必须以分号结束

public class Demo05变量 {
    public static void main(String[] args) {
        //int a,b,c;
        //int a=1,b=2,c=3;
        int a=1;
        int b=2;
        String name = "lijinyu";
        char x = 'x';
        double pi = 3.14;
    }
}

变量作用域

类变量
实例变量
局部变量

public class Demo08变量作用域 {
    //类变量  static
    static  double salary=2500;

    //main方法
    //属性：变量

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

    public static void main(String[] args) {

        //局部变量；必须声明和初始化值
        int i=10;

        System.out.println(i);

        //变量类型  变量名字 = new Demo08();
        Demo08变量作用域 demo08变量作用域 = new Demo08变量作用域();
        System.out.println(demo08变量作用域.age);
        System.out.println(demo08变量作用域.name);
        System.out.println(salary);

    }


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

    }
}

常量

常量(Constant):初始化(initialize)后不能再改变值!不会变动的值。

所谓常量可以理解成一种特殊的变量，它的值被设定后，在程序运行过程中不允许被改变。

final 常量名=值;
final double PI=3.14;

常量名一般使用大写字符

变量的命名规范

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

运算符

Java语言支持如下运算符：

*算术运算符:+， -， ，l，%，++，--

赋值运算符：=

关系运算符：>,<,>=,<=,==,!=,instanceof

逻辑运算符：&&(与) ||（或）！（非）

运算符:&，|，^，~，>>，<<，>>>(了解! ! ! )

扩展赋值运算符:+=，-=，*=，/=

代码：

package operator;

public class Demo01 {
    public static void main(String[] args) {
        // 二元运算符
        int a = 10;
        int b = 20;
        int c = 30;
        System.out.println(a+b);
        System.out.println(a-b);
        System.out.println(a*b);
        System.out.println(a/(double)b);

    }
}

package operator;

public class Demo02 {
    public static void main(String[] args) {
        long a = 12312313L;
        int b = 123;
        short  c = 10;
        byte d = 8;
        System.out.println( a+b+c+d);  //long
        System.out.println( b+c+d);  //Int
        System.out.println( c+d);  //Int
    }
}

package operator;

public class Demo03 {
    public static void main(String[] args) {
        //关系运算符返回的结果： 正确 错误 布尔值
        int a = 10;
        int b = 20;
        int c= 21;
        //取余，模运算
        System.out.println(c%a);   // 21/10=2.....1


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

自增自减++ --

package operator;

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


    //  ++  --  自增，自减   一元运算符
    int a = 3;
    int b = a++; //执行这行代码后。先给b赋值，再自增
     System.out.println(a);
     // a++ a=a+1
    int c = ++a;//执行这行代码前，先自增，再给c赋值
    System.out.println(a);
    System.out.println(b);
    System.out.println(c);

    // 幂运算 2^3 2*2*2 = 8
        double pow = Math.pow(2,3);
        System.out.println(pow );

}
}

逻辑运算

package operator;

public class Demo05逻辑运算符 {
    public static void main(String[] args) {
        // 与and  或or   非取反
        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));//如果是真则为假，如果是假则为真

        //短路运算
        int c = 5;
        boolean d =(c<4)&&(c++<4);  //(c<4)是错误的，则不执行（c++<4）了
        System.out.println(d);
        System.out.println(c);

    }
}

左移右移：

package operator;

public class Demo06 {
    public static void main(String[] args) {
        /*
        A = 0011 1100
        B = 0000 1101
----------------------------
        A&B= 0000 1100  A与B对比 同时为1则为1 反之则为0
        A/B=0011 1101  A与B对比，同时为0则为0，反之则1
        A^B=0011 0001   A与B对比，如果两数相同则为0，反之则为1
        ~B=1111 0010     与B相反

        2*8=16   2*2*2*2
        效率高
        << 左移  相当于把数字*2
         >>   右移 相当于把数字/2
         0000 0000 0
         0000 0001 1
         0000 0010 2
         .... ...
         0000 1000 8
         0001 0000 16
         */
        System.out.println(2<<3);
    }
}

扩展运算符：

package operator;

//拓展运算符
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);
        //字符串连接符  +  ,String
        System.out.println(a + b);
        System.out.println(" " + a + b);  //1020

        System.out.println(a + b + "");   //30


    }
}

三元运算

package operator;

//三元运算符
public class Demo08 {
    public static void main(String[] args) {
        // x? y: z
        //如果x==true， 则结果为y 否则为z
        int socre = 80;
        String type = socre < 60 ? "不及格" : "及格"; //必须掌握
        //if
        System.out.println(type);
    }
}

视频来源：

https://www.bilibili.com/video/BV12J41137hu?p=31

posted @ 2020-11-14 15:45 喂s别闹阅读(178) 评论(0) 收藏举报

刷新页面返回顶部