2021-03-11

最新推荐文章于 2021-11-10 17:26:45 发布

一叶611

最新推荐文章于 2021-11-10 17:26:45 发布

阅读量81

点赞数

本文链接：https://blog.csdn.net/junchaoa/article/details/114682886

版权

Java基础

类型转换

由于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 = b;

        //强制转换  （类型）变量名   高--低
        //自动转换    低--高
        System.out.println(i);
        System.out.println(b);
        System.out.println(c);


        /*
        注意点：
        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 d ='a';
        int e = d+1;
        System.out.println(e);
        System.out.println((char)e);
    }
}

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

        long total3 = money*((long)years); //先把一个数转换为long
        System.out.println(total3);

        // L l 要注意大小写 尽量都用大写的小写的l有点像1
    }
}

变量

变量是什么：就是可以变化的量！
Java是一个强类型语言，每个变量都必须声明其类型。

Java变量是程序中最基本的存储单元，其要素包括变量名，变量类型和作用域。

type varName  [=value] [{,varName[=value]}];
//数据类型  变量名 = 值；可以使用逗号隔开来声明多个同类型变量。

注意事项

每个变量都有类型，类型可以使基本类型，也可以是引用类型。

变量名必须是合法的标识符。

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

public class Demo04 {
    public static void main(String[] args) {
        //int a,b,c
        //int a=1,b=2,c=3;  //程序可读性
        String name ="junchao";
        char x ='X';
        double pi = 3.14 ;
    }
}

public class Demo05 {

    //类变量  static
    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 Demo05();
        Demo05 demo05 = new Demo05();
        System.out.println(demo05.age);
        System.out.println(demo05.name);

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

    }
}

常量

常量(Constant)：初始化(initialize)后不能再改变值！不会变动的值。
所谓常量可以理解成一种特殊的变量，它的值被设定后，再程序运行过程中不允许被改变。
```
final 常量名=值；
final double PI=3.14；
```
常量名一般使用大写字符

public class Demo06 {

    //修饰符，不存在先后顺序
    static final double PI =3.14;

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

变量的命名规范

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

运算符

Java语言支持如下运算符： 优先级()
- 算术运算符：+，-，*，/，%，++，–
- 赋值运算符：=
- 关系运算符：>, <, >=, <=, ==, !=(不等于)，instanceof
- 逻辑运算符：&&，||，！
- 位运算符：&，|，^，~，>>，<<，>>>（了解！！！）
- 条件运算符：？，:
- 扩展赋值运算符：+=，-=，*=，/=

package operation;

public class Demo01 {
    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);//要转换乘小数 不然0.5会变成0

    }
}

package operation;

public class Demo02 {
    public static void main(String[] args) {
        long a = 123123123123123L;
        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
        //cast 转换

        //类型转换：byte、short、char用运算符转换自动转换为int类型有L变为long类型
    }
}

package operation;

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

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

        //取余：模运算
        System.out.println(c%a); //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 operation;

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

        int b = a++;  //执行完这行代码后，先给b赋值，再自增 ++在后面b不变，a自增1
        //a = a+1;
        System.out.println(a);
        //a = a+1;
        int c = ++a;  //执行完这行代码钱，先自增，再给c赋值 ++在前面c等于a自增后的值，a自增1

        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 operation;

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);
        System.out.println(d);
        System.out.println(c);


    }
}

package operation;

public class Demo06 {
    public static void main(String[] args) {
        /*
        A = 0011 1100
        B = 0000 1101
        ----------------------
        A&B = 0000 1100  必须要两个1才为1
        A|B = 0011 1101  有一个1就为1
        A^B = 0011 0001  位置相同为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 0011    3
        0000 0100    4
        0000 1000    8
        0001 0000    16

         */

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

package operation;

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+"");
    }
}

package operation;

//三元运算符
public class Demo08 {
    public static void main(String[] args) {
        // x ? y : z
        //如果x==true,则结果为y,否则结果为z

        int score = 80;
        String type = score <60 ? "不及格":"及格"; //如果成绩<60就不及格，反之及格
        //必须掌握
        //if
        System.out.println(type);
    }
}

包机制

为了更好地组织类，Java提供了包机制，用于区别类名的命名空间。
包语句的语法格式为：
```
```java
```

package pkg1[. pkg2[. pkg3…]];
```

一般利用公司域名倒置作为包名： www.baidu.com com.baidu.www
**为了能够利用某一个包的成员，我们需要在Java程序中明确导入该包。使用“import”语句可以完成此功能

import package1[.package2…].(classname|*);
```

//导入这个包下所有的类！
import com.wang.base.*;

阿里巴巴开发手册https://www.jianshu.com/p/0d296596a74c

JavaDoc

JavaDoc命令是用来生成自己API稳当的
参数信息
- @author 作者名
- @version 版本号
- since 指明需要最早使用的jdk版本
- param 参数名
- return 返回值情况
- throws 异常抛出情况

package com.wang.base;

/**
 * @author junchao
 * @version 1.0
 * @since 1.8
 */

public class Doc {

    String name;

    /**
     *
     * @param name
     * @return
     * @throws Exception
     */
    //右键左边文件名Open In---Show in Explorer
    //打开命令行输入：javadoc -encoding UTF-8 -charset UTF-8 Doc.java


    public  String test(String name) throws Exception{
        return name;
    }

    //我是通过命令行 javadoc 参数 java 文件

    //作业：学会查找使用IDEA生产JavaDoc文档！  面向百度编程！
    //http://www.coozhi.com/youxishuma/g4/92496.html

    //基础部分得一切知识，后面几乎每天都会用
}

一叶611

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
2021-03-11

Java基础类型转换由于Java是强类型语言，所以要进行有些运算的时候，需要用到类型转换。低 --------------------------------------------------->高 byte,short,char–> int -->long -->float -->double 小数的优先级大于整数运算中，不同类型的数据线先转化为同一类型，然后进行运算。强制类型转换自动类型转换public clas
复制链接

扫一扫