Java基础（下）类型转换，变量、常量，运算符、包机制、javaDoc

最新推荐文章于 2024-06-12 23:40:32 发布

于暮夕中沉浸

最新推荐文章于 2024-06-12 23:40:32 发布

阅读量159

点赞数 1

分类专栏： Java 文章标签： java eclipse intellij-idea 开发语言 intellij idea

本文链接：https://blog.csdn.net/weixin_55070280/article/details/118845854

版权

Java 专栏收录该内容

13 篇文章 0 订阅

订阅专栏

Java基础（下）

1.类型转换

小数的优先级大于整数

public class Dom01 {
    public static void main(String[] args) {
        //强制转换 由高到低
        int i = 128;
        byte b = (byte) i;//将i强制转换为int类型
        //强制转换样式如：byte b = (byte) i; （括号里为所要转换的类型）
        //至于为什么会输出 -128呢，
        // 原因是：当大容器如int，转换为小容器如byte时，会出现 内存溢出 的结果

        System.out.println(i);
        System.out.println(b);
        //输出结果为 128 \ -128

        //自动转换 由高到低，不需要声明什么
        int a = 128;
        double c = i;

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

        //输出结果一致，因为是double类型，所以带有小数点

        /*注意点
        1.不能对布尔值进行转换
        2。不能把对象类型转换为不相干的类型
        3。在把高容量转换到低容量的时候，强制转换，反之则不用操作
        4。转换的时候可能存在内存溢出，或者精度问题!
         */
        //举例，类型转换之后的精度丢失

        System.out.println((int)15.5f);//输出为15
        System.out.println((int)45.45);//输出为45

        char d = 'a';
        int f = d+1;
        System.out.println(f);
        System.out.println((char) f);//强制转换f为char类型
        //输出为98 \b
    }
}

public class Dom02 {
    public static void main(String[] args) {
        //操作比较大的数时，注意溢出问题
        //JDK7新特性，数字之间可以用下划线分割，下划线不会被读取
        int money = 10_0000_0000;
        int years = 20;
        int total1 = money * years;
        long total2 = money * years;
        long total3 = money * ((long)years);

        System.out.println(total1);//输出为-1474836480，原因是计算时溢出了
        System.out.println(total2);//输出为-1474836480，
        // 原因是money * years 默认为int，计算完之后才转换为long，所以在此之前就已经出问题了
        System.out.println(total3);//输出为200亿，先把一个数转化为long类型，就能解决问题了
    }
}

2.变量、常量

（1）变量

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

在这里插入图片描述

变量的命名规范

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

注意事项

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

变量的作用域

类变量写在类里面，需要加一个static的静态关键词
实列变量写在类中间，不需要加
局部变量写在方法中

public class Dom04 {

    //类变量，需加一个static的关键字,从属于类，随类有随类无
    static double salary = 2500;

    //类里面除了可以定义一下方法，还能定义一些属性
    //属性：可以简单理解为变量

    //实列变量：作用域更大，从属于对象，比如类
    //如果不自行初始化，这个类型会有一个默认值
    //所有的数值类型初始化一般为0、0.0，字符串为u0000
    //布尔值默认是false
    //除了基本类型，其他的默认值都是null
    String  name;
    int age;


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

        //局部变量，存在于方法或者语句块里，使用之前必须声明和初始化值
        int i = 10;
        System.out.println(i);

        //实列变量举例
        Dom04 dom04 = new Dom04();
        System.out.println(dom04.age);
        System.out.println(dom04.name);

        //类变量，加一个static的关键字
        System.out.println(salary);
    }

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

    }
}

（2）常量

常量(Constant):初始化(initialize)后不能再改变值!不会变动的值。
所谓常量可以理解成一种特殊的变量，它的值被设定后，在程序运行过程中不允许被改变。
常量名一般使用大写字符
通过 final 来定义常量

3.运算符

运算符优先级

在这里插入图片描述

Java语言支持的运算符

在这里插入图片描述

算数运算符

public class Dom06 {
    //二元运算符
    //ctrl+D 复制当前内容到下一行
    public static void main(String[] args) {

    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);
    System.out.println((double) a/b);
   // System.out.println(a/b);输出结果为0
   //原因是int类型不输出小数，所以要将一个属转换为double类型，注意不要溢出


    }
}

public class Dom07 {
    public static void main(String[] args) {
        long a = 123123123L;
        int b = 123;
        short c= 10;
        byte d = 8;
        double e = 2.0;

        System.out.println(a+b+c+d);//输出为long型
        System.out.println(b+c+d);//输出为int型
        System.out.println(c+d);//输出为int型
        System.out.println(b+e);//输出为125.0，为double类型
        

        //如果在操作中有一个数为long或者为double，该结果定为long或者为double类型
        //如果没有这两个，这结果默认为int类型

    }
}

关系运算符

public class Dom08 {
    public static void main(String[] args) {
        //关系运算符返回的结果：正确 错误 布尔值
        //if 判读
        int a = 10;
        int b = 20;
        int c = 22;

        //取余，模运算
        System.out.println(c%a);// c/a 21/10 = 2 余1 然后输出这个1

        System.out.println(a<b);//小于
        System.out.println(a>b);//大于
        System.out.println(a==b);//等于
        System.out.println(a!=b);//不等于
    }
}

自增，自减

public class Don09 {
    public static void main(String[] args) {
        //++ -- 自增，自减 一元运算符
        int a = 3;
        int b = a++;//执行完该代码之后，先给b赋值，然后自增，故b输出为3

        //b完成赋值，在此进行自增，即a=a+1，输出为4
        System.out.println(a);//输出为4

        //基于上面，a为4，c在此先自增，即a=a+1，然后在输出
        int c = ++a;//执行完该代码之前，先自增，然后给c赋值

        System.out.println(a);//输出为5
        System.out.println(b);//直接输出赋值b，输出为3
        System.out.println(c);//输出为5
        //自减类似
        
        //幂运算 2^3 等于 2*2*2 = 8 但是java没有^,
        //所以对于很多运算，我们会使用一些工具类来操作，举例：
        double pow = Math.pow(2, 3);
        System.out.println(pow);
    }
}

逻辑运算符

public class Dom10 {
    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);
        System.out.println(d);//输出为false
        System.out.println(c);//输出为5，因为该程序没有运行到c++那一步，c没被加一
        System.out.println("==========");
        int f = 5;
        boolean g = (f>4)&&(f++<4);
        System.out.println(g);//输出为false
        System.out.println(f);//输出为6，说明程序已经跑完
    }


}

位运算符

public class Dom11 {
    public static void main(String[] args) {
        /* 举例两个二进制的位
        A = 0011 1100
        B = 0000 1101
        不要轻易去使用位运算
        不要轻易去使用位运算
        不要轻易去使用位运算

        $ | ~  ^
        A&B = 0000 1100 与 比较相同则为该数，不同为0
        A|B = 0011 1101 或 有1，则是1
        A^B = 0011 0001 亦或 两个比较相同为0，不同为1
        ~ 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这个是计算机二进制对应的16
         */
        System.out.println(2<<3);//输出2，往左移三位，结果为16
    }
}

扩展赋值运算符

public class Dom12 {
    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);//输出为30，此时a已经为30了。故以下运算出现50


        //字符串连接符 +
        System.out.println(a+b); //输出为50
        System.out.println(""+a+b); //输出为3020
        System.out.println(a+b+""); //输出为50

        System.out.println(a+b+""+a+b); //输出为503030
        //在+号运算符左右任意一番，只要出现了string类型的字符，后面其他的字符或者数组都会被改为string类型


    }
}

三元运算符

public class Dom13 {
    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);
    }
}

4.包机制

为了更好地组织类，Java提供了包机制，用于区别类名的命名空间（如同文件夹原理）。包语句的语法格式为:

在这里插入图片描述

扩展

在这里插入图片描述

5.JavaDoc

jdk1.8官网帮助api文档链接：Overview (Java Platform SE 8 ) (oracle.com)

javadoc命令是用来生成自己API文档的

参数信息

@author作者名
@version 版本号
@since指明需要最早使用的jdk版本
@param参数名
@return返回值情况
@throws异常抛出情况

生成javaDoc文档

目标1路劲下，cmd进入dos窗口
输入javadoc 加参数加 java 加该文件名

参数-encoding UTF-8 让编码为utf-8 -charset UTF-8 让字符集编码为utf-8

作用是减少乱码
生成一堆东西，点击index.html查看文档

在这里插入图片描述

于暮夕中沉浸

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java基础（下）类型转换，变量、常量，运算符、包机制、javaDoc

Java基础（下）1.类型转换小数的优先级大于整数public class Dom01 { public static void main(String[] args) { //强制转换由高到低 int i = 128; byte b = (byte) i;//将i强制转换为int类型 //强制转换样式如：byte b = (byte) i; （括号里为所要转换的类型） //至于为什么会输出 -128呢，
复制链接

扫一扫